Dependency management with Go Modules has become a standard part of the workflow, but it only solves one part of the puzzle. In environments with multiple repositories, we often need to share more than just libraries—think configuration templates, Docker service definitions, or shared mock objects for testing. These resources don't fit neatly into the module system and demand different approaches. This article looks at the landscape of options, from project generators that create and maintain snapshots of code to more direct methods like Git subtrees or even simple curl scripts. The goal is to find maintainable ways to ensure consistency and reduce manual toil, whether you're bootstrapping a new service or keeping a suite of projects in sync.

Over the past year, my writing has ventured deeper into the technical trenches while also stepping back to question broader industry trends. The journey moved from specific optimizations in Go and Rust to fundamental discussions about infrastructure resilience, developer workflows, and the role of AI. A consistent thread has been the pursuit of pragmatism—finding the right tool for the job, understanding the trade-offs, and building systems that are not just clever, but truly reliable and maintainable. This collection captures that ongoing dialogue between innovation, craftsmanship, and practical reality.

The software engineering conversation today is dominated by languages like Go, Rust, and Zig. Having worked extensively with them, I’ve often found them to be more 'different' than fundamentally innovative compared to my established tools. This led me to a surprising question: what if the real evolution wasn't in a new language, but in the modernization of an old one? My journey back to C++—a language I had long dismissed—revealed a ecosystem transformed by smart tooling, powerful paradigms like data-oriented design, and a philosophy that now feels strikingly aligned with clarity and performance. This is not the C++ I remembered.

It’s 2026, and the promise of Progressive Web Apps feels both tantalizingly close and frustratingly distant. While you can 'install' a web app like YouTube and access right-click menus from your taskbar, the mobile landscape—particularly on iOS—remains firmly in the grip of native applications. Apple’s restrictions on background tasks and push notifications act as powerful reinforcements for the app store status quo. Yet, for indie developers, the allure is undeniable: no gatekeepers, no fees, and instant updates. So why does the native app still reign supreme, and is there a viable middle ground for projects that need more than the browser sandbox allows? This article digs into the technical and commercial realities holding PWAs back and outlines a progressive strategy to extend their reach.

Every line of code we write, every system we design, rests on a towering stack of abstractions. It’s the fundamental law of computing: we build simpler interfaces to harness overwhelming complexity. But I’ve come to see that not all abstractions are created equal. Some are liberating tools that let us focus on solving higher-order problems. Others, however, are seductive traps that bundle complexity into a black box, creating hidden dependencies and obscuring the very systems we rely on. In this article, I want to unpack the distinction between these 'genuine' and 'camouflaged' abstractions. By examining examples from operating systems to modern web frameworks, we can learn to identify which layers truly empower us and which ones we should approach with caution and a deeper understanding.