fundamentals of software engineering ;

When you read, your brain needs to take the cognitive load. When you're watching videos, it's often spoon feeding. Ever thought about why our attention span is in 2-digit seconds nowadays? The aim is to be a builder, not a watcher. Articles let you learn at your own pace. You can skim, re-read, and jump around easily. You can highlight text, take notes in the margins, and search for keywords. You can also read offline or in low-bandwidth situations. Also, one of the biggest myths is that videos are better for learning. Research shows that active reading leads to better retention and understanding than passive watching. Here's a great video that dives into this topic: https://www.youtube.com/watch?v=rhgwIhB58PA

There's a big gap between using Docker and understanding how containers actually work. Between deploying to Kubernetes and knowing what happens when a pod starts. Between running a service and understanding the networking stack beneath it. I'm building this platform to help bridge that gap. It won't solve everything, but it might help developers build a foundation for understanding the infrastructure they work with every day. Because without some of that foundation, it's easy to end up blindly accepting whatever comes your way—even 'sudo rm -rf ~/'.

projectlighthouse is for the seekers. The ones who want to understand how things work under the hood. The ones who want to go beyond just using tools and platforms, and actually understand the infrastructure they interact with daily. You might be actively learning by building things, reading documentation, or challenging yourself with hands-on labs. Either way, if you have that curiosity and drive to understand containers, Kubernetes, and cloud-native technologies, this is for you. If you've ever wondered how Docker actually isolates processes, why your TCP connection hangs, what happens when you deploy to Kubernetes, or how service meshes route traffic—this is for you.

Language doesn't matter—except when it does. For containers, Kubernetes, and infrastructure work, it absolutely matters. Go powers Kubernetes, Docker, Terraform, containerd, and half the cloud-native tools you use daily. Its simplicity and concurrency model make it the lingua franca of cloud infrastructure. Rust offers memory safety without a garbage collector, making it ideal for performance-critical infrastructure components. It's being adopted widely in the industry—from the Linux kernel to new container runtimes and networking tools. C provides low-level access to understand how containers interact with the kernel, how namespaces work, and what's really happening under the hood. As projectlighthouse is still a one-man show, I had to pick languages that are industry-standard and that I work with daily—I can't teach something I don't know. Go for its dominance in cloud-native, Rust for its growing adoption in infrastructure, and C for foundational understanding.

For the articles, no—you can read and follow along on any OS. For the labs, you'll need a Linux environment. The labs run on real Linux microVMs in the cloud, so you can use them from any machine with a browser. But if you want to experiment locally, a Linux VM, WSL2 on Windows, or a Linux machine will serve you well. Containers and Kubernetes are inherently Linux-centric. Namespaces, cgroups, the /proc filesystem, container runtimes—these are Linux concepts. You can't learn them properly without touching Linux.