When did you first try Lisp seriously, and which Lisp family member was it?

Well, I'm not the oldest Lisper in the survey (kudos to you, Drew), but I do go quite a ways back. Here's my story.

Wow, this goes back a long way (jostles ancient neurons...). In the mid 1970s as a teen, I was swept up in the new personal computer revolution. I still have my copy of the January 1975 issue of Popular Electronics, introducing the MITS Altair 8800. Two magazines at that time, Creative Computing, and Byte would often have interesting articles about cool and exciting things going on with computers. One such activity, artificial intelligence really caught my imagination. The ability to program a computer to really be like HAL 9000 or the computers of Star Trek was very compelling to a young boy.

In particular, Byte magizine of that time would sometimes have one or two articles devoted to Lisp. Then, in August 1979, in their third language-themed issue, they covered Lisp. These articles were hard to understand for someone still in high school and no education in computer science. But I voraciously read everything I could get my hands on. At the same time, I had a strong interest in Smalltalk, and in September 1977's Scientific American where Alan Kay described the Dynabook and Smalltalk, he also prominently mentioned Lisp as a significant inspiration.

I just had to learn more!

When I got into Arizona State University in 1980, I immediately sought out the computers there and everything in the library I could find about artificial intelligence and Lisp. Unfortunately, ASU didn't have any professors that knew anything about AI, so I was on my own for AI and Lisp. Searching our library, the only book I found was Laurent Siklossy's Let's Talk Lisp. This was a very hard book to read. It did describe the basic structure of Lisp, circa 1976, but it all seemed pretty mysterious to me. For example, there was no quote operator ("'") and the modern style of indented code hadn't been invented yet (see for example, the uncut version of Evolution of Lisp, page 20 , where member is defined in this style).

The other book I was able to track down that year was John Allen's Anatomy of Lisp. This turned out to be extremely influential to me. The best way of describing it was as a primordial version of Structure and Interpretation of Computer Programs (which wouldn't be published until 1984). I still have my copy of Anatomy of Lisp from that time and consider it one of my most prized book posessions.

Unlike the Siklossy book that just seemed to be a mish-mash of CAR, CDR, CONS, and QUOTE without making any sense, Anatomy of Lisp was a beautifully written book. The book concerned itself with data driven programming, data structures and their representation, interface vs. implementation, and how Lisp is implemented. It developed several meta-circular interpreters and compilers in a style very similar to that of SICP. This was pretty heady stuff.

Anyway, I was reading this my first year of college before I even took a computer science course, so when I finally took Intro to Computer Science where we learned Pascal, I had already gotten a very modern treatment of the fundamental issues of computer science, and even had a basic understanding of how a Lisp interpreter and compiler worked.

This proved to be a very powerful mental lever for me, so while everyone else was struggling with Pascal and where the semi-colons go and how to deal with pointers and what not, I had a very solid grounding of what happens behind the scenes. I considered myself very, very lucky that I had innoculated my mind with Lisp before it was calcified by Pascal and the stultifying comp-sci education of the day. I was literally light years ahead of everyone else in my understanding of what "computer science" really means.

Anatomy of Lisp was also important in showing that Lisp just wasn't for AI, that it could be used as a general purpose language.

As far as actually using Lisp, instead of just reading about it, I was able to get the DECUS version of Lisp installed on the math department's PDP-11/70. It was one of those funky Lisp 1.5 inspired implementations that was close enough to Lisp 1.5 to be recognizeable as a Lisp, but different enough from Lisp 1.5 that the Lisp 1.5 manual wasn't really useful in helping me understand how to use it.

It was extraordinarily painful to use. It didn't have macros, the quote read macro, a debugger, inspector, or anything else that we expect in a Lisp today. It did have a rather primitive REPL, but that was about it. Input was via printer terminals, so there was no assistance for matching parenthesis or indentation. I'm really amazed and impressed with all of the Lispers who used punched cards. I can't imagine it.

I pretty much gave up on programming in Lisp because of that primitive, non-standard Lisp, however I kept reading whatever I could get my hands on. A notable book that I read after Anatomy of Lisp was Patrick Henry Winston's first edition of Lisp. It described MacLisp, and a little about Emacs and its integration with Lisp. This sounded really cool to me, and I was bummed that I didn't have access to it. It also was well written and quickly became the standard for learning Lisp. I especially liked its focus on artificial intelligence. I despaired though, for not being able to comfortably program in Lisp.

Then around 1982, ASU got a Vax-11/780 for the computer science department and they ran Berklely's early BSD Unix on it. I managed to get an account on it, even though it was primarily for the faculty and the graduate students. My computer life was transformed. Unix was so liberating. They had lots of CRT terminals so access was pretty easy. It had VI, Gosling Emacs, and Berkleley's Franz Lisp installed. Franz Lisp was much closer to MacLisp than anything else I had access to, so the Winston book was now useful in a practical sense. Also, it had a great manual. I finally I had a programming environment that supported Lisp. So I did lots of Lisp programming, but purely for my own enjoyment. They were mostly small, toy AI programs. Nothing really big or challenging. An interesting note about the Gosling Emacs: it had something called MockLisp as an extension language but it really wasn't very close to Lisp. Not like today's Emacs Elisp variant. I didn't write any extensions or macros with it and I don't recall that anyone else did either.

The next year, in 1983, ASU finally got an AI professor. He was a transplant from SUNY. He was basically unapproachable, as he brought along his own grad students from SUNY and really didn't think much of the homegrown ASU crowd. I pretty much gave up on AI as a field of study at ASU as a result of that. However, he did bring along a Honeywell computer running Multics MacLisp. It also had Multics Emacs, which was written in MacLisp. I didn't really use the Multics MacLisp very much, though, as it wasn't really holding my interest at that time. We had another transplant from England, who was heavily into functional programming and I latched onto his work with great fevor. I do recall helping out folks who had assignments in Lisp in their principles of programming class.

Having become uninterested in Lisp, something happened in 1984 that forever changed the course of my computer science career. ASU started hosting a series of lectures of famous professors. One of the first happened to be Dan Friedman. His lecture discussed Scheme (which I was somewhat familiar with, having previously read the Lambda papers) and more importantly macros. I had never fully grokked the power of macros, because when Dan started discussing macros it was as if I was struck by lightning. He happened to show an early version of hyginiec macros, using the famous Scheme macro definition of let. He went on to discuss continuations, using them for multithreading (engines) and logic programming. He also was hyping SICP as a revolutionaly new computer science textbook. This lecture so totally blew my mind. I was changed forever. For the next year, all I talked about was macros, macros, macros. I completely tore away from functional programming (to the great disappointment of my advisor). From this point on, it was obvious that not only was Lisp (in any of its dialects) the most powerful language around, it could continue to be the most powerful programming language by assimilating other paradigms (i.e., object-oriented programming with Flavors or CLOS, logical programming, etc.).

I immediately bought SICP and totally immersed myself in it. I thought it was the most brilliantly written, amazing book I had ever read. I only wish that I had been able to read it earlier. Even though to my disappointment SICP never discussed syntactic extension via macros, it still was a mind bending book for me. I definitely was lucky in having read Anatomy of Lisp first, as it prepared me for the material in SICP. I recall that even with my evangilizing of SICP around the department, no one really took notice of it. I had plans of pursuing a masters and phd there, but it became obvious to me that I wasn't going to be able to pursue Lisp or Scheme or research into it at ASU and unfortunately, I didn't have the financial resources to go somewhere more suitable (*sigh*).

The last significant Lisp oriented event of that time was the publication of CLtL (1st edition). Since our school wasn't on the ARPAnet, I didn't know about the standardization effort until it showed up in the bookstore. I was immediately impressed with how clean the design was. Finally, a lexically scoped Lisp, with lots of standard functions, powerful macros, and the promise that it could be easily (ha ha!) implemented on normal hardware. I was well aware of the MIT Lisp Machine project and thought they were pretty cool, but since they were practically mainframes, I knew I was never, ever going to see one, certainly not at ASU. So, Common Lisp was definitely the future, but I knew it would be quite a while before I would see it (much to my disallusionment).

I finished up the computer science degree, graduated, and moved on and never looked back at academia (mostly because I was already married and had a kid on the way, but also because I knew I would never be happy in a computer science environment that I considered to be backwards and way behind the scene).

