My thoughts after using Clojure for about a month

Original Article ↗ Hacker News Discussion ↗

Clojure’s appeal as a functional, Lisp-based language on top of the JVM is weighed against its awkwardness for newcomers, especially those used to OOP, static typing, or more conventional syntax. Commenters highlight strengths such as immutability, powerful REPL-based workflows, portability across multiple runtimes, and strong support for LLM-assisted coding, while contrasting the JVM’s evolving concurrency model with Erlang’s and Go’s actor-style runtimes. Others point to trade-offs: dynamic typing can complicate maintenance, the ecosystem and job market are relatively small, and effective use often depends on specialized editor tooling for managing parentheses and structural editing.

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.