Posts about Clojure

All the posts...

Clojure Projects

24 March 2025

I have a long list of Clojure projects I’ve created over the years to learn Clojure and accomplish various personal tasks.

Advent of Code

As of the end of 2024, I’ve done at least some of Advent of Code for 7 years in a row. I’ve had the most fun and practice parsing and transforming the input data for each puzzle into a suitable model.

I learned pretty quickly from the puzzles to store the common grids as sparse maps to save lots of memory and keep the problem in memory. I sometimes got stuck on the puzzle and the algorithm, but I still got lots of practice in general Clojure. I definitely see that the Clojure data structures lend themselves well to the puzzles. I’ve gotten to effectively apply lots of common Clojure libraries like core.async and core.logic.

Incidents

My incidents project scrapes an RSS feed of emergency response incidents in Lancaster County and stores them into an XTDB database for history. It generates static site of current events with hiccup and historical charts with Clerk.

Running this project day-to-day, I learned that the Clojure/JVM start up is a bit too heavy to start frequently from cron, so I run it as a service in systemd with its own scheduling. Clerk is also a bit heavy with the amount of historical data, so I have that scheduled to rebuild less frequently than the scraper. The site is still all static.

Event Logger

With this CLJS project, I was trying to derive a standard shadow-cljs workflow to make sure I could start any new CLJS web project quickly. It started using Reagent, and I migrated to Helix to be less-insulated from newer React features. I also wrote code to migrate data in local browser storage from an old Transit format to EDN. I’m constantly learning the better flows for data in React and local storage.

COVID Warehouse and COVID Web

The beginning of 2020 provided some of us with lots of downtime, so I started loading and analyzing Johns Hopkins University’s data on COVID with my own data warehouse and web app to display my data.

The data was pretty messy early on, and it changed over time, so I needed to parse lots of different formats. I generated a static site with my historic graphs and focused on World, US, and counties in Pennsylvania. It was a classic ETL for a star schema data warehouse, since I wanted to refresh my experience on that. I initially stored in in a SQL database using hugsql and next.jdbc.

After a bit of time, this became my first project to explore CRUX/XTDB and NoSQL data structures. I learned a bit about how changes applied in XTDB and how to limit history and otherwise save space on my small server environment. I could easily apply core.async when it was time to get things done faster.

The web app project that I added later provided a more dynamic Reagent app in CLJS that used the static data produced by warehouse project.

Planning Poker

I wanted a simple tool for conducting planning poker in sprint planning, so I built one in JS to run on mobile phones. When I started learning CLJS, I converted it to Reagent and used Leiningen to build it.

Clojure All the Other Things!

I’ve enjoyed finding there are ways to apply Clojure to everything!

Structured Intepretation of Computer Programs

I’m reading SICP and implementing all the exercises in Clojure.

Music in Overtone

I have a project where I play with data structures for music and explore lots of examples in Overtone, including Rich Hickey’s experiments in additive synthesis and sequencing some simple beats from drum-n-bass tutorials for other DAWs.

It required lots of yak-shaving work over the years to keep the native wiring to Supercollider and Linux sound working.

3D Objects

I’ve found a library to interface Clojure to OpenSCAD, so I have some 3D models defined in Clojure code for printing.

Roll Your Own HTML in Clerk

23 April 2023

The clerk/table component automatically limits itself to only showing 20 results. Other presentation components, especially text, have configurable elision behaviors, but it doesn’t apply to the table.

After searching, guessing at ways to do it, and even asking in conference talks, I finally realized that we can render our own HTML with clerk/html and hiccup. That HTML is not limited to any size, and building a table is easy. We used to do it all the time.

I wrote my own simple function to render a table, and I used that instead of the clerk/table. It takes the same parameters I was already using.

^{:nextjournal.clerk/visibility {:code :hide :result :hide}}
(ns sample
  {:nextjournal.clerk/visibility {:code :fold :result :show}}
  (:require
   [nextjournal.clerk :as clerk]))

^{:nextjournal.clerk/visibility {:code :hide :result :hide}}
(defn my-table
  "display a simple table in html.
  :head is the sequence of head labels.
  :rows is a sequence of sequences.
  :limit is the max to display of the rows. (default 100)"
  [params]
  (clerk/html [:table
               [:thead
                [:tr
                 (for [h (:head params)] [:th h])]]
               [:tbody
                (for [r (take (or (:limit params) 100) (:rows params))]
                  [:tr
                   (for [c r]
                     [:td c])])]]))

(my-table
  {:head ["x" "y"]
   :limit 100
   :rows [[1 2]
          [3 4]]})

Update 2023-11-27

As of the 0.15.957 release, clerk tables have a ::clerk/page-size parameter, so I use that now instead of the code above.

Podcast List for November 2022

03 November 2022

I have 73 feeds I currently follow. I have a whole system of prioritization, so I can listen to important things first. I’ve listed them alphabetically here:

Java Joyless

27 January 2021

Mr Haki has a Java Joy article about transforming a stream of strings into a map using functional Java. I’m having a bit of trouble embracing it enthusiastically, since each example is 81 lines of Java code and a pointy pile of type declarations!

I dashed out the same functionality in 4 lines of Clojure, and I can understand it a whole lot easier. I’m not even sure this is the fewest forms, but it’s still nicer.

  (->>
    ["language" "clojure" "username" "john"]
    (partition 2)
    (reduce (fn [m [k v]] (assoc m k v)) {}))
  ;; => {"language" "clojure", "username" "john"}

Update 2021-04-14: It can be done in one line of Clojure.

  (apply hash-map ["language" "clojure" "username" "john"])
  ;; => {"language" "clojure", "username" "john"}

Written with Clojure 1.10.2.

All the Posts

March 2025

April 2023

November 2022

January 2021

November 2020

October 2020

May 2020

March 2020

December 2019

March 2018

February 2018

January 2018