I can only answer for myself, but I'm happy to do that.
For context, I've been a professional programmer and technical writer since 1988, and more than half of my career has been spent writing Lisp code for a living.
What is it about Lisp that I love so much?
First and foremost, I can write a program by starting a Lisp running and teaching it incrementally to be the program I want. The Lisp is already a working program; it just isn't the one I want to build. So I teach it one expression at a time how to be the program I want. When it does everything I want it to do correctly and well, I'm done. I can save it and ship it.
This point is the single most important one for me. Most programming languages don't work this way (there are a couple of others that do). I am dramatically more productive working this way than in a batch-compiled style. That's not true for everyone, but it's true for some, including me.
Second, Common Lisp implementations in particular (as well as a small number of other languages, some of which are not Lisp) provide built-in comprehensive support for working that way. They offer a runtime that continues to run as I change it, even when errors occur. Rather than quitting with a backtrace, Lisp responds to an error by spinning up an interactive repl inside the dynamic context that generated the error, enabling me to rummage through the environment, examining and even editing everything in it.
The runtime provides tools and access that enable you to examine and change absolutely everything about iit, while it runs. The runtime has comprehensive information about itself built in, inspection and reflection facilities that enable me to examine and edit everything while it runs, and error-handling that enables me to inspect, diagnose, and repair errors as they occur, without leaving the running Lisp.
I can start a Lisp, interactively construct simple data structures to model my naive assumptions about the program I intend to write, write functions to construct, inspect, and transform those structures, modify their definitions, catch and examine errors, write corrections to data structures and functions while in the dynamic environment that generated an error, continue on my way after making the corrections, and all without leaving and restarting the Lisp.
I can go on in this vein ad infinitum, so I'll arbitrarily stop here. In brief, I love Lisp because it gives me all the tools I want to build and change a program while it runs, it doesn't get in my way, and it yields high-performance code (good native-code compilers are the rule in Common Lisp implementations, rather than the exception).
Oh, and about the idiosyncratic parenthesized syntax that everyone loves to hate: I hated it, too, when I first started, but the interactivity sucked me in. Like many Lispers before and after me, I thought the thing to do was to master the language and then implement a proper syntax for it. Again, like many Lispers before and after me, I eventually came to see the syntax as a strength rather than a weakness, both for how easy it is to write code-manipulation tools for it, and for a nice aesthetic that is maybe only noticeable after one gets over the hatred of parentheses. Parenthesized S-expressions feel like strings of pearls, where each pearl is a nugget of meaning composed of smaller pearls.
This is compelling:
“ First and foremost, I can write a program by starting a Lisp running and teaching it incrementally to be the program I want. The Lisp is already a working program; it just isn't the one I want to build. So I teach it one expression at a time how to be the program I want. When it does everything I want it to do correctly and well, I'm done. I can save it and ship it.”
I really find this compelling. I’m going to give the language a shot. I get some of this with Python. When stuck with a small thing I can code it in the Repl or even import a module or function of my own making and iterate on it.
I'm curious about this way of working. Can you get a preview of all the functions in the system and how they interact with each other? How do you refactor effectively? How do you work with other people in a repository? Compare git changes and other stuff?
For context, I've been a professional programmer and technical writer since 1988, and more than half of my career has been spent writing Lisp code for a living.
What is it about Lisp that I love so much?
First and foremost, I can write a program by starting a Lisp running and teaching it incrementally to be the program I want. The Lisp is already a working program; it just isn't the one I want to build. So I teach it one expression at a time how to be the program I want. When it does everything I want it to do correctly and well, I'm done. I can save it and ship it.
This point is the single most important one for me. Most programming languages don't work this way (there are a couple of others that do). I am dramatically more productive working this way than in a batch-compiled style. That's not true for everyone, but it's true for some, including me.
Second, Common Lisp implementations in particular (as well as a small number of other languages, some of which are not Lisp) provide built-in comprehensive support for working that way. They offer a runtime that continues to run as I change it, even when errors occur. Rather than quitting with a backtrace, Lisp responds to an error by spinning up an interactive repl inside the dynamic context that generated the error, enabling me to rummage through the environment, examining and even editing everything in it.
The runtime provides tools and access that enable you to examine and change absolutely everything about iit, while it runs. The runtime has comprehensive information about itself built in, inspection and reflection facilities that enable me to examine and edit everything while it runs, and error-handling that enables me to inspect, diagnose, and repair errors as they occur, without leaving the running Lisp.
I can start a Lisp, interactively construct simple data structures to model my naive assumptions about the program I intend to write, write functions to construct, inspect, and transform those structures, modify their definitions, catch and examine errors, write corrections to data structures and functions while in the dynamic environment that generated an error, continue on my way after making the corrections, and all without leaving and restarting the Lisp.
I can go on in this vein ad infinitum, so I'll arbitrarily stop here. In brief, I love Lisp because it gives me all the tools I want to build and change a program while it runs, it doesn't get in my way, and it yields high-performance code (good native-code compilers are the rule in Common Lisp implementations, rather than the exception).
Oh, and about the idiosyncratic parenthesized syntax that everyone loves to hate: I hated it, too, when I first started, but the interactivity sucked me in. Like many Lispers before and after me, I thought the thing to do was to master the language and then implement a proper syntax for it. Again, like many Lispers before and after me, I eventually came to see the syntax as a strength rather than a weakness, both for how easy it is to write code-manipulation tools for it, and for a nice aesthetic that is maybe only noticeable after one gets over the hatred of parentheses. Parenthesized S-expressions feel like strings of pearls, where each pearl is a nugget of meaning composed of smaller pearls.