This is a story of a most unexpected journey — one that is just starting. If somebody had told me four years ago that I’d be writing this today, I would have stared at them in astonishment or laughed dismissedly. Yet here I am, writing about a late-found hobby that has somehow become a very important part of my life.

I was wrong (or was I?)

In my last post, I stated:

I don’t think it’s [me writing about LLMs] likely to happen anytime soon: I prefer to write about things that I’m excited about.

I was wrong. And right at the same time. Here comes another post where LLMs play a prominent role.

’Tis the year’s midnight, and it is the day’s.

Well, it’s two weeks past Lucy’s as I write this, but it is still that time of the year: the time of slowing down, taking a step back from the hustle and bustle of everyday, reflecting on what has happened and what is yet to come. Perhaps no better time to put together my thoughts on LLMs, and more specifically on their use in programming.

This is my home-office desk on a typical day. Yuck – look at those mugs, cables and rubbish!

As a person with ADHD, I have a hard time maintaining cleanliness – and a high tolerance to mess around me. However, being in a cluttered environment does take its toll. Often I find myself frustrated by it, but also overwhelmed by tasks at hand, to the point of cleaning up feeling almost an insurmountable chore; often, when I start my workday by physically cleaning things up, I find it giving me a dopamine boost that impacts my productivity for the rest of the day.

What

Late last year, I had an idea that’s been steadily brewing in my head. I’ve found myself with some free time recently (it coincided with vacation, go figure), and I’ve hacked together some proof-of-concept code. Whether or not it is actually proving the concept I’m not sure, but the results are somewhat interesting, and I believe the idea is novel (I haven’t found any other implementation in the wild). So it’s at least worthy of a blog post.

Intro

I’ve been programming in Clojure for a long time, but I haven’t been using transducers much. I learned to mechanically transform (into [] (map f coll)) to (into [] (map f) coll) for a slight performance gain, but not much beyond that. Recently, however, I’ve found myself refactoring transducers-based code at work, which prompted me to get back to speed.

My adventure with learning Rust continues. As a quick recap from the previous post, I’m writing a tree viewer. I have now completed another major milestone, which is to rewrite the tree-printing function to use an iterator. (Rationale: it makes the code more reusable – I can, for instance, easily implement a tree-drawing view for Cursive with it.)

I’m enjoying a two-month sabbatical this summer. It’s been great so far! I’ve used almost half of the time to cycle through the entire Great Britain and let my body work physically and my mind rest (usually, the opposite is true). And now that I’m back, I’ve switched focus to a few personal projects that I have really wanted to work on for a while but never found time.