Flashforward several years to 1987 where I was employed at American Express in a small, skunkworks development group. Much to my suprise, I finally did get to see a Lisp Machine, a Symbolics. American Express was using them to run an expert system to make credit card authorization decisions (the famous Authorizer Assistant program). I was pretty interested in it, but could never get into the group that was responsible for it. They mostly used ART, one of the expert system shells of the time, and I wasn't really impressed with any of the expert system shells of the time, having fully studied logical programming in school. After finally getting access to the Authorizer Assistant source code a couple of years later, I was glad I didn't work on it. When Lisp was used, it was used very restrictively, which it had to be, considering the high-volume, near real-time demands put upon it. It was written totally garbage-free, which was my first exposure to that style of Lisp, and it didn't look very pleasant to me. It didn't really matter, as I was making quite a few waves in the company by myself by rolling out the company's first production use of Smalltalk, but that's a story for the Smalltalkers.

So, throughout the 1990s, I didn't really touch Common Lisp proper. I was really excited when CLOS came out but at that time I was professionally commited to Smalltalk. I continued to dabble in Common Lisp and even Scheme whenever the mood struck me, but really the lasting legacy of Lisp was on how I approached problem solving. I would always build up whatever language I was using to more closely model whatever domain I was using, then program in that, an approach readers of Paul Graham would recognize. The object-oriented languages were a great help in this, first Smalltalk, then C++. It's just easier in Lisp than in anything else. I continued to buy all of the significant books published, and eagerly read them, especially Peter Norvig's book, and Paul Graham's two wonderful books. I especially enjoyed Paul's books, because it felt like coming home after being away for so long. I hadn't really learned anything radically new from Paul's books, but they were so eloquently written and delightful to read. I'll pick them up every so often and just read at random and just enjoy the wonderful flow of words and ideas.

Now it's 2004. Having decided that I'm not seriously commited enough to Lisp, I've decided to step up my involvement. In the aerospace company I work for, I work on large scale satellite simulations as well as little support programs for different hardware projects. I am going to start using Lisp very seriously in both efforts. Being a hardware company, they care less about what stuff is written in, than in how long it will take and how little it will cost. Lisp will serve both efforts very well, I think.

The other effort I am doing is purchasing a Lisp Machine. A Symbolics XL1200. I don't have it yet, but should have it at the end of May 2004. One of my goals is to try and bring back the magic that the Lisp Machines had in terms of their incredibly wonderful programming environment. I figured I really couldn't do that without having a Lisp Machine.

The other effort is I've decided to start blogging about Lisp. I've lived my entire online life as a lurker, but not anymore. Right now, I'm just blathering on it, as I definitely don't have any street cred, other than having witnessed, if slightly afar, how Lisp has developed over the last 25 years. But, I want to document my efforts, both at work and with my Lisp Machine.

What led you to try Lisp?

Initially, interest in artificial intelligence, then a realization that it is a very powerful programming language that can tackle nearly any task thrown at it.

What other languages have you been using most?

In the past, I've programmed a very large Smalltalk system. I still do some work in Squeak or Cincom's Smalltalk. Alan Kay has always been my hero.

I consider myself to be a guru at C++, not because I like it, but because of a "keep your enemies close" philosophy.

I've recently had to use Perl. Perl so seriouslly offends all of my programming language esthetics, yet I marvel at the breadth and depth of CPAN. I recently had to write some hardware test code in Perl, so as my very first significant Perl program, I developed a compiler, an interpreter, and a debugger for a hardware test language. Although the syntax doesn't look like Lisp, the interpreter is very Lisp-ish inside. Suffice to say, that blew away some minds. I'm in the process of rewriting the hardware test language in Common Lisp to showcase how much smaller it would be in Lisp. Part of the Lisp advocacy campaign at work.

I know Java well enough that I don't tell people I know it.

How far have you gotten in your study of Lisp?

Well, it's truly been a life-long study with me. There's always something new I learn about it, although I learned the big picture ideas a long time ago.

What do you think of Lisp so far?

If God used a programming language, it would be Lisp.

Programming in Lisp is like playing with the primordial forces of the universe. It feels like lightning between your fingertips. No other language even feels close.