Welcome to Go Systems Programming

Go isn't just for web services. It's a first-class systems language: it talks to the kernel, manages processes, opens raw sockets, and handles signals, all from the standard library. This course teaches the layer beneath the app.

We stay close to the OS. Linux and Unix are the focus, with notes where Windows differs. We teach the idiomatic os, net, and os/exec packages first and drop down to raw syscalls only when they earn their place.

What We're Building

Small, real tools throughout, ending in a monitoring daemon: it watches directories, reloads its config on SIGHUP, locks its files, and exposes live stats over a Unix domain socket. Every lesson adds a piece you'll use in the capstone.

What You'll Learn

• Syscalls & errno: the system-call model, syscall.Errno, and retrying EINTR/EAGAIN
• File I/O: file descriptors, seeking, permissions, symlinks, and os.Root
• Permissions & privileges: uid/gid, umask, and dropping root safely
• Pipes & IPC: os.Pipe, wiring stdin/stdout/stderr, and Unix domain sockets
• Processes: os/exec, piping between programs, exit codes, and cancellation
• Signals: os/signal, signal.NotifyContext, and SIGHUP-driven reloads
• TCP: net.Listen/Dial from the socket up, deadlines, and a line protocol
• UDP: connectionless datagrams and when they beat TCP
• The netpoller: how Go turns blocking syscalls into cheap goroutines
• System introspection: reading /proc, resource limits, and process stats
• Zero-copy I/O: sendfile/splice and the ReaderFrom/WriterTo interfaces
• CLI tools: flag, exit codes, piped input, and cross-compilation
• Daemons: PID files, systemd, logging, and running as a real service

Why This Course?

• Current Go: built on Go 1.26 with slog, os.Root, and signal.NotifyContext. The classic systems books predate all of it.
• No filler: we assume you know Go, so we start at the OS boundary and stay there.
• Connected: each lesson links the rest of the Go track instead of re-teaching it.
• Practical: every concept builds toward a daemon you could actually run.

Prerequisites

Complete Go Essentials and ideally Go Concurrency Patterns. You should be comfortable with goroutines, channels, context, and basic file handling. Familiarity with Go in Practice helps, since the daemon lessons build on its config, logging, and shutdown patterns.

Course Structure

We move from the ground up: syscalls and files, then processes and signals, then the network stack, then the runtime that makes it all cheap, and finally building and shipping real tools. Ready to get close to the kernel? Choose your first lesson from the sidebar!