Last year, 2025, reinforced a familiar and worrying pattern: critical vulnerabilities, often stemming from memory-safety issues in foundational C++ code, continue to plague our most essential software. The logical, compelling answer from many corners of the industry is a shift towards memory-safe languages like Rust. I understand this push completely. However, by framing Rust as a silver-bullet solution, we risk addressing only the symptom while ignoring the underlying disease of complexity and superficial understanding in massive codebases. This article explores the tangible benefits and subtle pitfalls of the Rust transition, the immense reality of our C++ legacy, and why the future of software safety might not be decided by a compiler, but by the tools we build to augment our understanding.

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.