My thoughts after using Clojure for about a month

Functional vs OOP and Clojure’s Design

• Several commenters start from an OOP background and find the functional paradigm initially uncomfortable but increasingly compelling for large systems.
• Clojure is seen as offering “OOP à la carte” via maps/records, protocols, multimethods, and schemas, though some feel this is ad‑hoc compared to traditional class hierarchies.
• Others argue that good OOP and FP converge in practice, and that pervasive immutability plus simple data transforms make large-scale design and refactoring easier.

Syntax, Parentheses, and Editing Experience

• Opinions on Clojure’s syntax are mixed: some call it “parenthetical hell,” others say vectors/sets/maps and minimal core syntax are a net improvement over other Lisps.
• Structural editing tools (paredit, parinfer, Emacs sexp navigation, Ki editor, indentation-based movement) are repeatedly cited as essential for managing brackets and making refactoring pleasant.
• There is debate over specific syntactic choices (e.g., let bindings in vectors, differing traversal of list vs vector in other Lisps).

Runtime, Concurrency, and “Syntax vs Runtime”

• A major thread argues that runtime properties (green threads, actors, STM, immutability) matter more than syntax for real-world systems.
• Some strongly prefer Erlang/Elixir or Go runtimes for massive numbers of lightweight actors and share‑nothing designs.
• Others counter that the JVM is one of the most advanced runtimes, now with virtual threads, strong concurrency, and libraries like Akka; claims that it “lags” are called outdated.
• STM and actors on the JVM are acknowledged but seen as less idiomatic or less widely used than BEAM’s built‑in model.

LLMs, Clojure, and the REPL

• Benchmarks show raw LLMs have lower one‑shot “success rates” in Clojure (syntax, parens, evaluation order), but when hooked to a Clojure REPL they can iteratively test code and become much more effective.
• REPL‑driven development is framed as a superpower, both for humans and LLM agents, enabling incremental exploration, debugging, and library discovery.

Typing, Specs, and Reliability

• Some commenters struggle with dynamic typing, reporting subtle runtime bugs and missing compile‑time guarantees they get from typed FP languages.
• Others defend Clojure’s intentional dynamism and suggest leaning on the REPL plus schemas/spec (e.g., Malli, spec, Typed Clojure in research/limited use) for partial static checks and data validation.
• One strong view claims dynamic typing is always a mistake; others disagree and emphasize trade‑offs and productivity.

Portability and Ecosystem

• Clojure is highlighted as a hosted language with many dialects (JVM, JS, CLR, Dart, babashka, C++, Python-hosted, etc.).
• A shared clojure.core test suite is being used to measure and improve cross‑dialect compatibility.
• This portability is presented as a major advantage: much “pure” Clojure code can run unchanged across runtimes.

Jobs, Popularity, and Economics

• Some note there are relatively few Clojure job postings and see that as lack of market appeal.
• Others respond that Clojure roles often pay above average and signal non‑commodity hiring; popularity and number of jobs do not directly track technical merit.
• Discussion distinguishes “synergy” and politics (e.g., Python, JS, C#, PHP adoption) from language quality.

Static Site Generators and Lispy Toys

• Multiple commenters mention writing their own static site generators in Clojure or other Lisps as a rite of passage.
• Homegrown SSGs are fun and easy to extend with macros/templating, but fall short of mature tools for optimization, CSS handling, SSR, and Node ecosystem integration; many eventually migrate to mainstream SSGs.