Why do all lisp languages suck? Any sane person would agree that scheme-lineage languages (i.e. including racket and the like) are infinitely better-structured than the abomination that is common lisp. If languages were a purely academic pursuit then surely scheme languages would be near perfect. Writing in CL is practically like writing in C as soon as the program is any non-trivial, which defeats the whole point of not using C in the first place. Scheme-likes do not have that problem.
Unfortunately there is no lisp of any type with any good implementation. For example, they all have shitty gc with massive pauses, or massive overhead, or that leak memory (or all of the above, such as is the case in racket). Some don't even do anything without explicit gc calls (such as chez and ypsilon).
The gc also prevents all but chez (and bigloo?) and to a lesser extent racket (it is very limited but it's there) to support single-process multicore. But the problem isn't the gc but rather that each implementation has a garbage (haha) gc implementation (proof: none of the garbage collectors collect themselves).
How about a completely different massive wart: debugging and live programming. Gambit is pretty much the only implementation that supports restarts, and again it's quite limited. Other implementations don't even support that in the first place. Gambit's subrepls only evaluate at the current frame in interpreted code, if the compiled code breaks you have to evaluate in global scope exclusively, making them unsuitable for proper debugging.
As far as I'm aware, while racket is the worst offender there, none of the schemes have proper support for live programming. That is, when a change is performed, too much state must be reset and reloaded for actual use.
Common lisp implementations do not have these problems. Moreover, scheme implementations seem to have significantly worse error reporting than lisps', though lisps' aren't very good either most of the time. Since they have conditions and restarts, though, that's not much problem, unlike in scheme-land.
Other functional languages not in the lisp family (I'm talking mostly of the ML-family languages like ocaml, haskell and F#) manage to have (depending on which) competent gc's (parallel, low-pause gc's that don't block the existence of native threads), very high execution speed, efficient pattern matching, and optional (that is, hindley-milner based with proper inference, which is for all intents and purposes the same as optional) type checking (fantastic to help with program correctness). Typically, they have their own compiler-level extension systems ("macros", be it templatehaskell or camlp4/camlp5/ppx) as well. Unlike lisps, they can achieve sub-2ms max pause times on similar artificial tasks that take chicken 22ms, ypsilon 300ms, racket 50ms, and gambit 24ms pause times for example.
So what's the point of using a lisp since their strong points are directly mitigated and they don't offer any additional value other than these?
I'm not even going to talk about libraries or community because those can always be built or bootstrapped but it's a fact that they also impact the quality of the development experience with the language.
When are we going to get a lisp that doesn't suck? Lisp languages are objectively superior in design and features. Why can't they work in practice? Live image modifications and restarts are insanely powerful tools. Why do no schemes have them? Why is CL stuck in the 60's (despite having been formalized in 1996) to the point C is almost more expressive and more functional?
To be clear, I mean in non-academic pursuits. For sure, scheme is unparalleled to enable exploring language development and implementation technology.
Feel like implementing yet another lisp and see it go nowhere just so I can say "at least I tried". Who's with me?????