A week or two ago, he threw me a curveball:

“How’s it going? Do you understand it all yet?”

“No. I’m making progress, though. I’m probably not going to have this down for a while. It’s a completely different way of thinking from the programming I normally do.”

“How is it different?”

I froze. He’s “Mr.-Fix-It,” and understands the rock quarry/asphault business inside and out. He’s very analytical, and it’s almost impossible to stump him with my favorite “Devil’s advocate” questions. However, aside from what I’ve told him, he just doesn’t know much about programming.

“Metaprogramming” and “first-class functions” wouldn’t have meant anything. “It lets you write programs faster” is a cop-out; he’s given me detailed explanations of his business. I wanted him to understand.

I was able to stammer out the fact that the language encourages breaking problems into smaller versions of the same problem (recursion), but that other programming languages also supported it.

I eventually told him that I hadn’t even thought about explaining the difference to a non-programmer.

“Well, if you’re ever able to come up with it, let me know.”

In college, I was a Computer Science tutor. I could explain most CS concepts that students saw in early C++ and Java courses to the layman on the street. However, I had nothing for explaining the difference between Lisp and C++ to him, which was a little scary. I spent some time dreaming up examples.

Functions

All models are wrong, but some are useful.

~George Box

Abstract math notions are boring to most people, so I try to relate programming concepts to real-world items.

A fast-food restaurant is a great example of a function: An order and some money is input, and you get cheeseburgers, fries, a soda, and your change. Whether a person likes math or not, they know what a function is: you put something in, you get something out.

The idea is easily extensible to Object Oriented programming: all Burger Kings have orders, and you can place a specific order at an instance of a Burger King. A Burger King “is-a” fast food restaraunt.

I will use this metaphor to explain why Lisp is different from the programming I usually do (C++/Java/C#/Python).

Lambdas

Any restaraunt probably has a few different ways to order food: over the phone, at a drive-through window, at a counter, through a waiter, etc. However, there might be unofficial ways to order food: Bill Gates might write a letter requesting a buffet with a few hundreds slipped in as proof. Someone might tell the owner on his way to work that he’d like him to come back with a pizza.

The owner can easily define new ways to order food through a restaraunt.

Lisp, through “lambdas”, lets a programmer define new functions as easily as a restaraunt owner can devise new ways to order. The inputs and outputs are the same, but making new functions can have very low overhead compared to other programming languages.

Brevity

“Wiz Wit”.

This is my usual order at Pat’s in Philly. With just two words, I get a cheesesteak with Cheez-Wiz and fried onions in less than 5 seconds. The system is designed to maximize the number of cheesesteaks output per hour: orders are short, and you usually get your cheesesteak before you’re done paying [and sometimes, before you're done speaking!]

This lesson can be applied to writing: It’s easier to convey a short thought. Unless you are Charles Dickens or Neal Stephenson, economy of language should be a goal.

Lisp’s syntax is very simple and short, so you can usually convey a thought in Lisp much quicker than you can convey a thought in most other programming languages.

Macros

An order can come in several different forms: it can be written, it can be gestured, it can be be spoken, and it can be implicit.

A lot of programming languages let you generalize the details of what an order can receive. Most orders are the same, so you can handle the contents the same even though the orders are different. In C++, you could even use “templates” to write code that generates code that handles this idea.

Lisp takes this idea all the way to its logical conclusion through “macros.” You can easily write functions that define orders. The difference is that you can easily do this at any scope!

If you notice that all fast food restaraunts are the same except for color scheme, specials, and slogans, it is easy to write functions that define new fast food chains. If you notice that your functions for defining fast food chains are similar to your functions for defining hardware chains, you can write functions that generate these producers.

Lisp lets you easily do this manufacturing on a level that is unimaginable with any other language. It may be possible, but nothing beats Lisp’s ease-of-use.

Self-Modifying Code

The metaphor breaks down here, and I won’t force it. However, the idea is simple when it is explained.

Most programming languages are designed to modify memory. They all store their information in memory, retrieve it, modify it, and write it to memory again.

Some programming languages try to hide the fact that they’re based on a memory-modification model, but they are extremely similar to languages that don’t hide it.

Lisp, however, is written to modify lists. Lisp is also written using lists, so a Lisp program can be programmed to modify itself.

Conclusion

This is just the tip of the iceberg! There are a lot more ideas that lay beneath the surface here, and you can bet that I’ll think about how to explain them to an educated adult. However, this should get someone with passing familiarity to programming to understand what makes Lisp stand out: ease-of-use and brevity.