r/Clojure

I used to program in several programming languages, Clojure being one of my (but not only) favorite. Now that I have some acute (brain-related) disease, this is the only one that still really clicks for me ... from installation to running/testing my old code, the personnally-dreaded DevOps tasks included ! (with of course some remaining "muscle" memory). Resilience is not an empty word in this frantically-moving world, thanks Clojure (and by of transitivity, the JVM), I owe you much!

DISCLAIMER: This is my hobby project which I used to learn Replicant/Nexus (by Chris Johansen) and Datalevin/Datascript and to leverage data-driven approach of Clojure/script and these libraries. It started as a solution to "scratch my itch" problem and was inspired by u/cjno*.*

You might think sharing a handful of editable tasks among a few people would be dead simple in an era of todo-list apps. You'd be wrong.

To my knowledge, no simple tool of this kind exists. There are countless complex apps that want something from you and your collaborators — a subscription fee, registration, an email address, your smartphone's private data, permission to send you notifications, and everything in between.

So I built something my elderly father, wife, kids, and less tech-savvy co-workers can use instantly, without explanation from their phones.

The solution is deliberately minimal: just a URL per collaborator, opened in their browser (desktop or mobile) — no new tools, no new habits. The list is the single source of truth; ongoing communication happens through whatever channels they already use: chat, Messenger, email…

I built https://dotolist.eu for myself as a proof of concept — but friends quickly adopted it, and you're welcome to use it for free. It is NOT vibe-coded. It is love-coded in Clojure. Wrote about my journey here: https://lifehacky.net/dotolist-creating-a-one-click-team-065a18dbeccd (includes some tips and tricks for the app too).

Let me know if you find it useful.

https://preview.redd.it/42hzzu3c7o1h1.jpg?width=1400&format=pjpg&auto=webp&s=0215db74c5a05ca353a67d90701b19e642f47382

The Clojure development team is pleased to announce a Clojure Dev Call on May 26 @ 17:00 UTC!

Join the Clojure dev team for an update on what we’ve been working on and what’s on our horizon. We’ll save time for a Q&A, so bring your questions.

Register here: https://events.zoom.us/ev/Ag74cYrxFKu8A_qZwQHMzZzKZ-lnr15g1rmvUjSqdpS2aedAZIBo~AhzYDI3YXGVeo0auBgpDwpPDqiJbBBs2ZQo-ZZTVqNvxl4VqoZCyikRI-A

i work at a small data consultancy and we have around 160 youtube videos. recorded client workshops, internal tech talks, vendor demos, conference presentations people found useful. all shared through a notion page with links. the usual problem where nobody can find anything because the titles are things like "workshop recording feb 2024" and you'd have to open each video and scrub through it to figure out what was covered.

i built a search tool for it in clojure last weekend.

the backend is a ring server with reitit for routing. one GET endpoint for search, one for serving the html page. postgres for storage with full text search. the queries use honeysql to build the tsvector match and ts_headline calls. i have one namespace for the db queries, one for the handlers, and one for the system startup. the whole server is maybe 80 lines across those three files.

for pulling transcripts i use transcript api:

npx skills add ZeroPointRepo/youtube-skills --skill youtube-full

the ingestion side is a separate namespace with a -main that reads urls from a file and processes them sequentially. clj-http to call the api, cheshire for json parsing, next.jdbc to insert into postgres. each video gets a row with the title, date, speaker, tags, youtube url, and the full transcript. the ingestion namespace is about 40 lines.

the postgres full text search does the heavy lifting. tsvector on the transcript column with a GIN index. the honeysql for the search query ended up being surprisingly clean. something like:

(-> (select :title :date :speaker :youtube_url
            (call :ts_headline "english" :transcript (call :websearch_to_tsquery "english" ?query)))
    (from :videos)
    (where [:raw "transcript_tsv @@ websearch_to_tsquery('english', ?)" query])
    (order-by [(call :ts_rank :transcript_tsv (call :websearch_to_tsquery "english" ?query)) :desc]))

reads better than the raw SQL honestly.

the frontend is a single html page served from resources. plain html with a fetch call to the search endpoint. no clojurescript, no reagent, no build step. just a text input and a div that gets populated with results. the results show the video title, speaker, date, and a snippet of the transcript with the match highlighted.

i deploy it with an uberjar on a VPS we already had. java -jar and it's running. about 160 videos indexed. the consultants use it before client calls to look up whether we've covered a topic before. someone found a recorded workshop from 18 months ago that answered a question a client had asked that week.

the thing i like about this project is that it's small enough to hold the entire codebase in your head but useful enough that people actually open it daily. 120 lines of clojure, a postgres table, and a static html file.

I’ve been working on Beagle:

