I, Glenn Ehrlich, do solemnly offer these my responses to The Road to Lisp Survey:
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.
Please delete all but one of these cross-referencing tags: Switch Date 2004
RtL AI | RtL Language Curiosity | RtL SICP |