The Tinker Toy Mentality and the Beauty of Lisp
Tags: programming lisp
October 31st, 2022

LISP is a profound programming language. Unlike the variants of FORTRAN or ALGOL of the day, it was not meant for batch processing. You weren't supposed to write something, punch out the cards, and get the output from some mainframe room. LISP was interpreted and worked from a terminal. [0]

Where LISP became influential is that it encourage building things from scratch. Programming languages like COBOL have many keywords to memorize. The original LISP implementation only has seven(!) and didn't even do arithmetic. [1]

What a LISP programmer is encouraged to do is build all those fundamental building blocks. From scratch. That's a very different mentality. It means exploring the problem space and building the solution as you go instead of stitching together pre-built programs or libraries.

In practice, you do end up using libraries but the idea is still profound. Javascript, for instance, was highly influenced by Scheme, a LISP descendent. That's why Javascript has wacky prototyping rules: if an array can't do something for you then you can add it to the base class yourself (e.g. Array.prototype.__myNewFunction(...)) and always have it. Even in libraries you import.

The use of an interpreter also meant fast feedback. You didn't have to putz about waiting for a response. You got feedback immediately. That helps a lot in the problem-space-exploration phase. You can try something out quickly and see what comes back. Waiting until you can submit to the mainframe batch might take hours or even days.

I think the LISP mentality comes from things like Legos or Erector Sets. There are functionally no rules with these toys. Kids have no imposed constructions. They can create whatever world you wish. This encourages building everything in the lego set. The alternative is stiching together a mismash of mis-sized doll houses and GI Joe figures.

And what's more fun than building the world you inhabit?

_______

[0]: strictly speaking, LISP uses a REPL or Read-Evaluate-Print Loop. For the purposes of this piece, it's close enough to call it an interpreter.

[1]: for those curious how arithmetic works in LISP, you can look up Lambda Calculus and Church encodings.