Dutch Clojure Days 2022

So at last, after 2 years of waiting it was that time of year again! No, not Christmas, Dutch Clojure Days (DCD) of course..! Because of “things” that happened over the past two years there hasn’t been an edition of DCD, but last weekend, the 29th of October they were finally back, and oh Yes! It was a lot of fun.

The DCD is the annual International Gathering of Clojure Enthusiasts and Practitioners in the Netherlands! This year, 2022, was the 6th edition and it’s traditionally a free and non-profit Clojure conference organised by the community, for the community with a full day of amazing talks in a friendly welcoming atmosphere.

I first heard about DCD back in 2018 when I was graduating from University. I was doing some Clojure stuff for my thesis and my mentor encouraged me to do a talk about my project in one of their lightning talks for the 2019 edition. So I did, you can see it here. Enjoy seeing me fumbling around doing a live demo. It’s fun, trust me. Although when I look back at this talk I always wished the would have told me that I needed to speak more into the mic, but yeah, learned that for next time.

But enough about the 2019 edition. Today I want to talk about the 2022 edition of course. I got there at about 09:10 AM after a 3 hour commute. I had the chance to listen to some awesome podcasts though, as I do with all my commuting so that didn’t bother me that much. When we entered we all need to show our (free) tickets plus we got a name tag.

This is something I really like and I hope they keep doing. It really eases the communication a lot! As a Clojurian most people are active on slack, or have appeared different on podcasts done by the community, which means, faces are not that known, but their names are! So when people wear these name tags and you hear they speak you can fit a name with a face. And on the other side it’s a great way to start a conversation.

When the event started Carlo got on stage to welcome everyone and talked about some of the sponsors. Some of the got on stage like Brightmotive, Flexiana and Freshcode. Juxt wasn’t there at that moment, but they joined later.

After all this housekeeping, the first talk started and I really enjoyed it so let’s dig into it.


Clojure + UI = <3

by Nikita Prokopov


So this first talk was about a clojure project that focuses on UI. Mainly, Desktop UI. The talk started with the notion that there are multiple solutions to develop web and mobile UI’s with Clojure but there is no really library that provides proper abstractions and functions to develop native desktop UI’s.

But this is exactly what Nikita Prokopoc is doing with his project called HumbleUI. During this talk he showed of a lot of live demo’s using HumbleUI, especially since his presentation was made in HumbleUI. So he could show of demo’s directly inside his sheets. Also, showed of the performance, which was pretty impressive for a product in it’s alpha stage.

Also, the live editing, using a Clojure REPL of course was pretty amazing. No weird hiccups of glitches were detected when he was changing some text or styling. He compared this with other frameworks that support hot-reload but these often show some glitches when editing a live program. So this is also pretty awesome.

When I also specifically liked was the way he treated text in HumbleUI. In common HTML, text has this additional whitespace margin around it but in HumbleUI, this whitespace is removed making for a simpler way of positioning text. I’m bad at describing this, but once the links to the talks appear on youtube I’ll refer they so you can see exactly what I mean.


A Library Reckoning

by Paula Gearon.


So Paula is one of these people who everyone in the community probably knows. Even I as a Clojure Hobbyist have heard her name in multiple podcasts. She appeared on defn and the Clojure stream podcast as well I think. Mostly talking about her database adventures as she writes and maintains one herself. Really great stuff!

But the talk she was doing today was not about databasy things, it was about getting a library accepted into the core ClojureScript library, which in itself is pretty impressive. About a year ago she set out to implement the cljs.math library for ClojureScript because she needed the functionality for, yes, databasy stuff 😛 The official cljs math libraries were updated, yet were not feature complete compared to their JVM counterpart, and there were no active plans to add these missing parts. So, like a boss, she decided to implement all this herself.

Her talk was about how to translate and represent numbers in ClojureScript or better say, JavaScript. It was pretty fun to dig into this stuff again and it remembered me of doing some RFID tag reading a while ago with big and small endian notation.

So in this talk she showed more or less the steps she had to take to implement this library. There were some pretty gruesome algorithms in here to represent numbers as byte arrays in order to properly translate them to something JS can understand and fit in it’s 32bit buffers. I really recommend checking this talk out as it gives you some insight into they magic she conjured up here.




Next up, it was time for lunch. And knowing the organizers enjoy (vegan) Indian food I already expected the lunch to be great. Back in 2019, the lunch was awesome as well. This time we needed to take a short walk to another venue close-by called “Mediamatic ETEN”. They served some great Indian food and we got some tokens to have a drink etc. This was a lot of fun as I got to talk with some people from the community. I met some cool people, from Bulgaria, Belgium, Argentina and The Netherlands.

After the lunch we went back to the main venue to continue the conference with many more talks.

The next couple of talks were, quick lightning talks and we started with a pretty funny one. I think most of the people in the crowd enjoyed this talk. (Lightning talks at DCD are +- 15 minutes)


Golfing Clojure: Check Checker under 280 characters of Clojure

by Daniel Janus


So this talk was about the implementation of a coding challenge. The challenge was to implement an algorithm to check whether a user of a chess-game has a check-mate. In this talk Daniel takes us through all his optimizations to write this algorithm which was just a lot a of fun to listen to. He literally pulled all tricks out of his hat to pull this off, by even dropping unicode to shorten the algorithm. I think in the end he made the algorithm 279 characters, if I remember right.


Sorry for the Convenience: The importance of Progressive Enhancement

by Brendon Walsh


So… I kinda missed this talk because I got distracted, nature calls, and a refill of my coffee. I will try to add a proper description of this talk once the presentations are up on youtube so I can re-watch them.


Tagfl, task analysis generated from lisp

by Adrien Siegfried


