projectlighthouseSign in with your Google or GitHub account to get started
Programming concepts in depth, one topic at a time.
from zero to writing real Go — not toy examples, but the kind of code that ships. variables, structs, pointers, error handling, and testing, grounded in patterns you will actually use when building services, CLI tools, and systems software.
picks up where Go Fundamentals leaves off — concurrency, the GMP scheduler, channels, sync primitives, and performance profiling. understand how goroutines actually work, when to reach for context, and how to write Go that scales.
build a production log aggregator from an empty main.go to a deployed service. HTTP routing, PostgreSQL, authentication, middleware, HTML dashboards, and deployment — no frameworks, just Go and the standard library.
learn Rust by building rune — a real CLI password manager with encrypted vaults and git-based sync. ownership, borrowing, lifetimes, traits, and the type system, all through a project you will actually use.
inside the operating system — how processes are created, how memory is managed, how the scheduler decides what runs next. the layer between your code and the hardware, explored hands-on with real Linux tools.
beneath the abstractions — the language that kernels, databases, and embedded systems are written in. manual memory, pointers, structs, and the compilation model, with no garbage collector and no safety net. understand what your higher-level languages are doing for you by learning the language underneath.
data structures and algorithms from first principles — starting with how memory works and building up from there. arrays, linked lists, trees, graphs, heaps, hash tables, sorting, and searching, explained with the depth that helps you understand why things are fast or slow, not just what to memorize.
follow a packet from your keyboard to a server and back — what actually happens when you curl an endpoint. TCP/IP, sockets, routing, DNS, TLS, and HTTP, all from first principles with hands-on Linux tools.
Rust language fundamentals from the ground up. ownership, borrowing, lifetimes, structs, enums, pattern matching, error handling, traits, and generics — explained so the compiler stops feeling like an adversary and starts feeling like a mentor.
██████╗ ██████╗ ██████╗ ██╗███████╗ ██████╗████████╗██╗ ██╗ ██████╗ ██╗ ██╗████████╗██╗ ██╗ ██████╗ ██╗ ██╗███████╗███████╗ ██╔══██╗██╔══██╗██╔═══██╗ ██║██╔════╝██╔════╝╚══██╔══╝██║ ██║██╔════╝ ██║ ██║╚══██╔══╝██║ ██║██╔═══██╗██║ ██║██╔════╝██╔════╝ ██████╔╝██████╔╝██║ ██║ ██║█████╗ ██║ ██║ ██║ ██║██║ ███╗███████║ ██║ ███████║██║ ██║██║ ██║███████╗█████╗ ██╔═══╝ ██╔══██╗██║ ██║██ ██║██╔══╝ ██║ ██║ ██║ ██║██║ ██║██╔══██║ ██║ ██╔══██║██║ ██║██║ ██║╚════██║██╔══╝ ██║ ██║ ██║╚██████╔╝╚█████╔╝███████╗╚██████╗ ██║ ███████╗██║╚██████╔╝██║ ██║ ██║ ██║ ██║╚██████╔╝╚██████╔╝███████║███████╗ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚════╝ ╚══════╝ ╚═════╝ ╚═╝ ╚══════╝╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝╚══════╝