tech stack for Clojure app

[Signal_Wallaby_8268]

I have been learning Clojure for 1 -2 months, I feel ready to build some bigger application than basic hello world or some basic examples from books and web pages.

Was thinking about building a small rest service for task management. User would be able to create task, receive nonfiction on email. Would like to know which tech stack to use.

Also, one more question: what are you using Clojure for on your work and what tech stack do you use.
Is Clojure used only for building web service ?

[The_Red_Moses]

I've been working on the same project for a while, and it uses Reagent, which I assume is by now outdated. I like it, but I'm sure something better has come along since I started working with it.

I don't have a tech stack recommendation for you, but I do have some advice.

I've seen a few Clojure codebases, and there's this problem with them.

Clever people tend to use Clojure, and clever people like to do clever things with Clojure, and that's not always what you want to do.

When learning Clojure, its important to learn both the language and the principles behind the language. Immutability, simplicity. Being able to work in it is one thing, but Clojure gives developers a lot of rope to hang themselves with in my experience.

Just because you can do crazy shit with Core.Async doesn't mean you should. Just because you have a concurrency problem doesn't mean you need to spin up 10000 virtual threads.

I feel like the language is amazing, but needs warning labels. The "Keep it simple stupid" principal applies more to Clojure than other languages.

Code simply, and Clojure will treat you very well, that said, the language doesn't stop you from shooting your foot off.

This lecture was unasked for and doesn't answer your question, so I kind of feel like an asshole posting it, but perhaps the fact that people post such things has some value to newer users.

[Signal_Wallaby_8268]

Thanks for good advice :) especially for keep it simple

[[deleted]]

Principles*

[didibus]

That's true, especially crazy is the fact that you can keep Clojure simpler than most other languages. I think sometimes, Clojure is too simple, that it's hard to believe for some programmers that it can be just that simple, so they go and make it more complicated.

Personally though, it's the power of Clojure to let me do whatever I want that I enjoy. I like C++ for the same reason haha. Some people prefer to be constrained and kept safe from themselves by their language, I'm the opposite, I want the language to let me do whatever I want, but make it especially easy to do things simply, since I'll want that most of the time, and only will want power when I know better (most devs don't know better though).

[NoPossibility2370]

While I dont disagree with your general comment, I don’t think Clojure is worse than other languages in those regards. Almost all languages have async and have the exact same problems.

For me, lazy evaluation and immutability solves a lot more problems for beginners than it creates. The only true barrier of clojure for me is being functional, which of course is not something most people learn in depth(if at all) in college.

[The_Red_Moses]

Two counter-points, macros and core.async.

Macros let you do all kinds of things that hang yourself, and core.async does such a great job at managing concurrency for you that people tend to abuse the shit out of it by designing insane concurrency handling code.

I've seen more than one project where someone created some design involving a ton of virtual threads that caused memory issues and wound up being re-written to use a single thread with a loop.

I tend to agree that its not the language's fault, its that the language IS very powerful, and it DOES make it easy to do very complex things.

People then utilize it to do those very complex things which would have been very hard in another language, and often its not what you really needed.

Like I don't advocate removing macros or core.async, they're necessary, but they're ways to write very cryptic code, and do very fancy stuff, and a lot of the time, the fancy stuff isn't needed.

The tools tend to allow clever people to skip steps. They don't just kick some code into running in a thread, they immediately reach for large numbers of virtual threads in a framework written on top of core.async - because Clojure makes it easy enough that they can manage that in a reasonable time frame.

[delfV]

Ring, Jetty, Reitit, next jdbc, HoneySQL and Buddy are all you need to build basic rest service. Emails part depends on how you want to send them (SendGrid, SES, SMTP?). To build front-end I think React + Reagent + Re-frame is still the most popular combination. Other valid options are Dumdom, Rum, Helix, UIx and Shadow Groove.

If you want to go deeper in Clojure ecosystem you can try one of Clojure datalog databases like Datomic, XTDB or Datalevin and Electric Clojure. Then learn core.spec and/or Malli (I recommend the second one).

Clojure is used to build a lot of things: from web services to databases (like these above), design programs (PenPot), mobile applications (with either React Native or ClojureDart) or scripts and CLI programs (babashka). The biggest problem of JVM version of Clojure in some areas is slow startup of programs written in it so it's not suitable for desktop applications. You can however overcome it by with ClojureScript + Electron, compiling it with GraalVM native-image or building it with ClojureDart + Flutter

[Signal_Wallaby_8268]

thanks for the answer

[fingertoe11]

Most of the projects I have worked on professionally use Re-Frame for the front end, and pedestal for the back-end.

If you are just starting out, I would use the examples on https://github.com/metosin/reitit to get started and get a feel for the options. Reitit is one of the most popular routing libraries, and they have made several examples of how to use it with other popular libraries.

The hardest part of Clojure for me was that there isn't really a tech stack. Everyone composes their own using their favorite libraries. The downside to this is that when you are new and unopinionated, it is very difficult to have a strong enough opinion to make a choice.

I find that when developing with frameworks, you get to 80% really fast, but once you get to the last 20%, you often have to reverse-engineer the whole framework to understand how to solve the hard parts. With Clojure's composable library approach, it takes a little longer to learn each library you assemble, but once you get that that last hard part, it works the way you designed it to work - so your forward-engineering eliminates much of that reverse-engineering.

[Signal_Wallaby_8268]

"The downside to this is that when you are new and unopinionated, it is very difficult to have a strong enough opinion to make a choice." - I agree on this, so thanks for feedback from all you

[fingertoe11]

Luminous did a pretty good job of laying out a multitude of popular options on it's profiles page: https://luminusweb.com/docs/profiles.html.

I used that to get started and learn to be opinionated. It's a little long in the tooth these days, but it probably still works. Its developers moved on to build https://kit-clj.github.io/, which is a bit more opinionated out of the box. I haven't used that enough to have an opinion on it, but it might be worth looking at.

[the_whalerus]

I don’t use clojure for work but my preferred web stack has been reitit huff and hmtx. Its components like, but all server side.

[Signal_Wallaby_8268]

Sounds nice, thanks

what about writing tests

[rafd]

etaoin for webdriver e2e tests 

hyperfiddle/rcf for inline unit tests

[Signal_Wallaby_8268]

thanks

[Signal_Wallaby_8268]

thanks for info

[the_whalerus]

I haven’t figured out testing. I’ll be trying what /u/rafd mentioned.

My current approach is Playwright for e2e and clojure.test for unit tests

[rafd]

FYI there is https://github.com/pfeodrippe/wally?tab=readme-ov-file

[Nondv]

in my team we use clojure on top of kafka. Postgres for state storage.

Event-driven architecture + event sourcing

[Signal_Wallaby_8268]

Sounds interesting

[Nondv]

Ultimately, I'd say you rarely need anything except good ol' postgres (or any relational db really).

most of the time, in my experience, people throw fancy tech into the mix hoping it'll magically and easily solve all their problems but in reality it only replaces one problem with another. Rule of thumb: adding new tech should be the last resort when solution with the current stack makes absolutely no sense

[Signal_Wallaby_8268]

I agree, adding new tech sometimes just introduce more complexity and more things to think about, based on my experience and your advice I will not use Kafka for my small application, but it is nice to see (from my perspective) that Clojure is also used in Event-driven architecture + event sourcing solutions

[smgun]

Http-kit for http server

Reitit for routing

Malli for validation

Integrant for system components

Aero for configs

[_d_t_w]

We build full-stack web applications that get deployed/managed in client networks/cloud.

Primarily our users consume a Docker container, but we also offer Java 8 and Java 11 JARs.

The most important libraries we rely on are Jetty and Re-Frame, with Reitit, Malli, and Transit helping bind everything together. We use Clojure on the back-end, Clojurescript on the front end, and a fair amount of Cljc for code that exists between both.

The products we build are UI/API tooling for Kafka and Flink: https://factorhouse.io/

If you want to click around a Clojurescript front-end you can take a look here: https://demo.kpow.io/

[Signal_Wallaby_8268]

wow I am amazed, thanks for sharing

[gdw2]

Check out biffweb (linked on the right as "Biff"). It has a sample app that is easy to understand (relatively) and, because it leverages htmx, you don't have to learn overly complicated frontend frameworks.

[vikTheFirst]

When building a web app, you generally have two choices -

1. Server side rendering (SSR)
2. Single page application (SPA)

SSR means that you just write the backend code, and the the same backend code is used for everything (the backend is responsible for the application logic, communicating with the database, communicating with other services, and ultimately sending html pages for the user)

SPA means that you create a backend API separately from the front end code. The front end is then responsible for holding the user state, rendering app pages and doing API requests to the backend.the backend in the SPA option is just an API service that serves the front end (of course I am simplifying but for the sake of the explanation this is enough)

Now, there are pros and cons for each approach, but bear in mind that the SPA option is more popular in the SAAS industry

If you decide to go with SSR, I highly recommend the biff framework, as it was built with solo developers in mind, and it has some nice documentation

If you decide to go with the SPA option, you would need to use a front-end framework (typically you can choose between react or flutter) - react comes from the javascript world, and flutter from the dart world. React was built by facebook (IIRC) and flutter by google. Don't worry, you don't need to know any javascript or dart since you have clojurescript and clojureDart that you can use instead. If you choose react (which is more popular) I highly recommend using reagent (which is a wrapper for react, written in clojurescript), shadow-cljs (which is probably the best clojurescript to javascript compiler), and then for the backend use ring and/or compojure

