Course info
Jun 5, 2015
2h 36m

Almost every developer today is faced with the challenge of how to maximize the capabilities of today’s multi-processor equipped computers. The Go language is built from the ground up to enable applications to take full advantage of these machines with constructs that are clear and easy to reason about. In this course, we will explore Go’s concurrency model and learn how to use it to enable applications to realize the dramatic performance gains that multiple processing cores enable.

About the author
About the author

Michael Van Sickle is an application architect in Akron, Ohio. He is a mechanical engineer by training and a software engineer by choice. He is passionate about learning new programming languages and user experience design.

More from the author
The Go CLI Playbook
2h 8m
28 Feb 2018
Intern 4: Getting Started
2h 41m
9 Jan 2018
Object-oriented Programming with Go
1h 42m
11 Aug 2017
More courses by Mike Van Sickle
Section Introduction Transcripts
Section Introduction Transcripts

Concurrency Patterns
Hi, my name is Michael Van Sickle. Welcome to this course on Concurrent Programming with Google's Go Language. Over the next few hours we are going to be introducing the elements of Go that support the development of concurrent applications. Like a lot of other languages, these components are built into the language. However, as we'll discover, the components themselves are not the ones that you would typically find. Rather, Google chose a different set of primitives in order to make the development and maintenance of concurrent parts of an application much easier to manage.

Hi, my name is Michael Van Sickle for Pluralsight. Welcome back to this course where we are learning how to create concurrent application with Google's Go language. In the last module we discussed several concurrency models that exist in various parts of the software development world. We then focused in on Go's selection of the actor model as its preferred method for handling this challenging issue. In this module we are going to start to explore Go's method for starting asynchronous tasks, goroutines. When we get to module four, we'll see how these become the actors in the actor model. For now, we're going to play around with them on their own and see what they can do for us.

Hello, my name is Michael Van Sickle for Pluralsight. Well, it looks like you've stuck around to see what's coming next. I'm glad you came back. In the last module, we explored Go routines and found that on their own, they are very flexible and powerful. As a matter fact, if you finished this course and only get how these work, I think that you'll be able to do some amazing things. However, I hope you won't stop quite yet. In this module, we're going to introduce Go's mechanism for allowing Go routines to safely communicate with each other by passing messages to one another. While not that useful on their own, when combined with Go routines, a whole new world of possibilities opens up. I will warn you though, on their own, channels aren't as valuable as Go routines. Despite that, we are going to explore them in isolation for a while. By doing this, we can find out how to work with channels without cluttering up the conversation with concurrency issues.

Integrating Goroutines and Channels
Hi, my name is Michael Van Sickle. Welcome back to this final module in Pluralsight's Concurrent Programming with Go course. The last few modules have focused on the theory and components of working with concurrent applications, both in general and specifically in the context of the Go programming language. In this module we bring goroutines and channels together at last to see how they can collaborate to provide solutions that will be difficult or impossible to realize separately. We aren't going to talking a lot of theory in this module. This module is designed to expose you to a wide range of concurrent programming challenges and how Go can be used to solve them. I'm going to start by pulling something from all the way back in the first module where we talked about the different concurrency models. Each of those is going to make a reappearance in a bit. It turns out that each of those patterns can be really useful in different situations. As a result, we're going to reproduce those patterns by using goroutines and channels. After that, I'll show you a prime number generator that lets Go show off its ability to effortlessly handle thousands of actors. I've seen more mathematically efficient prime number generators, but rarely have I seen one as impressive as this one. Finally, I thought it would be fun to build an application that simulates an ETL job, short for Extract, Transform, and Load. This demonstration will develop through several iterations culminating in a blisteringly fast version at the end.