Zig articles tend to get a little too excited about rediscovering longstanding techniques.

The author has described a metaprogramming utility for allocating a contiguous hunk of memory, carving this hunk into fields (in the article's example, a fixed-sized Client header, then some number of bytes for host, then some number of bytes for read_buffer, and then some for write_buffer). I'll acknowledge the syntax is convenient, but

1. we've done this since time immemorial in C. See https://learn.microsoft.com/en-us/windows/win32/api/evntcons...

2. you can implement this pattern ergonomically in C++, and even moreso once the C++26 reflection stuff comes online

3. the zig implementation is inefficient. It desugars to

  const Connection = struct {
    ptr: [*]u8,
    lens: struct {
      host: usize,
      read_buffer: usize,
      write_buffer: usize,
    }
  }

That first pointer is needless indirection and probably a cache miss. You should (unless you have specific performance data showing otherwise) store the sizes in the object header, not in an obese pointer to it. (It's bigger than even a fat pointer.)