Why Clojure?

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Our great sponsors
  • SonarQube - Static code analysis for 29 languages.
  • Scout APM - Less time debugging, more time building
  • SaaSHub - Software Alternatives and Reviews
  • lispy

    Short and sweet LISP editing

    I’m using lispy[1] instead of paredit and absolutely happy about it.

    [1]: https://github.com/abo-abo/lispy

  • pomegranate

    A sane Clojure API for Aether / Maven Resolver + dynamic runtime modification of the classpath

    The only time I need to restart is when I load new libraries but you can use https://github.com/clj-commons/pomegranate

  • SonarQube

    Static code analysis for 29 languages.. Your projects are multi-language. So is SonarQube analysis. Find Bugs, Vulnerabilities, Security Hotspots, and Code Smells so you can release quality code every time. Get started analyzing your projects today for free.

  • babashka

    Native, fast starting Clojure interpreter for scripting

    Definitely. If you're using Clojure on the JVM, you definitly should read up on Java exceptions even if the errors have improved already, as it'll help you debug things, but the default error messages in Clojure has improved since then. Same if you're dealing with ClojureScript, you'll need to understand JavaScript errors and stack traces then.

    Probably a good starting point for people today is go straight for Babashka, easy to get started and fast: https://github.com/babashka/babashka

  • vertx

    A vertx core and web bindings for clojure.

    There haven't really been a lot of efforts to get a high-speed web frameworks done in just Clojure as that's not normally how professional Clojure developers work and deploy code. Not a lot of Clojure developers use frameworks in the first place, so the HTTP server ends up being something that gets pulled in as a library, and since it's running on the JVM, you use JVM servers, which are fast. vertx seems to be something that scores high, but unfortunately only the Scala binding seems to be in the benchmark you mentioned. Here's a Clojure alternative: https://github.com/vertx-clojure/vertx

    CLI apps are easily solved with Babashka now.

  • ghci-ng

    I've only dabbled with GHCI. I've used it as a standalone REPL for trying out small things, the same way I'd use a Python or Javascript REPL. I haven't used the REPL /the/ developer interface to the program. In Clojure, I would (1) start a REPL server, (2) connect to it from my editor, and (3) send expressions to it. I didn't develop Haskell that way, though I think it was possible with Intero[1].

    Within the Clojure community, there's a perception that the Clojure REPL is one of its strongest selling points[2].

    Are you using the REPL actively when developing?

    [1]: https://github.com/chrisdone/intero#readme

  • ghcid

    Very low feature GHCi based IDE

    Have you tried out ghcid? It basically just runs ghci on your program every time you save, and gives an updated list of errors and warnings. Not interactive in the sense that you don't manually test your functions with it, but like 95% of debugging in Haskell is just fixing errors at compilation time. I find it to be a very nice developer experience. Just need a text editor and a terminal with ghcid open and you get immediate feedback as you program.

    https://github.com/ndmitchell/ghcid

  • parinfer-rust

    A Rust port of parinfer.

    The Parinfer core algorithm is mostly "complete", with the remaining work being various editor integrations (which can be quite tricky).

    I maintain an up-to-date fork of Parinfer JS here: https://github.com/oakmac/parinfer

    The Rust implementation is also popular and actively maintained: https://github.com/eraserhd/parinfer-rust

  • Scout APM

    Less time debugging, more time building. Scout APM allows you to find and fix performance issues with no hassle. Now with error monitoring and external services monitoring, Scout is a developer's best friend when it comes to application development.

  • xforms

    Extra transducers and reducing fns for Clojure(script)

    * It's fast enough for 99% of apps out of the box. It's fast enough for 99.99% of the apps with minimal tuning.

    * Yes, if your project is very big and macro heavy, it can take some time, but startup times have improved. In any case, I BARELY need to restart my development JVM. I have one currently running that I haven't restarted for 1 week+.

    * Depending on what's your cup of tea, there's emacs/CIDER or IntelliJ/Cursive. They both work well. IntelliJ/Cursive is an excellent IDE combination. I use it every day.

    * Java interop is very straightforward, not sure what you mean. Sure your code might not be all pure anymore, but that's the price for solving actual problems.

    * Good java libraries have wrappers. A ton of original Clojure libraries as well. https://github.com/cgrand/xforms for example allows you to easily do things that I can't even imagine doing in an imperative language.

    * Static vs dynamic typing: don't want to get into that.

    * "Clojurescript isn't the same language". I use both Clojure and ClojureScript every day and as far as Clojure-only code is concerned, it works in both languages 99.99% of the time. One case you can encounter issues is if you do something host-specific, like dealing with numbers. That's by design. Clojure embraces each host, does not try to reinvent it. When you just use pure Clojure data structure manipulation, it works the same across both languages and works like magic.

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts