I feel uneasy about design patterns.
On the one hand, my university class on design patterns revived my interest in programming.
On the other hand, I find most patterns in the Gang of Four book to be irrelevant to my daily work;
they solve problems that a choice of programming language or paradigm creates.

My litmus test of a good design pattern is its cross-disciplinary applicability.
I’m more likely to accept an idea that pops up in fields beyond software engineering.
And the most convincing patterns are the ones that help me in everyday life.

This article describes a universal pattern that billions of people rely on daily, but software engineers rarely discuss—the plan-execute pattern.

In functional programming,
combinator libraries refer to a design style that emphasizes bottom-up program construction.
Such libraries define a few core data types
and provide constructors—functions that create initial objects—and combinators—functions that build larger objects from smaller pieces.

Combinators enable the programmer to use intuitive visual and spatial reasoning
that’s vastly more powerful than linear language processing.
As a result, solving problems with combinators feels like playing with lego pieces.

Things we wish we didn't know

I just learned that
you can use it to review a git commit like this and I thought that was really
cool.

zb is a tool for reproducibly building software, similar to Bazel.
(See the comparison page if you’re curious to know the differences.)
When a software build process is reproducible,
it will produce the exact same output
when given the same inputs.
Reproducibility is a desirable property for a software build process to have:
it simplifies debugging,
it enables build speed-ups,
and it is essential for digital supply chain security.
However, reproducibility is a difficult goal to achieve.

I have been using IntelliJ Idea at work for a decade or so by now, and it’s been a reliable companion. JetBrains IDEs have a bit of a reputation for being slow, but their feature set is incredible: powerful refactoring tools, a great VCS UI (though I like magit even more!), a huge number of supported frameworks, integration with just about any testing library for any language, code coverage tools, powerful debuggers, etc.

The solution to all of these problems

I humbly put forward that modern web development provides us all the utilities to move away from class names and implement something much more robust, with some fairly straightforward changes:

Attributes

Attributes allow us to parameterise a component using a key-value representation, very similar to Map<string, T>. Browsers come with a wealth of selector functions to parse the values of an attribute.

I have a lot of thoughts about the design of compiler intermediate representations (IRs). In this post I’m going to try and communicate some of those ideas and why I think they are important.

Extra is different than More. Extra is finishing those two screens, but then researching a new library for form validation that might reduce the boilerplate code. Or it's learning ways to protect against common security vulnerabilities from data entry. These little off-ramps from the main highway of Normal Work could be dead-ends and not have any practical value to the project. But they might also be important contributions. And that's the thing with Extra. While the tangible value to the project is uncertain (it could be nothing this time or it could be something), the value to you is real.

Why do people keep telling me to use PGP? The answer is that they shouldn’t be telling you that, because PGP is bad and needs to go away.

There are a lot of guides about how to use async Rust from a "user's
perspective", but I think it's also worth understanding how it
works, what those async blocks actually mean.

The share_target manifest member allows installed Progressive Web Apps (PWAs) to be registered as a share target in the system's share dialog.

Take control of your honks and join the federation.
An ActivityPub server with minimal setup and support costs.
Spend more time using the software and less time operating it.

This post is all about speculative compilation, or just speculation for short, in the context of the JavaScriptCore virtual machine.

Every so often I come across a paper, blog post, or (occasionally) video that completely changes how I think about a topic in programming languages and compilers. For some of these posts, I can’t even remember how I thought about the idea before reading it—it was that impactful.

Games can be made in many different ways. Many games are made using big, general purpose game engines such as Unity and Godot. I enjoy using the Odin Programming Language combined with Raylib.
Odin is a C-like programming language and Raylib is library for drawing graphics, checking input and playing sounds. So it’s just a program that uses a simple library, no engine!
There are no objectively best ways to create games.

When people say Rust is a “safe language”, they often mean memory safety.
And while memory safety is a great start, it’s far from all it takes to build robust applications.
Memory safety is important but not sufficient for overall r…

A well-equipped ASCII diagram builders freely available on the internet.
It stresses portability, simplicity, and immediateness.

Storage for private, distributed, offline-first applications. Earthstar is a specification and JavaScript library for building connected applications owned and run by their users.

Interesting setup for pet computers. Debian + sway + cage

In modern Java, the visitor pattern is no longer needed. Using sealed types and switches with pattern matching achieves the same goals with less code and less complexity.

Solving AoC on the DS with Rust.

Reading through the Emacs 30 NEWS file and picking
out the stuff I think is the most interesting.

My take on what could be a project template for Django advanced usage, with modern tooling (for Python and UI dependencies, as well as configuration/environment management), but not too opinionated.

Security testing starts with understanding vulnerabilities. The CVE website lists known software flaws. The OWASP Top Ten highlights common weaknesses. With this knowledge, we can improve our Go development. This article shows how to put in place robust practices. They are to: fuzz inputs, verify dependencies, and use static analysis tools (SAST).

I recently wrote about Async Pool, one of my favorite JavaScript / TypeScript helpers, and today I want to share an even simpler yet extremely useful utility

useDeferredValue is one of the most underrated React hooks. It allows us to dramatically improve the performance of our applications in certain contexts. I recently used it to solve a gnarly performance problem on this blog, and in this tutorial, I'll show you how! ⚡

Everything you need to write flexible, future-proof Rust applications using hexagonal architecture.

This blog series creates a small operating system in the Rust programming language. Each post is a small tutorial and includes all needed code.

A somewhat compact implementation of the awk programming language

There's a concept that I've heard called by a lot of different names, but my favorite name for it is …

Permacomputing is both a concept and a community of practice oriented around issues of resilience and regenerativity in computer and network technology inspired by permaculture.

A fun, hands-on guide to writing your own compiler for a real-world programming language.

A lightning post on logic programming in Haskell to construct a workout weekly schedule given the set of exercises, days and constraints.

Code discussions contain relevant information. Isn’t it a shame that we
keep these in the centralized GitHub/GitLab servers, far away from our
decentralized Git code? As soon as we move provider, we’ll lose all old
discussions! And how do you ever find the pull requests back from 5
years ago? Symfony has implemented a lightweight solution to this problem
years ago using a less-known feature of Git: Git Notes.

I’ve used a lot of tools over the years, which means I’ve seen a lot of tools hit a plateau. That’s not always a problem; sometimes …