Blog - fifth anniversary

Somehow I’ve missed the fifth anniversary of my blog! Oh well. Well, it’s not that big of a deal, but I want to reflect on my blogging a bit.

I started this blog on January 27th, 2020 with the following line:

This is the first public post that I wrote because I’ve finally thought that I’m clever enough to do so.

And that’s one of the most important decisions I made in the last five years.

In fact, I wasn’t smart enough to make that post. As I’m looking at my first set of articles about GRScheme, it is obvious that these were baby steps. But this kick-started my interest in writing and more importantly - learning.

Every time I write a post on this blog is usually because I learned something new. And every time I learn something new I want to make a post on my blog. And more often than not I want to learn something new to later make a post about it.

The only thing I regret is not starting this blog sooner in my life - I’m positive that it would help me grow much quicker and I wouldn’t make a lot of mistakes that I did.

2020

In 2020 most of my posts were all over the place. I was still figuring out what I wanted to write about and because I only had one recent project I was working on, I decided to use it as a starting point. That project was GRScheme - an implementation of an interpreter of a Scheme-like language written in Rust.

I was learning Rust because I felt that I couldn’t do C for a living and enjoy it at the same time. Don’t get me wrong, I like C, it has its charm, but I was working for almost five years with it at my day job, and it started to wear out. I didn’t want to switch to C++ full-time, so I started looking at alternatives. Rust was an obvious one - a hot new language with a lot of projects circulating over the web, the whole “rewrite it in Rust” shtick, etc.

Rust hit me at a weird time - I was discovering Lisps, and because I liked what I saw in both languages at the time, I decided that writing a Lisp from scratch in Rust would be a fun project. And a fun project it was! The result is horrible too!

I was also messing with Emacs a lot at the time, and Emacs was another reason for my passion for blogging. You see, I started this blog with Org Mode and Hugo, and I still use them for this blog. I would probably do so even after Hugo fades away and will be replaced with a new hot thing. Maybe it already was - I never checked. Hugo + Org Mode has everything I ever needed.

Emacs also played a role in my career, because it is configured in Lisp. And Lisps were an interest of mine at the time so all three things came in nicely. I configured Emacs with Lisp to use Rust, wrote Lisp in Rust, and blogged about it from Emacs.

After finishing the project and failing a few interviews for a junior Rust developer position I thought to myself: if I like Lisp that much, maybe I should learn a proper Lisp, instead of toying with a weird implementation of a thing I know nothing of? Yes, I knew nothing about lisps and still managed to make an interpreter. A horrible, yet working one, with a lot of bugs, of course. So I set myself on a journey to find the Lisp I want to learn.

After examining alternatives, and briefly considering Racket, I stumped on the talk by this guy Rich Hickey about simplicity. And kinda fell down the rabbit hole with this Clojure language that I never heard of before.

So after blogging a bit about Rust and Emacs, Clojure was the next thing I wanted to learn. And what better way to learn something than to blog about it?

I made a simple ray casting demo in ClojureScript, and was pretty confident in my knowledge of the language after just two months of messing with it. Sure, learning some Scheme beforehand helped, but only to make me feel easier about all these parentheses. Which I blogged about later.

So I applied for the junior Clojure developer into an organization I never heard of before. This company specializes in information security, and they were looking for a middle-to-senior Clojure developer. I still don’t know how I got this job, but I’m extremely glad that I did.

I feel that I need to address this thing though. I was applying for a junior developer despite having five years of experience in software development. Why?

Simply put - the stack is so different that I might as well don’t know anything. At my previous job, I hadn’t written any servers, never talked to a database, and so on. So junior position was the only thing I could really go for. Another five years passed since then, and I’m no longer a junior developer, but if I ever have to drastically change the stack again I don’t mind applying to the junior position again at all. I learn fast, so I won’t be a junior for long.

2020 was a year I learned about Fennel - another lisp language. And I fell in löve. You can kinda see that, given how many there are posts tagged fennel.

2021

This year was mostly Fennel-focused. I became a Fennel contributor by re-implementing the pretty-printer. This code is still used today, either because it is terribly complex and nobody is brave enough to rewrite it again, or because it works well enough. I’m on the latter side, although I feel that the former one is not entirely incorrect.

I further experimented with Fennel. Macros were a hot thing to learn, so I made a condition system implementation. This was another attempt at making something I know very little of, by just observing how it behaves. Turned out pretty well, and completely useless too!

On the brighter side, I made another library that year that implemented lazy sequences. It was fun to make, and I learned a lot about how lazy sequences work in Clojure along the way.

The next thing I tried was asynchronous programming. You see, at work, I started working with asynchronous code, and literally nobody understands asynchronous code. So the only way to understand async is to write a library for it - I thought to myself. And so I did.

This library was horrible, but I didn’t realize it until I understood how async works. Which was way after I made this library.

This year also was a year when I decided to participate in the Advent of Code event. I made a post each day, and by day 25 I was so exhausted that I decided that I would never do it again, and hidden all of the posts. They are still there if you know how to look, but I won’t give you any links.

Also, I grew to hate these AoC posts in the feed. Being bombarded each December in the RSS feed by “Advent of Code - day N shenanigans” type of posts kinda ruined AoC for me.

2022

2022 wasn’t as productive when it came to my personal projects, so I shifted my focus to writing posts in the “misc” and “random-thoughts” categories.

I also changed the theme of this blog to the current one, and used it ever since. It is a custom-made theme, and I purposely don’t share it. Don’t ask.

Because this year was more about thinking, rather than making, it might feel less productive, but I made a lot more posts than in the previous year.

One of my favorite posts from this year is about code coverage. I still think that 100% is the only acceptable coverage if you know why you measure coverage at all.

More Fennel stuff this year though. I’ve participated in my first ever game jam, and made a decently-looking game (at least I think so). I also made a library for evaluating Fennel from Org Mode source code blocks, and turned it into a kind of a notebook.

Finally, I made a small library for Clojure, that fixes a long-standing bug in the core.async library. Sadly, this patch wasn’t accepted by Clojure maintainers, but I was expecting that.

Overall, not a bad year. I only had three major projects, but I kinda wanted to go for quality over quantity.

2023

And I went back to quantity over quality pretty quickly.

For some reason in 2023, I felt a huge urge to write. Forty-four posts, including the hidden ones!

Another bad async implementation, now in Emacs Lisp.

A new REPL implementation for Fennel.

Clojure’s core.async port to Fennel! (Finally, a decent one. All it took was to actually look inside one of the libraries actually used in the industry.)

And of course, gamedev.

This year I decided to really get into game development, so I set myself a goal - make five games, each in one month.

The first game was a basic platformer. I was pumped up and worked on this project a lot. Probably, the longest I ever worked on a game before or to this day. After finishing it (stopping would be a more accurate word), I realized how hard it is to pump games out each month.

The second game didn’t go as planned at all. I was so burned out from the previous game, that I couldn’t bring myself to work on the second one. So the only obvious solution was to start working on the third one, right?

The third game I actually managed to complete to the point of having some kind of a game loop. Not a good one, but give me some slack - I have been programming non-stop day and night for three full months now.

The fatigue was real though. I decided to abandon this self-assigned challenge, after making a portion of a game and deleting everything in frustration. I’ve later written a postmortem on all this marathon thing, and to this day I’m recovering and it’s really hard for me to get back into game development. Maybe this year, who knows?

Apart from gamedev, I decided to revisit the language development field. So I started working on language by following the Crafting Interpreters book. This was the project I spent most of my time remaining in 2023.

2024

The year started with me and my wife getting divorced. I’ve finished the Crafting Interpreters book, but this was the last push - I haven’t any energy left to continue with the blog. I made a post reflecting on this blog but later hidden it away. I wasn’t planning on feeling down for long, just needed a break from things. It’s still there to remind me of my past self.

So I took a break for a full month until I felt the urge to write again. It started slow, mostly with posts about thinking on various programming topics. And hobbies.

And I rediscovered my passion for a different hobby I had years ago - playing guitar and recording videos about it!

Then an inspiration struck again and I started working like a crazy man on a new passionate project. I started working on an asynchronous HTTP client for Fennel, actually applying all of my knowledge and previous projects that I made. I worked on it almost til the end of the year.

I dipped my toes into game development for a brief moment again.

One of the things I reflected upon was doing things blindly. That was the style of learning I applied til the last year. This year was different, I was reading specs, different implementations, and learning from stuff people made instead of reinventing the wheel. Hopefully, this method will stay with me and evolve further.

Another spontaneous project was about bringing Fennel into Emacs as a second extension language. While working on it, and preparing for the FennelConf 2024 where I wanted to talk about fnl-http I suddenly found myself working on yet another project that I already made several attempts at - the dependency manager. So, somehow by the end of the year, I was working on three projects at once again.

2025 and beyond

And that’s what brings us to 2025! I’m still working on this dependency manager project, and I have high hopes that it will be useful to the Fennel community. Not sure what other projects this year will bring, but I hope they will produce exciting and interesting posts!

All in all, starting this blog five years ago made me who I am today. My only advice to you - if you want to start doing something, but you’re waiting til you’re ready, then do not wait! Act, and you will see that you’re probably already capable of doing what you always wanted to do. And even if you’re not, you will clearly see what parts you have to work on. And others will help you with that.

If you’ve been here for the past five years, I gladly appreciate that a lot. A lot of comments were sent to me in 2024, helping me make this blog better, and move through life. And if you’re just passing by, I’m still glad that you made it here!

Thank you for reading!