The Ultimate Go Study Guide

The Ultimate Go Study Guide eBook version →

101+ coding interview problems with detailed solutions, test cases, and program analysis →

Join my mailing list to get the latest updates here →

Context

Last updates is on August 2020.

A year ago, in August 2019, I shared this Ultimate Go Study Guide project on GitHub, and surprisingly, it got a lot of attention from the community. Fast forward to August 2020, it now has over 11K stars, 900 forks with the help of more than 20 contributors.

The project is a collection of my notes while learning Go programming language from Ardan Labs's Ultimate Go course. Honestly, I couldn’t thank Bill Kennedy and the Ardan Labs team enough for open-sourcing this wonderful material. They’ve done such great jobs putting together their knowledge, insights into their courses and making them available to the public.

Different people have different learning styles. For me, I learn best by doing and walking through examples. That said, I take notes carefully, comment directly on the source code to make sure that I understand every single line of code as I am reading and also be mindful of the theories behind the scene.

As Ultimate Go Study Guide keeps growing, there’s one issue that keeps coming up. That’s about the format of the project. Specifically, many people have requested an eBook version where the content is more streamlined and they can read it at their convenience.

So, here comes The Ultimate Go Study Guide eBook version. For the last 3 months or so, I have spent most of my free time putting together everything here into a 200-page book. Other than all the good stuff from Ultimate Go, two new and better things in this version are:

• Follow-along code input and output.
• Diagrams.

Hope it makes your journey of learning Go a bit easier. And again, thank you all for your support. I really appreciate it.

Here’s the link for the book: https://gum.co/bpUYF.

Note that I’ve made it free, though I would really appreciate your support. Regardless, you will receive the book in 2 different formats: PDF and ePub.

Table of Contents

• Design Philosophy: Guideline
• Language Mechanics
  • Syntax
    • Variable: Built-in types | Zero value concept | Initialization | Conversion vs Casting
    • Struct: Initialization | Name type vs Anonymous type
    • Pointer:
      • Passing by value | Escape analysis | Stack space | Garbage Collection
      • Golang's Code Review Receiver Type
    • Constant: Initialization | iota
    • Function: Initialization
  • Data Structures
    • Array: CPU Cache | TLB | Initialization | Iteration | Type array | Contiguous memory allocation
    • Slice: Initialization | Length vs Capacity | Reference Type | Appending | Slice of Slice | Copy of Slice | UTF-8
    • Map: Initialization | Iteration | Deleting | Finding | Restriction
  • Decoupling
    • Method:
      • Value and Pointer Receiver Call
      • Value and Pointer Semantics
      • Methods are just functions | Function variable
    • Interface:
      • Valueless type | Concrete type vs Interface type | Relationship | Polymorphic function
      • Interface via Pointer Receiver | Method set | Slice of Interface
    • Embedding:
      • Declaring fields, NOT Embedding
      • Embedding type | Inner type promotion
      • Embedded type and Interface
      • Outer and inner type implementing the same Interface
    • Exporting:
      • Guideline
      • Exported identifier
      • Accessing a value of an unexported identifier
      • Unexported fields from an exported struct
      • Exported types with embedded unexported types
• Software Design
  • Composition: Guideline
    • Grouping types:
      • Grouping By State
      • Grouping By Behavior
    • Decoupling:
      • Struct Composition
      • Decoupling With Interface
      • Interface Composition
      • Decoupling With Interface Composition
    • Conversion:
      • Interface Conversions | Type Assertion
      • Runtime Type Assertion
    • Interface Pollution:
      • Interface Pollution
      • Remove Interface Pollution
    • Mocking:
      • Package To Mock
      • Sample Client
  • Error Handling:
    • Default error values
    • Error variables
    • Type as context
    • Behavior as context
    • Finding the bug/pitfall of nil value of error interface
    • Wrapping Errors
  • Packaging: Guideline
  • Dependency management: Go Modules
• Concurrency
  • Mechanics
    • Goroutine:
      • Go Scheduler Internals
      • Language Mechanics
      • Goroutine time slicing
      • Goroutines and parallelism
    • Data race:
      • Race Detection
      • Atomic Functions
      • Mutexes
      • Read/Write Mutex
    • Channel:
      • Guideline
      • Language Mechanics | Unbuffered channel: Signaling with(out) data
      • Unbuffered channel: Double signal | Buffered channel: Close and range | Unbuffered channel: select and receive | Unbuffered channel: select and send | Buffered channel: Select and drop
      • Unbuffered channel (Tennis match)
      • Unbuffered channel (Replay race)
      • Buffered channel: Fan Out
      • Select
  • Patterns
    • Context:
      • Store and retrieve values from a context
      • WithCancel
      • WithDeadline
      • WithTimeout
      • Request/Response
    • Pattern
      • Task
      • Logger
• Testing and Profiling
  • Testing:
    • Basic Unit Test
    • Table Test
    • Sub Test
    • Web Server
    • Mock Server
    • Test Coverage
  • Benchmarking
    • Basic Benchmark
    • Sub Benchmark
  • Fuzzing
    • Guideline
  • Profiling
    • Stack Trace: Review | Packing
    • GODEBUG: Memory Tracing

References & resources:

• Ultimate Go Programming
• ardanlabs/gotraining/topics/courses/go
• Computer Systems: A Programmer's Perspective
• Free Gophers Pack
• Thoughts on Go performance optimization

Stargazers over time