May 2023: Short Term Project Updates

By Kathy Davis

With several project cycles winding down, we have final reports in from Clerk, Clojure-ts-mode, Exercism, Kaocha, and Uncomplicate Neanderthal. Great work all! As always thanks for your commitment and contributions to the Clojurists Together community.

Project Clerk: Martin Kavalar
Project Clojure-ts-mode: Danny Freeman
Project Exercism: Bobbi Towers
Project Kaocha: Arne Brasseur
Project Uncomplicate Neanderthal: Dragan Duric

Project Clerk: Martin Kavalar

Update: 2 May 2023; Final Report
Funding Round: Q1 2023

In April we worked on the following:

Project clojure-ts-mode: Danny Freeman

Update: 15 May 2023; Final Report
Funding Round: Q1 2023

Project Update:

Clojure-ts-mode is now in a pretty usable state and should be ready for people to try out. Through this funding project I’ve implemented the following features:

Additionally I’ve been working on the documentation to make getting started with clojure-ts-mode easier. It is available for install now through package-vc on Emacs 29

(package-vc-install "")

And should be available on MELPA package repository soon.

Next steps

I was not able to get semantic indentation implemented yet, as I found the indentation mechanisms in tree-sitter difficult to use at first. However, I have a much better understanding now of them (and how to debug them). Over the coming months I will be working on semantic indentation to more closely match what clojure-mode does today. Once I have semantic indentation in a good place I will probably consider clojure-ts-mode ready for a 1.0.0 release. Until then it will stay in the 0.. version range.

Documentation is always a work in progress and will continue to improve over time.

Additionally, I will request to have clojure-ts-mode listed in Non-GNU ELPA package repository. This should make it easier to install for people that do not have MELPA configured.

Project Exercism: Bobbi Towers

Update 29 April 2023: Final Report
Funding Round: Q1 2023

Inline evaluation via SCI

I’m very excited about this feature because it transforms the online editor into a proper interactive Clojure environment. When the track was first launched in 2021 we received some valuable feedback from fellow Clojurists, who said that the online editor was quite lacking to someone familiar with using an editor connected REPL. I too consider this an inseparable part of the Clojure development experience, so this is something I’ve wanted to do for a long time.

Once I prototyped the desired behavior using Nextjournal’s clojure-mode, the next task was to figure out how to best integrate it into the existing Ruby on Rails/React application while making as minimal impact on the codebase as possible. The first thing I tried was to use scittle to load SCI via the <script> tag. This worked great, but I wanted something more modular and realized the best thing to do would be to make it into a proper plugin for Codemirror 6 and package it as an npm library similar to @nextjournal/lang-clojure which I was able to fork and use as a template, which is itself based on @codemirror/lang-javascript. This makes it extremely easy on the website team because it simply replaces the legacy plugin used previously, with the added benefit of creating a Clojure-evaluation plugin that can be used by the rest of the Clojure community to build highly interactive editors on the web. Repo:


Revised existing exercises:

New concept exercises in progress:

Concept exercises planned:

New practice exercises

Test runner upgrade

The learning exercise test suites now include metadata linking each test case to its respective task in the instructions. This enables a better user experience, because now after the tests are run, there is a button to return the student to the proper place.


Besides allowing me to work on this full-time, the funding enabled me to adopt two beautiful kitty cats! Now, coding is even more fun. Many thanks to all who made this possible.

Project Kaocha: Arne Brasseur

Update: 4 May 2023; Final Report
Funding Round: Q3 2022

In this last month of Clojurists Together funding the Gaiwan Team, in particular Alys and Laurence, worked on a few different fronts. Kaocha, kaocha-cljs, and kaocha-cucumber all saw smaller maintenance releases. Kaocha-cljs in particular had some documentation improvements done. Testing ClojureScript is a bit trickier than testing Clojure. The reason is that the compiler and the runtime live in different processes (one runs in the JVM, the other in a JS environment like your browser), and so there’s significantly more communication and coordination involved.

You might also be wondering about Kaocha-cljs vs Kaocha-cljs2. Why are we still releasing updates to the old version? In fact we maintain both, since they take radically different approaches, and so are suitable for different situations. The short version is that kaocha-cljs is much simpler in its setup, but is only usable with a very “vanilla” ClojureScript setup. We use it a lot for testing our libraries for instance.

