Backstory
If you browse around many programming forums you always see some comments buried saying that Lisp "changed my thinking" or helped "see the light" and you will, of course, raise an eyebrow. What's so special about it? If you weren't raising yours, I was at least raising mine. Yet here we are reading the same words.
When I started this hashnode account I was predominantly interested in Common Lisp. In fact, there were two "pending" drafts I just published: one on Common Lisp, one on automation. That was about half a year ago, and since that half year I've moved on from Lisp (for now)! Although shelved, there were some invaluable takeaways to share.
These are some takeaways from my journey and maybe you'll find resonance and try some Lisp yourself.
Functional is flexible
The shift from OOP to Functional is ever-so-slowly trudging along. It's quite likely you've touched a map or filter as is so popular to do so within JS land. When I first picked Lisp up I was already quite disheartened by any class declaration and the bolted on complexity that came with it. Yet when you first start trying out Functional languages, the most popular ones are a typedef nightmare.
What's so beautiful about Lisp is how snug a glove functional programming feels. And there aren't any types. And then you start seeing the other side of functional: funcall and apply and zip and piping, little building blocks – we brick layers make things of cathedrals! The amount of flexibility and the lack of variables you need to track is akin to turning off the child safety lock, opening car doors you didn't know existed.
Learning what's under the hood
Once you start opening those "car doors" one inevitably bumps into the large bronze scary monsters of language compilation, ASTs and macros. And when you start fiddling around with that, you only begin to realize how free one can be. With a catch! If you open the hood, you have to know what you're doing. You have to stretch your mind and sink into how Lisp was created, how it compiles, why it does, the before and after compilation, etc. Yet fiddle with enough Lisp and you'll find yourself bumping into these statues and confident enough to topple them. And you will.
You can do anything
For here's the biggest takeaway. Once you walk through the pillars of Macros and Lambdas you'll find yourself more certain. You can figure it all out. There are no more programming "dark spots" too intimidating to dive into after you wrangle in all Lisp has to offer. Next thing you know you'll happily write a lexer and tokenizer for a module you need and there's nothing to be afraid anymore.
Lisp is the cure to imposter syndrome. Get rid of yours!