Hacker News Reader

Comment by buggythebug | Hacker News Reader

“LISP is worth learning for a different reason — the profound enlightenment experience you will have when you finally get it. That experience will make you a better programmer for the rest of your days, even if you never actually use LISP itself a lot.”

— http://www.catb.org/~esr/faqs/hacker-howto.html#skills1

Honestly, "just because I want to" sounds like a more compelling argument than talking about enlightenment. Mainly because the latter implies that people who don't know lisp are somehow unenlightened or lacking in some way - that comes across as really arrogant and it's clearly false since there are many successful and highly skilled programmers who don't know or care about lisp.

I kind of agree with the GP comment - nobody needs to learn lisp. The main reason to learn it is some personal interest or curiosity.

There is some enlightenment experience, when you get it. This it is when one figures out why Lisp is how it is: a language programmed in a data structure, programmable in itself. One can live without that enlightenment. One can also live without understanding recursion, but it was a small enlightenment for me when I understood recursion and how to use that in programming. There are a bunch of enlightenment experiences one can have. I had another one when I first read the Smalltalk books and later saw a Smalltalk system - I thought that was the end of programming, everything was done.

Alan Kay (the 'Alan Kay' of OOP and Smalltalk ) had an enlightenment experience with Lisp:

https://queue.acm.org/detail.cfm?id=1039523

"AK Yes, that was the big revelation to me when I was in graduate school—when I finally understood that the half page of code on the bottom of page 13 of the Lisp 1.5 manual was Lisp in itself. These were “Maxwell’s Equations of Software!” This is the whole world of programming in a few lines that I can put my hand over."

For background on this:

https://michaelnielsen.org/ddi/lisp-as-the-maxwells-equation...

> false since there are many successful and highly skilled programmers who don't know or care about lisp

Still they unknowingly may use a lot of things that were once pioneered in Lisp, like these: conditionals, functional programming, managed memory and garbage collection, evaluator/interpreters, read-eval-print-loops, image-based programming, ...

> when I finally understood that the half page of code on the bottom of page 13 of the Lisp 1.5 manual was Lisp in itself

Even histories of Lisp often don't emphasize this: Lisp was not, originally, invented as a programming language. It was a notation for describing the mathematics of computation. A variant of lambda calculus that could describe itself compactly.

The fact that eval could actually be implemented, was an accidental discovery. To quote McCarthy:

> Steve Russell said, look, why don't I program this eval ... and I said to him, ho, ho, you're confusing theory with practice, this eval is intended for reading, not for computing. But he went ahead and did it. That is, he compiled the eval in my paper into IBM 704 machine code, fixing bugs, and then advertised this as a Lisp interpreter, which it certainly was.

https://web.archive.org/web/20050405213907/http://www8.infor...

it was developed as a programming language from day one. It just had no such evaluator, until they came up with the idea and implemented it. There were Lisp programs already before that.

> Mainly because the latter implies that people who don't know lisp are somehow unenlightened or lacking in some way

But if you haven't learned Lisp you are absolutely lacking in some way as far as understanding programming languages. One obvious example is don't really understand what the url of this website is referring to (though I do suspect a huge number of today's HNers have never implemented the y-combinator).

To be clear, you can be an excellent software engineer and never touch or understand lisp, but if you are seriously interested in programming languages you really are missing a major part of picture if you don't know a lisp.

Anyone who is seriously interested in programming, beyond just creating software, absolutely must have experience in a lisp. It's completely fine if you aren't interested in programming other than solving a specific problem, but the idea that "nobody needs to learn lisp" is false.

What is it about lisp that's so important? Is it just the functional programming side? Metaprogramming?

The several important things about lisp that you won't find in other languages without learning lisp include (I'm considering all lisps here, including schemes):

- it's essentially a working implementation of the untyped lambda calculus, an essential model for thinking about computing outside of the Von Neumann architecture.

- It is a symbolic programming language which allows for unique ways of manipulating code as data. The only other programming language that I know of that offers symbolic programming to the same degree is Prolog (outside of computer algebra systems).

- The parens and prefix notation really are a powerful feature, despite being off putting to beginners. You are essentially programming an Abstract syntax tree. All programming language spend some of their time in this form, you just don't usually get to play with the code this way. This makes it incredibly easy to prototype ideas for languages and compilers in Lisps

The functional programming and meta-programming benefits naturally fall out of all of these. The reason metaprogramming is so powerful in Lisp is because of a combination of writing code in a tree structures and being a symbolic programming language.

The big picture reason that lisp is so great for people interested in better understanding programming is that it is a language that encourages you to write domain specific languages to solve your problems.

I'll be the first to admit that this is not great for real world software engineering, but if you want to understand programming better, it is essential.

Fantastic response, highly appreciated.

I've found more recently I want to solve problems with domain specific languages, so I'm totally on board with that. I would say that making dsls to solve problems is a great way to engineer software, as the code is usually testable and you don't need to modify it. Sort of where functional programming meets solid. Maybe not the best approach if you're in a startup though.

