Generics in Go:
Tradeoffs and Alternatives
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.
PGO in Go: Optimizing AOT Code Like JIT
We often think of JIT-compiled languages like Java or JavaScript as the kings of runtime optimization, dynamically adapting to usage patterns. But what if I told you Go—a strictly AOT-compiled language—can achieve similar optimizations without runtime overhead? Thanks to Profile-Guided Optimization (PGO), introduced in Go 1.20, we can now give the compiler a 'cheat sheet' of how our code behaves in production. This isn’t just theoretical: real-world cases show measurable gains, especially for long-running services. Let’s explore how PGO works, when to use it, and why it might change how you think about AOT compilation.
Why Go Isn’t Always Ideal for Beginners
Go has earned its reputation as a robust, cloud-native language—fast, simple, and reliable. But as its adoption grows, so does the mismatch between its design and the expectations of newcomers. Many assume Go’s minimalism means ease of use, only to encounter its unique error handling, goroutines, and lack of familiar abstractions. This isn’t just about syntax; it’s about how the language shapes problem-solving. Whether you’re considering Go for a team or as a learner, understanding these nuances early can save frustration later.