The last time I touched ClojureScript was almost two years ago. It was a really fun experience, and actually, it was a bit special to me personally. Prior to that post, I only learned lisp1 via books and mostly used it only for configuring Emacs, and while I’ve liked the idea of code as data and other lisp aspects, I never did anything more with the language.
I think that the only acceptable test coverage percentage is about 100%.
And in this post, I’ll try to explain why I choose to believe it.
A day ago I was asked if it’s possible in C to make some kind of a 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’ve 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’ve 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!
Originally these were all separate posts, but this generated way too many entries in the feed, so I’ve decided to put these into a single one. I’ve kept the content as is, and this very post originally contained the following message:
This is just a quick update on the upcoming posts schedule.
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.