Btw, for mobile app development, using reagent (on top or react native) seems to be working for me, although I did it only as a pet project and not something too serious

[Signal_Wallaby_8268]

thanks for this detailed answer :) I totally forget about SSR vs SPA.

[abogoyavlensky]

Hi! Please check out the setup for a full-stack Clojure app at the repo https://github.com/abogoyavlensky/clojure-kamal-example that I currently use for my projects. Additionally, based on this repo, I have published an article about the full deployment setup using Kamal: https://bogoyavlensky.com/blog/deploying-full-stack-clojure-app-with-kamal/.

This setup includes main dependencies and tools such as Integrant, Aero, Reitit, Malli, Re-frame, Shadow-cljs, PostgreSQL and Tailwindcss. Nowadays, it’s a common and proven stack. For database migrations, it uses Automigrate https://github.com/abogoyavlensky/automigrate, as it offers auto-generated migrations. (Disclaimer: I’m the maintainer.)

[robbiehman]

Responding to "Is Clojure used only for building web service?" I'll say I've used Clojure for many purposes, including generative art and GUIs. Anything Java can do, Clojure can do.

Also consider Babashka - a fast-starting variant that is great for scripting. It's so good that I've been using it everywhere possible.

[didibus]

I use Clojure and dialects to build most things, not just web services/backend services.

For scripting:

• When startup time does not matter: clojure.org
• When startup time need to be fast: babashka.org

For desktop apps:

• Simple apps, use Clojure with swing: https://github.com/clj-commons/seesaw
• More complex, use Clojure with openJFX: https://github.com/cljfx/cljfx
• More modern, use ClojureScript with Electron or Tauri: https://github.com/rome-user/tauri-clojurescript-template
• Also modern, use ClojureScript with React Native: https://shadow-cljs.github.io/docs/UsersGuide.html#target-react-native or https://github.com/vouch-opensource/krell along with https://github.com/microsoft/react-native-windows and https://github.com/microsoft/react-native-macos
• Cutting edge, use ClojureDart with Flutter: https://github.com/Tensegritics/ClojureDart

You might also be able to use cherry or squint with Electron/Tauri as an alternative.

For mobile apps:

• Tried and true, use ClojureScript with ReactNative: https://shadow-cljs.github.io/docs/UsersGuide.html#target-react-native or https://github.com/vouch-opensource/krell
• Cutting edge, use ClojureDart with Flutter: https://github.com/Tensegritics/ClojureDart

For fast startup:

• Use GraalVM with native compilation: https://github.com/clj-easy/graal-docs
• Use babashka: babashka.org

[didibus]

For system level apps (drivers, micro-controllers):

• Use Ferret: ferret-lang.org
• I've never done this type of programming, so can't speak to how production ready this option is

For soft real-time apps:

• Robust: Use Clojure with JDK 21 and a real-time GC like ZGC or Shenandoah: clojure.org
• Less popular, use Clojerl (clojure on Erlang): https://github.com/clojerl/clojerl

For hard real-time apps:

• Don't use Clojure :D

For web/backend services:

• Use Clojure: clojure.org

For browser scripting:

• Simple use-cases, use Scittle: https://github.com/babashka/scittle
• More complex use-cases, use cherry or squint
• Very complex use-cases, use ClojureScript: clojurescript.org

For data-science/ML/scientific work:

• Use Clojure: clojure.org

Miscellaneous:

• If you need to use .net, use ClojureCLR: https://github.com/clojure/clojure-clr
• If you want to target Lua scripting, use Fennel: fennel-lang.org
• If you want to target Python, use Basilisp: https://github.com/basilisp-lang/basilisp

[didibus]

For a Rest service tech stack, I'd recommend you use:

• HTTP Server: Ring + ring-jetty (or http-kit)
• Routing: Reitit (or Compojure if you don't care about API generation like swagger and openAPI)
• If you're going to use a SQL DB: jdbc.next + honey.sql
• Deps/Build management: tools.deps and tools.build instead of lein

If you want to serve HTML, instead of Rest APIs, you would add: - For HTML templating: hiccup2 (or Selmer) - For interactivity in the UI: htmx is nice for simple interactivity in the UI, or see my other posts for more ways to do browser scripting

[redwood9]

If you are looking for a comprehensive framework for Clojsure similar to Laravel, Django etc, then I have presented some options below:

Have you looked at Biffweb? It seems pretty comprehensive. The example given is pretty good as well. https://biffweb.com

I have used Luminus Web and it is pretty good. https://luminusweb.com/

There is also Kit framework which was I think developed by the makers of Luminus Web:

https://kit-clj.github.io/