by smlckz on 2/17/21, 4:02 AM with 13 comments
by mikelevins on 2/17/21, 1:34 PM
Some people learn it and it becomes important in their lives. I'm one of those. Others don't seem to get much out of it.
If you're someone who doesn't get much out of it, then you won't lose much if you don't learn it.
If, on the other hand, you're one of those that it can enrich, then you'll be missing out on a lot if you don't learn it.
There are a few ways that Lisp can be important.
One way is by being a small set of concepts with large ramifications. Alan Kay (the creator of Smalltalk) famously described it as "the Maxwell's Equations of software", meaning that the short page of pseudocode that defines Lisp also defines all of computation.
In case you want to know what short page he was talking about, it's a page from the Lisp 1.5 manual, which you can find here:
https://michaelnielsen.org/ddi/wp-content/uploads/2012/04/Li...
What Kay meant, as he has explained before, is that once you understand that page, you understand the foundations of computation, and can use them to build anything you need.
Realizing that all of computation is embodied in a small set of concepts that can be written down on less than one page and understood in a brief moment is an empowering realization. It means that there is a small toolkit that offers you unlimited expressive power. It means that a set of tools you can hold in your hands offers you the power to build worlds.
Another way Lisp can enrich you is by providing a programming system of unsurpassed flexibility and interactivity. Old-fashioned Lisps (and Smalltalks) are designed to redefine themselves as they run, enabling you to build up structures of arbitrary complexity by interacting with them, and to interrogate, comprehend, and modify those structures while they continue to run.
Different kinds of programming systems provide different levels of support for interactivity and livecoding. Old-fashioned Lisp and Smalltalk systems are at the extremely interactive end of the spectrum, and are worth learning just to see what that looks like. Not everyone prefers extremely interactive programming systems, but, again, if you're someone who does, then you'll be missing out if you don't experience what it's like to redefine some part of a running program and watch it adapt in real time to your new definitions.
Another way Lisp can enrich you is by illustrating what happens when you make it really really easy to manipulate code.
Most programming languages' source code is made of text strings. Lisp code isn't. Lisp code is made of s-expressions--that is, lists and atoms. Yes, you typically write it in the form of text strings, but the text strings are not Lisp code; they are one possible serialization of Lisp code. Others are possible.
(Historically, some Lisps have offered editors that bypass text strings and work directly on s-expressions in memory. One such editor is INTERLISP's S-Edit.)
When you give your text to Lisp, it starts by deserializing it into actual Lisp source code. Because the source code is made of lists and atoms, which are standard, first-class Lisp data structures, the source code is really really easy to operate on. You can walk its structure, take it apart, analyze it, put it back together, transform it, rewrite it, and so on, all using standard, built-in Lisp functions.
A C compiler does all of these sorts of things in the process of compiling C code, but it doesn't typically expose its internal data structures or the functions that operate on them to you, the programmer. Lisp uses standard, built-in data structures to represent its source code--data structures that are available to you as a user. It uses standard, built-in procedures to operate on the code--procedures that are part of the standard API of the language. Everything it uses to process and compile source code, you can use for your own purposes just as easily.
That circumstance makes it unusually easy to write a wide variety of coding tools in Lisp, including code walkers, analyzers, macro processors, editors, interpreters and compilers, optimizers, code-coverage tools, cross-referencers, and so on. It can be inspiring to work with rich Lisp development environments and see what people build when it's so easy to work with source code. It's one of the reasons that so many experiments in language design have emerged from Lisp. It's also a reason that Lisp programmers come to like the idiosyncratic parenthesized syntax that seems to unappealing at first. That syntax--those s-expressions--are part of what makes it so easy to work with Lisp code.
If your reaction is, "so what?" then Lisp may not be for you. If you're intrigued, then I recommend you learn more about Lisp. You might find that it enriches your life.
I'd say the main hazard is discovering that you really love it, and that it's relatively hard to find employers who will pay you to work with it all day. On the other hand, if you do happen to love Lisp, and you do find a job working with it, it's worth the wait.
by kettunen on 2/17/21, 7:05 AM
Best reason to learn it is just if you have some curiosity towards it, just go and learn it. Especially if Lisp might be something out of your comfort zone this could give lots of different ideas on your other work even though I might not use Lisp ever again. To me, Lisp tends to be my first go to language when I want to write something quickly and prototype something, which is mainly due to built-in interactivity in the language that allows this.
To me, what makes Lisp great is the fact how it generalizes the interaction between you and the machine. Basically everything that we as programmers do is to interact with data (programs being data for compilers), which Lisp makes almost indistinguishable from the code itself. This kind of approach with S-expressions makes data representation very easy and clean which the reduces your cognitive overhead since you don't need think about how the data is structured, since S-expressions itself provide an minimal syntax for it.
by thesuperbigfrog on 2/17/21, 5:51 AM
by notoriousarun on 2/17/21, 7:06 AM
> Have you read SICP? https://www.amazon.com/Structure-Interpretation-Computer-Pro...
by fractallyte on 2/17/21, 12:51 PM
https://mitpress.mit.edu/books/little-lisper-trade-edition
https://mitpress.mit.edu/books/little-schemer-fourth-edition
Exercises in recursion, not so easy to do in other languages, and they really expand your thinking.
by GianFabien on 2/17/21, 6:07 AM
by bjoli on 2/17/21, 6:40 AM
Some other languages also had this effect. F# and factor are the most notable. Guile scheme is the only one I use daily though.
by rzzzwilson on 2/17/21, 5:49 AM
by kazinator on 2/17/21, 5:28 PM
by jimmyvalmer on 2/17/21, 5:13 AM
