The Rebirth of Lisp

January 31, 2011

In the 1980’s I was very interested in learning about “Artificial Intelligence” software. So, in 1987, I purchased Digitalk’s Smalltalk/V (for DOS) and muLisp (also for DOS) and started learning both Smalltalk and Lisp at the same time.

As for the question “Which is better – Smalltalk or Lisp?” my answer is that if you asked a carpenter “Which is the better tool – a saw or a hammer?” he would probably tell you that it is a stupid question – it depends upon what problem you are trying to solve. So I find that “language wars” are a complete waste of time; I have used dozens of different languages since I started programming in 1969 and each is useful in its own way.

Lisp and Smalltalk have had similar histories in the marketplace.

1) At first there were great expectations:
There were numerous “Lisp Machines” in the late 1980’s. Symbolics and Texas Instruments sometimes ran full page color advertisements for their Lisp machines.
Parc Place Systems became a $50 million Smalltalk company. IBM developed VisualAge Smalltalk with plans to run Smalltalk across the full range of their hardware

2) Then everything fell apart:
People began talking about an “AI winter” in the early 1990’s and Lisp started a steep decline. Smalltalk seemed to be doing well until about 1995 when IBM discovered Java. After that, Smalltalk started its own decline.
The reasons for the decline of both probably are mostly due to the high prices charged by the language vendors – people learned to solve problems with cheaper solutions (eg Java running on a PC or Unix workstation).

3) The languages were almost forgotten:
There were still groups of enthusiasts for both Lisp and Smalltalk. But, with very rare exceptions, nobody was proposing Lisp or Smalltalk for new commercial applications.

4) Clojure Lisp becomes popular
Clojure Lisp has very active user forums and several new books published within the past two years.
Here is what I think happend:
— the “ideas” behind Lisp — that code can be easily handled as data — are just as useful today as when John McCarthy proposed them in 1958. That is, the need for Lisp (or something like Lisp) has never disappeared
— Clojure simplified the overly complex Common Lisp syntax and introduced some very useful formats for data that are very similar to Python
— most importantly, Clojure runs on the Java Virtual Machine (JVM) which is available for nearly any environment. *And* that means it can use all of the Java libraries that are available.
— so, to do a Clojure Lisp project today, you can simply tell your boss that it is really a Java (buzzword compliant) project since it runs on the JVM and “we just use Clojure for scripting”

5) Smalltalk should be popular today

The “big idea” behind Smalltalk is messaging – work gets done by objects sending “messages” to other objects.
Here is a summary by Dan Ingalls (the man who wrote both Smalltalk-80 and Squeak):

Messages: Computing should be viewed as an intrinsic capability of objects that can be uniformly invoked by sending messages.

or you can listen to Alan Kay (who invented Smalltalk and created the term “object oriented”) in his speech “The Computer Revolution Hasn’t Happened Yet

Both Alan Kay and Dan Ingalls emphasis that the idea behind Smalltalk is “messaging” between objects. They don’t talk about “IDE’s” or “debuggers” or “image files” – those are implementation details. They talk about “messages”.

People today are spending most of their time with computers in a “messaging environment” whether it is a browser, an iPad, or a smart phone.

It seems obvious to me that the ideal language for a “messaging” environment would be a “message-based” language (ie Smalltalk) which was designed from the beginning to be easy for humans to use.

That is what Silver Smalltalk is all about.

Advertisements

2 Responses to “The Rebirth of Lisp”

  1. Canol Says:

    Hi, I often hear that the key feature of Smalltalk is messaging. What is meant by this? Is messaging different then, for example, calling a function or method? I’m not sure but I also heard that it is even more important than being oo. So, is it possible to apply messaging to a non-oo language?

    • Peter Fisk Says:

      Messaging is more flexible than method calls.

      For example, if there is an object named “X”, I could send it a message ‘hello’ like this in Smalltalk –> X hello.

      X may respond something like “hello to you also” if it understands the message.
      Or, it may respond “I don’t understand ‘hello'” if it doesn’t understand.

      Smalltalk has all kinds of conventions about what you can ask an object.
      For example, every object should at least tell you its class.
      So if you send the message ‘class’ to X, you are guaranteed to get a reasonable response:

      X class ==> an Integer (or String, or Blob, or some other class name)

      Objects can also decide what to do when they receive a message that they don’t understand – they may forward the message to another object for example.

      And you can also ask an object to tell you what messages it does understand.

      Why this is important is that in a network you will not always know what other nodes on the network are capable of.
      With messaging you can start to build a conversation by starting with only very simple messages.

      In general RPC strategies you often just get a response that the call failed if you use the wrong parameters.

      Here is an explanation of message passing:

      “Almost all computation in Smalltalk happens via the sending of messages. The only way to invoke a method is to send a message—which necessarily involves dynamic binding (by name) of message to method at runtime (and never at compile time.) The internals of an object are not externally accessible, ever—the only way to access or modify an object’s internal state is to send it a message. So function and data abstraction are both complete and universal. Pervasive message passing is Smalltalk’s most important feature—a point that was lost on most of those who have tried to emulate Smalltalk when designing other programming languages.”


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

%d bloggers like this: