To add further clarification, Paul Graham was one of the founders of YC and built Hacker News in a LISP dialect named Arc (See https://news.ycombinator.com/item?id=9270478 for more information).
...and wrote a couple of classical common lisp books. He has obviously contributed a lot to HN’s culture.
I personally found out about both reddit and HN by means of deeping further into lisp in the internet, beyond his “ANSI Common Lisp” book which I used in university.
Lisp is a very simple thing that allows you to make very complicated stuff. You can write your own interpreter and then write a program to solve your problem with reasonable effort.
If that bothers you, it could be worse: we could be addicted to FORTH! :D
Really though, the majority of comments I have seen in every Lisp thread is about Lisp not giving you any advantages over the mainstream languages for "real world business apps", a common example mentioned is reddit switching to Python from Lisp. Also that stuff like the language ecosystem is more important.
It would help to get a better idea of your current context with regards to programming. What’s your experience so far? That will help frame the discussion.
I'm not sure there's anything now that 'LISP' could refer to beyond the family of languages, of which Clojure, Common Lisp, and even Scheme are all 'modern' dialects.
- you can make your own domain specific language in Lisp (e.g. imagine that you want to create a custom 'for' statement, or some kind of a new pattern matching operator)
- you can easily write programs that edit themselves
I see both of those things a lot. The problem is if you aren't already familiar with those idea, the statements mean literally nothing. They basically don't make sense.
These examples aren't so far out there. DSLs exist in other languages. Statements exist in other languages. A programmer who has never used macros can imagine being able to create these, even if they have no idea what exactly that would look like in a Lisp program.
That issue is also true of any game-changing technology you haven't used yet. If you hadn't used a personal computer, we could enumerate the features and advantages, but you probably wouldn't be able to truly appreciate it until you used one yourself.
I wonder if we struggle needlessly though in "regular software development" - and entire jobs or teams exist because we didn't find the right way to express things in a language. OTOH you could create lisp code that is so unique and weird in it's semantics that it's hard for a new team member to get onboard. But I've seen that done in C# too which allows you to have code that writes code at runtime (not as elegantly though!).
Yeah, writing your own language and self-modifying code can give you a lot of leverage, but usually they also make the code so much harder for other people to pick up that it's not worth it.
LISP syntax is uniform,everything(functions,data,argument lists) is nested lists of lists like (list(list(list))), so that allows altering specific places "in-the-list"(place 1,2,3...) as form of meta-programming,
where normal syntax FOR( A IN B) would be written roughly as (for a b) where for is used as a function taking 'a' and 'b' as parameters, but in this form(where 'for' is just the first element of the list) you can have functions that "alter-the-list" by example (replace-first-list-element (for a b) replacement-part) returns (replacement-part a b).
You should use '__file__' for increased generality.
Note that you can also import a module and refer to its location on disk as 'module.__file__'. I may or may not have used this to modify a few core python modules in place.
1. Novelty. We get bored easily at our jobs, and Lisp is different (but not Haskell different), so we're naturally pulled towards learning about it.
2. Nostalgia. A lot of people here have enjoyed Lisps for years or even decades (myself included) and we have a natural bias towards preferring Lisp-based blogs or articles or projects, partly in the hopes that something is new in the land of Lisp (it never is).
3. Chain effect. When one topic comes up that's very interesting, people often want to know more about that topic or similar topics. People who want more points are eager to submit related links.
4. Propaganda. Some people have bought into a certain Lisp full-scale, and really want to help spread it in the industry. There's even a full-time job title for this called "evangelist".
Have you tried it, just a beginner tutorial or something? But if you do, please use an editor that puts paired parens in for you automatically, otherwise there's a risk of thinking that it is painful.
I tried it years ago, but I think I had too little experience to understand the use case back then. I hadn't ever done any functional programming at that point so it kind of went over my head.
I still hate Haskell. But maybe I would like Lisp? A lot of people here seem to love it so that's why I made this thread :)
OK I'll have a go, but others will be able to do a better job than me!
Yes, you might like lisp and I definitely think it's worth trying. You often hear people saying "lisp has no syntax" and that's one of the main things about lisp. I think a good first step is to understand what people mean by that. You know the way a compiler or interpreter, after tokenizing and parsing, transforms code into an intermediate data structure representation called an "abstract syntax tree"? What they mean is that lisp is like jumping straight in at the AST stage. You're literally programming with data structures, instead of programming with syntax that gets turned into data structures. People find that a very rewarding intellectual/mental experience. It really teaches you that the words "statement" and "expression" mean different things. And it shows you a way of programming without a lot of "state" -- just expressions feeding into other expressions, without as much use of "local variables". More deeply, this is directly connected with formal ideas in mid-20th century theoretical computer science (in particular the "lambda calculus") about the minimal programming constructs needed to create a Turing complete language. In lisp it leads also to very powerful and somewhat mind-bending "macros" -- since code is data structure, you can very naturally write code to transform code, so the "final" code that is executed is partially the product of an initial execution phase where code is just working on code creating other code.
Having no syntax (or minimal, languages like clojure introduce a bit with square and smooth parens etc) means you basically just write expressions grouped by smooth parens. It's very beautiful and minimal experience to write. Just, seriously, do it with an editor/IDE that inserts paired parens for you, it promises to be a great experience with that, but without it a lot of people just give up saying why do they have to keep writing so many parens, which is missing the point entirely -- The parens are the fabric of the program!
It's elegant. It's (relatively) easy to write a basic parser. LISP code is readily expressible in the same basic data structures provided in the language so you get meta programming almost for free and thus extending LISP is (relatively) easy too. Whereas C feels like an abstract machine language, LISP feels like an abstract 'mathematical computation' language. It's, like all languages, a different way of thinking about computation in the same way that human languages also seem to be (at least marginally) different ways of representing or expressing thought.
And once you've come to appreciate it, jokes like "HAVE YOU READ YOUR SICP TODAY?" will be funny to you.
In terms of 'getting shit done', it's not so 'good', not that one can't get shit done with LISP, but that it's not necessary nor, given all likely real world constraints, particularly that much of, if at all, an advantage relative to other (families of) languages.
It's also historically important so there's a benefit in knowing about it and being familiar with it too. And knowing the history helps understand why people still love it, even as a lot of what was once unique or special about it can be found much more widely.
In what way is Latin powerful, compared to other languages? Or elegant?
I've had to learn a little Latin, because it's the root of half the English language, and I would not describe it this way at all. It's overly complex and arbitrary. The https://en.wikipedia.org/wiki/Latin_spelling_and_pronunciati... article is full of tables of exceptions. Over its lifetime, they not only couldn't agree on pronunciation, but whether it had lower-case letters, whether to put spaces between words, or which direction to write it.
C is Latin. It's revered because of its age and the the works written in it. It was in the right place at the right time. Half the world who came after tried to make their own improved version, and those improved versions are the languages that are actually popular today.
What spoken language is powerful and elegant? When I was in college, a friend was taking a language (I think it was Swahili but don't quote me on that) that was so simple students learned all of the grammar in the first semester. Everything after that was just learning vocabulary and getting comfortable with it. Turkish has a completely 1:1 mapping of letters to sounds, and perfectly regular conjugation. Korean also has an extremely consistent writing system. Any of those seem more Lisp-like to me than Latin.
Here is a powerful and elegant human language:
https://en.wikipedia.org/wiki/Esperanto
(although it should be said that its power is mostly hypothetical until it becomes widely used, which may be never)
> a language that was so simple students learned all of the grammar in the first semester.
Natural languages tend to be similar in complexity, which tends to increase to the bounds placed by a child's ability to learn. Languages with simpler grammar often have eg. more complex phonetic systems. For instance, mandarin is "simple" in that it doesn't have conjugations or tenses, but it's complex in that it has tones. Likewise, Turkish has vowel harmony.
> Korean also has an extremely consistent writing system.
Not only that, but the gylphs actually represent the mouth movements necessary to make the sounds. It's like that because Hangul is a relatively new writing system that was designed with discoveries in linguistics in mind, unlike English and French that have things like vestigial spellings (eg. "through"). So I'd say that Korean would be like an up-and-coming like, uh... Rust. Of course, writing systems aren't really part of a language itself: you can write any language in IPA.
I think the general consensus is that it's great for "getting big shit done" – in other words, it's hard to beat for creating large, complex programs, but relatively crap for scripting or smaller tasks. I'm still kind of amazed how difficult it is to create a Lisp program that isn't hundreds of MB in size.
> I'm still kind of amazed how difficult it is to create a Lisp program that isn't hundreds of MB in size.
That's not true IME. No doubt SBCL binaries are large, but they start around 70 Mb and grow from there. The growth depends partly on how many shared libraries are loaded when the image is created. Commercial Lisps are supposed to be better, but I haven't used them so I can't really say.
For smaller tasks SBCL (and possibly others) support scripting using a "shebang line" of "#!/usr/bin/sbcl --script".
Sure, I'm not saying these things can't be done, just that you get the distinct feeling that it isn't how Lisp was made to work. I might have been exaggerating about size, but 70 Mb is pretty damn big for a program that might not do all that much! I haven't ever used commercial Lisps, either.
Lisp is very valuable in the concepts which it teaches; expression trees and their inherent parallelism, functions without side-effects, structured data definition, lazy evaluation.
I've been programming for about 30 years, and did a fair bit of scheme, then lisp early on. I no longer use it, and it's not a great modern language for a lot of internet or IO stuff, but as a data transformation language, few are its equal. I still apply what I learned from lisp to write better code in Java, Go, Python. It puts you into a mindset of using composition of simple functions and data structures, which will generally lead to better code in any language.
> it's not a great modern language for a lot of internet or IO stuff
I think Clojure is a great language for internet stuff and possibly great even for IO stuff too, depending on what you mean by that. The LISP-iness is probably better for the former but builtin Java interop probably goes a long way towards being pretty-good for the latter.
What exactly were you thinking-of by "IO stuff"? Graphics? Embedded systems programming? I'd think Clojure could be just as good as Java or Python for all of those, tho existing libraries aren't going to be quite as good as C/C++, and Go will probably be better-performing generally.
And there are (because of course there are) LISPs for real-time embedded systems programming:
- [nakkaya/ferret: Ferret is a free software lisp implementation for real time embedded control systems.](https://github.com/nakkaya/ferret)
Extending Lisp can be hard work. Take an existing Common Lisp implementation and give, say, support for continuations.
Adding the necessary syntax will not be hard, however, whereas in a in a different kind of language framework, that part will have difficulties also.
What will also be easier in Lisp is for downstream users to manage the change. For instance, maybe some code relying on the new feature can work fine with some hack that just fakes some the semantics. That can be disguised under compatible syntax.
I am not a programmer by profession, so I can chose my own poison. Scheme is just too much fun! I never liked python,ruby,c# etc. What scheme gave me was a smallish set of well-chosen primitives that compose well. Simple syntax together with macros so that I can abstract away any boilerplate that any eventual language designer forgot to foresee in a way superior to any other language. Lisp macros really are superior. I know enough haskell to know that "we don't need macros because we have typeclasses/an expressive typesystem/template haskell" is only a half true.
Guile scheme is my scheme of choice. Not the fastest scheme (that would be chez), but it is a bliss to write things in.
I have this idea that if you are a "programming language searcher" that can never really be satisfied with what they have you either end up in the ml camp or in the lisp camp. I myself would love a lisp/ml lovechild, which is why I am following hackett closely!
I personally am not a big lisper, but know others who are. It's not as cool among young people, but there's a certain segment of those, mostly over 50, who will swear by lisp and build some pretty cool things in it.
1. It's got a minimal core and is easy to implement. This means it runs in many places.
2. Very, very easy to extend due to its treating code as data. You can assemble your own language on top of the base you're given with macros. This is why it's often recommended for building your first compiler. By the time you've written a lisp program, you're basically writing in a different dialect.
I think some people also use it for a challenge, or to make themselves think. It's very different from your normal C programming, or OO, or even other functional languages (even though it influenced many of them). There's a certain family of languages such as lisp, scheme, ocaml, ml, etc. which seem to appeal to those with a more academic bent and so some interesting stuff can be written in them.
Well we software developers have the right of a culture of our own, just like plane pilots like to talk endlessly about old war birds, and fly gliders.
For me, Lisp is akin to a Concorde or a P-51, it is not the aircraft of choice today but helped to shape everything that came next.
> Lisp is a programmable programming language.
— John Foderaro, CACM, September 1991
Often times programming languages are designed with a particular use case in mind. (E.g. JS: web, Perl: scripting, Erlang: telephony, etc.) LISP was made to think about computation, and it acts well as a programming language work with programming.
One of the goals of Racket (a dialect of LISP) is to make it easy to create your own languages.
> Racket is the second best programming language in the world—the first best one is the one you build in Racket.
Obsessed? Or you just like it. I think obsession is a bit too strong in this context. I also pretty much like Lisp even though I cannot use it day to day because everybody else works in Java, Python, Go and most developers do not consider any of the Lisp languages production ready.
Lisp is the red pill to programming. A mind-blowing out-of-the-box experience. An alien technology. -- Lisp has a so called "no turning back point", true lispers cannot bear other dialects after experiencing it. From scientists in underground military bases to rich tech VCs: everyone obeys Lisp here..
Although I don't use Lisp in my daily programming, I do tinker with it when exploring new concepts. Basically I find that any abstraction can be quickly, not necessarily efficiently, implemented using Lisp. The absence of syntactic and even semantic constraints allows novel ideas to be tested which would be too awkward in more "conventional" languages.
As it has been said, many advanced systems contain an incomplete, faulty implementation of Lisp. So cutting to the chase, simply use your favourite Lisp system and hack away.
Because we are computer scientists, and Lisp allows for the specification of abstract concepts directly and efficiently without syntax getting in the way.
One thing not mentioned in the current set of responses is the REPL style and interactive coding style that you can have with a LISP that is different than what a traditional compiled language gives you in the edit-compile-run-edit loop or a dynamic language gives you in the edit-run-edit loop. When you are using a REPL you can poke and push at any part of the system like a debugger but the system is still alive. Without that interactive nature sometimes you end up doing print/debugger work to understand some quirk of a datastructure but in a LISP/REPL it's plainly visible and you don't have to think about it.
If it's integrated with an editor you can load functions or different versions of the function and see how each work with live data, you can slurp new data in, and all sorts of flexible dynamic things that let you find the program you want (which always helps when using third-party or unfamiliar code). This is more a feature of all kinds of REPL languages and not wholly specific to LISPs.
One of the basis of a LISP/Scheme language is that it is constructed of very few basic primitives that are assembled into a greater system and that greater system is part of your program instead of being things you don't touch (like libc), and you are (generally) welcome to touch them, alias them, or manipulate them to help your goal and program. This allows things like being able to temporarily hook a function call to add some debug information and then unhook a function call via a REPL and carry on. I find that pointing to people to r5rs https://schemers.org/Documents/Standards/R5RS/HTML/ and focusing on sections 4, 5, and 6 help show off how little is required to describe the basics of the language.
Check out https://xkcd.com/224/ . Many of us Lispers go through this phase where the universe appears to crystallize around Lisp concepts. Like Forth or APL and other languages built around a unifying theory there is a conceptual elegance which is mind-opening. Eventually most of us come back down to Earth but it is a fun ride.
There is also a mystique around the powers of Lisp. I do believe it is a massively expressive and powerful language in the hands of a master. But part of it is historical. During the heyday of Lisp it was the language of choice for the best hackers in the land and certainly was vastly more powerful for individuals/small groups than the existing alternatives. Today that talent base is just spread across so many other choices.
107 comments
[ 4.8 ms ] story [ 487 ms ] threadI personally found out about both reddit and HN by means of deeping further into lisp in the internet, beyond his “ANSI Common Lisp” book which I used in university.
I don’t get to do near as much these days, but the lessons I’ve learned have made me a better developer for sure.
Type safety and pure functions make debugging and refactoring an entirely different beast
If that bothers you, it could be worse: we could be addicted to FORTH! :D
Really though, the majority of comments I have seen in every Lisp thread is about Lisp not giving you any advantages over the mainstream languages for "real world business apps", a common example mentioned is reddit switching to Python from Lisp. Also that stuff like the language ecosystem is more important.
It would help to get a better idea of your current context with regards to programming. What’s your experience so far? That will help frame the discussion.
Mostly object oriented (distributed systems and game dev), and some embedded development.
The Little JavaScripter https://www.crockford.com/little.html
Lisp causes you to think in different ways. It allows for metaprogramming in ways other languages don't allow. It is endlessly reconfigurable.
I've never heard this before. Modern C++ sure, but I thought most of the "modernization" in lisp was done in descendant languages (i.e. racket).
One core feature of any Lisp dialect is that you can extend the language using Lisp.
Thus, you don't need to "change" the language spec or write a new compiler to extend (and thus modernize) the language.
- you can easily write programs that edit themselves
That issue is also true of any game-changing technology you haven't used yet. If you hadn't used a personal computer, we could enumerate the features and advantages, but you probably wouldn't be able to truly appreciate it until you used one yourself.
LISP syntax is uniform,everything(functions,data,argument lists) is nested lists of lists like (list(list(list))), so that allows altering specific places "in-the-list"(place 1,2,3...) as form of meta-programming,
where normal syntax FOR( A IN B) would be written roughly as (for a b) where for is used as a function taking 'a' and 'b' as parameters, but in this form(where 'for' is just the first element of the list) you can have functions that "alter-the-list" by example (replace-first-list-element (for a b) replacement-part) returns (replacement-part a b).
On top of that everything is a function, including if statements, assignment, and even how you define a new function. So factorial in lisp is:
You'll notice that it ended with 5 close-parentheses. Different people have different strategies for managing that along with indents and newlines.Hah! I can do that too:
Clearly Lisp is of no use in 2019.Note that you can also import a module and refer to its location on disk as 'module.__file__'. I may or may not have used this to modify a few core python modules in place.
2. Nostalgia. A lot of people here have enjoyed Lisps for years or even decades (myself included) and we have a natural bias towards preferring Lisp-based blogs or articles or projects, partly in the hopes that something is new in the land of Lisp (it never is).
3. Chain effect. When one topic comes up that's very interesting, people often want to know more about that topic or similar topics. People who want more points are eager to submit related links.
4. Propaganda. Some people have bought into a certain Lisp full-scale, and really want to help spread it in the industry. There's even a full-time job title for this called "evangelist".
As Alan Kay said, Lisp is the "Maxwell’s equations of software" https://queue.acm.org/detail.cfm?id=1039523
> 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.
It's elegant.
I still hate Haskell. But maybe I would like Lisp? A lot of people here seem to love it so that's why I made this thread :)
Yes, you might like lisp and I definitely think it's worth trying. You often hear people saying "lisp has no syntax" and that's one of the main things about lisp. I think a good first step is to understand what people mean by that. You know the way a compiler or interpreter, after tokenizing and parsing, transforms code into an intermediate data structure representation called an "abstract syntax tree"? What they mean is that lisp is like jumping straight in at the AST stage. You're literally programming with data structures, instead of programming with syntax that gets turned into data structures. People find that a very rewarding intellectual/mental experience. It really teaches you that the words "statement" and "expression" mean different things. And it shows you a way of programming without a lot of "state" -- just expressions feeding into other expressions, without as much use of "local variables". More deeply, this is directly connected with formal ideas in mid-20th century theoretical computer science (in particular the "lambda calculus") about the minimal programming constructs needed to create a Turing complete language. In lisp it leads also to very powerful and somewhat mind-bending "macros" -- since code is data structure, you can very naturally write code to transform code, so the "final" code that is executed is partially the product of an initial execution phase where code is just working on code creating other code.
Having no syntax (or minimal, languages like clojure introduce a bit with square and smooth parens etc) means you basically just write expressions grouped by smooth parens. It's very beautiful and minimal experience to write. Just, seriously, do it with an editor/IDE that inserts paired parens for you, it promises to be a great experience with that, but without it a lot of people just give up saying why do they have to keep writing so many parens, which is missing the point entirely -- The parens are the fabric of the program!
And once you've come to appreciate it, jokes like "HAVE YOU READ YOUR SICP TODAY?" will be funny to you.
In terms of 'getting shit done', it's not so 'good', not that one can't get shit done with LISP, but that it's not necessary nor, given all likely real world constraints, particularly that much of, if at all, an advantage relative to other (families of) languages.
It's also historically important so there's a benefit in knowing about it and being familiar with it too. And knowing the history helps understand why people still love it, even as a lot of what was once unique or special about it can be found much more widely.
I've had to learn a little Latin, because it's the root of half the English language, and I would not describe it this way at all. It's overly complex and arbitrary. The https://en.wikipedia.org/wiki/Latin_spelling_and_pronunciati... article is full of tables of exceptions. Over its lifetime, they not only couldn't agree on pronunciation, but whether it had lower-case letters, whether to put spaces between words, or which direction to write it.
C is Latin. It's revered because of its age and the the works written in it. It was in the right place at the right time. Half the world who came after tried to make their own improved version, and those improved versions are the languages that are actually popular today.
What spoken language is powerful and elegant? When I was in college, a friend was taking a language (I think it was Swahili but don't quote me on that) that was so simple students learned all of the grammar in the first semester. Everything after that was just learning vocabulary and getting comfortable with it. Turkish has a completely 1:1 mapping of letters to sounds, and perfectly regular conjugation. Korean also has an extremely consistent writing system. Any of those seem more Lisp-like to me than Latin.
Natural languages tend to be similar in complexity, which tends to increase to the bounds placed by a child's ability to learn. Languages with simpler grammar often have eg. more complex phonetic systems. For instance, mandarin is "simple" in that it doesn't have conjugations or tenses, but it's complex in that it has tones. Likewise, Turkish has vowel harmony.
> Korean also has an extremely consistent writing system.
Not only that, but the gylphs actually represent the mouth movements necessary to make the sounds. It's like that because Hangul is a relatively new writing system that was designed with discoveries in linguistics in mind, unlike English and French that have things like vestigial spellings (eg. "through"). So I'd say that Korean would be like an up-and-coming like, uh... Rust. Of course, writing systems aren't really part of a language itself: you can write any language in IPA.
That's not true IME. No doubt SBCL binaries are large, but they start around 70 Mb and grow from there. The growth depends partly on how many shared libraries are loaded when the image is created. Commercial Lisps are supposed to be better, but I haven't used them so I can't really say.
For smaller tasks SBCL (and possibly others) support scripting using a "shebang line" of "#!/usr/bin/sbcl --script".
A mocl application might start around 1 MB. But that's an unusual whole-lisp-program-to-c compiler.
I’ve used Chicken in the past to create static binaries that were on the order of hundreds of kilobytes.
http://nongnu.org/txr
I released version 223 today, which marks the tenth anniversary, since the project's August, 2009 start.
I've been programming for about 30 years, and did a fair bit of scheme, then lisp early on. I no longer use it, and it's not a great modern language for a lot of internet or IO stuff, but as a data transformation language, few are its equal. I still apply what I learned from lisp to write better code in Java, Go, Python. It puts you into a mindset of using composition of simple functions and data structures, which will generally lead to better code in any language.
I think Clojure is a great language for internet stuff and possibly great even for IO stuff too, depending on what you mean by that. The LISP-iness is probably better for the former but builtin Java interop probably goes a long way towards being pretty-good for the latter.
What exactly were you thinking-of by "IO stuff"? Graphics? Embedded systems programming? I'd think Clojure could be just as good as Java or Python for all of those, tho existing libraries aren't going to be quite as good as C/C++, and Go will probably be better-performing generally.
And there are (because of course there are) LISPs for real-time embedded systems programming:
- [nakkaya/ferret: Ferret is a free software lisp implementation for real time embedded control systems.](https://github.com/nakkaya/ferret)
Adding the necessary syntax will not be hard, however, whereas in a in a different kind of language framework, that part will have difficulties also.
What will also be easier in Lisp is for downstream users to manage the change. For instance, maybe some code relying on the new feature can work fine with some hack that just fakes some the semantics. That can be disguised under compatible syntax.
Guile scheme is my scheme of choice. Not the fastest scheme (that would be chez), but it is a bliss to write things in.
I have this idea that if you are a "programming language searcher" that can never really be satisfied with what they have you either end up in the ml camp or in the lisp camp. I myself would love a lisp/ml lovechild, which is why I am following hackett closely!
Haskell-like Lisp in Racket https://github.com/lexi-lambda/hackett
1. It's got a minimal core and is easy to implement. This means it runs in many places.
2. Very, very easy to extend due to its treating code as data. You can assemble your own language on top of the base you're given with macros. This is why it's often recommended for building your first compiler. By the time you've written a lisp program, you're basically writing in a different dialect.
I think some people also use it for a challenge, or to make themselves think. It's very different from your normal C programming, or OO, or even other functional languages (even though it influenced many of them). There's a certain family of languages such as lisp, scheme, ocaml, ml, etc. which seem to appeal to those with a more academic bent and so some interesting stuff can be written in them.
For me, Lisp is akin to a Concorde or a P-51, it is not the aircraft of choice today but helped to shape everything that came next.
Often times programming languages are designed with a particular use case in mind. (E.g. JS: web, Perl: scripting, Erlang: telephony, etc.) LISP was made to think about computation, and it acts well as a programming language work with programming.
One of the goals of Racket (a dialect of LISP) is to make it easy to create your own languages.
> Racket is the second best programming language in the world—the first best one is the one you build in Racket.
I can relate to that feeling.
Although I don't use Lisp in my daily programming, I do tinker with it when exploring new concepts. Basically I find that any abstraction can be quickly, not necessarily efficiently, implemented using Lisp. The absence of syntactic and even semantic constraints allows novel ideas to be tested which would be too awkward in more "conventional" languages.
As it has been said, many advanced systems contain an incomplete, faulty implementation of Lisp. So cutting to the chase, simply use your favourite Lisp system and hack away.
See also: Forth.
If it's integrated with an editor you can load functions or different versions of the function and see how each work with live data, you can slurp new data in, and all sorts of flexible dynamic things that let you find the program you want (which always helps when using third-party or unfamiliar code). This is more a feature of all kinds of REPL languages and not wholly specific to LISPs.
One of the basis of a LISP/Scheme language is that it is constructed of very few basic primitives that are assembled into a greater system and that greater system is part of your program instead of being things you don't touch (like libc), and you are (generally) welcome to touch them, alias them, or manipulate them to help your goal and program. This allows things like being able to temporarily hook a function call to add some debug information and then unhook a function call via a REPL and carry on. I find that pointing to people to r5rs https://schemers.org/Documents/Standards/R5RS/HTML/ and focusing on sections 4, 5, and 6 help show off how little is required to describe the basics of the language.
There is also a mystique around the powers of Lisp. I do believe it is a massively expressive and powerful language in the hands of a master. But part of it is historical. During the heyday of Lisp it was the language of choice for the best hackers in the land and certainly was vastly more powerful for individuals/small groups than the existing alternatives. Today that talent base is just spread across so many other choices.