Optimizing Go Memory Management for Performance
Reflections on My Technical Writing Journey
Technical ideas often emerge at the intersection of current trends and perennial challenges. Over these past months, my writing has explored this space - examining everything from cutting-edge web capabilities to fundamental architectural choices. Some articles respond to new developments, while others revisit established practices with fresh perspectives. What connects them is a shared focus on practical solutions grounded in solid engineering principles, regardless of when those questions first appeared in our field.
Generics in Go:
Tradeoffs and Alternatives
When Go introduced generics three years ago, it marked a turning point for type safety without runtime overhead. Yet as a language designed for simplicity, its implementation deliberately lacks some features found in Rust or TypeScript. In this article, I examine how Go’s generics compare to these alternatives, when to use interfaces instead, and why code generation tools like sqlc sometimes outperform them all. The choice isn’t about ‘best’—it’s about aligning solutions with specific needs while honoring Go’s philosophy.
Revisiting Technology Choices in Modern Development
In software development, the tools we choose today might not serve us tomorrow. New languages emerge, ecosystems evolve, and yesterday’s 'best practice' becomes tomorrow’s technical debt. Yet too often, we treat technology decisions as permanent—ignoring how quickly the landscape shifts. This isn’t about chasing trends, but about recognizing when a choice no longer fits our needs. Through the lens of Go’s simplicity, Rust’s safety, Zig’s potential, and TypeScript’s compromises, let’s examine how to balance conviction with adaptability in our tech stack.
From Makefiles to Bun:
Modern Task Automation Tools
Every developer reaches a point where manual tasks beg for automation—whether it’s generating article templates or handling repetitive workflows. While classics like Makefiles and shell scripts still work, their limitations become apparent across different systems. My journey through tools like Taskfile and Go revealed trade-offs between power and simplicity. Now, I’ve settled on an approach that balances both: Bun’s TypeScript integration with native shell capabilities. Here’s why it might be your next automation ally.
Balancing Function Splitting and Performance in Go
Writing maintainable code often means breaking logic into smaller functions, but does this abstraction come with a performance penalty? In Go, the compiler aggressively optimizes by inlining functions, blurring the line between clean code and efficient execution. To understand the real-world impact, I dissected how Go handles closures, standalone functions, and forced non-inlined calls—down to the assembly level. The results reveal when splitting code matters, and when it’s effectively free. Let’s dive into the compiler’s behavior and what it means for practical design decisions.