Go Concurrency Deep Dive

Give your apps a speed boost and delight your users

Achieve the next level of developing high-performance applications

A purely sequential app has two downsides.

- If the app maxes out the CPU, you need to switch to faster hardware.
- If the app waits for I/O operations to finish, nothing else can be done during that time.

To make your app run faster and be more responsive, there is no way around thinking and programming in terms of concurrency.  

Have you shied away from concurrent programming because you were afraid of having to tackle the added complexity?  

Think twice.  

Can you afford not writing concurrent code? 

Single-threaded code is certainly easier to write and easier to troubleshoot. So why bother with all the pitfalls and unknowns of concurrent programming? Here is why: concurrent code enables your backend software to serve more clients, faster. Users love responsiveness and quick turnarounds. And you can provide them with that. If you know how to go beyond single-threaded programming.  

Boost your Go code with concurrency 
for highest performance and lowest latency 

Go has concurrency built into the language, but concurrency itself is tricky by its very nature. Concurrent execution flows add a new dimension of complexity to programming.  

Learn and practice concurrency in Go to achieve mastership in building concurrent applications.

What you'll learn in this course 

- All about Go's concurrency primitives: goroutines and channels
- Useful concurrency patterns: do not re-invent the wheel
- Troubleshooting concurrent code: what do do if things go wrong
- And more!

Concurrency Deep Dive comes in two sizes 

If you only need to get up and going, the standard version is for you.  

Or take the extended version, to get deeper insights and the skills that not everyone else has.
Note: ​The extended course will be launched once the standard course is complete.​​​

Be the first to get notified 

and get the course at a discount 

A beta version of this course launches soon.  

Sign up to –  
- get a generous early-bird discount,
- access the first lectures instantly, and
- get notified about new lectures as they come.

Leave me your email and I'll notify you when the beta phase is open.

I have read and agree to the terms & conditions.

Course Summary

Concurrency is a core aspect in Go. Learn how to leverage the basic concurrency mechanisms, how to design concurrent flows, and how to observe and troubleshoot concurrent services.

These are the planned lectures (I may make modifications where needed):

Standard Course

Intro

Section 1: Basics

Goroutines

Are goroutines threads?

Two caveats

Channels

Channel axioms

The Select Statement

Section 2: Go concurrency patterns

Managing goroutines

Error handling with ErrGroup

The context package

Fan-in, fan-out

Managing resources with sync.Pool

Memoization with sync.Once

Section 3: Troubleshooting

Data Races

Deadlocks

Livelocks

Starvation

Goroutine leaks

The go trace tool

The runtime/trace package

net/http/pprof handlers

Extended Course

Section 4: Inside the runtime

The goroutine scheduler

Caveat: cache line invalidation

Section 5: More concurrency patterns

Futures

Pipelines

Queues

Publisher-Subscriber (Pub-Sub)

Section 6: Package APIs and concurrency

Asynchronous APIs

Callbacks

Course Curriculum

Christoph Berger

Hi, I am Christoph.

I started programming at the age of 13, when computers still had 8-bit processors. I always had a genuine interest in programming languages, powered by the belief that picking the right language does matter if you want to be productive and generate fast, robust, and maintainable code.

After studying Computer Sciences at the Technical University of Munich, I worked as a project consultant and later as a technical support engineer for many years, and this is where I learned how to explain complex technical things in a way that is easy to understand, yet does not leave anything important out.

In 2011, an article about (pre-1.0) Go in an IT magazine caught my attention, and since them I am hooked. I loved (and still do!) how the incredibly clean design of the language, as well as the awesome tool chain, suddenly made coding a breeze.

I love Go for being simple and effective at the same time, boosting programmer productivity by focusing on the language features that matter.

Still, every language able to produce production-level code has some inherent complexity, and soon I found myself dragging pieces of information together,from various tutorials, blogs, forums, books, and other parts of the internet. You bet that these information bits were often incomplete, targeted at a different level than I needed, or even contradicted each other.

I really wished I had everything in one place, carefully collected and assembled into a sane curriculum, presented in a pleasant way, with consistent style, easy to digest.
And so I started building Go courses, to give you the training that I wish I had. Courses designed to be efficient, intuitive, and complete.

I write about Go since 2016, through my well-received blog "Applied Go". By building online courses I want to go one step further and help everyone becoming fluent with one of the coolest and most pragmatic languages around.

Course Pricing

  • Beta Price
  • $19 USD

    Instead of $29 standard price - valid until full course launch

    Buy Now

Be the first to get notified 

and get the course at a discount 

A beta version of this course launches soon.  

Sign up to –  
- get a generous early-bird discount,
- access the first lectures instantly, and
- get notified about new lectures as they come.

Leave me your email and I'll notify you when the beta phase is open.

I have read and agree to the terms & conditions.