Zig Mastery: The Final Project and Assessment

← Back to Zig Mastery

Zig Mastery: The Final Project and Assessment

1. The Physics of the Finale: Full-Stack Systems Integration

To graduate, you must demonstrate that you can bridge the gap between Silicon and the Cloud.

The Finale Mirror

The Concept: True systems architecture isn't just about one language; it is about the Movement of Data through multiple layers (Registers -> RAM -> Kernel -> Wire -> Sandbox).
The Physics: You will be measured on Latency Determinism. A systems master ensures that their code never blocks the CPU needlessly. Whether it is a CAS loop at the pointer level or an io_uring loop at the network level, you must prove that your hardware is always at 100% utilization.
The Culmination: This project mirrors the reality of modern engineering—where your Zig code might power a high-speed database core on a Linux server while simultaneously running as an optimized WASM engine in the client's browser.

2. The Challenge: A Zero-Leak Proxy

Your proxy must sit between a web browser and a website.

It must log all traffic.
It must handle "Timeout" errors perfectly using Error Sets (Module 151).
It must run for $24$ hours without leaking a single byte of memory. (The GPA will be watching!).

2. Using Comptime for Configuration

Don't use a messy JSON parser for your configuration.

Use Comptime Reflection (Module 156) to read a .config file at compile-time.
If the config is invalid (e.g., a port number is missing), the program should Fail to Compile.
This ensures your production binary is "Pre-Validated" and perfectly fast.

4. Requirement 3: Multi-Target Bridge (Native + WASM)

In 2026, the best apps run on the server and in the browser.

The Portability Mirror

The Requirement: Build a fetchReport() function that retrieves data from a URL.
The Native Logic: On Windows/Linux/macOS, use TCP Sockets (Module 191).
The WASM Logic: On the Web, use extern fn to call JavaScript's fetch() API (Module 192).
The Strategy: Use @import("builtin").target to automatically swap the implementation at compile-time. Your final binary should work on a server and a website with the same codebase, demonstrating total Platform Sovereignty.

5. The Graduation: A 'Self-Hosting' Review

A proxy is only good if it can handle $1,000$ users at once.

You will use Zig's Async functions to manage connections.
You must use suspend and resume (Module 161) to manage the network I/O.
You will prove your speed by running a Benchmark (Module 155) against a standard Nginx proxy.

4. The Graduation: A 'Self-Hosting' Review

As your final step, you must perform a "Self-Review" of your code.

Find one place where you used a "Many-Item Pointer" and replace it with a "Safe Slice."
Find one place where you used a Global Allocator and replace it with an "Explicit Allocator."
The Goal: Your code should be "Idiomatic Zig"—simple, explicit, and perfectly safe.

Frequently Asked Questions

What if I fail the performance test? Don't panic. Use zig-perf or a profiler to find the "Hot path." Usually, it's a hidden allocation inside a loop. By moving that allocation to the "Init" step, you can reach $10x$ speeds instantly.

Can I put this on my resume? YES. Building a high-performance network tool in Zig is a "Badge of Honor." It proves you understand memory, threads, network protocols, and the deepest parts of the compiler. You are now a Systems Master.

You have graduated. By building a high-scale, zero-leak network proxy, you have mastered the world's most modern systems language. You have the power to build the infrastructure of 2026. You aren't just a "Developer" anymore; you are a Systems Engineer. Go build something that lasts.

Phase 30: Systems Master Graduation Checklist

Audit your Memory Hygiene: Use the GeneralPurposeAllocator and verify that the program exits with zero leaks under heavy load.
Implement Full-Stack Portability: Verify that your networking code compiles and runs correctly on both x86_64-linux and wasm32-freestanding.
Use Comptime Schema Validation: Ensure your configuration structs are validated at compile-time using reflection.
Setup Atomic Non-Blocking Synchronization: Replace any remaining Mutex locks with wait-free atomic structures in your proxy's hot path.
Verify Throughput Saturation: Run a stress test using wrk and confirm that your proxy saturates the available network bandwidth with minimal CPU overhead.

Certification Issued: You are now a Topictrick-Certified Zig Systems Architect.

You have completed the Zig Mastery Course — masters of the zero.