This talk was not necessarily a Clojure talk but more about the power of LISP more specifically Tagfl, which interprets and aggregates multiple s-expressions describing tasks and automatically generates graphs. These graphs can be used to document flowcharts. He gave a “classic” example of how such a flowchart would look for a ATM. He gave us some example of how a bad ATM would be designed, namely allowing the user to take his money before he actually takes his card. He said that many people will forget to take the card once they have the money. They already have the money so they achieved their goal and thus are now more likely to forget about their card. So a properly designed ATM requires you to first take your card and then, and only then, are you able to collect your money. Haha, he’s totally right. He showed of how to document this using lisp, and then to generate the flowchart quickly to showcase how the tool works. Pretty cool!


Clojupedia, linking the Clojure Ecosystem

by Adam Helins


This was the last lightning talk, and it was from a guy I spoke to during lunch at our table. The project, called Clojupedia, is a new initiative to provide a dynamic graph of the Clojure ecosystem. In this knowledge graph lot’s (but far from all) publicly hosted Clojure libraries are shown. You can then use the graph to view interesting links, libraries that were forked or improved. The goal of this project is to have a central and easily searchable place to find Clojure libraries, tools and projects. The example he gave in his talk was searching for an SQL (ORM) library for Clojure. You will quickly find Sean Connerfield’s JDBC library and interestingly also some forks and previous versions. Clojupedia then recommends the library you should use. Contributing to Clojupedia is highly appreciated and the github page describe the process how to do so. Adam already spoiled that the process is a bit cumbersome but he hopes to improve it in the future.


Automated Correctness Analysis for core.async

by Sung-Shik Jongmans


Fortunately, I know all about this talk. This talk is based upon the research I conducted while graduating from Uni. I did my thesis on so called protocol languages and how one should look and be implemented in Clojure. Now, 4 years later, the project is still active and has spawned many publications in scientific journals. It feels a bit surreal to me that my little project is appealing to the scientific community. I also still believe that Discourje is useful for tracking down the difficult multi-threading bugs and common mistakes.

The Discourje project aims to help programmers cope with channels and concurrency bugs in Clojure programs (that use core.async), based on dynamic analysis. The idea is that programmers write not only implementations of communication protocols in their Clojure programs, but also specifications. Discourje then offers a run-time verification library to ensure that channel actions in implementations are safe relative to specifications

In this talk, Sung-Shik dives into the context of the research of Discourje and shows off some of the examples included to demonstrate common mistakes. He also shows how Discourje can offer a way out and eradicate these bugs by implementing some of the components provided by Discourje. I wont go to far into detail as I think it’s best for him to explain. But, if you would like a more detailed blog about Discourje, which I think is inevitable, since I never wrote one on this blog, let me know in the comments.


Got a Guru?

by Jordan Miller


So this was a talk about personal development, leadership and a bit of team topology. In this talk Jordan talks about her progression in her career for a dev role towards a devrel aka developer relations role. She talked about her having to do, and sometimes volunteering to do, so called “glue work”. Glue work is all those tiny little tasks at work that essentially no one wants to do, like taking notes at meetings, booking meeting rooms and many other small non-dev stuff.

She also explained something interesting which is that; people that do the glue work are often not recognized for it. While the glue work gets done by some random person, another might be promoted because management or someone else responsible for promoting thinks the “seniors” or “leads” are taking care of such things. Jordan then also makes the case that glue work often falls in the lap of the woman on the team. At least, that’s how she experiences it.

Personally, that doesn’t resonate with me. I don’t recognize how this gets dumped on the woman. I think we live by an unwritten rule, that the one that initiates some work, also does the glue work. For example; if I want to have a meeting with some people, I book the room, I take notes if needed and I will do all the follow-up work if there is any. This might change if someone else really is required to do the follow-up work but generally if I want that done, it’s my responsibility. I can’t help but think that what she is describing, the experience, the situations, is a cultural problem. And cultural in the sense of Europe vs. America. Seeing how politics infiltrated almost every facet of American culture nowadays. It appears you can’t do shit without being judged on whatever.

What’s also interesting is that she mentioned the Clifton Strengths tests. I’ve heard these being mentioned a couple of times over the past couple of weeks. I guess I need to take one now, maybe soon 😉


ClojureScript reimagined

by Michiel Borkent


The man, the myth, the legend Michiel Borkent aka borkdude. If anyone in the Clojure community does not know this guy, they deserve a slap in the face in order to wake them up a bit. Borkdude is the author of very popular tooling that drives most of the development tools in the Clojure ecosystem.

In this talk, Borkdude focused mostly on two new tools that are in active development, Cherry and Squint. Cherry is a realtime cljs to js compiler for to use in the browser. Squint is similar, but its more of a reimplementation of cljs that outputs js, even js objects. So while using Squint, you might create a map, but that’s not an immutable clj(s) map you are used to, it’s a mutable js map. This is something you will need to keep in the back of your mind while using Squint!

The most amazing thing he demoed was Cherry, running as a realtime compiler in a browser. Then simply point cherry to a github repo and run that code directly. Amazing stuff! Although, how secure is it? I totally forget to ask haha.

I strongly encourage you to check out this talk for yourself as anything this dude produces turns to gold overnight. You will find these tools being widely used in the near future I think, so better know them now already, right?


So that’s it for my summary of Dutch Clojure Days 2022. It was an amazing day, filled with great talks, great people and great lunch 😉 I will go again next year and I’m already looking forward to it. Leave me a comment if you like and see you next year at DCD2023!



01010010 01110101 01100010 01100101 01101110

Hey, sorry to bother you but you can subscribe to my blog here.

Never miss a blog post!

You have Successfully Subscribed!