I have the same feeling with the Author. The comments on the previous post are people triggered, mostly defending Haskell and Rust without looking at what's gre

I have the same feeling with the Author. The comments on the previous post are people triggered, mostly defending Haskell and Rust without looking at what's great about Common Lisp and dynamic programming environment in general. I love Haskell, Rust, and Common Lisp all the same. But what I found is static tribes like Haskell and Rust often overlook what's so great in dynamic tribes, because the benefits are not obvious on paper - you have to experience it and live in it. The key to great dynamic programming languages is dynamism. The doctrines are different so the technique should also be different. When I'm using Common Lisp and Slime, I usually hit C-x C-e repeatedly to evaluate forms like every 2 to 5 seconds. It's like a hot debate with Emacs, instead of filing your code into the compiler. It's like drawing with a pencil instead of a fountain pen. If you're not doing something similar, you only receive penalties from the cons of dynamic programming languages without reaping benefits from the pros - the result would definitely be boring and disappointing. This reminds me of digital painting. When it comes to digital painting, different people have different ways: some people mostly drawing, and some people spent half of their time erasing! It sounds confusing, but because of the nature of digital painting, it's much easier to erase things than physical painting. So some people took advantage of this and split the painting process: First, they use large brushes to paint without worry about the shape, they only worry about rendering. Then, they use the eraser to trim to the shape they want. They do the two steps repeatedly from the beginning to the end. This technique usually results in painting faster and rendering better despite the fact they're spending half of the time erasing. But it's tricky to get the idea in the first place, as many people may try it out and use the eraser more, but if they don't adjust the mentality around this technique the result would be disappointing as well. Another great thing about dynamic languages is it's easier to think outside the box. Languages like Haskell are expressive, but they still cast restrictions on how people program. As a result, dynamic programming language communities tend to think outside the box more often: You can implement things much easier like Erlang processes and hot reload them; or having ClojureScript evaluated in a remote browser then come back in Emacs, right beside your expression; or have something like Clojure Pathom which turn static GraphQL like API schemas into pathfinding problems, resulting in APIs that are magically effortless and flexible. As a personal experience, I find libraries from most static programming language communities are similar, while libraries from some dynamic counterparts could be drastically different from each other, and they're weird and fun.