🛠️ clojure camp mobs and tooling

I have been running online intro-to-Clojure "mob coding" sessions since July 2021 (1 to 3 times per month), first as part of Clojure Toronto and now as part of Clojure Camp.

I set up a system to make it easy for participants to work on the same codebase, and later, tooling to make it easy to run said system.

In early 2020, I started hosting a "Learn Clojure" meetup as part of the Clojure Toronto Meetup group(the existing meetings are typically a "user-group" of senior Clojurians and were/are not great for beginners). Note the period: "early 2020". We were able to hold 1 session in person, and then a month later, everyone was trapped at home.

...and so, I continued the sessions online, with several graduates of Lighthouse Labs in regular attendance (the job market was on full pause in those early months, so there was nothing better for them to do). In the beginning, the sessions weren't "mobs," but more like tutorials or workshops (and sometimes... "watch me codes"), run over Google Meets or Zoom.

After a few months of this, I yearned for a way to make it easy for the various participants to be able to directly participate (ie. write code).

The Remote Online Mob System

I wanted an experience that...

• gave participants a real Clojure development experience
  • (ideally, VS Code + Calva + paredit, a terminal and a browser)
• as little set-up as necessary for the participant
• good performance (low latency and decent resolution with 10-15 participants)
• quick swapping between participants

Some alternatives that were considered:

• Zoom - paid, or sessions limited to 50 min, required app download, awkward control switching, high latency
• Tuple - great UX and performance, but paid, expensive, requires app download, simultaneous user limit, Mac only (as of 2020)
• REPL.it - not a true Clojure experience
• VS Code Live Share - not a true Clojure experience for everyone, buggy
• Pop - didn't scale well with more than 3 viewers (because it is streamed from the host)
• mob.sh - required every participant to be set up prior

And then I found Apache Guacamole - a software the lets you "screen share into a machine" (like VNC and RDP) using a browser. Better yet, there was a one-click installer for Linode. It was perfect: I could set up a real machine in the cloud, and then just share a link for others to connect.

Being hosted on the cloud meant that latency was low (to those near the deploy location, but certainly better than from a residential IP) and the bandwidth was high (supporting a lot of participants; again, much higher than hosting from a residential IP).

To save costs, instead of keeping the server running or shut down, I would "imagize" the disk and destroy the server when I didn't need it. This let me run a fairly beefy server for each 2 hour session for about 25 cents and $2.50/mth for the image storage (vs 96 $/mth for a 24-7 server).

A few gotchas:

• being a Linux machine, it uses Ctrl- instead of CMD- , which often confuses Mac users
• it requires participants to take turns because they are all controlling the same mouse and keyboard
• if someone Alt-Tabs away, the Alt- key is "stuck"
• copy-pasting to/from your local machine in some cases is awkward
• there is a limit to image storage; I run a script to remove temp files and logs to keep things lean
  • you could probably use a separate volume instead of images to work around this

If you want something like this for yourself, I recommend the follow links:

• https://guacamole.apache.org
• https://www.linode.com/docs/marketplace-docs/guides/guacamole/
• https://github.com/MysticRyuujin/guac-install
• https://kifarunix.com/install-apache-guacamole-on-ubuntu-20-04/

Also, there are similar tools to Guacamole that may work better for you:

• https://github.com/novnc/noVNC
• https://github.com/Xpra-org/xpra
• https://cedrozor.github.io/myrtille/

Fun fact: I presented about this tooling at ReClojure 2022 (slides here), after which Jordan reached out to me, and then I got involved in Clojure Camp.

The Mob Sessions

At some point, I transitioned from "tutorials" to "mob sessions" - ie. where the participants were made to actually code a solution to a problem together.

In my 2024 Conj Talk, I talk about how mobs are a great learning experience, because they can be adapted to the various levels of the participants and it gets the participants actually doing rather than being passive.

There are various mob "styles", and eventually I settled on "twitch style mobs:" wherein a participant would take control for 2-3 minutes, do whatever they wanted, and then pass it on (sometimes, instead of coding, someone would use their time to ask a question). I have more notes in my Facilitator Guide.

Here is an archive of all the code written at the mobs.

Orchestration

Every time I ran a mob session, I had to:

• login to Linode and launch the server (from an image)
• change the DNS to point at a new IP
• wait a few minutes
• (run the session)
• shut down the server
• "imagize" the disk
• wait 10 minutes
• destroy the server
• destroy old images

A few other mentors at Clojure Camp wanted to run their own sessions, but the set-up steps were error- and disaster- prone (and I didn't want to share my Linode account willy-nilly).

So, over a few weeks, pairing with Oleh, we wrote the mob-server-controller: a Clojure tool to help launch and tear down the mob system on-demand. It performs all the steps I used to, but reliably. And now I can share it with others, without giving them full access to my Linode account (and associated credit card).

(Why a Clojure app, and not, say, and Ansible script? Because I have come to hate Ansible with a passion. ...and, some form of app would have been necessary to enable access to other mentors without leaking underlying credentials).

Even just for me, this automation has paid off in terms of time saved (no more waiting for intermediate steps to finish - just one button to start, and one button to stop).