Common Lisp – thanks for the good times!

Well I’ve been meaning to start blogging for a while now. It’s mainly because everyone else is doing it, and although my contribution won’t be great, I can use it as a place to note down interesting articles and observations that I find. However, I had kept putting it off, because the postings are never quite good enough. But I’ve now realised that my writing style can only improve with practice, so here we go.
 
I was hoping to start by doing a series of quick observations on what I like about Common Lisp and why I think it is so great. My motivation for this is that, sadly, I’m doing less and less Common Lisp in my every day programming, and in the near future I’ll be moving to a company that doesn’t do any Lisp at all, so I’d like to take the opportunity to detail some of the good things about the language.
Common Lisp and me, we go back a long way. 
 
I first heard about Lisp in the early 1981-1982 in one of the PC magazines of the time, PC world I think it was, and then bought a copy to run on the BBC micro. The language was interesting as it was all about manipulating symbols and lists and seemed closely tied to interesting things like AI.
I took a year industrial placement as part of a sponsorship from the computer company ICL, and during this time I started learning C in my spare time. My first fun project in this new language, was to write a simple Lisp interpreter. This was nothing fancy. The reader was implemented in C and only dealt with lists and atoms that were symbols. The memory consisted of a few thousand cells, where a cell was a C union type that was either a symbol (with a name of up to 20 characters) or a cons cell, and a simple mark-and-sweep garbage collector that could free up some space. The neat thing was that I only had to implement a simple evaluator in C for EVAL/APPLY, and expose a few C implemented primitives into the Lisp language, CAR/CDR/CONS/IF/ATOM/EQ/SETQ/LAMBDA and I could write some quite interesting programs.
 
The idea of a language with a small number of built in features that could be built up into something much more powerful really appealed to me.
 
After university, where I studied for a degree in mathematics and then did a postgraduate diploma in Computer Science, I joined Harlequin Ltd , to work mainly on the LispWorks Common Lisp programming environment though with a year here and there spent working on an ML compiler and programming environment. When Harlequin got taken over by Global Graphics in 1999, I moved to Scientia Ltd, a software company who’s scheduling software was written in Common Lisp, and where I implemented exclusively in Common Lisp until about 2002, when C# and the CLR started becoming a focus.
 
Common Lisp has paid my bills for nearly 20 years and I’ve very grateful for that. As a language I think it’s very much the quiet one in the corner, the language with lots of clever ideas (such as first class functions, objects, internal domain specific languages via macros, reflection), a language that doesn’t push itself forward, but which contains a great deal of very deep ideas.
 
Advertisements
This entry was posted in Computers and Internet. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s