Many new Haskellers make it through initial material (everything up
to and including the Monad typeclass, let’s say), write a couple
of “Hello, world!”-tier projects that use the IO type, but
struggle to make the jump to industrial libraries and/or find
projects that excite them. I think text-mode games can grow very
smoothly alongside a programmer learning a new language, so here’s
some thoughts on how to get started, how you might extend a game,
and some advice for Haskell specifically.
Smart SVG techniques, from generative SVG grids to SVG paths with
masks, grainy SVG gradients, cut-out effects and fractional SVG
stars. Let’s look at some magical SVG techniques that you can use
Installing your Python application’s dependencies can be
surprisingly slow. Whether you’re running tests in CI, building a
Docker image, or installing an application, downloading and
installing dependencies can take a while.
In this post I'll be talking about recent work I and others have
done to make crash handling and reporting in Rust a (fairly)
straightforward procedure by introducing several new crates that can
be used in conjunction with each other, or with other crates you may
already have. Keep in mind that some of the crates and details I'll
be talking about might change as it is still early days, but the
broad strokes should stay true even if you're reading this blog
post a couple of years in the future.
A recent anonymous tip from a reader drew my attention to a
malicious IP address allegedly involved in a widespread phishing
campaign against users in Ireland.
The malicious actors behind this campaign have created hundreds of
fake domains, impersonating several Irish banks, the national postal
service of Ireland, courier services, Sky TV, covid pass issuers, as
well as several other financial entities abroad, the English NHS and
Two years ago Perl 7 was announced. A key idea for Perl 7 was to
significantly reduce the boilerplate needed at the top of your code,
by enabling a lot of widely used modules / pragmas, but this would
have come at the price of breaking some backwards
compatibility. This would have meant that some existing code
wouldn't have worked without modification.
Nix Flakes allow us not just to precisely specify TeX Live
packages we need to build our document, but also to include external
resources as additional dependencies. By pinning the versions of our
inputs in flake.lock, it guarantees us that the document can be
reproducibly built anywhere.
In this post I look at how you can split a repository in two,
creating a "history" repository, and a current repository, while
retaining the ability to temporarily merge them again when
required. This is made possible by the git-replace tool.
This is a look back at the huge progress that has been made since Go
1 released and what I'd consider to be the headline features of
Go 2. This is a whirlwind tour of the huge progress in improvement
to the Go compiler, toolchain, and standard library, including what
I'd consider to be the headline features of Go 2. I highly encourage
you read this fairly large post in chunks because it will feel like
a lot if you read it all at once.
Everyone who knows me IRL (and, I suppose, who follows me online for
long enough), knows that I have a… special relationship with
LaTeX. I think it has something to do with its obscurity, when it
wasn’t specifically made to be obtuse, and then being so good at
what it does — which is typeset documents. It doesn’t help that
people consistently make impressive things with
thus showing that it’s not just theoretically Turing-complete, but
really something you can bend to your will, provided you’re willing
to grapple with books from the 70s and obscure PDFs scattered
online, in lieu of some modern documentation.
This is the fourth article in a series trying to understand systemd
by creating small containerized examples. In Part
we created a minimal systemd setup in a container. In Part
we took a close look at systemd’s dependency management. In Part
we saw the basics of services and how to define them. In this post,
we will see another way to add dependencies for units. This
technique is most commonly used when adding new units to the system
that should be activated during bootup.
FreeBSD Jails is a great piece of container technology pioneered
several years before Solaris Zones. Not to mention 15 years before
Docker was born. Today they still work great and offer some new
features like entire network stack for each Jail called
VNET. Unfortunately they also have downsides. For example anything
related to NFS is broken inside FreeBSD Jails (especially when they
are VNET based Jails) and the relevant 251347 Bug
There is however a way to run NFS server inside VNET based FreeBSD
Jail – we will use userspace NFS server implementation instead of
using the FreeBSD base system kernel space NFS server. Its available
as net/unfs3 package and this is exactly what we will gonna use
for this guide.
Sometimes you just have a bunch of example data laying around and
you want to make sure your code works with all of them. Some of them
are probably short and sweet and could live happily as
which are amazing btw. But some of them are more awkward to present
in such form, because, for example, of their size or
number. Typically when you have an example of how the program should
behave you write an example-based unit test. Ideally, each of them
would represent an isolated example and they should fail
independently. But, converting your source data files into a unit
test one by one, manually, can be a bit tedious.