#zig

Learn Zig Series (#96) - Mini Project: Chat Server - Server Core What will I learn? How to turn last episode's paper protocol into a running server that many people can connect to at once; Why the heart

Learn Zig Series (#95) - Mini Project: Chat Server - Protocol Design What will I learn? Why a real multi-user program starts with the messages, not the sockets -- a protocol is a contract written in bytes,

Learn Zig Series (#94) - NAT Traversal and Hole Punching What will I learn? What a NAT actually is once you stop fearing it -- a box on your router that rewrites the source address and port of every packet

Learn Zig Series (#93) - SOCKS5 Proxy What will I learn? What a SOCKS5 proxy actually is once you strip the mystique away -- a tiny handshake, a one-shot connect request, and then dumb byte-copying in

Learn Zig Series (#92) - gRPC Service in Zig What will I learn? What gRPC actually is once you strip the branding away -- protobuf payloads, HTTP/2 transport, and one small calling convention bolted on

Learn Zig Series (#91) - MessagePack Format What will I learn? Why a self-describing binary format exists, and how it differs from the schema-driven protobuf we built last episode; How MessagePack packs

Learn Zig Series (#90) - Protocol Buffers Serialization What will I learn? Why a binary serialization format exists at all, and what protobuf buys you over hand-rolled byte layouts or JSON; How protobuf's

Learn Zig Series (#89) - MQTT Messaging Protocol What will I learn? Why MQTT exists, and what the publish/subscribe-through-a-broker model buys you over plain sockets; How the fixed header packs a packet

Learn Zig Series (#88) - WebSocket Server What will I learn? How a WebSocket connection lives and dies -- the handshaking, open, closing, closed state machine; How to perform the server-side upgrade by

Learn Zig Series (#87) - WebSocket Protocol What will I learn? Why WebSocket exists, and what it does that plain HTTP simply cannot; How the opening handshake upgrades an ordinary HTTP request into a

Learn Zig Series (#86) - TLS via C Interop What will I learn? Why you should NEVER hand-roll your own TLS, and what to do instead; How to link a battle-tested C crypto library (OpenSSL) into a Zig build;

Learn Zig Series (#85) - HTTP/2 Frames and Streams What will I learn? Why HTTP/1.1 hit a wall and what problem HTTP/2 was designed to solve; How the binary framing layer works -- the 9-byte frame header

Learn Zig Series (#84) - HTTP/1.1 Deep Dive What will I learn How HTTP/1.1 works at the byte level -- request lines, headers, and message bodies; How to build a compliant HTTP/1.1 parser that handles chunked

Learn Zig Series (#83) - DNS Server Implementation What will I learn How to build a DNS server that listens for queries and sends responses; How to implement zone file parsing for storing DNS records;

Learn Zig Series (#82) - DNS Resolver from Scratch What will I learn How DNS works at the protocol level -- query format, response parsing, record types; How to construct raw DNS query packets in Zig using

Learn Zig Series (#81) - UDP Sockets and Datagrams What will I learn How UDP differs from TCP at the protocol level and why you'd choose one over the other; How to create, bind, and use UDP sockets with

Learn Zig Series (#80) - Mini Project: File Sync Tool - Part 4: Polish Part of a multi-episode project What will I learn How to implement conflict resolution strategies -- newest-wins automatic mode and

Learn Zig Series (#79) - Mini Project: File Sync Tool - Part 3: Network Protocol Part of a multi-episode project What will I learn How to design a binary wire protocol for file synchronization with handshake,

Learn Zig Series (#78) - Mini Project: File Sync Tool - Part 2: Delta Transfer Part of a multi-episode project What will I learn How to implement the rsync delta transfer algorithm in Zig; How to use rolling

Learn Zig Series (#77) - Mini Project: File Sync Tool - Part 1 Part of a multi-episode project What will I learn How to design a file synchronization tool architecture from the ground up; How to recursively