Advanced Systems Programming

This repository is a comprehensive, modular study guide for mastering Advanced Go Concurrency, High-Performance Proxy Data Structures, OS/Systems Programming, and Network Resilience. The examples mirror the internal architectures of industry-standard ingress controllers and Service Mesh proxies (like Envoy, NGINX, and Kubernetes networking).

All files are heavily commented to explain why these patterns are used in production Edge environments, making this the perfect curriculum to ace systems programming interview.

---

📚 Table of Contents & File Index

1. High-Performance Data Structures

In massive proxy architectures, global mutex locks destroy performance. These structures unlock high concurrency.

• Sharded LRU Cache: Eliminates global lock contention by hashing keys across an array of 256 individual sync.RWMutex shards.
• Lock-Free Ring Buffer: A zero-allocation, lock-free circular queue utilizing sync/atomic to process packets without triggering the Go Garbage Collector.
• Blocking Queue: FIFO queue utilizing sync.Cond for efficient producer-consumer synchronization.
• Hierarchical Timing Wheel: Scales millions of active socket timeouts efficiently with O(1) tick execution, replacing the resource-heavy time.AfterFunc().
• Lock-Free Fundamentals: Implementing atomic-based lock-free data structures.

2. OS Kernel & Systems Programming

Understanding what the Go Standard Library hides under the abstractions.

• Robust File I/O: User-space batching (bufio), Kernel page caches, atomic appends (O_APPEND), and zero-copy DMA utilizing the sendfile syscall.
• WAL Durability (fsync): Guaranteeing hardware-level disk persistence using the Unix fsync syscall.
• Basic File Operations: Standard file I/O, appending, and hex binary encoding for systems data.
• Systems: File IO Deep Dive: Low-level file descriptors and buffer management.
• Systems: Pipes & IPC: Inter-process communication using Unix pipes.
• Systems: Signals Handling: Managing OS signals for graceful process control.
• Systems: Unsafe Pointers: Bypassing Go's type safety for direct memory access.
• Memory Mapping (mmap): Mapping absolute physical hard drive space into Virtual Memory natively for zero-copy file serving (used by BoltDB/caches).
• Darwin/macOS Kqueue Event Loop: Mimics Envoy's core routing engine. Shows how to handle 10,000+ sockets on a single thread using the kqueue syscall (equivalent to Linux epoll).
• Raw Socket Provisioning: Bypassing Go's net package entirely to craft non-blocking Unix TCP sockets via C-level calls (unix.Socket, unix.Bind, unix.Listen).
• Systems: GC & Allocations: Understanding stack vs heap and Go's garbage collector.
• Systems: Process Management: Command execution, timeouts, and environment variables.
• Systems: File Watcher: Monitoring filesystem events for dynamic configuration reloads.

3. Concurrency Mastery

Controlling the Go Runtime flawlessly under massive request load.

• Channels Deep Dive: Buffered vs. Unbuffered behavior, multiplexing via select, and directional locking.

• Concurrency: Select Patterns: Advanced multiplexing, default cases, and non-blocking operations.

• ErrGroup Request Fan-Out: Multi-backend fetching where one failure cancels the entire aggregate group.

• Bounded Worker Pool: Preventing OOM crashes by strictly pacing Goroutine spawning using a Job Dispatcher pipeline.

• Context Deep Dive: Advanced context propagation, cancellation trees, and value-passing.

• WaitGroup Synchronization: Coordinating parallel task execution with sync.WaitGroup.

• Classic Ping-Pong: Demonstrating synchronized communication between two goroutines using unbuffered channels and sync.WaitGroup.

• Concurrency: Work Stealing: Custom scheduler patterns and task distribution.

• Lock-Free Hot Swapping (xDS): How Proxies update massive routing tables dynamically while traffic flows by swinging pointers with sync/atomic.Value.

• Atomic Benchmarks: Comparing performance between sync.Mutex and sync/atomic.

4. Edge Proxying, Traffic & Routing

The lifeblood of the Data Plane.

• L7 Reverse Proxy & Header Injection: Appending X-Forwarded-For and trace IDs dynamically using Go's httputil.ReverseProxy.
• Networking: Bandwidth Throttler: Token-bucket traffic shaping for io streams.
• L4 TLS SNI Inspector: Peeking inside raw TLS ClientHello frames to extract the Server Name Indication (SNI) for routing decisions without decrypting the SSL payload!
• Networking: TCP/HTTP/UDP Servers: Building custom protocol handlers from the ground up.
• TCP Keep-Alive Connection Pool: Reusing upstream proxy sockets and gracefully blocking queued Goroutines using sync.Cond.
• Networking: Port Scanner: Efficient reconnaissance using parallelized socket connections.
• Passive Outlier Detection: Envoy's pattern for dynamically monitoring and ejecting a bad upstream node mathematically without active health checks.
• Graceful Shutdown Listener: Trapping SIGINT/SIGTERM OS Signals to drain active proxy traffic connections gracefully during deployments safely.
• Networking Basics: Foundational TCP/IP server implementation.

5. Load Balancing Algorithms

Distributing throughput flawlessly across cluster farms.

• Thread-Safe Round Robin: Purely atomic, lock-free routing iteration (atomic.AddUint32).
• Consistent Hashing Ring: Implementing a Virtual-Node Hash map with crc32 hashing and sort.Search for deterministic sticky-session routing without mass-resharding.

6. Mesh Resiliency & Rate Limiting

Protecting your cluster from cascading downtime and Thundering Herds.

• Circuit Breaker State Machine: Mathematical Closed -> Open -> HalfOpen states used to fast-fail traffic and protect a dying upstream database.
• Sliding Window Log Rate Limiter: Perfect-precision time-pruning API rate limiting vs Token Buckets.
• Token Bucket Rate Limiter (API): Robust API-level rate limiting implementation.
• Bulkhead Resource Isolation: Using Weighted Semaphores (golang.org/x/sync/semaphore) to ensure an external API outage never consumes all proxy resources.
• Exponential Jitter Backoff: Randomized retry algorithms designed to stop 50,000 proxies from crashing a database upon reboot (Thundering Herd shield).
• Raw Network Server Protocols & UDP Host (sync.Pool): Foundational packet framing, TCP Read Deadlines, and UDP zero-allocation Datagram parsing.
• Simple Rate Limiter: Lightweight token-refill implementation.