Hofstadter on Lisp (1983)

I just love his writing so much -- he captures what I felt when I discovered Lisp. As a kid learning programming in the 80s, I had already done some BASIC, Fortran, Pascal and COBOL in high school and early college. There were differences, of course, but they had some fundamental commonality.

At UC Berkeley, however, the first computer science class was taught in Scheme (a dialect of Lisp)...and it absolutely blew me away. Hofstadter is right: it feels the closest to math (reminding me a ton of my math theory classes). It was the first beautiful language I discovered.

(edit: I forgot to paste in the quote I loved!)

"...Lisp and Algol, are built around a kernel that seems as natural as a branch of mathematics. The kernel of Lisp has a crystalline purity that not only appeals to the esthetic sense, but also makes Lisp a far more flexible language than most others."

Have you tried Haskell? It feels much closer to math to me. Definitions, not procedures. It even looks like math.

No! After about 10 years of writing software professionally, I moved over to product management, and my time spent coding decreased drastically (in the last 15 years, only some Python to show my kids a thing or two).

But I'd love to try! Maybe I'll take an online class for fun.

At the risk of diverging off from the original post, I also think that calling it "math" might make things a bit murky (and this is coming from someone who wanted to be algebraic topologist!)

It _is_ an elegant and minimal expression of a style of programming that is ubiquitous among dynamically-typed, garbage-collected languages. And it's a "theory" in the sense that it seems complete, and that you can think of ways to solve problems into Scheme and translate that into other dynamically-typed languages and still end with an elegant solution. Emphasis on the elegant (since minimal, wart-free, consistent and orthogonal, etc.).

Scheme was a simplification and a "cleaning up" compared to conventional Lisps of the time (lexical scoping, single shared namespace for functions and variables etc.)

I can't recommend it highly enough. You're already familiar with laziness from Lisp, but purity is another head-trip. It made me a better programmer in any language, and even a better software architect before I've written a line of code.

And algebraic data types make it possible to make your code conform to reality in ways that classes can't. Once you're exposed to them, it's very much like learning about addition after having been able to multiply for your whole life. (In fact that's more than a metaphor -- it's what's happening, in a category theoretic sense.)

Haskell has other cool stuff too -- lenses, effect systems, recursion schemes, searching for functions based on their type signatures, really it's a very long list -- but I think laziness, purity and ADTs are the ones that really changed my brain for the better.

Have you tried Coalton? It's a Common Lisp library that adds Haskell-esque (or near-Haskell) type wonders, and which smoothly interoperates with your Common Lisp code.

Your comment is great though, consider me convinced. I've done a bit of messing with Lisp, but really would like to try write something in Haskell, or slog through a book or two, some day.

Personal anecdote: I got a lot more out of lisp that stuck with me than Haskell. Occasionally I say "oh this is a monad" or think about a type signature, but that's about it.

Damn that was a really good pitch. I think I’m too dumb to learn Haskell though lol. I’m struggling enough with immutability in clojure!!

Haskell makes it easier, because immutability comes more natural there.

Maybe Haskell is more like Bourbaki math, whereas Lisp is more like Russian style maths (ala Vladimir Arnold). I prefer the latter tbh, and I come to programming from a maths background. We are all different. Lisp to me is yet to be surpassed in terms of ergonomics when transfering my thoughts into computer code.

> I think I’m too dumb to learn Haskell though lol.

I felt the same way, a lot of people feel that way.

This is in part because FP is difficult, typed FP is difficult, and Haskell is difficult. All by themselves. They do get easier once you intuit more and more FP in general I'd say.

Then there's also a phenomena described in the Haskell Pyramid[0] where it sometimes appears more difficult than it really is.

Like a lot of things, actually building something gets you a long way, esp. with the advent of chat AIs as it's comparatively easy to go back an fourth and learn little by little.

[0] https://patrickmn.com/software/the-haskell-pyramid/

Do you ever code just for fun?

Interesting. How would you characterise each (Bourbaki and Russian-style)?

As someone with some experience in Haskell (although not an expert by any means): Haskell and some of its concepts are foreign to many people, but I think that it is actually easier to program in Haskell than in many other languages I know. At least for my ADHD brain ;)

This impression can be changed somehow by the fact that Haskell and its community has two faces: There is the friendly, "stuff-just-works" and "oh-nice-look-at-these-easy-to-understand-and-usefull-abstractions" pragmatic Haskell that uses the vanilla Language without many extensions, and being written by people that solve some real-world problem by programming.

Then there is the hardcore academic crowd - in my experience, very friendly, but heavily into mathematics, types and program language theory. They make use of the fact that Haskell is also a research language with many extensions that are someones PhD thesis. Which might also be the only documentation for that particular extension if you are unlucky. However, you can always ask - the community is rather on the side of oversharing information than the opposite.

Rust fills that gaping hole in my heart that Haskell opened a bit - not completely, but when it comes to $dayjob type of work, it feels somewhat similar (fight the compiler, but "when it compiles, it runs").

I'm not sure what you mean by characterize. Bourbaki-style is extremely rigorous, to the point of missing the forest for the trees. The so-called Russian style (there are plenty of non-Russian examples) is more driven toward building intuition and getting to the essence of the matter. In this way lisp is more similar to the latter because it facilitates prototype (essence) development. In Haskell you pretty much have to do a captcha equivalent of programming just to prove to the compiler you are allowed to do io :)

That is a very interesting perspective of Haskell vs. Lisp., I don't come to programming from a math background, but I am Russian. Maybe that's why I always preferred Lisp-style instead of Haskell :)

I mean what it usually means: to list distinguishing features, or at least give (necessary and sufficient?) criteria for membership of some class.

Whilst I'm vaguely familiar with Bourbaki and how it strongly influenced the way mathematics is written today, I hadn't come across that dichotomy before. Your answer was what I was looking for!

Maybe, I also see lisp as the slavic language of programming :)

I should have listed immutability as another thing that changed my brain for the better.

Most obviously (from the linguistic's point) Lisp is Latin of programming languages. Has the similar historical importance; similar foundational role; continued relevance, elegance and power; evokes similar reactions from neophytes.

From the point of Biology: Lisp is a prokaryotic cell - simple, fundamental, highly adaptable.

In Chemistry: Lisp is carbon - versatile, forms the basis of complex structures.

In Geology: Lisp is like bedrock - foundational and supporting diverse structures above it.

In Astronomy: Lisp is a primordial star - ancient, influential, contributing to the formation of newer elements.

In Physics: Lisp is a quark - the basis of all baryonic matter.

</nerd-rant>

I would say in physics, lisp is like the formulation of physical laws in terms of lagrangians and hamiltonians - ie it is the least action principle

Here's a hard one. In political science Lisp would be like...?

Juche ?

The difference is that it's not the case that a majority of chemists are ignorant about carbon, or geologists about bedrock, or astronomers about primordial stars or physicists about quarks.

Lisp is like an entire branch of computer science, about which a lot of people in computer science are ignorant.

Allow me to gently disagree. Most computer scientists I know are not ignorant about Lisp. Some scholars consider computer science a branch of mathematics, while others avoid such broad generalizations, as modern computer science has evolved into a broader discipline.

It's just that the majority of modern programmers are not concerned with mathematics, and that's perfectly acceptable. Mathematics itself has so many different levels that even mathematicians themselves are not always certain if they are indeed practicing mathematics.

You may be conflating programmers and computer scientists, but this could also be a perfect case of selection bias, where both of us are simultaneously correct and incorrect in our assertions.