That’s A Lisp Machine In Your Pocket

Computer languages have always advanced faster than computer hardware. Case in point: we’re just now getting CPU instructions for JavaScript floating point numbers. The 1970s and 80s wasn’t the garbage fire of JavaScript instructions in silicon, instead they were all about garbage collection. Lisp machines were CPUs designed to run Lisp efficiently. They were great, until the companies responsible realized you had to sell a product to stay in business. Combine an interesting architecture with rarity and historical interest, and you have a centerpiece of any retrocomputing enthusiasts collection. Yes, we all want a Lisp machine.

Now there’s an interesting project on CrowdSupply that will make that possible. It’s the MakerLisp Machine, a credit card-sized computer that runs bare-metal Lisp.

We first saw the MakerLisp Machine in its raw prototype form at VCF West last August, and it was in a very, very raw state. That was just a prototype, though, but the MakerLisp business card-sized computer still features the Zilog eZ80 running at 50MHz. The basic board includes a USB port for a serial connection and a microSD card slot for storage. It boots into a Lisp environment, and you don’t even have to use a NuBus card. We’re living in the future here.

Because this is a credit card-sized computer, there is of course an expansion board that breaks everything out, including the GPIOs. Being a Z80, you’re also going to get CP/M support, but the real story here is Lisp, in your pocket.

VCF West: Homebrew Lisp Machines And Injection Molded PDPs

Someone walks into the Vintage Computer Festival and asks, ‘what’s new?’. It’s a hilarious joke, but there is some truth to it. At this year’s Vintage Computer Festival West, the exhibit hall wasn’t just filled to the brim with ancient computers from the Before Time. There was new hardware. There was hardware that would give your Apple IIgs even more memory. There was new hardware that perfectly emulated 40-year-old functionality. There’s always something new at the Vintage Computer Festival.

Some of the more interesting projects are just coming off the assembly line. If you want a modern-day Lisp machine, that one won’t be assembled until next week, although there was a working prototype at VCF. If you want the greatest recreation of the most beautiful hardware, VCF has your back. Check out these amazing builds below.

Continue reading “VCF West: Homebrew Lisp Machines And Injection Molded PDPs”

MicroLisp With Matching Parens

Lisp is a supremely elegant programming language, but you won’t find it around much today. That’s a shame; in the 80s and 90s, all the cool kids were using Lisp machines, computers dedicated to the creation and interpretation of Lisp. While the AI renaissance of the 80s is dead, replaced with the machine learning fad of today, Lisp machines have gotten much smaller. Now, they’ll fit in your pocket, and they have parenthesis matching, to boot.

If this build looks familiar, you’re not wrong. A while back, we saw a similar pocket Lisp computer based around the ATMega328 microcontroller with 32k of Flash and 2k of RAM. That’s not a lot by any measure, and a much more suitable processor for an AVR-based pocket Lisp machine would be the big boys of the ATMega family.

The new and improved version of the Tiny Lisp Computer is built around the ATMega1284. If it’s capable enough to run a 3D printer, it should run Lisp very well. With more program space and more RAM come more features including matching parens when entering code, a serial monitor interface, and a program editor – basically a text editor on the chip.

Apart from the larger chip, the circuit remains relatively unchanged. The display is still an OLED that can be had for a few dollars from the usual online retailers, and the other bits of circuitry are still just a handful of resistors, caps, and wire. An off-the-shelf FTDI module (or whatever serial chip you desire) can be added to connect to a serial terminal, and support for a PS/2 keyboard rounds out the board.

Old LISP Language Used For New Raspberry Pi OS

On the scale of awesomeness, writing an operating system ranks near the top for software hackers and ranks just below writing a whole new language. [Lukas F. Hartmann] is reaching for the epic status with the Raspberry Pi operating system dubbed Interim. In an interesting mixture of old and new, it’s written in LISP!

LISP (LISt Processing) is the second oldest high-level programming language that received wide-spread usage. The only one older is FORTRAN (FORMula TRANslation), and that is just by one year. LISP is generally associated with artificial intelligence research but it also surfaced as a utilitarian scripting language in various applications like AutoCad. You may have also heard of a more recent dialect, Clojure, which has been receiving a lot of attention.

lisp-raspberry-pi-2-thumbThe source code, an image for the Pi 2, and directions for making it all work are available. [Lukas] also describes how to get a new OS up and running on a Pi.

[Lukas] isn’t the first to create this type of system. Back in the ’70s MIT worked on a Lisp machine that led to commercially available systems. If you have an old Apple IIe around you can make it into a Lisp Machine. You can also find LISP in the Internet of Things. And then there is [kremlint] who actually scored an original LISP Machine. We’ll have to keep an eye on his progress in restoring it to working condition.

Thanks for the tip, [krs013].

The Apple IIe Becomes A Lisp Machine

Way back in the late 1970s and early 1980s, a few very awesome people around MIT were working on Lisp machines. These computers were designed specifically to run Lisp as their main programming language. Around the same time, a few [Steves] in California were working on the Apple II, which would soon become one of the most popular computers of all time. The Apple II ran BASIC as its main programming language, fine for the time, but surely not as elegant as Lisp. It took more than 30 years, but [Alex] and [Martin] figured out a way to turn the lowly Apple IIe into a Lisp machine.

Developing Lisp for the Apple IIe was surprisingly easy for these guys – they simply wrote a Lisp interpreter in C and used a 6502 compiler to generate some machine code. The main problem of porting Lisp to an Apple II was simply getting the code onto the Apple. We’re assuming this would have been easier had the same project been attempted in the 80s.

To get their interpreter onto the Apple, they used the very awesome ADTPro library that allows data to be loaded onto an Apple II via the cassette port and a modern computer’s microphone and speaker jack. After a solid minute of loading analog data onto this digital dinosaur, [Alex] and [Martin] had a Lisp interpreter running on ancient yet elegant hardware.

The source for the 6502 Lisp interpreter can be found on the GitHub along with all the necessary tools to load it via a modern computer. That’ll give you all the ancient lambdas and parens you could ever want. One warning, though: backspace doesn’t exactly work, so be prepared for a lot of frustration.

You can check out the demo video below.

Continue reading “The Apple IIe Becomes A Lisp Machine”