DEVELOPER NEWS STREAM
Direct logs, engine updates, and framework notifications parsed from curated RSS feeds and announcements, updated hourly.
Gabriel AnhaiaReflection in Go: The Few Times It Is Justified (and the Cost)
Reflection in Go is the slow escape hatch. Here are the few cases it earns its keep, the runtime cost, and when codegen beats it.
Gabriel AnhaiaVariadic Functions and the append(s, more...) Spread in Go: The Gotchas
Nil vs empty variadic slices, the shared-backing-array append trap, and the copy-when-you-must rules that keep Go slices from mutating each other.
Gabriel AnhaiaUsing defer to Modify a Named Return in Go (Carefully)
The defer-closure-over-named-return trick wraps errors and rescues cleanup failures in Go. Here is why it only works with named returns.
Gabriel AnhaiaGo Slice Tricks: Insert, Delete, and Filter Without a Helper Library
In-place delete, insert, filter, and reverse in Go — plus the aliasing and memory-retention traps, and where the slices package covers you now.
Gabriel AnhaiaThe comma-ok Idiom in Go: One Pattern, Four Places It Shows Up
One two-value pattern shows up in map lookups, type assertions, channel receives, and range. Learn where the ok half saves you from a class of Go bugs.
Gabriel Anhaiapanic and recover in Go: The 3 Times They Are Actually Correct
Most recover() calls in Go hide bugs. Here are the three places panic and recover are the right tool, and the pattern that turns them into landmines.
![String and []byte in Go: The Conversions That Quietly Allocate](https://media2.dev.to/dynamic/image/width=1000,height=420,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftbyaitbz5a4jo46z8zmy.png)
Gabriel AnhaiaString and []byte in Go: The Conversions That Quietly Allocate
Every []byte(s) and string(b) copies memory. Here are the ones the Go compiler skips for free, and how to prove which is which.
Gabriel AnhaiaTyped vs Untyped Constants in Go: The Rule That Prevents Overflow Bugs
Untyped Go constants carry arbitrary precision and hand you a free compile-time overflow check. Here is when a typed constant earns the keyword.
Gabriel AnhaiaSentinel, Typed, or Opaque: Choosing an Error Style in Go
errors.Is sentinels, errors.As typed errors, opaque behavior-checked errors. How to pick one style per package boundary in Go.
Gabriel Anhaiavar _ Iface = (*T)(nil): The Go Compile-Time Interface Check You Should Use
One line of Go turns a silent runtime interface break into a build error. Where to put var _ Iface = (*T)(nil) so it actually helps.
Gabriel AnhaiaGo Struct Tags Beyond json: validate, db, and Writing Your Own
How reflect reads Go struct tags, why validate and db keys coexist, and how a single typo makes your tag vanish with zero errors.
Gabriel AnhaiaMake the Zero Value Useful: A Go Design Habit That Saves Constructors
Design Go types so the zero value already works. sync.Mutex and bytes.Buffer do it. Here is how to copy the habit and when a constructor still earns its place.
Gabriel AnhaiaNamed Return Values in Go: When They Help and When They Bite
Named returns clean up defer-modify and docs, then bite you with shadowing and naked returns. Here's when to name and when to stay positional.
Conor DobbsMigrating from Go to Rust: The Tradeoffs Worth Knowing First
Go to Rust moves nil derefs, data races, and GC pauses from runtime to compile time, at the cost of function coloring, slow builds, and a 3-6 month learning curve. A grounded, calibrated look at when
Timur GilyazovI Built a Visualizer for Go's Garbage Collector
Go's garbage collector is one of those things that usually "just works". And that is a good thing:...
Kevin NambubbiWhy I’m Learning Go and JavaScript Together Instead of Separately
Most programming tutorials teach technologies in isolation. You learn a language. Then a...