Antique Programming Language Road Show
XKCD comic about Lisp
Cmm is derived from C, of course. What's interesting about C? Well, it's everywhere. C's ubiquitous, and even if you never write any of it, you use it. It's the lingua franca of programming. Part of the reason why is that it was written to be cross-platform. It's got a standard library, and so a C program written against that library should compile on multiple computers. Emphasis on should.
Ok, where'd this come from? Well, there was an experimental language called Self at the time. Been around since the late 80s. We're 25 years in the past at this point. This language is the progenitor of prototype-based objects. What's interesting about it? Well, besides introducing prototype-based programming, it uses this idea of an image - a virtual machine that writes out to disk, so it maintains its state. This lets you debug and hot-swap code - "on the fly" development. It's a little unwieldy to use, but has its advantages.
And that feature comes from an earlier language, Smalltalk. Here's an influential language. One of the first object-oriented languages. Everything's an object - even classes, so you can manipulate them like any other object. It's got message passing, which is how objects tell other objects what to do, but it's also special in Smalltalk. It's not just calling a function: each object takes its messages and decides how to process them. And Smalltalk came with a complete integrated development environment, one so integrated with the language that modern IDEs still don't touch it.
We don't use Smalltalk a lot today, but it birthed one of the biggest languages around, Java. Java's a lot less ambitious than Smalltalk in my opinion, but it's done well. Almost everything's an object - although there's no meta-classes. It's got a virtual machine, and that's important. It's not an image like Smalltalk's, so it's easier to use. You could write other languages that run on it, plus you can write the same VM for different platforms, so it's really cross-platform.
And so Java's other parent is C. It's got similar syntax, and it aims to be even more cross-platform.
Ok, back to Smalltalk. Its ideas are in a lot of languages.
Here's Erlang. Erlang took message passing and did something great with it. Messages can be passed between objects, even ones running remotely. And objects don't have to immediately reply. So this can be used for concurrent applications. Erlang can control many objects on multiple machines, all passing messages and responding when they feel like it. These are sometimes called actors. They act independently.
And that brings us to Scala, which takes its actors from Erlang. But look! It's on the Java Virtual Machine.
It's one of those languages we talked about that could run on there. So Java is a parent of it, too. Cool.
Back to Smalltalk.
Look what else it inspired: Ruby, one of my favorite languages. Everything's an object and it's got meta-classes. Every object can be manipulated at runtime. You can do some really cool, really spooky stuff. But what else is cool about Ruby. What's a first-class function? (Or higher-order function, you might call it.)
These first-class functions are in Ruby, like we said.
And in a bunch of other languages.
The hottest one right now is Clojure. Clojure looks like Lisp. It's a modern version of Lisp. It's got code as data, which is super-powerful. It's got first-class functions. And look! It runs on the Java Virtual Machine. Now we're back to Java. This doesn't just mean that it can use the same virtual machine to execute Clojure code. Nope - code in any language that runs on the Java Virtual Machine can be called from Clojure.
And from Java. And from Scala. That's amazing. That opens up libraries from all sorts of other languages.
So you can see how these languages are connected. C and Smalltalk beget Java. Java and Erlang beget Scala.
LISP begets everything, with some help from Smalltalk and C.
And look what we haven't mentioned. The point is that these older languages have features that made the features we have today. Some of them have features we still haven't replicated. Mining these languages is where we get ideas for new and amazing languages to help us in the future.
And that's my talk.