Go Patterns

A practical reading order for concurrency in Go: how work starts, moves, stops, and stays bounded.

11 published parts

Reading order

Part 1 of 11

Go Concurrency Patterns: A Practical Reading Order

Goroutines are cheap. Channels are simple. The hard part is choosing which pattern fits the problem you actually have — and knowing, when you outgrow it, what comes next.

Go & concurrency 3 min

Part 2 of 11

30 Nov №07

Understanding the Producer-Consumer Pattern in Go

The Producer-Consumer pattern is a fundamental concurrency pattern in Go that elegantly separates the production of data from its consumption. By using channels as intermediaries, this pattern creates a robust foundation for concurrent data processing.

Go & concurrency 3 min

Part 3 of 11

3 Dec №09

Generator Pattern in Go: Lazy Sequences with Channels

The Generator pattern in Go is a powerful concurrency pattern used to create functions that produce a sequence of values. It leverages Go’s goroutines and channels to generate data asynchronously, providing an elegant way to work with streams of data or implement iterators.

Go & concurrency 4 min

Part 4 of 11

10 Dec №11

Mastering the Worker Pool Pattern in Go

The Worker Pool pattern is a fundamental concurrency design in Go that efficiently manages a pool of worker goroutines to process tasks from a shared queue. This pattern excels at handling a large number of independent tasks concurrently while maintaining precise control over system resources and performance.

Go & concurrency 5 min

Part 5 of 11

24 Apr №13

Go Pipeline Pattern: Turning Streams into Useful Data

Sometimes, the hard part of concurrent programming is not making things run in parallel. The hard part is keeping the flow of data understandable.

Go & concurrency 6 min

Part 6 of 11

4 Jul №25

Context and Cancellation in Go: Stopping Work That Shouldn't Have Started

Every goroutine you spawn is a promise that something will eventually stop. If you don’t control when that happens, you leak intention: your program keeps doing work nobody asked for, long after the caller moved on.

Go & concurrency 7 min

Part 7 of 11

12 Dec №12

Flexible Approaches to Worker Pools in Go

While the standard Worker Pool pattern is powerful, Go’s flexibility allows for alternative approaches to concurrent task processing. This article explores the Shared Semaphore method and discusses the use of third-party libraries for managing concurrency in Go applications.

Go & concurrency 3 min

Part 8 of 11

2 Dec №08

Producer-Consumer in Go: Beyond the Basics

In our previous article, we explored the fundamentals of the Producer-Consumer pattern in Go. Today, we’ll take it a step further by examining more practical scenarios and introducing buffered channels - a powerful feature that can significantly improve your concurrent applications.

Go & concurrency 3 min

Part 9 of 11

9 Aug №05

Solving the Sum of Squares Problem: Optimizing Performance

Before delving into the main topic, I want to express my respect for the original post’s intent. My response aims to provide slight corrections that can benefit readers seeking accurate information. In the spirit of shared learning, I intend to contribute constructively rather than criticize. <br />Clarifications and alternative viewpoints can foster a deeper understanding of complex concepts. Let’s continue engaging in open discussions, embracing diverse insights as we collectively refine our knowledge.

Go & concurrency 7 min

Part 10 of 11

4 Jul №26

Go Goroutines vs C# async/await: Who Carries the Cognitive Load?

Goroutines and async/await solve the same problem. They start from opposite assumptions about who you trust: the runtime, or your future self. Everything else about Go and C# concurrency flows from those two starting positions.

Go & concurrency 12 min

Part 11 of 11

6 Dec №10

Advanced Generator Patterns in Go: Test Data and Streams

The introduction to the Generator pattern covered the mechanics: a function returns a receive-only channel, a goroutine sends values, the caller ranges over them. This article is the next step — two applications where generators earn their keep: generating test data for a web service, and composing generators into a streaming pipeline.

Go & concurrency 5 min