Course Introduction

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

Requirements:

  • 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.
  • Bundle Fee:

    $699
    (Part of Ultimate Go Bundle)

  • Skill Level:

    Advanced

  • Course Length:

    16+ Hrs

The class builds layers of foundational knowledge that will give you a deeper understanding into data semantics, decoupling, concurrency and tooling. Perfect for developers just starting out or developers with years of Go experience. Everyone will be writing better code after this class.

Course Curriculum

We will talk about semantics, guidelines, mechanical sympathy and data oriented design. We are going to talk about package oriented design and how to structure your Go projects for the long term.

01.

Design Guidelines

  • 1.1 Prepare Your Mind
  • 1.2 - Productivity vs. Performance
  • 1.3 - Correctness vs. Performance
  • 1.4 - Code Reviews
  • 1.5 - If Performance Matters

02.

Memory & Data Semantics

  • 2.1 - Variables
  • 2.2 - Struct Types
  • 2.3.1 - Pointers-Part 1 (Pass by Values)
  • 2.3.2 - Pointers-Part 2 (Sharing Data)
  • 2.3.3 - Pointers-Part 3 ( Escape Analysis)
  • 2.3.4 - Pointers-Part 3 ( Stack Growth)
  • 2.3.5 - Pointers-Part 3 ( Garbage Collection)
  • 2.4 - Constants

03.

Data Structures

  • 3.1 - Arrays-Part 1 (Mechanical Sympathy)
  • 3.2.1 - Arrays-Part 2 (Semantics)
  • 3.2.2 - Arrays-Part 3 (Range Mechanics)
  • 3.3.1 - Slices-Part 1 (Declare, Length & Reference Types)
  • 3.3.2 - Slices-Part 2 (Appending Slices)
  • 3.3.3-Slices-Part 3 (Taking Slices of Slices)
  • 3.3.4 - Slices-Part 4 (Slices & References)
  • 3.3.5 - Slices-Part 5 (Strings & Slices)
  • 3.3.6 - Slices-Part 6 (Range Mechanics)
  • 3.4 - Maps

04.

Decoupling

  • 4.1.1 - Methods-Part 1 (Value & Pointer Semantics)
  • 4.1.2 - Methods-Part 2 (Function/Method Variables)
  • 4.2.1 - Interfaces-Part 1 (Polymorphism)
  • 4.2.2 - Interfaces-Part 1 (Method Sets & Address of Value)
  • 4.2.3 - Interfaces-Part 3 (Storage by Value)
  • 4.2.4 - Interfaces-Part 4 (Type Assertion)
  • 4.3 - Embedding
  • 4.4 - Exporting

05.

Composition

  • 5.1 - Grouping Types
  • 5.2.1 - Decoupling-Part 1
  • 5.3.1 - Conversion & Assertions-Part 1
  • 5.3.2 - Conversion & Assertions-Part 2
  • 5.4 - Interface Pollution
  • 5.5 - Mocking

06.

Error Handling

  • 6.1 - Default Error Values
  • 6.2 - Error Variables
  • 6.3 - Types as Context
  • 6.4 - Behavior as Context
  • 6.5 - Find the Bug
  • 6.6 - Wrapping Errors

07.

Packaging

  • 7.1 - Language Mechanics & Design Guidelines
  • 7.2 - Package-Oriented Design

08.

Goroutines

  • 8.1 - OS Scheduler Mechanics
  • 8.2 - Go Scheduler Mechanics
  • 8.3 - Creating Go Routines

09.

Data Races

  • 9.1 - Managing Data Races

10.

Channels

  • 10.1 - Signaling Semantics
  • 10.2 - Basic Patterns
  • 10.3 - Fan Out
  • 10.4 - Wait for Task
  • 10.5 - Pooling
  • 10.6 - Fan Out Semaphore
  • 10.7 - Fan Out Bounded
  • 10.8 - Drop Pattern
  • 10.9 - Cancellation Pattern

11.

Concurrency Patterns

  • 11.1 - Failure Detection

12.

Testing

  • 12.1 - Basic Unit Testing
  • 12.2 - Table Unit Testing
  • 12.3 - Mocking Web Server Response
  • 12.4 - Testing Internal Endpoints
  • 12.5 - Sub Tests
  • 12.6 - Code Coverage

13.

Benchmarking

  • 13.1 - Basic Benchmarking
  • 13.2 - Validate Benchmarking
  • 13.3 - CPU-Bound Benchmarking
  • 13.4 - IO-Bound Benchmarking

14.

Profiling & Tracing

  • 14.1 Profiling Guidelines
  • 14.2 Stack Traces
  • 14.3 Micro Level Optimization
  • 14.4 Macro Level Optimization
  • 14.5 Execution Tracing

Looking for a business account?

If you have a team of engineers that can benefit from our courses, we have a business account for you.

With a business membership you get:

  • ✓ Group discounts based on volume
  • ✓ Easy enrollment for your team members
  • ✓ Track your team's progress through the course
  • ✓ Custom curriculum progress settings
  • ✓ Live training discounts
  • ✓ Exclusive content
Request a Quote