What I Learned About AI by Programming in LISP at University

Back in university, I had to learn a language that most of my peers had never even heard of: LISP. It wasn’t on any job listings. It didn’t have flashy frameworks or a massive GitHub community.

But it had something else — it was the AI programming language of its time.

It was strange, elegant, and unlike anything I’d used before. And while I haven’t written production code in LISP since, what it taught me about thinking in AI terms still shapes how I approach programming today.

---

1. Why LISP was built for AI

---

LISP was created in 1958 by John McCarthy, in the early days of artificial intelligence. At the time, AI wasn’t about deep neural networks — it was about symbolic processing: representing knowledge as lists, manipulating logic, and reasoning over structured data.

What made LISP stand out was:

• Lists as the core data structure — perfect for representing knowledge bases and rules.

• Minimal, consistent syntax — everything is an S-expression (operator arguments...).

• Dynamic evaluation — code could generate and run new code at runtime.

Example: A simple fact and query in LISP

(setq facts '((likes alice bob)
              (likes bob carol)
              (likes carol alice)))

(defun likes? (x y)
  (member (list 'likes x y) facts))

(print (likes? 'alice 'bob))  ; T (true)

For AI researchers, this was gold: you could model relationships and reason about them without fighting the language.

2. Core concepts that made LISP unique

---

Homoiconicity

Code and data share the same structure. This means you can write programs that manipulate other programs — a concept still rare in mainstream languages.

First-class functions

Functions are just another type of data. You can pass them around, store them in variables, and call them dynamically.

(defun square (x) (* x x))
(setq math-fn square)
(funcall math-fn 5) ; 25

Macros and meta-programming

LISP lets you transform code before it runs. This ability to extend the language from within is one reason it’s still beloved by language designers.

---

3. LISP’s influence on modern AI programming

---

Even if you’ve never written a line of LISP, you’ve used its ideas:

• Python’s list comprehensions and first-class functions? Influenced by LISP.

• JavaScript’s map, filter, and reduce? That’s pure LISP heritage.

• Functional languages like Clojure and Haskell carry LISP’s DNA in their emphasis on immutability and composition.

Example: LISP vs Python for mapping a function

(mapcar #'(lambda (x) (* x 2)) '(1 2 3))  ; (2 4 6)

list(map(lambda x: x * 2, [1, 2, 3]))     # [2, 4, 6]

---

4. Could LISP’s philosophy help us program LLMs?

---

Modern AI development is increasingly about meta-programming — orchestrating multiple models, generating code on the fly, adapting logic in real time.

This is exactly what LISP was good at:

• Self-modifying code.

• Flexible data/code representation.

• Extensible syntax.

It’s not hard to imagine a LISP-like DSL (Domain-Specific Language) designed specifically for prompting and structuring LLM behavior — something minimal, verifiable, and expressive.

---

5. Hands-on: A tiny LISP rule engine

---

Here’s a basic example:

(setq rules '((if (likes ?x ?y) (friends ?x ?y))
              (if (friends ?x ?y) (trusts ?x ?y))))

(defun apply-rule (rule facts)
  ;; Naive application: check head, add tail if matched
  ;; This is extremely simplified for demo purposes
  facts)

(setq facts '((likes alice bob)))
(print (apply-rule '(if (likes ?x ?y) (friends ?x ?y)) facts))

In Python, you’d probably wrap this in classes and methods — but LISP’s minimalism makes the transformation logic explicit and easy to extend.

---

6. LISP’s quiet influence

---

LISP is not “coming back” in the mainstream sense. But its ideas — code as data, first-class functions, meta-programming — are more relevant than ever.

If we end up creating programming languages for AI to use, I wouldn’t be surprised if they look a lot like LISP under the hood.