A day ago I was asked if it’s possible in C to make some preprocessor macro that will create a tuple object from something like tuple(a, b, c). I’m not writing in C actively anymore, since I switched to Clojure some years ago, but I still like to poke with C from time to time.

About a year ago I’ve started thinking about changing the theme of the blog and hopefully designing my own theme. This didn’t go so well, as I had very little free time to actually sit and do the thing. So at the end of the last year, I decided that I’ll prioritize this task at the start of 2022, as usually there’s not so much stuff to do at the year’s start, rather than mid-year.

Not so long ago I’ve written about Paredit and its quirks. I’ve been happily using Smartparens ever since that post, but something still bugged me. I was constantly thinking about the fact that Smartparens has numerous quirks in various languages and some known bugs that are unlikely to be fixed in the foreseeable future, given that the main maintainer doesn’t have a lot of spare time.

Lua is one of the most pleasant languages that I’ve used so far. Well, I’m not writing in Lua directly, instead, I use Fennel - a compiler for a Clojure/Lisp-like syntax to Lua. Because of that, I actually don’t really know Lua syntax that well, even though it’s really simple, it still has some quirks.

Some blogs I read occasionally post monthly and yearly status updates. From now on I’ve decided to do a recap of what’s happened during the year, to see what I’ve achieved, and maybe plan something for the upcoming year as well. So without further ado, let’s jump straight to January 2021!

Lately, I’ve been into understanding asynchronous programming. Since my background is mostly bare metal C, which has no asynchronous programming whatsoever (apart from running on multiple chips, and communicating via shared memory), and I did only a little bit of C++ and Rust, it’s fair to say, that async is pretty new for me.

Today’s topic will be about lazy sequences and how these are different from iterators. I’ve wanted to make an article on this topic for some time, but unfortunately, there was no good way to show the differences using a single language (that I know), because usually, languages stick to one of those things.

Here’s a quick rant, kinda. I’ve become a huge fan of structural editing recently. My structural editing journey was maybe a bit unusual, but I’ve finally settled on Smartparens for quite some time. Originally I was introduced to structural editing by Parinfer mode which had some Paredit functionality, so it got me interested.

Not long ago I posted a small article on a Condition System in Clojure language. In that article, I was mostly trying to understand what a condition system is, and how it can enhance error handling in the code I write. Since that time, I’ve understood this system a lot better, by actually trying it in the Common Lisp language, the place where it came from, as far as I know.

I started using IRC in the early 2000s and was primarily using it because at that time there was no global internet access in our city. However we had a city-wide local network, and our internet provider ran an IRC server for everyone to chat.