Course Introduction

Learn to write better, more idiomatic and performant code in Go with a focus on micro-level engineering decisions. The course begins with a focus on Go internals that are critical to understanding the core tradeoffs on readability, simplicity and performance.

You will learn about data semantics, guidelines, mechanical sympathy, data oriented design, package oriented design, and how to structure your Go projects for the long term.

Requirements:

You need to know how to program and core concepts of working with computers (such as files, HTTP, memory management…)

Studied CS in school or has a minimum of two years of experience programming full-time professionally.
Familiar with structural and object-oriented programming styles.
Has worked with arrays, lists, queues and stacks.
Understands processes, threads and synchronization at a high level.

Operating Systems:

Has worked with a command shell.
Knows how to maneuver around the file system.
Understands what environment variables are.

You should have the following installed on your computer prior to the workshop:

Go SDK from golang.org/dl/
An IDE, either VSCode with Go extension or GoLand
Git

Price:
Regularly: $399.99

On Sale: $199
Skill Level:
Beginner - Advanced
Course Length:
20+ Hrs
Team Pricing:
Contact Advisor
Please Note: Your purchase is for a one year subscription.

Course Outline

Strings & Formatted Output:

1.1 - Prepare Your Mind - ( 17:38 )
1.2 - Productivity vs. Performance - ( 06:24 )
1.3 - Correctness vs. Performance - ( 07:14 )
1.4 - Code Reviews - ( 19:16 )
1.5 - If Performance Matters - ( 03:31 )

Memory & Data Semantics:

2.1 - Variables - (05:04)
2.2 - Struct Types - (22:55)
2.3.1 - Pointers (Pass by Values) - (17:43)
2.3.2 - Pointers (Sharing Data) - (07:50)
2.3.3 - Pointers ( Escape Analysis) - (19:46)
2.4 - Constants - (23:50)

Data Structures:<

3.2.1 - Arrays (Mechanical Sympathy) - (15:00)
3.2.1 - Arrays (Semantics) - (11:10)
3.2.1 - Arrays (Range Mechanics) - (06:39)
3.3.1 - Slices (Declare, Length & Reference Types) - (10:00)
3.3.2 - Slices (Appending Slices) - (03:00)
3.3.3 - Slices (Taking Slices of Slices) - (03:00)
3.3.4 - Slices (Slices & References) - (05:35)
3.3.5 - Slices (Strings & Slices) - (10:23)
3.3.6 - Slices (Range Mechanics) - (04:15)
3.4 - Maps - (11:23)

Decoupling:

4.1.1 - Methods (Value & Pointer Semantics) - (16:37)
4.1.2 - Methods (Function/Method Variables) - (14:43)
4.2.1 - Interfaces (Polymorphism) - (18:19)
4.2.2 - Interfaces (Method Sets & Address of Value) - (13:42)
4.3 - Embedding - (09:50)
4.4 - Exporting - (09:52)

Composition:

5.1 - Grouping Types - (15:21)
5.2.1 - Decoupling Part 1 - (37:02)
5.3.2 - Conversion & Assertions - (04:49)
5.4 - Interface Pollution - (08:51)
5.5 - Mocking - (08:15)

Error Handling:

6.1 - Default Error Values - (05:51)
6.2 - Error Variables - (10:52)
6.3 - Types as Context - (06:59)
6.4 - Behavior as Context - (08:14)
6.5 - Find the Bug - (04:19)
6.6 - Wrapping Errors - (10:16)

Packaging:

7.1 - Language Mechanics & Design Guidelines - (11:15)
7.2 - Package-Oriented Design - (15:50)

Go Routines:

8.1 - OS Scheduler Mechanics - (33:00)
8.2 - Go Scheduler Mechanics - (27:11)
8.3 - Creating Go Routines - (19:37)

Data Races:

9.1 - Managing Data Races (22:15)

Channels:

10.1 - Signaling Semantics - (11:08)
10.2 - Basic Patterns - (06:21)
10.3 - Fan Out - (05:28)
10.4 - Wait for Task - (02:31)
10.5 - Pooling - (05:14)
10.6 - Fan Out Semaphore - (05:22)
10.7 - Fan Out Bounded - (06:14)
10.8 - Drop Pattern - (05:06)
10.9 - Cancellation Pattern - (07:28)

Concurrency Patterns:

11.1 - Failure Detection (18:30)

Testing:

12.2 - Table Unit Testing - (04:10)
12.3 - Mocking Web Server Response - (07:21)
12.4 - Testing Internal Endpoints - (09:01)
12.5 - Sub Tests - (05:40)
12.6 - Code Coverage - (03:33)

Benchmarks:

13.1 - Basic Benchmarking - (09:24)
13.2 - Validate Benchmarking - (07:01)
13.3 - CPU-Bound Benchmarking - (07:03)
13.4 - IO-Bound Benchmarking - (06:05)

Profiling & Tracing:

14.1 - Profiling Guidelines - (05:42)
14.2 - Stack Traces - (08:28)
14.3 - Micro Level Optimization - (28:20)
14.4 - Macro Level Optimization - (24:47)
14.5 - Execution Tracing - (38:56)

Earn your Certificate of Completion for this training.

Earn your Go programming certificate of completion upon finishing this training! This certificate verifies that you've completed this training, which helps boost your resume, helping you stand out in the tech industry.

Hear from our Students

See what our students are saying about their learning experience!

"This class was awesome"

Dan Hutchinson

I learned so much and the instructor was incredibly knowledgeable. Would highly recommend to anyone who is interested in more advanced Go knowledge.

"Really well defined structure"

Kunal Duran

The course structure is really well defined. It covers fundamentals and explains how things work under the hood and at a large scale opened a whole new dimension in mind.

"Perfect Course"

Remco

The perfect course for someone that is writing Go code for some time but wants to take the next step.

Tired of Go tutorials?

We have the solution for you!

Ultimate Go: Language Guide