If kaocha-cljs doesn’t cut if for you, you can use kaocha-cljs2. This one is adaptable to virtually any cljs setup and compiler config, but it takes more effort. We have some stuff in the pipeline though to hopefully make that easier, so stay tuned!

If you want to know more about what’s involved in testing ClojureScript, and about the differences between the two kaocha-cljs versions, you can listen to the ClojureScript Podcast with Jacek Schae Ep30 (since renamed to ClojureStream) where Arne and Jacek talk at length about these Topics.

April also saw the first release of Plenish a tool we (the Gaiwan Team) have been using to help one of our clients do analytics over Datomic. It lets you transfer your Datomic database to a Postgres database, allowing for analytical workloads to run on Postgres. For a, watch Arne’s talk about it. A related project is EmbedKit, which allows you to use Metabase as a dashboard engine, which is also mentioned in Arne’s talk, and which also saw a maintenance release in April.

Finally we released a new version of Ornament, our css-in-clj(s) styled component libraries, improving support for Tailwind 3 classnames.

We want to thank the community for putting their trust in us, and allowing us to work on these different projects over the last 6 months. And a huge thanks to the people who support us directly on OpenCollective. Due to staffing challenges we didn’t yet dip into the OpenCollective budget. We’re going to do some internal reflecting on how to best approach our open source work going forward, to make sure it’s relevant, visible, and sustainable, so stay tuned!

Kaocha 1.83.1314 (2023-05-05 / 1438ce7)

Kaocha-cljs 1.5.154 (2023-04-17 / f969eae)

Kaocha-cucumber 0.11.100 (2023-05-08 / 5c7009a)

Ornament 0.9.87 (2023-04-15 / dac82f4)

Plenish 0.4.50 (2023-04-24 / 1d5eca9)

Embedkit 0.0.56 (2023-04-14 / fd0bc4a)

Project Uncomplicate Neanderthal: Dragan Duric

Project Update: 28 April 2023; Final Report
Funding Round: Q1 2023

My goal with this round was to implement Sparse Matrix support in Neanderthal.

During the initial phases of the project, I realized that the domain area is bigger than I thought. I also decided to use JavaCPP MKL bindings instead writing my own JNI C code. This prompted me to create the ClojureCPP library, with lots of helpers and convenience functions. It proved a great help when dealing with JavaCPP pointers and native shenanigans.

Since Neanderthal is not based on JavaCPP pointers, I needed to create a port of Neanderthal’s native CPU engine. I could have attached the new JavaCPP parts to the existing ByteBuffer-based engines, but that would introduce complexity in code. So I decided to take the opportunity and implement a prototype of native CPU implementation of a part of Neanderthal core that is based on JavaCPP. This helped me in learning how to deal with JavaCPP itself, since it has sparse documentation and a ton of functionality.

So all this work went into another new project, Neanderthal Sparse, which I eventually plan to merge into Neanderthal. It contains both the port of existing CPU engines for vectors and GE matrices to JavaCPP, and the new sparse vector and sparse matrix implementations.

Regarding sparse matrices, the domain is larger than I expected, which was not helped by extreme sparseness of the documentation, and even related information on the Internet in general. I had to discover many things by poking and experimenting (Clojure REPL wins big here!). In the end, I managed to implement compressed sparse vectors (CSV), and compressed sparse row matrices (CSR) (with both row and column layout support), all related data structure interfaces that make sense with sparseness, the Float and Double engines with sparse vector operations, and the Float and Double engines with CSR operations for GE CSR matrices. I tested a lot of this, but it still needs polishing.

I could only release snapshots, as I discovered a few omissions in JavaCPP MKL preset that are then fixed in the new version 1.5.9, which is still only a snapshot, so Neanderthal Sparse is still only available only as a snapshot on GitHub.

All in all, I am satisfied with what has been done in this round. It may not be exactly what I imagined when I started, but become much broader, with a huge chunk of work that is more general and will benefit Uncomplicate libraries in future.

In short, Q12023 resulted in: