Late in the morning Alice, Adam, Esme, and I left by public transport
for the Dutch Design Week. After a bus trip, and two train trips we
arrived in the city of Eindhoven where the event was held.
After we had bought our family ticket we took a bus to the Evoluon
museum, which is shaped like a flying saucer.
On the ground floor I admired the Urban Reef and the Algorithmic
Perfumery. We also saw all kinds of materials made by bacteria and funghi.
After we had walked around a bit and eaten an ice cream we got for
free we decided to pay the fee for visting the other levels of the
museum which held the Retro Future Expo. We didn't have to pay for
Alice and Adam. We spent quite some time on those levels: there was
a lot to see and do.
After the expo we walked to a nearby building for another part of the
Dutch Design Week. We had to go to the back of a building and enter a
creepy looking elevator which took us to the eight floor.
I liked "Hyle square 22.2" a lot, and both the sea turtle and exoot
After looking around for a bit longer we left the building and paid a
visit to several nearby small shops. We had a nice dinner in nearby
restaurant "Ketelhuis". Afterwards we took the bus to the central
station and soon where on our way back home.
As you code, you might have a coworker, or friend, or a little voice
in your head, reminding you of Knuth’s famous saying: “premature
optimization is the root of all evil.” But what makes an
optimization premature, anyway?
The short answer is that this aphorism is a tautology. “Premature”
means “too early,” so we can rephrase the point as “doing things at
the wrong time isn’t ideal.” Can’t argue with that!
The problem with this saying is that many people wrongly interpret
it as “early optimization is the root of all evil.” In fact,
writing fast software from the start can be hugely beneficial.
This page lists the changes I make to a vanilla install of Arch
Linux for security hardening, as well as some other changes I find
useful. Most of the changes will work on any Linux distro that's
reasonably up to date. It's not a one-size-fits-all setup, but
hopefully certain pieces will be useful to anyone wanting a more
secure Linux system.
With their diverse use cases, Rust and Swift share numerous similar
features. The languages are both general-purpose and provide modern
While Apple built the Swift programming language to replace
Objective-C and the Mozilla Foundation built Rust as a substitute
for C++ for writing memory-safe code, the languages have increased
in popularity amongst the developer community.
Since the release of systemd in 2010 the project has been getting a
continuous and steady stream of new features and added
capabilities. With a code count of more than 1.3 million lines of
code, where Lennart Poettering has just added yet another 20.000 new
lines of code with the merge of his personal systemd-homed git tree
into systemd, and with a continuous open issue counter at about
1.400 issues, where new issues and bugs keep popping up, systemd
should be considered experimental and not safe to run anywhere.
When GHC 9.2 was released in late 2021, I was eager to migrate my
projects, particularly to reap the ergonomic benefits of the record
disappointment was immeasurable as I discovered that some of my more
involved type-level computations caused GHCi to get stuck, just
spinning indefinitely at full CPU load – it meant that in order to
get productive with the new compiler, I would have to invest a
potentially significant amount of time to debug a regression. Since
my plate was already full at the time, I postponed this with the
hope of an upcoming minor release magically fixing the issue.
We all know that we can use Haskell to write functional programs
that compute stuff. But can we also use Haskell to write
mathematical proofs? Yes! In case you have never been exposed to
dependent types, the concept of writing proofs with a programming
language will surely sound alien to you. In this blog I hope to give
you an informal introduction to dependent types in Haskell that will
allow you to understand what does it mean to prove something in
Haskell and how to do it. I strongly recommend that you follow along
with ghci on your side.
Emacs is the “extensible text editor”, and it wouldn’t be fun if one
didn’t at least try to take advantage of that, right? Having just
for my Emacs configuration, I thought it might be nice to somewhat
expand on certain ideas and give a little context to some snippets
that have accumulated over time.
Python provides a lot of ways to ask questions about your
code. Whether it's basic things like help() function, builtin
functions like dir() or more advanced methods in inspect
module - the tools are there to help you find the answers to your
Let's find out what kinds of questions about our own code can Python
answer for us and how it can help us during debugging sessions,
dealing with type annotations, validating inputs and much more.
Designing a system to shutdown gracefully can be tricky. In an ideal
world, every service would be managed by a systemd unit. ExecStart
would start a process that handles SIGTERM by stopping itself and
an ExecStop would inform the process and block to gracefully stop
the process and its resources.
But not all software stops gracefully or does a full teardown of
what it set up. In this post, we’ll look at systemd’s shutdown
behavior and strategies for writing systemd units that perform
custom cleanup tasks before shutdown.
The concept of encapsulation is closely related to object-oriented
programming (OOP), and you rarely hear the word in discussions about
(statically-typed) functional programming (FP). I will argue,
however, that the notion is relevant in FP as well. Typically, it
just appears with a different catchphrase.
Python 3.11 is finally released. In the CPython release team, we
have put a lot of effort into making 3.11 the best version of Python
possible. Better tracebacks, faster Python, exception groups and
except*, typing improvements and much more.
This commit reduces the total wall clock duration for sweep
execution by approximately 50%. It does so by reducing branch
mispredictions from dereferencing storage blocks while sweeping the
cons blocks. Parsing the output from some subprocesses such as LSP
servers creates huge amounts of conses, so this commit is
significant for increasing the responsiveness for modes such as
eglot or company-mode.
Professional Nix users often create a shared cache of Nix build
products so that they can reuse build products created by continuous
integration (CI). For example, CI might build Nix products for each
main development branch of their project or even for every pull
request and it would be nice if those build products could be shared
with all developers via a cache.
However, uploading build products to a cache is a little non-trivial
if you don’t already know the “best” solution, which is the subject
of this post.
One of my least favorite kinds of bug is when two different systems
are interacting and the result has bad behavior but it’s difficult
to say which (if either!) system is at fault. This is one of those
stories, about Python’s buffer protocol and Rust’s memory model.