Understanding the Power of Lisp (2020)

> Do I need to spend more time on a project?

It depends on your interest. For me in particular Lisp was a "profound enlightenment experience" because:

1. I have been programming for a long time and had so many problems I could not(in practice) solve in any language but Lisp.

2. Lisp gives you two things no other language gives you: very basic Metaprograming(it can read itself) and the ability to design your own DSL(domain specific language).

3. It also gives you REPL(Read eval print loop) immediate feedback other languages tried to copy(but have not been able to replicate entirely).

Having said that, Lisp design is also obsolete today because it was mainly designed in the 1970s. I hate it (specially parentheses and interface) and love it at the same time.

>Do I need to spend more time on a project?

You don't need to do anything, nobody needs to learn a new language for living.

The fastest way to understand what Lisp is all about is to be near a very proficient Lisp programmer, because he will be able to run circles around you solving problems.

That combination of someone proving to you what is possible at the masters level and natural human competition is probably much more powerful than anything else you could do on your own.

We are humans after all, we see a great hunter hunt and only then we desire to be as good as he is and learn from him. We do it subconsciously and that is the reason elite tennis players sell razors so well, people copy naturally those who they admire without being conscious about it.

I don’t consider myself a Lisp wizard and mostly stick to pretty simple code but to name a few cool things that would have been tedious or impossible in another language:

- A desktop application for a bank in which not only the gui’s content but the look and structure was generated or changed on the fly mimicking the status of a database.

- An interpreter in which most of its classes and methods were automatically generated. The Java rewrite took pretty nasty code generation hacks, visitor pattern madness and way more LOC.

- Some program with a huge cache (glorified hash table) that was not catching simple strings or objects as keys but actual code as s-expressions. I always thought that was pretty cool.

Most if not all of my Lisp (and Perl) projects have been eventually rewritten in Java, and not exactly due to technical issues. I mostly put up with Go these days which is great most of the time but of course makes me yearn for a more powerful language or wished I never dabbled with those.

Note that functions in other languages, like Haskell and Scala, do allow some control over evaluation order. One can annotate function parameters to achieve call-by-value or call-by-need as required.

Macros can analyse/manipulate the abstract syntax tree of their inputs, so I think of them as extending the compiler.

That would be the time, where I would consider to write a macro. The macro would capture similar logic, but would provide me no-overhead syntax.

In Common Lisp:

    (defmacro return-first-working (&body body)
      "Expects a sequence of expressions as body.
       Returns the value of the first expression of body
       which returns without error."
      (when body
        `(handler-case ,(first body)
           (error ()
             (return-first-working ,@(rest body))))))

    (return-first-working
      (error "hi")
      (error "there")
      (error "!")
      "hello-world"
      (error "wtf?"))

That way I can easily implement primitive control structures, without resorting to add to my code visibly complex things (like making expressions into functions).

Above is a recursive macro, which takes its subexpressions and returns a simplified expression, reusing itself. That way code transformation itself is described as a recursive process. One can learn how to apply such transformation patterns to the code itself and then it gets relatively easy to write.

SOLID and a dozen of DPs and you get there pretty fast. Then you rewrite by another team with their interpretation of SOLID and another dozen of "better suited" DPs and you get there again. On 3rd iteration you just buy something as a service that covers 80% of your needs and consider the rest 20% non-essential business. And life is finally good.