Sounds like you understand the pros and cons of DSLs: If you have a high functioning, disciplined software engineering team, a good DSL can smoke your competitors. If you don't have such a team, a DSL can smoke you.

> outside of the Von Neumann architecture

Lambda calculus is agnostic about stored program architectures. What it contrasts with is the Turing Machine model of universal computation.

This is a very common argument. It's true that Lispers sometimes come across as arrogant but that's because of the asymmetry inherent in evaluating programming language power. Paul Graham calls it the Blub Paradox.

http://www.paulgraham.com/avg.html

Another reason to learn Lisp is that it’s been around for over 6 decades. Algol 60 is the only other language from that era that I can think that still strongly influences contemporary practice. Since all of Algol’s descendants have felt the need to introduce their own syntactic novelties, contemporary Lisps feel considerably closer to the parent language.

The Lindy effect means that the odds are very good that if you do learn Lisp it will remain relevant for the rest of your life.

Any quote from ESR necessarily weakens your argument.

I.e., it is always weaker with the attribution than without.

Your comment is the very definition of an ad hominem.

Actually not, being precise.

Perhaps not, but need is not the only reason to learn; people also learn things because they are fun, pleasurable, interesting, challenging, entertaining, beautiful, revelatory, creative, inspiring etc. It'd be a dull life if we only learn what we need to know.

What's the point of this comment? If you don't care about Lisp, skip the thread.

Take a look at this - https://www.defmacro.org/ramblings/lisp.html, it may give you a different perspective :)

Need, maybe not, but want to yes some folks do.

Even though Common Lisp isn't used widely it never hurts to learn new things (especially when those things can be quite different than what you normally use).

Okay but everyone needs to think deeply about lisp.

No, I think most people don't need to think deeply about lisp. I'd even argue no one "needs" to think deeply about lisp.

Some people want to. It’s good for those people to have resources.

Come on, this is HN, you're not even allowed to think that here.

Wrong.

I'm a software engineer interested in getting more productive at my job, which namely involves the current React/typescript ecosystem. I have no interest in lower-level programming as a career path.

What benefits would learning Lisp provide me so that I "Need" to learn it?

Reading a couple chapters of SICP (https://xuanji.appspot.com/isicp/) or these articles might give you an idea: https://michaelnielsen.org/ddi/lisp-as-the-maxwells-equation... https://queue.acm.org/detail.cfm?id=1039523 https://www.defmacro.org/ramblings/lisp.html

I read the defmacro link and found it very interesting and cool; but I still feel as if I'm missing what makes this so earth-shattering? Do not get me wrong - it is insanely cool and wonderful to be able to modify lisp's syntax with lisp... but it just seems like that... it's cool. I don't see why this would be any different than defining a function like I normally do.

Sure, I can create an entirely new operator that becomes valid syntax, like `*` which creates an exponential operator. But why is this more productive than simply defining a "exponent()" function or something similar?

It seems also that tech debt would accrue incredibly fast as joining a lisp codebase would require learning almost an entirely new set of syntax. I'm sure I 'm missing something, but I can't see at all why I need to learn LISP. It's cool, neat, and wonderful... but that's about it from my understanding.

It's not easy to get the point across just by reading about it. Id honestly say you should just learn some lisp and implement something cool.

> I don't see why this would be any different than defining a function like I normally do.

Because with functions you don't define any new syntax or implement a DSL; you don't have access to the compiler during read, compilation, and run time. This allows you to easily extend the language: do you miss list comprehensions from Python? Add it yourself with a macro. Want to generate boilerplate code? Macro. Prolog compiler? Yes. Basically anything in this book: https://github.com/norvig/paip-lisp

> But why is this more productive than simply defining a "exponent()" function or something similar?

It's not just about defining a new operator, you can basically implement a DSL with C-like syntax if you want to: https://github.com/y2q-actionman/with-c-syntax

Some people recommend to learn some basics of Lisp to better understand JavaScript.

Though one of the core Lisp/Scheme books now has a JavaScript edition: https://mitpress.mit.edu/books/structure-and-interpretation-...

There’s a solid argument that JavaScript is a Lisp descendant.

No one needs to learn anything.

Need for... what? To survive? To get a job?

Need is always relative to a goal, so what you are saying there is there is no legitimate goal for which learning Lisp would be an appropriate step.

Indeed, I've been told countless times I don't "need" to learn some branch of math I was interested in (by mathematicians no less).

Also, I've been told I "can't avoid" some branch of algebra (I've never touched it since).

Those aren't necessarily incompatible. Nobody can avoid linear algebra, but almost nobody actually needs to use or know linear algebra. Heavily symbolic fields like math are probably not great examples though - different methods can be used to reach the same results because it's all fundamentally the same, just differing representations.

didn't godel prove something like the conclusions you can reach depend on your axioms?

Reply on news.ycombinator.com