technologybriefs
Saved
Software · Tech history

Lisp (programming language)

John McCarthy · 1958

Lisp isn’t about AI—it’s about making programs readable to other programs.

Worth your time?4.5/5Yes.Study the whole thing.What works, what does not, who it is for ↓
11:03in productionCh. 1 · A notation, not a language/ 11:03 · ceiling 15 min
6 chapters · 11:03Ceiling 15:00

The brief is written and checked. The video joins this page when it is cut.6 chapters · 1 min read · 11:03 planned

Read the brief

Lisp is the first language to treat code as data—and the first to prove that a small set of primitives plus eval suffices for universal computation. Its cost is runtime overhead; its payoff is programmable programmability.

SoftwareTech historyProgrammingComputingAbstractionProgramming across the network →
Chapters & takeaways6
  1. 1:04
    A notation, not a language

    Lisp was designed as notation—not syntax—so mathematicians could write programs like equations.

  2. 2:10
    Hardware before theory

    The first Lisp ran on an IBM 704 using punched cards, with eval hand-coded in machine language.

  3. 3:12
    Self-compiling code

    The 1962 compiler—written in Lisp—proved the language could build faster versions of itself.

  4. 4:30
    Memory management, not magic

    Garbage collection arrived before 1962, but as a separate routine—not a seamless part of the runtime.

  5. 6:05
    Code that reads code

    Homoiconicity made Lisp the first language where code could reliably generate, inspect, and modify other code.

  6. 7:26
    Minimalism with consequences

    Lisp established that Turing completeness could emerge from three operators and eval—not from hardware features or complex syntax.

Worth your time?

Yes. Study the whole thing.

4.5/ 5
What works
  • homoiconicity
  • runtime metaprogramming
  • self-hosting compilation
What does not
  • solve real-time control problems
  • enable efficient numerical computation
  • scale to concurrent systems without extension
Study it if
  • language designers
  • symbolic AI researchers
  • compiler engineers
Skip it if
  • embedded systems developers
  • web application teams
  • data pipeline engineers
The written brief1 min read

What it is and the problem it solves

Lisp is a practical mathematical notation for computer programs. It solves the problem of expressing symbolic computation—like algebraic manipulation or theorem proving—in a form that machines can evaluate directly.

How it works

Lisp works by treating code as data: programs are written as nested lists, and the eval function—implemented in machine code on the IBM 704—interprets those lists directly. Homoiconicity means the language’s syntax is its own data structure.

What works

The eval function works. Implemented in machine code on the IBM 704, it produced a working interpreter from day one. Homoiconicity works: code is data, enabling self-modifying programs without syntactic indirection.

What does not

Lisp does not solve performance bottlenecks by default. The interpreter was slow until the 1962 compiler delivered a 40-fold speedup. Garbage collection existed before 1962 but was not yet integrated into a robust, automatic runtime.

What it changes

Lisp changes how programs are built: it enables metaprogramming at runtime, lets code inspect and rewrite itself, and establishes that a language can be defined entirely in terms of a few primitives plus eval.

Is it worth your time

Yes—if you work with symbolic computation, program transformation, or language design. Its mechanisms remain legible and reusable, but its runtime costs and niche abstraction limit broad applicability today.

Same field · Software4 of 114
11:20
FortranJohn Backus · 1957Fortran is the first high-level programming language to achieve broad use. It succeeded not by abstracting away hardware, but by proving abstraction could coexist with assembly-level performance — specifically for numeric computation on the IBM 704. Its compiler introduced the basic block and Monte Carlo–driven memory layout, establishing techniques that remain standard. It made computing accessible to scientists — but only those doing number-crunching, and only on IBM hardware.
8:34
Objective-C1984Objective-C is a strict superset of C that introduces Smalltalk-style message passing as its core object-oriented mechanism. It was developed by Brad Cox and Tom Love in the early 1980s and first formally described in Cox’s 1986 book. Its design centers on runtime message resolution — not compile-time method binding — enabling dynamic typing, delegation, and forwarding. Syntax for non-object features matches C exactly; object features use Smalltalk-inspired messaging syntax. The language was standardized informally through that 1986 publication and later implemented in GCC and Clang.
9:41
BASICJohn Kemeny and Thomas Kurtz · 1964BASIC is a pedagogical tool, not a general-purpose language. It succeeded by narrowing scope — to Dartmouth, to undergraduates, to time-shared interaction, to FORTRAN II’s grammar stripped of complexity. Its value lies in what it excluded.
10:01
Python (programming language)Guido van Rossum · 1991Python is a dynamically typed, whitespace-delimited programming language conceived by Guido van Rossum in December 1989 as a successor to ABC. Its first release was Python 0.9.0 in 1991. It introduced a strict visual grammar for code blocks, paired dynamic typing with reference counting and cycle detection for memory management, and codified its philosophy in PEP 20. Python 3.0 (2008) broke backward compatibility. Optional static typing arrived in 3.5. Van Rossum named it after Monty Python's Flying Circus and wrote the first interpreter as a Christmas holiday project.
Up next in Technology

LoRaWAN

· 9:26

LoRaWAN’s new TR013 standard doesn’t fix congestion—it just makes collisions slightly less random.

Next brief →Back to Software
9:26