Previnder

How to test local area network speed

Mon, 20 Oct 2025 00:00:00 +0000

To test the link speed between two machines on a local network, a method that is often used is to send a file from one machine to the other using a network file sharing protocol such as SMB, NFS, SSHFS, or rsync over SSH.

Unless one of those protocols is already set up on the two computers, this is a very cumbersome way to test network speeds between them. And if the network is faster than one of the storage devices of the two computers involved, either the one from which the file is read or the one to which the file is written (or both), this method would not test the maximum network speed possible. This can easily happen if one of those storage devices happens to be an old fashioned hard-disk.

Ext4 reserves five-percent of the filesystem's available space by default

Tue, 14 Oct 2025 00:00:00 +0000

By default, Ext4 reserves 5% of the filesystem’s block count for the super-user, so that root processes can continue to run without problem even if other non-privileged processes are prevented from writing to the filesystem when it’s full.

This makes perfect sense for the root partition where the operating system is installed, but for most other partitions, reserving 5% of the disk space for the super-user is probably a waste of storage space.

Storing IP addresses in MariaDB

Wed, 16 Jul 2025 00:00:00 +0000

What’s the best datatype to store IP addresses as in MariaDB?¹ It’s 2025 and, according to Google, nearly half the internet now supports IPv6. So whichever data type is the best, it will have to support both IPv4 and IPv6 addresses.

There are, in that case, three main options:

VARBINARY(16): With this option you could store IPv6 addresses as 16-byte byte-strings and IPv4 addresses as 4-byte byte-strings; or you could store all IP addresses as 16-byte byte-strings by converting all IPv4 addresses to IPv4-mapped IPv6 addresses first.² If you go with the latter option, then of course the data type could simply be BINARY(16) instead of VARBINARY(16), making the type a little bit simpler and saving you a byte per each row.³
VARCHAR(45): This is the simplest option. You just store the IP addresses in their textual representation. Like in the previous option, you could convert IPv4 addresses to IPv4-mapped IPv6 addresses first, but what would be the point?
INET6⁴: This is of course the data-type that MariaDB provides for storing IPv6 addresses, as well as IPv4 addresses mapped into IPv6 addresses. Internally, all INET6 values are stored as 16-byte fixed length byte-strings, and clients interacting with MariaDB see them in their textual representation.

As you might expect, if there’s nothing special that needs to be taken into consideration, INET6 is the best option for storing IP addresses in MariaDB, for several reasons.

Make KDE Plasma’s file indexer, Baloo, usable

Mon, 28 Apr 2025 00:00:00 +0000

KDE Plasma is great, but the file indexer that ships with it, Baloo, is not. In fact, it’s terrible. If I leave it as it is, one of its processes, for some reason, inevitably starts using 100% CPU, which I only notice once my laptop starts heating up. You’d think this only happens for a short period of time when a lot of new files are waiting to be indexed at once, but that doesn’t seem to be the case, from what I can tell.

Migrating a Progressive Web App (PWA) to a new domain without breaking existing installations

Sun, 09 Mar 2025 00:00:00 +0000

Recently, I migrated Discuit, which is a Progressive Web App (PWA), from discuit.net to discuit.org. Everything went smoothly and seamlessly, I’m glad to say, without it messing up the existing user experience in any way. In fact, had I not made an announcement about it, most users wouldn’t have even noticed the change.

Migrating a website to a new domain is usually straightforward, at least for simple websites: a basic HTTP 301 “Moved Permanently” response is often enough to redirect traffic from the old domain to the new. But for PWAs, this approach can break existing installations. This is because a blanket 301 redirect would change the origin of both the manifest file and the service worker file, both of which are required to be on the same origin they were first installed from.

Setting up a trusted, self-signed SSL/TLS certificate authority in Linux

Mon, 17 Feb 2025 00:00:00 +0000

With OpenSSL, it’s pretty easy to generate a simple self-signed TLS certificate. Just run the following command:

1openssl req -x509 -newkey rsa:4096 -sha256 -days 365 -nodes -keyout cert.key -out cert.crt

The files that this command generates, cert.key and cert.crt, could be passed to a web server, for example, and it will work fine; that is, all the connections made to that web server will be properly encrypted. The only problem with using this certificate, however, is that our browser doesn’t trust it, because it has not been signed with a certificate authority that the browser trusts.

How to convert TTF fonts to WOFF2

Wed, 01 Jan 2025 00:00:00 +0000

When you download a font from a source like Google Fonts, it’s likely in either TTF or OTF formats, the two most widely used font formats in the world. If you’re going to use these fonts on the web, however, it’s a good idea to convert them to WOFF2 first, because WOFF2 fonts are significantly smaller in size (WOFF2 fonts are the same as TTF or OTF fonts but compressed).

Of course, in many cases (as with Google Fonts) one can just use a CDN, but it’s generally a good idea to go to the trouble of self-hosting fonts (on the same domain as your site), rather than using a CDN, as then the fonts would be delivered to the end-user slightly faster when they visit your site. That’s because accessing a CDN involves making additional network requests, DNS lookups, fetching additional CSS files, etc.

How to gracefully shutdown a Go HTTP server

Tue, 03 Dec 2024 00:00:00 +0000

The following code snippet of Go starts a simple HTTP server that responds with “Hello World” to every request it gets.

 1func main() {
 2	server := &http.Server{
 3		Addr: ":8080",
 4		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 5			w.Write([]byte("<html><body><h1>Hello World</h1></body></html>"))
 6		}),
 7	}
 8	if err := server.ListenAndServe(); err != nil {
 9		log.Fatal(err)
10	}
11}

But there’s a small problem: the Server.ListenAndServe method blocks until the server terminates—until, to be more specific, one of Server.Close or Server.Shutdown methods is called, or it encounters a fatal error. In this example, the server never terminates (unless there’s an error), and one would have to terminate the process manually from the outside, by for instance hitting Ctrl+C and sending an interrupt signal to the process.

By way of beginning

Sat, 16 Nov 2024 00:00:00 +0000

There is perhaps a uniquely human instinct to leave our mark on the world, if nothing else to simply say that we were once here to whomever comes later. People have a tendency to carve their names or initials on rocks, trunks of trees, walls, benches, or some other hard surface they know is not going to be withered away by the elements too soon, especially if they’ve spent a lot of time in that place. The image that best illustrates this instinct to me is the stenciled hands humans have left, thousands of years ago, on the walls of Cueva de las Manos, in Santa Cruz, Argentina.