https://github.com/tompassarelli/beagle

It’s an experimental typed authoring layer for Clojure. You write Beagle source, it gets parsed and checked by Racket, and then it emits plain .clj files that run on the normal Clojure runtime.

Roughly:

Beagle source
  -> parser
  -> custom type checker
  -> emitted .clj
  -> normal Clojure runtime

It is not Typed Clojure, and it does not change the Clojure runtime. The type checker is custom and lives on the authoring side.

Some pieces that may be interesting:

• preserves Clojure [] vs () syntax
• emits ordinary Clojure
• has about 666 pre-typed Clojure stdlib functions
• includes an LSP server, typed REPL, and reactive checker daemon
• has repair tooling that can turn some failures into ranked patch suggestions

The main thing I’m testing is whether this kind of typed layer helps coding agents repair Clojure programs.

Early result: on an ~8,500 LOC test with 35 injected bugs, Beagle got 3/3 full repair correctness. Raw Clojure got 0/3 in the same setup.

I’m not claiming that proves the whole idea yet. The tests need to get larger, cleaner, and harder. But the early result was interesting enough that I figured it was worth sharing.

I just put the docs on a small Clojure framework I've been hacking on, **stube**. It's a personal research project, not a product — somewhere I'm working out an idea about web apps that has pulled at me for twenty years.

Short version: components are plain maps of pure functions, the conversation is a value, handlers return effects, and one component can *call* another and read its *answer* like a return value (Seaside / UCW lineage). The wire is Datastar (SSE + morph by id); the implementation is a small effect kernel over plain Clojure data.

(s/defcomponent :demo/save-or-cancel
  :render (fn [self]
            [:div (s/root-attrs self)
             [:button (s/on self :click :as :save)   "Save"]
             [:button (s/on self :click :as :cancel) "Cancel"]])
  :handle (fn [self {:keys [event]}]
            (case event
              :save   [(s/call :ui/confirm {:question "Save changes?"} :on-confirmed)]
              :cancel [(s/answer :cancelled)]))
  :on-confirmed
  (fn [self yes?]
    [(s/answer (if yes? :saved :cancelled))]))

Built heavily with LLM assistants — wouldn't have shipped it this fast otherwise — but the shape, the namespace layout, and the choice of what to include and what to leave out is mine and reflects how I think about systems.

If you're a re-frame person and the conversation map feels familiar: yes, deliberately. The conversation here is closer in spirit to a re-frame app-db than to a Smalltalk image.

- Repo: https://github.com/zekzekus/stube

- Rationale (why this exists at all): https://github.com/zekzekus/stube/blob/master/docs/rationale.md

- Tutorial: https://github.com/zekzekus/stube/blob/master/docs/tutorial.md

Happy for feedback, war stories, "have you seen X" pointers.

I’m particularly interested to hear anecdotes from folks who have previously used Typescript or Elm or some other statically typed front end tech.

Announcing Ducktape!

Pleased to announce that we just released the first version of dynamic-alpha/ducktape for people who feel like helping us test. It is a near drop-in replacement for tmducken but uses java.lang.foreign instead of JNA for FFI. Highlights include:

• Deterministic native memory. Allocations live in scoped Arenas and are released with with-open rather than via GC finalizers. Helps avoid possible doublefrees under GC load
• 12 more DuckDB types  -BLOB, HUGEINT, DECIMAL, INTERVAL, ENUM, LIST, STRUCT, MAP, and the full timestamp precision family.
• Streaming appender API -  open-appender / append-dataset! / flush-appender! keeps DuckDB's appender alive across batches, amortizing per-call setup. Handy for Kafka consumers, paginated API ingest, file shards - up to 10x faster than repeated insert-dataset! for small batches.
• Performance -  Parallel column encode/decode, direct MethodHandle dispatch, partitioned parallel-concat for multi-chunk reads. Lands at 1.1–4.0× vs tmducken across numeric / string / uuid / mixed / wide workloads (1M rows, JDK 25, DuckDB 1.5.2, all significant at 95% CI - full table in the README).

Get Clojure up and running in IntelliJ for a fast, productive Lisp development workflow on the JVM. I focus on practical setup for REPL-driven development, dependency management, code evaluation, and debugging so I can build and iterate efficiently. A strong use case is developing a data transformation pipeline that ingests EDN or JSON, applies functional business rules, and validates results directly from the IntelliJ Clojure REPL.

Leiningen on Windows is a practical way to manage Clojure projects, handle dependencies, and build and run applications from the command line. I use it to streamline Clojure development, automate project setup, and package JVM-based programs efficiently. A common technical use case is creating a command-line data processing tool in Clojure, then using Leiningen to compile, test, and run it consistently on Windows.