I recently built an “Automatic #plotloop Machine”, named after the
common socialmedia hashtag for these
animations made of individually plotted frames. This article is a
thorough description of the project, covering both hardware and
I have been a user of Nix (a “reproducible” package manager) and
NixOS (the Linux distribution based on this package manager) for
almost two years. I use it in a personal and professional
context. In this article I will focus on the “pain points” in my
use of Nix and NixOS. While there are many positives, the NixOS
experience is far from being a smooth ride. I still mostly enjoy
using Nix and NixOS, and this article is not about blaming
anyone. I’m also a part of the problem, as I could probably
participate more actively in the project.
This week I received a new 12th Gen
Intel laptop from
Framework. And like with any new piece of
hardware I get these days, my first instinct was to put
NixOS on it 😄.
But I wasn’t just content with firing up the NixOS
installer and getting to work. Oh
no no no. You see, I knew there was a better way. I didn’t now
exactly what that better way looked like just yet, but I could feel
in my bones that it existed.
So I did what I usually do when I suspect there’s a better way of
doing something in Nix land and pinged
Mic92. What you’ll read in the rest of
this post is the result of our conversations.
Creating a custom linter can be a great way to enforce coding
standards and detect code smells. In this tutorial, we'll use
linter in just a few lines of code.
When I first started using Linux in 2006 I remember dreaming of a
Linux Console. The idea maybe wasn't so far fetched at the time, the
PlayStation 3 had just been released with OtherOS support which
allowed users to install Linux (or BSD). Still, it seemed that a
Linux-first console would only ever be a dream. Now in 2022, Valve's
Steam Deck is a hackable Linux-first portable console.
Today, we'll be putting Nix on it, because what's Linux without Nix?
PEP 622 proposed syntax for
pattern matching, which received detailed discussion both from the
community and the Steering Council. A frequent concern was about how
easy it would be to explain (and learn) this feature. This PEP
addresses that concern providing the kind of document which
developers could use to learn about pattern matching in Python.
Locality-sensitive hashing (LSH) is a set of techniques that
dramatically speed up search-for-neighbors or near-duplication
detection on data. These techniques can be used, for example, to
filter out duplicates of scraped web pages at an impressive speed,
or to perform near-constant-time lookups of nearby points from a
geospatial data set.
A neat trick is then to add a fragment part to the URL you use, and
then do the globbing there. The fragment is the rightmost part of a
URL that starts with a #-character and continues to the end of the
This is a four day Rust course developed by the Android team. The
course covers the full spectrum of Rust, from basic syntax to
advanced topics like generics and error handling. It also includes
Android-specific content on the last day.
The goal of the course to teach you Rust. We assume you don’t know
anything about Rust and hope to:
Give you a comprehensive understanding of the Rust syntax and
Enable you to modify existing programs and write new programs in
Once upon a time, I was on a small team tasked with building a data
pipeline. On this team was someone we’ll call Bob, who was fresh out
of grad school and hadn’t had much experience with software
engineering, and no experience with SQL. As part of this data
pipeline, Bob had to combine the data from two tables. JOIN is a
core feature of SQL, so this ought to be simple, right?
Unfortunately, Bob hadn’t learned any SQL past SELECT and WHERE.
One common complaint from industrial users of Haskell is that of
compilation times: they are sometimes painfully slow. Some of that
slowness is difficult to avoid—no matter how you slice it,
typechecking and optimizing Haskell code takes a lot of work—but
nobody would argue that there is not ample room for improvement. For
the past few months, Krzysztof Gogolewski and I have had the
opportunity to work with Mercury to identify
what some of those improvements might be, and I am pleased to report
that our first major
toward that end will be part of GHC 9.6.
The context for this post is that at work I recently implemented Nix
ecosystem support for “incrementally” building Haskell packages. By
“incrementally” I mean that these Nix builds only need to build what
changed since the last full build of the package so that the package
doesn’t need to be built from scratch every time.
The pull requests implementing this feature have not yet been
approved or merged at the time of this writing, but I figured that I
would explain the motivation, design, results, and limitations of
this work to hopefully persuade people that this work should be
This article will explain what is WebAssembly, why it is relevant to
the Docker ecosystem and provide some hands-on examples to try
on. We assume you are familiar with the Docker tooling. We will be
using our work on the WebAssembly port of
demonstrate how to build a PHP interpreter, package it as part of an
OCI image and run it using Docker.
So the past week has been interesting, to say the least...
I got tired of ubuntu/popOS's BS and decided it was time to try
something new, and instead of going with the mainstream power user
options such as Arch, Debian, or even Gentoo, I went with something
a little more obscure...
NixOS! I've been using it full-time for a week and a half now and I
have some thoughts to share with you
This post represents my attempt to convince you that sigils are a
powerful tool for writing clear, expressive code. No, strike that,
I’ll go further – this post is my argument that sigils are a
powerful tool for clear communication in general; sigils being
useful for programming is just an application of the more general
The Advent of Code is an annual set of
coding puzzles. I find today’s
puzzle interesting because
it’s a good example of how sometimes better memory management can
make a real difference in performance.
Finishing a PhD is a weird emotional experience. All the hard work,
the joys, the pains, the pulled hairs, everything gets condensed
into a scary-looking PDF and
then you're just… done? What? This makes no sense whatsoever. Or
rather, this makes sense on paper, but then you feel this weird
sense of grief somehow. And you're not quite at the acceptance stage
yet. So instead, you decide to deal with those feelings in a
perfectly normal and healthy way, and you embark on a journey to
compile said thesis into a series of HTML
Everybody with an Emacs blogs raves about Emacs 29 these
days. Things like Eglot, tree-sitter, SQL support and the
like. Well, this is all nice – more than nice, brilliant! – but
let’s not forget a few minor advances which are coming with
Emacs 29. Let me mention a few things that I especially like.
You can’t edit code without temporarily breaking it. What you can
do, however, is move in small, deliberate steps. Every time you
reach a point where the code compiles and all tests pass: commit the
changes to Git.
Tim Ottinger calls this a micro-commit. Not only should you commit
every time you have a green bar—you should deliberately move in such
a way that the distance between two commits is as short as
possible. If you can think of alternative ways to change the code,
choose the pathway that promises the smallest steps.