My own programming evolution was Locomotive BASIC -> Z80 -> Pascal -> C -> C# -> Ruby / Coffeescript -> Lisp. Only towards the end of that evolution have I been using machines capable of running practical Lisp implementations; the machine I learned to program on had 42kB free RAM!

Also, note that as the hardware has progressed, more and more features that were once solely the domain of Lisp have been assimilated into ‘mainstream’ languages.

I’d argue that it was the triumph of microcomputers that killed Lisp as a mainstream language; when you’re dealing with an 8 bit CPU and many orders of magnitude less memory and storage than a cheap candybar phone, you’re not going to be able to run Emacs and Common Lisp ;)

You walk into the room, with your pencil in your hand,
…..
Because something is happening here
But you don’t know what it is
Do you, Mister Jones ?”

Move on folks, nothing to see here. To the author, well, everybody uses powerpoint that doesnt mean its any good.

regards
sam

=== Introduction ===
I’m a software architect for real-time assembly machines, I’ve been through many many languages in my career, and for my company I choose languages by popularity : because I can find some developers on the job market.

=== Chapter 1: Me and LISP ===
Yes, I choose the main stream languages for my company, but NO I do not like them more than LISP. In fact I personally prefer LISP over any other languages I’ve ever used professionally, and here is why, in a single word: Homoiconicity
http://en.wikipedia.org/wiki/Homoiconicity

So where do I use LISP? not at work as I said, but for research projects on evolutionary algorithms. Homoiconicity is way more powerful that .NET’s Reflection for instance, because it allows both self-examination and self-modification and is so natural in LISP syntax.

Also LISP, by it’s syntax, allows you to extend the language in respect to the core language syntax. This allows you to extend the language in a natural manner. (please look at my programming challenge in this post).

Do I earn money with LISP : no.
Do I think LISP is the way programming languages should have evolve : yes.
Do I think LISP is like quantum mechanics : yes, because some geniuses have found a revolutionary approach but it took them 4 decades to have the rest of the world understanding it’s core power.
Do I give an advantage to joob seekers who like LISP: yes, because they’re way smarter in their resulting Java or C# architecture.

=== Chapter 2: Programming Challenge ===
I believe that language extension is very important, and that the resulting extension should respect the language syntax.

So, here is my challenge: Extend a mainstream language (Java, C++, C# or PHP) to have an IF working with 3 states (useful in signal processing): TRUE, UNKNOWN, FALSE
But you must respect the core language syntax so that programmer don’t get confused. So with these mainstream language the 3 state IF call should look something like:
if3 (my-3-state-variable) {
//my code executed the TRUE
…
} unknown {
//my code executed the UNKNOWN
…
} else {
//my code executed the FALSE
…
}

=== Chapter 3: Challenge solution in LISP ===
Here is a standard IF call in LISP:
(if my-boolean-variable
‘(print ‘true)
‘(print ‘false))

Here is the 3 states IF definition in LISP (the solution):
(defmacro if3 (test t-case nil-case ?-case)
‘(case ,test
((nil) ,nil-case)
(? ,?-case)
(t ,t-case)))

here is the new IF3 call:
(if3 my-3-state-variable
‘(print ‘true)
‘(print ‘unknown)
‘(print ‘false))
You can see that it looks like the standard IF syntax, the language has been extended in respect to the original syntax.

I’m waiting for the mainstream languages solutions for IF3… in respect to the standard IF syntax or their originating languages.

=== Chapter 4: More language extension ===
Now, please imagine yourself extending the C# language to add the LINQ feature, how would you have performed this in C# 2.0 ??? for lispers this is strait forward (“Practical Common Lisp” Chapter 3).

This is the reason of LISP’s longevity: user language extension.
The price for longevity: parenthesis, okay I’ll pay!

=== Conclusion ===
Please, do us a favour, read at least Paul Grahm’s “On Lisp” or Peter Seibel’s “Practical Common Lisp” before criticising the probably most elegant language syntax and core set of features (not libraries, just the naked language).

“If LISP is so amazing, and if LISP has first mover advantage over anything the average programmer has ever heard of, why is it so resoundingly a bit player?”

That rings true to me.