Joey Innes

Writing a panel-method solver in Zig

Sun, 26 Jul 2026 00:00:00 +0000

I’ve been flying soft wings for years without really understanding the sections they’re built from. Paragliders, speedwings, kites — they all live or die on the shape of a slice through the wing, and I’ve mostly taken that shape on trust. So I’ve started building something to fix that: a simulation backend called Camber, which takes a wing section, an angle, and an airspeed, and tells you what the air does about it.

Elegance in Global Cooperation: Engineering Simplicity, Purity and Correctness

Thu, 09 Jan 2025 00:00:00 +0000

Today, after reading a good chunk of Serious Cryptography, by J. P. Aumasson, I was lamenting over the likeness of computer science and society, and the way that game theory and complexity theory are interlinked. Reflecting on my day’s study, and my view of the world in general, I found myself drawing many comparisons that seemed insightful.

For example, the security of a given cryptographic scheme is in practice dependent on it’s understandability, for if an algorithm is difficult to understand, there is a high likelihood that it will be implemented poorly or misused. That is to say that the number of possible attack vectors scales with complexity.

Progress on the Peregrine HTTP server

Thu, 09 Jan 2025 00:00:00 +0000

I’m implementing a HTTP server from scratch in Zig, as a fun way to learn the Zig systems programming language, and also to get more comfortable and familiar with some modern kernel features that make highly performant network IO possible.

I started this project on the 24th December 2024, and within a couple of days, I had a bare-bones TCP server that could parse and respond to HTTP requests. Initially, I followed Karl Seguin’s excellent guide to creating a TCP server in Zig. If you’re interested in learning Zig, after solving some Ziglings, I suggest that you look at Karl’s blog posts on Zig.

The beginning of project Peregrine - a bleeding fast HTTP server

Thu, 26 Dec 2024 00:00:00 +0000

If you’re very familiar with Zig, then you’ll know that the standard library HTTP server is not written to be highly performant.

Zap is an alternative. Zap is built on the fantastic Facil.io networking library written in C.

Now, while there are plenty of fast HTTP servers, at time of writing, I couldn’t find a production-ready high-performance HTTP server written purely in Zig. There is http.zig, but according to Karl, the developer, it must sit behind a reverse-proxy because it’s not resilient to DoS attack.

First thoughts on Zig

Mon, 23 Dec 2024 00:00:00 +0000

I’ve done very litte systems programming. I wrote Conway’s Game of Life in C as a teenager. I also did a bit of assembly at GE Aviation Systems. A few years ago, I completed the Rust programming book, but struggled with the language beyond that, and never grew to love it.

I’m currently diving quite deep into systems programming in Zig. While there are many things I love about the language, namely it’s elegant approach to generics and meta-programming, I do feel that the language is lacking in some ways.

The relationship between turn radius and velocity

Wed, 10 Jul 2024 00:00:00 +0000

R=(v^2)/a_c, where R is turn radius, v is velocity, and a_c is centripetal acceleration. Turn radius is proportional to the velocity squared.

This means that for a given centripetal acceleration, doubling the speed results in a quadroupling of the turn radius. Therefore, higher speeds require wider turns.

Applied to flight, for a given force of lift, doubling the speed results in 4x the turn radius. This is why you will very occasionally see me use brakes to turn, where the line is too tight to negotiate otherwise.

Leaving some projects unfinished is cruicial for maximising rate of learning

Mon, 20 May 2024 00:00:00 +0000

As I browse old works from venerable computer scientists, I often encounter brilliant yet unfinished projects.

This led me to reflect on my own habbit of leaving personal projects unfinished. I see merit in occasionally parking ideas indefinitely. That is, if the real goal of any personal project is not to output a piece of work, but to acquire skills necessary for a future project, it follows that we must let it go once we see a bridge to the next phase of learning.

Comparing the performance of a de Bruijn sequence against a simple lookup table

Fri, 17 May 2024 00:00:00 +0000

While optimising the naive proof-of-work algorithm in my dave protocol implementation, I compared the efficiency of some methods of counting the number of leading zero bits in a byte slice.

Approaches

1. Naive approach

func nzerobit_1(key []byte) int {
    var n int
    for _, b := range key {
        for i := 0; i < 8; i++ {
            if b&(1<<i) == 0 {
                n++
            } else {
                return n
            }
        }
    }
    return n
}

Iterating over each byte in the given key, we use the bitwise AND operator & to check if the i-th bit of the byte is zero. The expression 1<<i creates a bitmask with only the i-th bit set to 1, and the & operator performs a bitwise AND operation between the byte and the bitmask. If the result is zero, it means that the i-th bit is zero, and we increment n. If the bit is set, we return the current value of n.

Dave

Wed, 01 May 2024 00:00:00 +0000

EDIT: In September & October I made significant changes to the DHT, and so much of this article is out of date. I have not yet found time to update this article, and I’m not currently working on the project.

So… what am I doing? When I started this project (first commit 2024-04-05), I didn’t know exactly, beyond designing a peer-to-peer network application that disseminates information. Now my vision is finally becoming clear, and I’m able to describe it.

logd

Fri, 15 Mar 2024 00:00:00 +0000

Started ~2023-12 Real-time logging (tail & query) for virtually unlimited logs. A map of in-memory ring buffers. Built on UDP & homegrown ephemeral HMAC. Go std lib + Protobuf. Image is built from scratch (Linux kernel + app executable).

2024-05: Looking back, this was an enjoyable project to rediscover writing software. It’s amazing to return to something after a change of mind. A new mind has more fun, and is more productive. The same thing happened when I re-imagined speedflying after my spinal-cord injury. Some years after my recovery, I rediscovered a lost joy with a new mind.

arpload

Sat, 09 Mar 2024 00:00:00 +0000

Arweave is a decentralized storage network that offers a unique approach to data storage.

The network is designed to provide permanent information storage, where users pay a one-time fee to store data for at least 200 years, with the potential for it to last much longer, possibly forever.

This is based on the assumption that the cost of storage will continue to decrease over time, and the initial fee paid by the uploader is invested in an endowment that accrues value, similar to interest in a bank account.

First time in Madeira

Tue, 19 Dec 2023 00:00:00 +0000

https://youtu.be/8CO--11bj_E

Flare have given me a Line 8 (cheers Beni), and they asked me if I’d kindly take it flying.

Considering the Maritime alps, I looked further afield, to warmer climes. I almost went to Corsica.

After hearing of the Bitcoin conference and arranging wirh a couple of friends to go together, I saw photos & videos of this incredible island.

My imagination ran wild as I explored 3D maps, marvelling at the topography.