Version 100 of the MIT Lisp Machine software recovered

A new version of very old software for a very old, but very important, computer

The LM-3 project has announced version 100, the last ever release of the system software for the MIT CADR Lisp Machine. So, both a new release and a very old one all at once.

News of this release came yesterday in a LinkedIn post by IBM's Eric Moore, who helped in the recovery effort. A more detailed post from the restoration project describes what the software is, and from where it was recovered.

Why does it matter? Well, this piece of software, and the machines it ran on, are markers, memorials of a significant battle. That battle was one stage in a war: a war of rival ways to make computers. "History is written by the victors," as Winston Churchill wasn't the first to say.

This war was, like most, between two rival camps. One side believed the right way to make computers was to write the best possible software in the best possible language, and if necessary, design special fancy computers to run that software. The other side believed the right way to make computers was to make software and hardware that was small, quick, easy, and simple, that did what most people needed at that point in time.

And again, like most wars, this one was long and vicious, with some dirty in-fighting on both sides. In the end, one side conclusively won, but it took long enough that the winners were mostly the descendants and relatives of the people who started fighting. Today, they don't even remember that there was a war at all, and the winning side ended up incorporating a lot of ideas and technologies from the losers. The end result was that the software wasn't small, or quick, or easy, or simple. The side that won forgot that they were fighting or that there was anyone to fight against.

When the winners forget they've won, or that they were fighting, that means that the losing side get to write some of the best summaries of the war. One famous account is a 1991 article called Lisp: Good News, Bad News, How to Win Big, which says:

The two philosophies are called The Right Thing and Worse is Better.

The Right Thing is the MIT/Stanford style of design. The other side?

Early Unix and C are examples of the use of this school of design, and I will call the use of this design strategy the New Jersey approach.

The article is only a few pages long, but if you don't have the time right now, there's a quite short, readable extract called Worse is Better.

In other words, one side started up at MIT and Stanford University, and they ended up designing a type of computer called a Lisp Machine. The other side built Unix and later special workstations to run Unix fast, which needed special processors designed to run compiled C code fast, known as RISC chips. Intel and AMD adapted some of the techniques and methods from RISC into the 486 and Pentium Pro, and AMD with the Opteron and x86-64, and as a result x86 PCs ended up driving RISC workstations off the market. Today, though, thanks to Apple Silicon Macs on the high end and RISC-V on the low end, RISC is enjoying a renaissance.

But x86, and RISC and CISC, and the whole family of languages based on Algol, including everything from BASIC to C++ to Pascal to Go, are basically factions on the winning side. The other side is largely forgotten now, but there are two big examples. One is Lisp, as created by the late great John McCarthy, and the Lisp Machines that entire Lisp-based operating systems ran on. The other is Smalltalk and the Xerox Alto.

MIT's first attempt to build a computer to run Lisp was a 1974 prototype called CONS, named after a Lisp keyword. In 1979, its more successful offspring was called CADR. The CADR computer went on to form the basis of the first products of two commercial Lisp Machine companies, LMI and Symbolics, the latter of whom had the first ever dot-com domain on the Internet. The founding of these companies, and the splitting of their software, started the career of a young hacker called Richard Stallman.

This is the blue touchpaper that started Emacs, the GNU Project, and so the Free Software movement. That project built tools such as GCC which were used to create Linux, which itself kicked off the Open Source movement.

What's been recovered is the final version of the system software of the MIT CADR Lisp Machine. The software was pulled off a backup tape in MIT's Tapes of Tech Square collection, or ToTS for short, but it's taken a decade of work to extract the data, clean it up, and get it running for the first time in 35 years. It's a big project.

And yes, it is possible to run the software today, at least on software emulators, such as usim, originally by Brad Parker. Its source and some history are on Github. ®


Thanks to reader Mike W for letting us know about this.

Similar topics


Send us news

Other stories you might like