GoLang Concurrency

GoLang Concurrency, available at $39.99, has an average rating of 3.2, with 225 lectures, based on 17 reviews, and has 1420 subscribers.

You will learn about Go (GoLang): Concurrency Concurrency Patterns. This course is ideal for individuals who are Go ( GoLang ) programmers It is particularly useful for Go ( GoLang ) programmers.

Enroll now: GoLang Concurrency

Summary

Title: GoLang Concurrency

Price: $39.99

Average Rating: 3.2

Number of Lectures: 225

Number of Published Lectures: 225

Number of Curriculum Items: 225

Number of Published Curriculum Objects: 225

Original Price: 19.99

Quality Status: approved

Status: Live

What You Will Learn

Go (GoLang): Concurrency

Concurrency Patterns.

Who Should Attend

Go ( GoLang ) programmers

Target Audiences

Go ( GoLang ) programmers

This is a short and sweet course dedicated to Go ( GoLang ) concurrency. I use a simple POC ( Proof of concept ) Module approach to demonstrate each micro topic in the simplest manner I can. First we will discuss what concurrency and parallelism is and break it into a simple concept of building blocks.Then we will be exploring go’s sync package which includes a (Conditional, Locker, Map, Mutex, RWmutex, Once, Pool  and Wait Group). Moving from there we will demonstrate Channels and Channel Selects.

Next well move on to other more involved concepts like the Context API.

Course Curriculum

Chapter 1: Introduction && Foundations

Lecture 1: About:

Lecture 2: Install Node

Lecture 3: Intall PHP 7.4 ubuntu 19.10

Lecture 4: Python 3.8 ubuntu 19.10 install

Chapter 2: Concurrency

Lecture 1: Resources

Lecture 2: The Setup

Lecture 3: Concurrency Rant 1

Lecture 4: Concurrency Breakdown Rant 2

Lecture 5: Deadlock Example

Lecture 6: Deadlock Example2

Lecture 7: Livelocks

Lecture 8: Write Skeleton Application

Lecture 9: First Micro Engine

Lecture 10: First Dual Engine

Lecture 11: Setup the roadmap

Lecture 12: Simulate Work Lab Setup

Lecture 13: Coordinate Work Engines with Wait groups

Lecture 14: Wait Group Use Case

Lecture 15: Sync.Cond Example One

Lecture 16: Sync.Cond Example Two

Lecture 17: Sync.Once

Lecture 18: Sync.Mutex

Lecture 19: sync.RWMutex

Lecture 20: Cli Utility One

Lecture 21: CLI Utility Two

Lecture 22: Quick note on inerfaces

Lecture 23: Intro To Pool Excersise

Lecture 24: Pool One Exercise Solution

Lecture 25: Debug Multiple Clients One port

Lecture 26: Solution Concurrent Ports Concurrent Connections

Lecture 27: Sync.Map Exercise

Lecture 28: Sync Map Exercise One Solution

Lecture 29: PM2 Keep Go Binaries Alive!!!

Lecture 30: Rant: Connection Pool Vs. Memory Allocation Pool

Lecture 31: Slim Connection Pool Part I

Lecture 32: Using Our Slim Connection Pool

Lecture 33: Memory Pool Project Intro

Lecture 34: Pool Project p1

Lecture 35: Pool Project Intro to P2

Lecture 36: Pool Project P2 Client

Lecture 37: Pool Project P2 Server

Lecture 38: Pool Project P2 Optimized Server

Lecture 39: Pool Project With Sync.Pool

Lecture 40: Pool Exercise Github Repo

Lecture 41: Road Map From Here

Lecture 42: Installing Mongo

Lecture 43: Test Mongo Remote Conn & Security

Lecture 44: Quick Mongo Crash Course

Lecture 45: Redis Install Config

Lecture 46: Mongo Connection Module Part I

Lecture 47: Mongo Connection Module Part II with Private Repo Config

Lecture 48: Websocket Pool Part I

Lecture 49: Websocket Pool Part II

Lecture 50: Websocket Pool Part III

Lecture 51: Websocket Pool Part IV

Lecture 52: Websocket Pool Convert Http To Gorilla Mux

Lecture 53: Websocket Pool add Public Data Mod

Lecture 54: Websocket Pool Upgrade Http to Ws

Lecture 55: Websocket Pool Test JSON Msg

Lecture 56: Start Pure Go Websocket Client

Lecture 57: Finish Non TLS Websocket Client

Lecture 58: Start TLS Websocket Client & Server

Lecture 59: Upgrade WSServer to TLS add UUID

Lecture 60: Finish Websocket Server Client TLS Upgrade

Lecture 61: Websocket Client Pool Part I

Lecture 62: Websocket Client Pool Part II

Lecture 63: Dead Audio Next 5 Videos Listen To your favorite Music

Lecture 64: AsyncQ Public Module

Lecture 65: Redis Part I

Lecture 66: Redis Part II

Lecture 67: Redis Part III

Lecture 68: Tie Redis Websocket Asycq Together

Lecture 69: AUDIO BACK!!! -> Redis To Public Mod Tie 3 Players Together

Lecture 70: Continue to Tmux Project

Chapter 3: The Go Tmux Project

Lecture 1: About

Lecture 2: Coming Tmux Project

Lecture 3: Tmux Part I

Lecture 4: Tmux Part II

Lecture 5: Tmux Part III

Lecture 6: Tmux Part IV

Chapter 4: Basic Context 101

Lecture 1: Context Done 001

Lecture 2: Context Done TODO & Background

Lecture 3: Context Deadline

Chapter 5: Channels && Wait Group && Go Func Exercises

Lecture 1: Mutliple File GZip Excercise

Lecture 2: Wait Group Word Count Part I

Lecture 3: Wait Group Word Count Part II

Lecture 4: Basic Channels Exercise 001

Lecture 5: Channels 002

Lecture 6: The Ominous ok

Lecture 7: Closed Channels with ok and read

Lecture 8: Channel 005 Defer Channel Close and Range pattern

Lecture 9: channels 006 Simulate sync.Cond with channels

Lecture 10: Channels 007 Safe Cleanup Closing Pattern

Lecture 11: Watch out for nil value on closed channel

Lecture 12: channels 008 Unblocking and Blocking Behavior

Instructors

Zach LaCourse
Lets Rock and Code

Rating Distribution

1 stars: 5 votes

2 stars: 0 votes

3 stars: 2 votes

4 stars: 3 votes

5 stars: 7 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!