Fork me on GitHub

Go Progression Ladder

The Go progression ladder is a grouping of concepts and skills relevant to Go programming. It provides aspiring Go programmers with a way to track and improve their Go skills.

novice
CONCEPTS SKILLS RESOURCES COMPLETED
Line break rules Understand line break rules In Go such as semicolon insertion and comma separator rules link link
Variable rules Understand rules about unused variables and exceptions to each case link link
Import rules Rules about unused imports and exceptions to each case link link
Type inference Understand what is type inference when declaring variables link
Type assertions Understand what is type assertions and how to perform them link link
Variable scopes Understanding how scopes work and what is variable shadowing link link link
The nil value Understanding how nil is handled in Go link link
Strings Understanding how strings are represented link link link
Slices and Arrays Declare and work with Slices and Arrays link link link
Maps Declare and work with Maps link link link
Range loop Understanding how to loop using range in Go link link link
Goroutines Learn what are Goroutines and how to use them link link
Channels Define and use channels link link link
Structs Understand what are structs and how to define them link link link
Interfaces Learn how to use interfaces link link link
Methods Define and use methods link link link
Errors Understand what are errors and how to do error handling link link link
Deferred calls Learn what Defer does and how to use link link link
Exported/Unexported identifiers Understand how to export or hide identifiers link link
advanced_beginner
CONCEPTS SKILLS RESOURCES COMPLETED
Underlying types Understand underlying types and type identity rules link link
Type Embedding Understand and use Type Embedding link link link
Panic and Recover Understand the mechanics of Panic and Recover link link link
Reflection Understand and use Reflection link link link
Pointers Use pointers effectively link link link
Concurrency Synchronization Techniques How to utilize concurrency in Go link link link
Atomic Operations Use atomic variables and operations link link
Race conditions and deadlocks Detecting and fixing race conditions and deadlocks link link link
Pointer vs value receivers Understand pointer vs value receivers in types link link link
JSON/GOB encoding Use JSON and gob encoding link link link
competent
CONCEPTS SKILLS RESOURCES COMPLETED
Unsafe types Working around the type system with types.Unsafe link link link
Bounds check elimination Understand what is bound check elimination and how to use it link link
Value comparison and assignment rules
Go Memory Model Understand more about the memory model link link
Type Alignment and Type Value Sizes Understand the inner layout of memory and alignment guarantees link link link
Goto statements Use goto and label statements link link
proficient
CONCEPTS SKILLS RESOURCES COMPLETED
Profiling Go programs Understand how to profile Go programs for performance link link link
Cgo How to bridge C with Go link link link
Escape analysis What is escape analysis and how can you utilize it link link link
System Calls Execute System Calls link link
expert
CONCEPTS SKILLS RESOURCES COMPLETED
Go Assembly Understand the How Go compiles to Assembly link link link
Channel structure Understand the internal structure of Channels link link
Garbage collector Learn more about the Garbage Collector link
Go modules Learn about Go modules link link
This is a community-driven document, please share your feedback, help us to improve it. Please open an issue or send us a PR on Github!

Contributors

Theo Despoudis https://twitter.com/nerdokto

We need your help!

This is a community-driven project, please share your feedback and help us to improve it.
Please open an issue or send us a PR on GitHub!