Karl T.

This one's a little rough around the edges:

A friend of mine commented on his journal/blog recently that he likes the Microsoft Windows interface, and that he expected me to be upset with him for this. I replied that the Windows interface wasn't a good fit for me (I'm a command-line junkie), but that I believed that people should use what's comfortable for them, and most of all, what gives them the least urge to pitch the machine out the nearest window. (I suppose the marketing-and-usability experts would label this the 'most positive user experience.')

I'm comfortable with small tools. The first programming language I truly felt I understood was Forth. (I don't count BASIC because I didn't learn how a BASIC interpreter works until much later.) Forth is an astonishingly simple language. Data goes on the data stack, addresses go on the return stack, exit means pop an address off the return stack, set the instruction pointer, and away you go. Compared to Forth, even C looked complicated, with its stack frames and auto variables.

The first language covered in my university education was Pascal (which dates me pretty firmly), but it was taught as a black box: code in, results out, what happens in-between is a mystery. Something about compiling to p-code and then interpreting the result. I didn't mind Pascal so much; structured programming was new to me, but the notion that a subroutine should have one entry point and one exit point didn't seem too radical. The tendency of my fellow-students to write two-hundred-line procedures, however, baffled me utterly. "How can you wrap your head around that?" I asked, bewildered, "How can you know what's going in and what's coming out?" The inevitable reply was, "Well, the program runs." I couldn't manage more than a screenful for a procedure; otherwise things got lost. I longed for the simplicity of typing words on a screen and seeing results on the stack. When I discovered that dbx, the VAX debugger, would actually let me run one procedure at a time, inspecting the results as I went, I spent so much time in the debugger that my TAs must have thought I wrote the buggiest code on the planet. It wasn't Forth, but it was nearly instant gratification. And that was that: I was hooked on the interaction. My father wrote thousands of lines of FORTRAN on punched cards submitted in batches; sometimes he'd wait days for output of a single run. His father sold and repaired Marchant Pony mechanical calculating machines, doing laborious debugging by hand. I'm immensely grateful that I have the tools I do; I'm not sure I would have had the patience they did.

I learned C more or less at the same time as Pascal, and FORTRAN shortly after. I spent some fascinated time reading the output of an early version of f2c; it really brought home to me the fact that C, Pascal, and FORTRAN are very closely related -- one can be transformed into another with a fairly simple computer program. Lisp was something new; I hadn't run into the code-as-data paradigm yet, and it didn't stick immediately. The syntax of Lisp also put me off quite a bit -- I had trouble seeing the code for the parentheses. I'm told they become almost transparent to veteran Lispers; I haven't had that experience yet.

(More tomorrow -- I've got to get going.)