Ask HN: Have you felt that Clojure is a bad version of Common Lisp?

Not so much as a bad version of Common Lisp, but a half-baked Lisp. I am well aware that a response like this is bound to stir the opinions of other people about things like this, but I am also bound to express mine. There is not one correct response, and that everything can be considered subjective.

Clojure (on the JVM) is a lisp-y way to talk to the JVM and the rest of its ecosystem. Because it uses s-expressions, it allows for abstractions that are not possible otherwise. I have used Clojure myself in the past. It was fun.

However, there are still many things that are not polished in Clojure that are well-established in Common Lisp. The debugger of Common Lisp is one of the best out there. Its object system is also top class. Backtraces in Common Lisp allow you to get as much information as you can get from your program. Metaprogramming in Common Lisp is also out there in the top. The inverse, however, is not true. You need to have a PhD in JVM in order to read Clojure backtraces. You can easily create a program then dump it into a single executable with Common Lisp, not so much with Clojure. You want fast startup? Not with Clojure.

If you haven’t spent a significant amount of time with the different kind of lisps, it’s hard to make objective comparisons and judgement—everything that Clojure has would look cool and fancy.

I know some people who share the same sentiments that I have, who won’t reply to this thread. However, I’m a fool to even write this response.

They're not trying to be the same thing.

- Clojure has a unique take on state management backed up by unique value semantics. This has created an emergent data-oriented paradigm.

- It heavily favours functional programming and all of the built-in data structures are persistent.

- It is designed to be used and reused across different host environments (CLJC), not just the JVM.

- It bases its collections on a common, flexible abstraction (seq) and has introduced very useful data literals for maps, sets, vectors, regexes, etc.

- It eliminated a bunch of anachronisms like superfluous parens everywhere and car/cdr, while introducing useful syntax for destructuring.

- It's a Lisp-1 like Scheme.

Yes I felt the same. It always just disappointed me that it was built on top of the JVM, even though (or maybe because) I did write professional Java code for a few years. I can understand the decision and the reasoning behind it, but this made Clojure feel very limited, made it feel like it will never really "grow" as a language because it always had to stay within the Java realm.

When I tried Clojure I had to set up a "project structure" with files before I could run any code. With common lisp I can just start typing in a buffer in memory, and evaling right away. I can use common lisp as a quick little calculator. More freedom to use lisp as I see fit, not in someone else's vision of a "project".

The clojure repl took FOREVER to start up. Pocket programming is a no-go. SLIME starts up in a flash.

I don't have anything against the Clojure language itself. I'd say this is more of a credit to common lisp for getting so much so right in the language, runtimes, performance, and tooling. It's a unicorn.