A

autochitect

Explore software architecture ◆

All Write-ups

2026

  • May 22
    Storage DurabilitySystem DesignStorage

    How databases and filesystems guarantee that committed writes survive crashes — from fsync and write-ahead logs to the hardware tricks that make them work.

  • May 22
    ReplicationSystem DesignDistributed Systems

    How distributed systems copy data across multiple nodes to survive failures, scale reads, and reduce latency.

  • May 22
    Memory AllocatorsInternalsRuntime

    How allocators carve up heap memory, the algorithms behind malloc and modern arenas, and why TigerBeetle's fixed-memory model eliminates allocation entirely.

  • May 22
    Leader ElectionSystem DesignDistributed Systems

    How distributed systems agree on a single coordinator — the algorithms, failure modes, and trade-offs of electing a leader without a central authority.

  • May 22
    Just-In-Time (JIT) CompilationCompilersPerformance

    How JIT compilers generate native machine code at runtime — from mmap and PROT_EXEC to a recursive codegen that walks an AST and emits real x86-64 instructions.

  • May 22
    HTTP/2 & HTTP/3NetworkingProtocols

    How HTTP evolved from a text protocol with one request per connection to a multiplexed binary stream, and then to a transport built on UDP that survives network switches.

  • May 22
    Garbage CollectionInternalsRuntime

    How runtimes automatically reclaim memory, the algorithmic trade-offs between throughput and pause time, and why GC behavior should shape your service architecture.

  • May 12
    TCP/IP 4-Layer ModelNetworkingProtocols

    The network model that actually shipped. How four layers — Link, Internet, Transport, Application — carry every byte your services send, and why every architecture decision you make is secretly a layer decision.

  • May 12

    What a socket actually is, how the OS manages the full lifecycle of a connection, why unmanaged sockets drain CPU at scale, and how DNS prefetch and stale cache interact with socket behaviour.

  • May 12
    OSI ModelNetworkingProtocols

    How decomposing network communication into seven independent layers solved vendor lock-in and became the mental model every engineer still reaches for.

  • May 11
    Gossip ProtocolSystem DesignDistributed Systems

    How nodes in a distributed system spread information reliably using epidemic-style peer-to-peer communication.

  • Apr 20
    BackpressureSystem DesignStreaming

    How producers and consumers negotiate throughput so that a fast upstream never overwhelms a slow downstream.

  • Apr 10
    Raft ProtocolSystem DesignDistributed Systems

    How Raft achieves distributed consensus with leader election and log replication, making it the readable alternative to Paxos.