Context and Cancellation in Go: A Practical Guide
Learn how Go context cancellation works in real systems: timeouts, request lifecycles, errgroup fan-out, and graceful shutdown without leaked goroutines.
How to Merge PGN Files in F#: Streaming, Performance, and Discriminated Unions
How I built a CLI tool to merge chess PGN files using F#'s type system, streaming I/O, and functional patterns — merging gigabytes of games with 64 KB of memory.
TDD Isn't About Bugs — It's Your Permission to Refactor
Learn why test-driven development is really about permission to refactor, not catching bugs. With TypeScript examples, Result<T, E> patterns, and behavior-based testing from 3 years in production.
Why I Built ZaString
On zero allocations, Span<T>, and the pursuit of performance without sacrifice.
Generic Methods Coming to Go
Go just accepted the proposal for generic methods on concrete types. Here's what changes, what doesn't, and why it matters.
Go Pipeline Pattern: Turning Streams into Useful Data
Learn the Pipeline Pattern in Go using goroutines and channels. Build composable stages for parsing, filtering, enriching, and processing log streams.
Flexible Approaches to Worker Pools in Go
Explore flexible approaches to the Worker Pool pattern in Go, including the Shared Semaphore method and third-party libraries. Learn when to use each approach for optimal concurrency management in your Go projects.
Mastering the Worker Pool Pattern in Go
Master the Worker Pool Pattern in Go to manage concurrent tasks efficiently. Control resource usage, improve throughput, and scale your applications.
Advanced Generator Pattern: Consuming and Testing Data Streams
Advanced Generator Pattern in Go: testing, error handling, and real-world data generation techniques for robust applications.
Advanced Generator Pattern in Go: Test Data Generation
Practical Generator Pattern examples in Go for test data generation, streaming, and building composable data pipelines.
Mastering the Generator Pattern in Go
Master the Generator Pattern in Go using goroutines and channels. Learn lazy evaluation, composability, and practical examples for data streams and iterators.
Producer-Consumer in Go: Beyond the Basics
Explore advanced aspects of Go's Producer-Consumer pattern with buffered channels and real-world examples. A beginner-friendly deep dive into practical applications.
Understanding the Producer-Consumer Pattern in Go
Understanding the Producer-Consumer Pattern in Go with channels. Modular architecture, flexible scaling, and real-world concurrent data processing examples.
Solving the Sum of Squares Problem: Optimizing Performance
Optimize Go performance by solving the sum of squares problem. Benchmark goroutines vs sequential code and avoid common concurrency pitfalls.
Merge Sort using Goroutines
Implement parallel Merge Sort in Go using goroutines. Compare performance with sequential version and learn when parallelization pays off.
Goroutine vs Simple function
When are goroutines overkill in Go? Benchmark comparison showing simple functions can outperform goroutines for small datasets.
How to optimize a Go deployment with Docker
Optimize your Go deployment with Docker using multi-stage builds. Reduce image size from 1GB to 15MB with practical Dockerfile examples.