Covered In LaTeX

Although I haven’t used LaTeX much in the past few years, it was one of the primary tools that hastened my shift to using GNU/Linux full time. Why? I’d grown sick of fighting with document preparation and publishing systems (e.g. Microsoft Word/Open Office), and had started using LaTeX on my Mac to produce all of my papers and documents that needed to be output to paper-formats. Why switch? Because after a certain point of having every tool you use be Free software (because it’s better!), it becomes easier and more cost effective to just jump the gun and by commodity hardware and use a system that’s designed to support this kind of software (managing a large selection lots of free software packages on OS X can become cumbersome).

So why LaTeX? What’s the big deal? Why do I care now? Well…

LaTeX is a very usable front-end/set of macros for the TeX typesetting engine. Basically, you write text files in a particular way, and then run LaTeX (or pdflatex) and it generates the best looking PDF in the world of your document. You get full control over things that matter (layout, look and feel) and you don’t have to worry about things that ought to be standard (titles, headlines, citations with BibTeX, page numbering, hyphenation). The best part, however, is that once you figure out how to generate a document correctly once, you never have to figure it out again. Once you realize that most of the things you need to output to paper are in the same format, you can use the same template and be able to generate consistently formated documents automatically. There’s a “compile” step in the document production process, which means changes aren’t often immediately recognizable, but I don’t think this is a major obstacle.

Word processing and document preparation is a critical component of most common computer users. At least, I’d assume so, though I don’t have good numbers on the subject. In any case, I think it might be an interesting project to see how teaching people how to use LaTeX might both improve the quality of their work, and also the way that they’re able to work. It’s advanced, and a bit confusing at first, but I’d suspect that once you got over the initial hump LaTeX presents a more simple and consistent interface: you only get what you tell it to give you and you only see the functionality that you know about. This might make the discovery of new features more difficult, but it doesn’t limit functionality.

I’m not sure that this post is the right space to begin a lesson or series on getting started with LaTeX, but I think as a possible teaser (if there’s interest) that the proper stack for getting started with LaTeX would consist of:

• A TeXlive distribution. You need the basic tool kit including pdflatex, TeX, Metafont, LaTeX, and BibTeX.

• A Text Editor with LaTeX support: emacs, TextMate, etc. Plain text can be difficult and cumbersome to edit unless you have the right tools for the job, which include a real text editor.

• Some sort of macro or snippet expansion system. TeX is great. But it’s also somewhat verbose, and having an easy way to insert text into your editing environment, both for templates but also for general operations (emphasis, notes, etc.) is incredibly useful, and reduces pain greatly.

• A template management system. This probably needn’t be a formal software system, but just something to organize and store the basic templates that you will use.

And the rest is just learning curve and practice. Onward and Upward!

Console Use for the Uninitiated

I have a computer, an old laptop, that I mostly use as the foundation of my stereo system. It’s just a basic system with a few servers (a web server and the music player daemon), and it doesn’t have a running window manager. This configuration usually doesn’t bug me: I connect remotely and the computer sits under the couch, but since my recent move I’ve not had a network connection at home and I’ve defaulted to playing music and managing the system from the console.

This works just fine for me. The virtual terminals aren’t noticeably different from the terminal I get over ssh (as you would expect/hope), except now I have to walk across the room. The people who listen to music with me haven’t yet been other terminal geeks, and so I’ve taken on the role of stereo whisperer. Until a friend looked over my shoulder and wanted to change the track. Using the console is sometimes (often) a slippery slope.

I realized immediately that this situation was much more conducive to learning to use the console than the kinds of introductions to using the console that I’ve typically written. The commands we used were very limited: the mpc program that acts as a simple command-line client to the music player daemon (mpd) and grep. We also used the pipe operator.

There are thousands of commands on most Linux/UNIX systems and remembering all of them can be a bit challenging. The console is a limiting environment basically you can do one thing at a time with it, and you don’t have a lot of leeway with common errors. At the same time, there are a great number of programs and commands that a beginner has no way of knowing about or knowing when to use. Legitimately, the console is both too limiting and expansive to be quickly accessible to the uninitiated. Starting with a very limited selection of commands is way to break through this barrier.

The terminal environment is also very “goal-oriented.” Enter a command to generate some sort of output or result and then repeat. At the end your system will have done something that you needed it to, and/or you’ll learn something that you didn’t already know. When you’re just trying to learn, all of the examples seem fake, contrived, and bothersome because many people already have an easy way of accomplishing that task using GUI tools. Learning how the terminal works, thus, needs a real example, not just a potentially realistic example.

The great thing, I think, is that once you have a need to learn command line interaction, it makes a lot of sense even to people who aren’t die-hard geeks: Commands all have a shared structure that is fairly predictable and inconsistencies are apparent. Perhaps most importantly the command line’s interaction model is simple: input a command and get a response. Advanced users may be able to bend the interaction model a bit, but it is undeniably parsimonious.

It seems, in conclusion, that the command-line is easy to learn for the new user for the same reason it is beloved by the advanced. Ongoing questions, include:

If this kind of realization were to catch on, how might it affect interaction design in the long run? Might “simple to design” and “easy to use” move closer together?

Is there a way to build training and documentation to support users who are new to this kind of interaction style?

Collaborative Technology

I agreed to work on an article for a friend about the collaborative technology “stuff” that I’ve been thinking about for a long time. I don’t have an archive that covers this subject, but perhaps I should, because I think I’ve written about the technology that allows people to make things with other people a number of times, though I have yet to pull together these ideas into some sort of coherent post or essay.

This has been my major post-graduation intellectual challenge. I have interests, even some collected research, and no real way to turn these half conceptualized projects into a “real paper.” So I’ve proposed working with a friend to collect and develop a report that’s more concrete and more comprehensive than the kind of work that I’ve been attempting to accomplish on the blog. Blogging is great, don’t get me wrong, but I think it leads to certain kinds of thinking and writing (at least as I do it,) and sometimes other kinds of writing and thinking are required.

Regarding this project, I want to think about how technology like “git” (a distributed version control system) and even tools like wiki’s shape the way that groups of people can collaborate with each other. I think there’s an impulse in saying “look at the possibilities that these tools create! This brave new world is entirely novel, and not only changes the way I am able to complete my work, but how I look at problems, and make it so much easier for me to get things done..” At the same time, the technology can only promote a way of working it doesn’t necessarily enforce a way of working, nor does any particular kind of technology really remove the burdens and challenges of “getting things done.” More often perhaps new kinds of technology, like distributed version control, is responsible for increasing the level of abstracting and allowing us (humans) to attend to higher order concerns.

Then, moving up from the technology, I think looking at how people use technology in this class allows us to learn a great deal about how work is accomplished. We can get an idea of when work is being done, an idea of how quality control efforts are implemented. Not only does this allow us to demystify the process of creation, but having a more clear idea of how things are made could allow us to become better makers.

The todo list, then, is something like:

• Condense the above into something that resembles a thesis/argument.

• Become a little more familiar with the git-dm (“data mining”) tool that the Linux Foundation put together for their “state of Kernel development.”

• Develop some specific questions to address. I think part of my problem above and heretofore has been that I’m saying “there’s something interesting here, if we looked,” rather than. “I think w kind of projects operate in x ways, where y projects will operate in z ways.”

• Literature review. I’ve done some of this, but I’ve felt like I need to do even more basic methodological and basic theory reading. And even though an unread Patterns of Culture is on my bookshelf, I don’t need to read that to begin reading articles.

That’s a start. Feedback is always useful. I’ll keep you posted as I progress.