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.

This course is part of the Ultimate Go Track. Not sold separately.

Note: All of our bundles are for a one-year subscription.

At the end of the subscription period, your membership does not automatically renew.

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

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)

Trusted by Top Technology Companies

We've built our reputation as educators and bring that mentality to every project. When you partner with us, your team will learn best practices and grow along the way.

30,000+

Engineers Trained

1,000+

Companies Worldwide

14+

Years in Business