The Lenovo IdeaPad 5 has a CoPilot where it should have a Control Key. The key simulates a combination of keys, so normal ways of mapping the key (udev/hwdb.d on Debian) do not work. keyd can hook the key, though, and present another virtual keyboard device.

There are inexpensive USB adapters that allow plugging a CW key or Iambic paddle into the computer for use with vBand or other games. The adapter presents as a keyboard, and the paddles show up as additional Left and Right Ctrl keys. If you are running keyd on the machine, its default behavior of mapping Right Ctrl to be Left Ctrl (which I guess lots of people find useful) will interfere and cause both sides of the paddle to trigger the same dit or dah. Fortunately, we can undo this broken behavior to get the key working again.

Create /etc/keyd/default.conf:

Restart keyd: systemctl restart keyd

After the mappings have been applied, you can be observe it with evtest. You’ll also see the key working in vBand.

I wouldn’t have needed keyd if it wasn’t for needing to remap the useless CoPilot key.

I’ve had Gemini CLI installed on my workstation since August 2025.

Originally, it would default to use the gemini-2.5-pro model and your "access" to that would run out for the day, and it would switch to using gemini-2.5-flash. I found the flash model to be adequate for the way I’d use it to do Clojure and ClojureScript, so most the time I’d override it to just use flash from the beginning. I thought I could kick over to pro if I found a problem for which I’d need more power.

Eventually, Gemini CLI started switching back and forth between models more intelligently, so it didn’t burn through your limited access to pro, so I no longer override it with 3.0 models.

The AI agent by itself has read lots of documentation, and it’s pretty good at Googling the answers to questions and picking something to try. (I often get a bit of analysis paralysis when trying to choose a library.) It can be surprisingly good at translating sample usage of some JavaScript library it finds into a simple bit of ClojureScript.

In my experience, it’s sometimes bad at matching parentheses, so I just fix them myself. Recently, it may be getting better, and some Clojure MCP projects can cleanup parentheses automatically.

I only ask it to do small tasks, and I closely review and test the code it generates. When it looks good, I commit and push the code, but I know I can always easily go back to a previous working version when the AI goes off the rails. I don’t have to worry too much about it getting too confused or destroying something. I tell it to forget what we were doing, /clear the context, or just restart the agent completely, and recover my known good state from git.

I find that even if it fails to complete a task, I at least learn a little from what it did, and often have an initial direction or two to explore.

It’s pretty good at keeping my momentum when working and keeping me from spinning my wheels, like pairing with another programmer.

The machines are behind a firewall and running on a read-only overlay filesystem for resiliency, so I had the machines periodically pull the event images from the website, and I can change out the images on the website any time.

This was all done with desktop autostart scripts and cron for quite some time, but eventually, we needed more control.

We wanted to have different sets of images and to be able to choose them. For a show, we may want to only show the logo, while other times might call for all the normal advertisements.

The machines have no keyboards or mice, so they needed to be controlled by a web browser. I also don’t know if they’ll start up on the same IP addresses, so I needed a bit of Javascript in a static place to have the browser search and find running slide servers.

The service on each machine now runs as a babashka script that starts upon automatic login. It pulls new images from the website and from a Google Drive, periodically refreshes them, and starts Eye of Mate (eom) to run the slide show.

The babashka script also starts a small web server on http-kit to let us to choose image sets and to trigger a refresh of the images. http-kit is provided by default in babashka.

The SRCC website is a static site built with Hugo, so I add all the events to it via an image or 2 and some YAML. It’s hard to train another normal person to do this stuff, so the responsibility fell exclusively on me. I scripted it up with some bash, but that’s still only accessible to me.

Finally, I’ve been coding all Clojure code for the past couple weeks, and I’ve started playing with Gemini CLI to see what it can do with some Clojure code.

I now have a web form available to allow others to create events for the website, and it interacts with git for publishing to the Hugo site.

The service is deployed on my normal Linux servers as a container run by podman kube play and systemd quadlet.

I can direct Gemini to make changes or add features, and I review the code, ask for corrections or just make updates myself. It’s kind of like pair programming with someone who’s really good at Googling answers and jumping to some (mostly) useful conclusions. Having the AI agent has helped maintain some momentum and saved me jumping down some deep rabbit holes before I needed. I’m asking it for small changes and iterating, not trying to get it to do everything in one shot.

Gemini’s CLI interface makes it easy to switch to another project directory and let it try some stuff on lots of my projects recently.

I had also played with Claude CLI for a day, but Gemini’s free tier is proving capable enough for me so far.

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.

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.

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.

This project also now has a back-end API running on http-kit as a server and storing its data in XTDB 2.

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.

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.

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

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.

I’ve been coding for a very long time, so I’ve had lots of projects in various languages, on various platforms, and stored very differently.

I got nostalgic on and off over the past couple years and went digging around to recover the source for some of those old projects. I uploaded the more notable projects to my GitHub account.

I spent money to buy a 3.5-inch USB floppy drive and an old 386 PC with a 5.25-inch and 3.5-inch floppy drive, so I could ultimately copy files from really old 5.25-inch floppies that I used in the late 1980s and early 1990s to my live storage of today. Among those old files were binaries and source in GWBASIC and QuickBasic.

I found one of the first games I wrote and sort of distributed, Gravity Blocks. I could play the compiled binary with DOSBox and read the main source file, but some of the source code for my common libraries is still locked up in a compressed format from QuickBasic 4.5. I may need to dig deeper into QB64, a clone of QuickBasic 4.5 that seems to be able to read, run, and compile those old compressed files.

I also found source code for the first software I wrote for the local fire company to help track statistics on calls and print reports to submit to the local municipalities we served.

It was written in GWBASIC, so I was able to decode the compressed source where needed to read it. I published my CALL-REP source, so I could go back and have a look at the simple, but useful, things I used to write as a kid.

I continued to build stuff through college (and obviously beyond). Some of it was in C, PERL, and Java.

I recovered these bits of source code laying around in backups and copies of old Linux servers I’ve run over the years. This source was in old Subversion repositories that used old versions of Berkeley DB. Initially, This BDB version mismatch kept svn checkout from working, but the current Subversion tools have an svnadmin recover command that could fix the repository for normal reading today. I’m sure some of those old SVN repositories had previously been migrated from CVS.

I found the source code from my final project in the Java class in my last year of college in 2000.

Pop-a-Prof is a clone of my favorite puzzle game, Bust-a-Move. It’s a Java Applet that ran in Netscape allowing any number of players, and it coordinated everyone’s play with a shared public server, Each round lasted 5 minutes, and any time you topped-out, you’d lose some points, and start over, so no one needed to sit around watching the last people battle it out.

After school, I started on Pop-a-Prof 2. This one ran as a plain Java application, and implemented rebounding balls in the game. It was more of a proof-of-concept for the new game mechanics, and it never got network play.

I liked running little bits of code, like applets did, so I continued into writing Java ME (J2ME) for my feature phones around 2005.

I did a gas-logging app that stored fuel-ups and drew graphs to show fuel economy.

I also wrote a quick little game called Ben’s Backhoe to give the kids a little something to do on my phone. By the time I was building this sort of thing, though, I’m a decent Java programmer, so it’s not the fun mess that we see in the other old project.

I spent most the day poking around at various old BASIC files and trying to tweak them a bit to run in PCBasic or QB64. I used lots of weird graphics modes from the Tandy 1000 and didn’t think much about portability. I may post more projects over time.

The Friendly Orange Glow tells the history of a piece of educational software, PLATO, that grew into a whole microcosm of the internet and cyber culture years before the internet we’ve known for the past 25 years.

Brian Dear attributes the obscurity of PLATO to it having been built and developed at University of Illinois in the Midwest and not at a school on the coast. The PLATO system also used dedicated client hardware with integrated slide projectors, and it ran on a single mainframe. Everything was coded in a programming language called TUTOR, which was primarily designed for authoring interactive lessons using the orange gas plasma display, a rudimentary touch input for the screen, the keyboard, an slide projector integrated into the display, and even occasional peripherals like some sort of synthetic woodwind sound device. It was all very specialized from the beginning.

I loved the time the author dedicated to describing technical details, like how the orange gas plasma display was developed: the grids of wiring, pockets of noble gases trapped between them, and the way accidental contamination allowed them to discover a memory effect they could use to keep each pixel lit. Fixing the contamination lost the memory effect. He presented a wonderful level of detail for my interest.

Donald Bitzer showed off PLATO to anyone who would take a moment to try it. He wanted people to learn and get creative, seldom shutting down experiments. He’d embrace the high school and university hackers who would wander into the labs, and he put some of them to work building hardware or testing. These people would go on to build all sorts of multiplayer games and other software to be used by other users on the system. Bitzer recognized the value in observing what people did with the spare cycles of the system at night. From that freedom sprung an entire hacker culture similar to what I found in my youth, so I felt great nostalgia for this work. Again though, I was discovering this culture in the 1990s with bulletin board systems and the internet in college, and Bitzer’s revolution had already happened in the 1970s. We were always pushing the limits of what we were supposed to do with these systems. It looked like wasted time, but we learned the most.

Discovering new lessons or software on the PLATO system seemed akin to our exploration of BBSes via our modems in the 1990s. We’d stumble around trying to find some new phone number or new corner of an existing BBS, and these kids in the 1970s were exploring PLATO to find games or long threaded discussions in notes that others were developing.

PLATO started as a way to display some slides and teach a self-paced lesson, but grew into games, forums, and email before such things existed. It could have grown into one of the great online services that followed, but they may have gotten too tied up in their centralization and specialized hardware. The management of their commercial partner may not have helped either, because they just wanted to sell mainframes, and didn’t recognize the value of community that had been built around the system.

The book was an exciting listen, and I blasted through the whole thing in about 2 days, because I just couldn’t put it down. It reminded me of my childhood and all the potential of the systems of the day and the creativity that came from the limitations of the day. PLATO evolved in an alternate universe in the middle of the country away from the technology hubs.

I made the transition, and I love Podcast Addict. Listening to podcasts is easily my #1 pastime, so it’s important that I found the perfect software.