Go Roadmap
This Go Roadmap is a free, full-text syllabus of 172 lessons in 36 stages, starting with Introduction to Go and ending with Realtime Communication. It suits anyone who wants to learn Go, whether new to it or filling gaps. There is no fixed length: every lesson is open from the start, so you go at your own pace and skip what you already know.
Last updated
Reading is open to everyone. Sign in to join this roadmap and track what you finish.
Continue learning
1. Introduction to GoIntroduction to Go
0%Introduction to Go
6 topics · 5 sub-topics · 0 completed
The diagram draws the same 172 lessons as a map, with lines showing the order. It needs JavaScript; the full syllabus below lists every lesson as text.
Full syllabus: every lesson in the Go roadmap
36 stages and 172 lessons, in the order the roadmap suggests. Every lesson is free to read and open from the start.
Stage 1: Introduction to Go
Introduction to Go
Statically typed, compiled programming language developed at Google. Designed for simplicity, concurrency, and performance. Features garbage collection, strong typing, efficient compilation, built-in concurrency with goroutines and channels. Excellent for backend services, CLI tools, and distributed systems.
Why use Go
Go offers exceptional performance with single binary deployment, built-in concurrency, fast compilation, and comprehensive standard library. Simple language that's easy to learn and maintain. Excels at web services, microservices, CLI tools, and system software.
History of Go
Created at Google in 2007 by Griesemer, Pike, and Thompson. Announced publicly in 2009, version 1.0 in 2012. Key milestones include modules (Go 1.11) and generics (Go 1.18). Designed for large-scale software development combining efficiency and simplicity.
Setting up the Environment
Install Go from official website, configure PATH, and set up workspace. Configure editor with Go support (VS Code, GoLand, Vim/Emacs). Use modules for dependency management. Verify installation with go version and test with simple program.
Hello World in Go
Traditional first program demonstrating basic structure: package main, importing fmt, and main() function using fmt.Println(). Teaches Go syntax, compilation, execution, and verifies development environment setup. Entry point for learning Go.
`go` command
Primary tool for managing Go source code with unified interface for compiling, testing, formatting, and managing dependencies. Includes subcommands like build, run, test, fmt, mod. Handles the entire development workflow automatically.
Stage 2: Variables & Constants
Variables & Constants
Variables store changeable values declared with var or := (short declaration). Constants store unchangeable values declared with const. Variables can be explicitly typed or use type inference. Constants must be compile-time determinable. Both support block declarations and package/function scope.
var vs :=
Go provides two main ways to declare variables: using var and using the short declaration operator :=.
Zero Values
Default values for uninitialized variables: 0 for numbers, false for booleans, "" for strings, nil for pointers/slices/maps. Ensures predictable initial state and reduces initialization errors. Fundamental for reliable Go code.
const and iota
Constants declared with const represent unchanging compile-time values. iota creates successive integer constants starting from zero, resetting per const block. Useful for enumerations, bit flags, and constant sequences without manual values.
Scope and Shadowing
Scope determines variable accessibility from universe to block level. Shadowing occurs when inner scope variables hide outer ones with same names. Go has package, function, and block scopes. Understanding prevents bugs from accidentally creating new variables.
Stage 3: Data Types
Data Types
Rich set of built-in types: integers (int8-64), unsigned integers (uint8-64), floats (float32/64), complex numbers, booleans, strings, runes. Statically typed - types determined at compile time for early error detection and performance. Crucial for efficient, reliable programs.
Stage 4: Commands & Docs
Commands & Docs
Go provides built-in documentation tools including go doc for terminal documentation and godoc for web interface. Documentation uses special comments. go help provides command information. Essential for exploring standard library and writing well-documented code.
Stage 5: Arrays
Arrays
Fixed-size sequences of same-type elements. Size is part of the type, so different sizes are different types. Declared with specific length, initialized to zero values. Value types (copied when assigned/passed). Slices are more commonly used due to flexibility. Foundation for understanding Go's type system.
Integers (Signed, Unsigned)
Signed integers (int8, int16, int32, int64) handle positive/negative numbers. Unsigned (uint8, uint16, uint32, uint64) handle only non-negative but larger positive range. int/uint are platform-dependent. Choose based on range and memory needs.
Floating Points
Two types: float32 (single precision) and float64 (double precision, default). Represent real numbers using IEEE 754 standard. Can introduce precision errors, not suitable for exact financial calculations. Essential for scientific computing and graphics.
Complex Numbers
Built-in support with complex64 and complex128 types. Create using complex() function or literals like 3+4i. Provides real(), imag(), abs() functions. Useful for mathematical computations, signal processing, and scientific applications.
Boolean
The bool type represents true or false values with default zero value of false. Essential for conditional logic, control flow, and binary states. Results from comparison (==, !=) and logical operations (&&, ||, !).
Runes
Represent Unicode code points as int32 type. Enable proper handling of international characters and emojis. Use single quotes like 'A' or '中'. Essential for internationalized applications and correctly processing global text content beyond ASCII.
Raw String Literals
Enclosed in backticks (\) and interpret characters literally without escape sequences. Preserve formatting including newlines. Ideal for regex, file paths, SQL queries, JSON templates, and multi-line text where escaping would be extensive.
Interpreted String Literals
Enclosed in double quotes (") and process escape sequences like \n, \t, \". Support Unicode characters and formatting. Most common string type, ideal for text needing control characters but requiring escaping of special characters.
Type Conversion
Convert values between different types using Type(value) syntax. Go requires explicit conversion even between related types like int and int64. Essential for working with different data types and ensuring type compatibility in programs.
Stage 6: Slices
Slices
Dynamic arrays built on top of arrays. Reference types with length and capacity. Created with make() or slice literals. Support append, copy operations. More flexible than arrays - most commonly used sequence type in Go.
Capacity and Growth
Slice capacity determines when reallocation occurs during append operations. Go typically doubles capacity for smaller slices. Pre-allocate with make([]T, length, capacity) to optimize memory usage and minimize allocations in performance-critical code.
make()
Creates and initializes slices, maps, and channels. Unlike new(), returns usable values. Examples: make([]int, 5, 10) for slices, make(map[string]int) for maps, make(chan int) for channels. Essential for initializing reference types.
Slice to Array Conversion
Convert slice to array using [N]T(slice) (Go 1.17+). Copies data from slice to fixed-size array. Panics if slice has fewer than N elements. Useful when array semantics or specific size guarantees are needed.
Array to Slice Conversion
Convert arrays to slices using expressions like array[:] or array[start:end]. Creates slice header pointing to array memory - no data copying. Modifications through slice affect original array. Efficient way to use arrays with slice-based APIs.
Stage 7: Strings
Strings
Immutable sequences of bytes representing UTF-8 encoded text. String operations create new strings rather than modifying existing ones. Iterate by bytes (indexing) or runes (for range). Convert between strings and byte slices. Understanding strings helps with text manipulation and performance.
Stage 8: Maps
Maps
Built-in associative data type mapping keys to values. Reference types created with make(map[KeyType]ValueType) or map literals. Keys must be comparable types. Support insertion, deletion, lookup operations. Check existence with comma ok idiom: value, ok := map[key].
Comma-Ok Idiom
Pattern for safely testing map key existence or type assertion success using value, ok := map[key] or value, ok := interface.(Type). Returns both value and boolean status, preventing panics and distinguishing zero values from missing keys.
Stage 9: Structs
Structs
Custom data types grouping related fields under single name. Similar to classes but methods defined separately. Create complex data models, organize information, define application data structure. Access fields with dot notation, pass to functions. Fundamental for object-oriented designs.
Struct Tags & JSON
Struct tags provide metadata about fields using backticks with key-value pairs. JSON tags control field names, omit empty fields, or skip fields. Example: json:"name,omitempty". Essential for APIs and data serialization formats.
Embedding Structs
Struct embedding includes one struct inside another without field names, making embedded fields directly accessible. Provides composition-based design following Go's philosophy of composition over inheritance. Enables flexible, reusable components.
Stage 10: Loops
Loops
Go has only one looping construct: the flexible for loop. Basic form has initialization, condition, post statement. Supports for range for arrays, slices, maps, strings, channels. Can create infinite loops or while-style loops. Control with break and continue.
for loop
Go's only looping construct, incredibly flexible for all iteration needs. Classic form: initialization, condition, post statements. Omit components for different behaviors (infinite, while-like). Use with break, continue, labels for nested loops. for range for convenient collection iteration.
for range
Special form of for loop for iterating over arrays, slices, maps, strings, and channels. Returns index/key and value. For strings, returns rune index and rune value. For channels, returns only values. Use blank identifier to ignore unwanted return values.
Iterating Maps
Use for range to iterate over maps, returns key and value pairs. Iteration order is random for security reasons. Use blank identifier to ignore key or value. Cannot modify map during iteration unless creating new map. Safe to delete during iteration.
Iterating Strings
Iterate over strings with for range to get runes (Unicode code points) not bytes. Returns index and rune value. Direct indexing str[i] gives bytes. Use []rune(str) to convert to rune slice for random access. Important for Unicode handling.
break
Immediately exits innermost loop or switch statement. In nested loops, only exits immediate loop unless used with labels to break outer loops. Essential for early termination when conditions are met. Helps write efficient loops that don't continue unnecessarily.
continue
Skips rest of current iteration and jumps to next loop iteration. Only affects innermost loop unless used with labels. Useful for filtering elements, handling special cases early, avoiding nested conditionals. Makes loops cleaner and more efficient.
goto (discouraged)
Go includes goto statement but discourages its use. Can only jump to labels within same function. Creates unstructured code flow making programs hard to read, debug, and maintain. Use structured control flow (loops, functions, conditionals) instead. Rarely needed in modern Go programming.
Stage 11: Conditionals
Conditionals
Control program flow based on conditions. if for basic logic, if-else for binary decisions, switch for multiple conditions. if supports optional initialization, no parentheses needed but braces required. switch supports expressions, type switches, fallthrough. Fundamental for business logic.
Stage 12: Functions
Functions
First-class citizens in Go. Declared with func keyword, support parameters and return values. Can be assigned to variables, passed as arguments, returned from other functions. Support multiple return values, named returns, and variadic parameters. Building blocks of modular code.
if
Basic conditional statement for executing code based on boolean conditions. Supports optional initialization statement before condition check. No parentheses required around condition but braces mandatory. Can be chained with else if for multiple conditions. Foundation of control flow.
if-else
Basic conditional statements for binary decision making. if tests condition, else handles alternative path. Can include optional initialization statement. No parentheses needed around condition but braces required. Foundation of program control flow.
switch
Clean way to compare variable against multiple values and execute corresponding code blocks. No break statements needed (no fall-through by default). Works with any comparable type, supports multiple values per case, expression/type switches. More readable than if-else chains.
Stage 13: Pointers
Pointers
Variables storing memory addresses of other variables. Enable efficient memory usage and allow functions to modify values. Declared with Type, address obtained with &. No pointer arithmetic for safety. Essential for performance and building data structures.
Pointers Basics
Variables storing memory addresses of other variables. Declared with Type, dereferenced with ptr, address obtained with &var. Enable efficient memory usage and allow functions to modify caller's data. Essential for performance and reference semantics.
Pointers with Structs
Pointers to structs enable efficient passing of large structures and allow modification of struct fields. Access fields with (ptr).field or shorthand ptr.field. Common for method receivers and when structs need to be modified by functions. Essential for memory efficiency.
With Maps & Slices
Maps and slices are reference types - passing them to functions doesn't copy underlying data. Modifications inside functions affect original. No need for explicit pointers. However, reassigning the slice/map variable itself won't affect caller unless using pointer.
Functions Basics
Reusable code blocks declared with func keyword. Support parameters, return values, multiple returns. First-class citizens - can be assigned to variables, passed as arguments. Fundamental building blocks for organizing code logic.
Variadic Functions
Functions accepting variable number of arguments of same type. Syntax: func name(args ...Type). Arguments treated as slice inside function. Call with multiple args or slice with ... operator. Common in functions like fmt.Printf() and append().
Multiple Return Values
Go functions can return multiple values, commonly used for returning result and error. Syntax: func name() (Type1, Type2). Caller receives all returned values or uses blank identifier to ignore unwanted values. Idiomatic for error handling pattern.
Anonymous Functions
Functions declared without names, also called function literals or lambdas. Can be assigned to variables, passed as arguments, or executed immediately. Useful for short operations, callbacks, goroutines, and closures. Access enclosing scope variables. Common in event handlers and functional patterns.
Closures
Functions capturing variables from surrounding scope, accessible even after outer function returns. "Close over" external variables for specialized functions, callbacks, state maintenance. Useful for event handling, iterators, functional programming. Important for flexible, reusable code.
Named Return Values
Function return parameters can be named and treated as variables within function. Initialized to zero values. return statement without arguments returns current values of named parameters. Improves readability and enables easier refactoring but use judiciously.
Call by Value
Go creates copies of values when passing to functions, not references to originals. Applies to all types including structs and arrays. Provides safety but can be expensive for large data. Use pointers, slices, maps for references. Critical for performance optimization.
Stage 14: Methods vs Functions
Methods vs Functions
Methods are functions with receiver arguments, defined outside type declaration. Enable object-like behavior on types. Functions are standalone, methods belong to specific types. Methods can have value or pointer receivers. Both can accept parameters and return values.
Memory Management
Largely automatic through garbage collection. Runtime decides stack (fast, auto-cleaned) vs heap (slower, GC required) allocation via escape analysis. Understanding allocation patterns and avoiding memory leaks helps write efficient, scalable Go programs.
Garbage Collection
Go's GC automatically reclaims unreachable memory using concurrent, tri-color mark-and-sweep collector designed for minimal pause times. Runs concurrently with your program. Understanding GC helps write efficient programs that work well with automatic memory management.
Stage 15: Pointer Receivers
Pointer Receivers
Methods receive pointer to struct rather than copy using func (p Type) methodName() syntax. Necessary when method modifies receiver state or struct is large. Go automatically handles value/pointer conversion when calling methods.
Stage 16: Value Receivers
Value Receivers
Methods receive copy of struct rather than pointer. Use func (v Type) methodName() syntax. Appropriate when method doesn't modify receiver or struct is small. Can be called on both values and pointers with Go automatically dereferencing.
Stage 18: Generics
Generics
Introduced in Go 1.18, allow functions and types to work with different data types while maintaining type safety. Enable reusable code without sacrificing performance. Use type parameters (square brackets) and constraints. Reduce code duplication while preserving strong typing.
Why Generics?
Introduced in Go 1.18 to solve code duplication when working with multiple types. Before generics: separate functions per type, empty interfaces (losing type safety), or code generation. Enable type-safe, reusable code maintaining compile-time checking.
Generic Functions
Write functions working with multiple types using type parameters in square brackets like func FunctionNameT any T. Enable reusable algorithms maintaining type safety. Particularly useful for utility functions and data processing that don't depend on specific types.
Generic Types / Interfaces
Create reusable data structures and interface definitions working with multiple types. Define with type parameters like type Container[T any] struct { value T }. Enable type-safe containers, generic slices, maps, and custom structures while maintaining Go's strong typing.
Type Constraints
Specify which types can be used as type arguments for generics. Defined using interfaces with method signatures or type sets. Common constraints include any, comparable, and custom constraints. Enable writing generic code that safely operates on type parameters.
Type Inference
Allows compiler to automatically determine generic type arguments based on function arguments or context. Reduces need for explicit type specification while maintaining type safety. Makes generic functions cleaner and more readable by eliminating redundant type specifications.
Stage 17: Interfaces
Interfaces
Define contracts specifying method signatures without implementation. Types satisfy interfaces implicitly by implementing required methods. Enable polymorphism and loose coupling. Empty interface interface{} accepts any type. Foundation of Go's type system and composition patterns.
Interfaces Basics
Define contracts through method signatures. Types automatically satisfy interfaces by implementing required methods. Declared with type InterfaceName interface{} syntax. Enable polymorphism and flexible, testable code depending on behavior rather than concrete types.
Empty Interfaces
The empty interface interface{} can hold values of any type since every type implements at least zero methods. Used for generic programming before Go 1.18 generics. Requires type assertions or type switches to access underlying values. Common in APIs handling unknown data types.
Embedding Interfaces
Create new interfaces by combining existing ones, promoting composition and reusability. Embedded interface methods automatically included. Enables interface hierarchies from simpler, focused interfaces. Supports composition over inheritance for modular, extensible systems.
Type Assertions
Extract underlying concrete value from interface. Syntax: value.(Type) or value, ok := value.(Type) for safe assertion. Panics if type assertion fails without ok form. Essential for working with interfaces and empty interfaces.
Type Switch
Special form of switch statement that operates on types rather than values. Syntax: switch v := i.(type). Used with interfaces to determine underlying concrete type. Each case specifies types to match. Essential for handling interface{} and polymorphic code.
Stage 19: Modules & Dependencies
Modules & Dependencies
Go modules are the dependency management system introduced in Go 1.11. Define module with go.mod file containing module path and dependencies. Use go get to add dependencies, go mod tidy to clean up. Supports semantic versioning and replacement directives. Essential for modern Go development.
go mod init
Initializes new Go module by creating go.mod file with specified module path (typically repository URL). Marks directory as module root and enables module-based dependency management. First step for any new Go project.
go mod tidy
Ensures go.mod matches source code by adding missing requirements and removing unused dependencies. Updates go.sum with checksums. Essential for maintaining clean dependency management and ensuring reproducible builds before production deployment.
go mod vendor
Creates vendor directory with dependency copies for bundling with source code. Ensures builds work without internet access. Useful for deployment, air-gapped environments, and complete control over dependency availability.
Stage 20: Packages
Packages
Fundamental unit of code organization in Go. Group related functions, types, and variables. Defined by package declaration at file top. Exported names start with capital letters. Import with import statement. Enable modularity, reusability, and namespace management.
Stage 21: Package Import Rules
Package Import Rules
Key rules: no circular imports, main package for executables, lowercase package names, exported identifiers start with capitals. Import paths are unique identifiers. Understanding ensures proper structure and follows Go conventions.
Stage 22: Using 3rd Party Packages
Using 3rd Party Packages
Import external libraries using go get package-url which updates go.mod. Consider maintenance status, documentation, license, and security when choosing packages. Go modules handle version management and ensure reproducible builds.
Error Handling Basics
Go uses explicit error handling with error return values. Functions return error as last value. Check if err != nil pattern. Create errors with errors.New() or fmt.Errorf(). No exceptions - errors are values to be handled explicitly.
`error` interface
Built-in interface with single Error() string method. Any type implementing this method can represent an error. Central to Go's error handling philosophy, providing consistent error representation across all Go code. Fundamental for effective error handling.
errors.New
Simplest way to create error values by taking a string message and returning an error implementing the error interface. Useful for simple, static error messages. Often combined with error wrapping or used for predefined error constants.
fmt.Errorf
Creates formatted error messages using printf-style verbs. Supports %w verb for error wrapping (Go 1.13+) to create error chains preserving original errors while adding context. Essential for descriptive errors with dynamic values and debugging information.
Wrapping/Unwrapping Errors
Create error chains preserving original errors while adding context using fmt.Errorf() with %w verb. Use errors.Unwrap(), errors.Is(), and errors.As() to work with wrapped errors. Enables rich error contexts for easier debugging.
Sentinel Errors
Predefined error values representing specific conditions, defined as package-level variables. Check using errors.Is() or direct comparison. Examples: io.EOF. Enable predictable APIs where callers handle specific errors differently.
`panic` and `recover`
panic() stops execution and unwinds stack, recover() catches panics in deferred functions. Use sparingly for unrecoverable errors. While Go emphasizes explicit errors, panic/recover serve as safety net for exceptional situations.
Stack Traces & Debugging
Go automatically prints stack traces on panic showing call chain. Tools include Delve debugger, pprof profiling, and race detection. Stack traces show function calls, file locations, and line numbers for effective troubleshooting.
Stage 23: Goroutines
Goroutines
Lightweight threads managed by Go runtime enabling concurrent function execution. Created with go keyword prefix. Minimal memory overhead, can run thousands/millions concurrently. Runtime handles scheduling across CPU cores. Communicate through channels, fundamental to Go's concurrency.
Stage 24: Publishing Modules
Publishing Modules
Share Go code through version control systems using semantic versioning tags. Go proxy system automatically discovers and serves modules. Follow Go conventions, maintain documentation, and ensure backward compatibility to contribute to the ecosystem.
Stage 25: Channels
Channels
Primary mechanism for goroutine communication following "share memory by communicating" principle. Typed conduits created with make(). Come in buffered and unbuffered varieties. Used for synchronization, data passing, and coordinating concurrent operations. Essential for concurrent programming.
Stage 26: Worker Pools
Worker Pools
Concurrency pattern using fixed number of goroutines to process tasks from shared queue. Controls resource usage while maintaining parallelism. Typically implemented with buffered channels for task distribution and WaitGroups for synchronization. Ideal for CPU-bound tasks and rate limiting.
Select Statement
Multiplexer for channel operations. Waits on multiple channel operations simultaneously, executing first one ready. Supports send/receive operations, default case for non-blocking behavior. Essential for coordinating multiple goroutines and implementing timeouts.
Buffered vs Unbuffered
Unbuffered channels provide synchronous communication - sender blocks until receiver ready. Buffered channels allow asynchronous communication up to capacity. Unbuffered for coordination/sequencing, buffered for performance/decoupling. Critical distinction for concurrent system design.
fan-in
Concurrency pattern merging multiple input channels into single output channel. Allows collecting results from multiple goroutines. Typically implemented with select statement or separate goroutines for each input. Useful for aggregating parallel processing results.
fan-out
Concurrency pattern distributing work from single source to multiple workers. Typically uses one input channel feeding multiple goroutines. Each worker processes items independently. Useful for parallelizing CPU-intensive tasks and increasing throughput through parallel processing.
pipeline
Concurrency pattern chaining processing stages where output of one stage becomes input of next. Each stage runs concurrently using goroutines and channels. Enables parallel processing and separation of concerns. Common in data processing, transformation workflows, and streaming applications.
Stage 28: `context` Package
`context` Package
Carries deadlines, cancellation signals, and request-scoped values across API boundaries. Essential for robust concurrent applications, especially web services. Enables cancelling long-running operations, setting timeouts, passing request data. Typically first parameter passed down call stack.
Deadlines & Cancellations
Context package mechanisms for controlling operation lifetime and propagating cancellation signals. Supports deadlines (absolute time) or timeouts (duration). Functions should check ctx.Done() and return early when cancelled. Essential for robust concurrent applications.
Common Usecases
Context package common uses: HTTP timeouts, database deadlines, goroutine cancellation coordination, and request-scoped values. Essential for web servers, microservices, circuit breakers, and building responsive APIs that handle cancellation gracefully.
Stage 29: Concurrency Patterns
Concurrency Patterns
Established design approaches for structuring concurrent programs using goroutines and channels. Key patterns: fan-in (merging inputs), fan-out (distributing work), pipelines (chaining operations), worker pools, pub-sub communication. Help build efficient, scalable apps while avoiding race conditions and deadlocks.
Stage 27: `sync` Package
`sync` Package
Provides synchronization primitives for coordinating goroutines and safe concurrent access. Includes Mutex (mutual exclusion), RWMutex (reader-writer locks), WaitGroup (waiting on goroutines), Once (one-time init). Essential for avoiding race conditions.
Stage 30: Race Detection
Race Detection
Built-in tool for detecting race conditions in concurrent programs. Enabled with -race flag during build/test/run. Detects unsynchronized access to shared variables from multiple goroutines. Performance overhead in race mode. Essential for debugging concurrent code safety.
Mutexes
Mutual exclusion locks from sync package ensuring only one goroutine accesses shared resource at a time. Use Lock() before and Unlock() after critical section. RWMutex allows multiple readers or single writer. Essential for protecting shared data from race conditions.
WaitGroups
Synchronization primitive from sync package for waiting on multiple goroutines to complete. Use Add() to increment counter, Done() when goroutine finishes, Wait() to block until counter reaches zero. Essential for coordinating goroutine completion in concurrent programs.
Stage 31: Standard Library
Standard Library
Comprehensive collection of packages providing core functionality. Includes I/O, networking, text processing, cryptography, testing, JSON handling, HTTP client/server. Rich ecosystem reducing need for external dependencies. Well-documented, tested, and performance-optimized packages.
I/O & File Handling
Go's I/O system provides comprehensive file and stream handling through io package interfaces (Reader, Writer, Closer) and os package file operations. The interface-based design allows working with files, network connections, and buffers using consistent patterns.
flag
Standard library package for parsing command-line flags. Supports string, int, bool, duration flags with default values and descriptions. Automatically generates help text. Simple API for basic CLI argument parsing before using frameworks like Cobra.
time
Standard library package for time and date operations. Handles parsing, formatting, arithmetic, timers, tickers, and timezone operations. Key types: Time, Duration, Location. Supports RFC3339 format, custom layouts, time zones. Essential for scheduling, timeouts, timestamps.
encoding/json
This package provides robust and efficient functionalities for marshaling (encoding) Go data structures into JSON and unmarshaling (decoding) JSON into Go data structures. This process is largely handled through the json.Marshal and json.Unmarshal functions. For a Go struct to be properly encoded or decoded, its…
os
Standard library package providing operating system interface. Handles file operations, environment variables, process management, and system information. Includes functions for file I/O, directory operations, process control, and cross-platform OS interactions. Essential for system programming.
bufio
Provides buffered I/O operations wrapping io.Reader/Writer interfaces for better performance. Reduces system calls by reading/writing larger chunks. Includes Scanner for line reading, Reader for buffered reading, Writer for buffered writing. Essential for efficient large file/network operations.
slog
Structured logging package introduced in Go 1.21. Provides leveled, structured logging with JSON output support. Better than basic log package for production use. Supports custom handlers, context integration, and performance optimization. Modern replacement for traditional logging.
regexp
Standard library package for regular expression functionality. Implements RE2 syntax for safe, efficient pattern matching. Provides functions for matching, finding, replacing text patterns. Supports compiled expressions for performance. Essential for text processing, validation, parsing.
go:embed for embedding
The go:embed directive embeds files and directories into Go binaries at compile time using //go:embed comments. Useful for including static assets, configs, and templates directly in executables, creating self-contained binaries that don't require external files.
Stage 32: Building CLIs
Building CLIs
Go excels at CLI development due to fast compilation, single binary distribution, and rich ecosystem. Use standard flag package or frameworks like Cobra, urfave/cli, Bubble Tea. Cross-compilation support for multiple platforms. Great for learning Go while building useful tools.
Cobra
Powerful library for modern CLI applications. Used by kubectl, Hugo, GitHub CLI. Provides nested subcommands, flags, intelligent suggestions, auto help generation, shell completion. Follows POSIX standards with clean API. Includes command generator for quick bootstrapping.
urfave/cli
urfave/cli is a simple package for building command-line applications with intuitive API for commands, flags, and arguments. Features automatic help generation, bash completion, nested subcommands, and environment variable integration for lightweight CLI tools.
bubbletea
Bubble Tea is a framework for building terminal UIs based on The Elm Architecture. Uses model-update-view pattern for interactive CLI applications with keyboard input, styling, and component composition. Excellent for sophisticated terminal tools and dashboards.
`testing` package basics
Standard library package for writing tests. Test functions start with Test and take testing.T parameter. Use t.Error(), t.Fatal() for failures. Test files end with test.go. Run with go test. Supports benchmarks and examples.
Table-driven Tests
Table-driven tests use slices of test cases to test multiple scenarios with the same logic. Each case contains inputs and expected outputs. Makes adding test cases easy and provides comprehensive coverage with minimal code duplication.
Mocks and Stubs
Mocks and stubs replace dependencies with controlled implementations for isolated testing. Stubs provide predefined responses while mocks verify method calls. Go's interfaces make mocking natural. Essential for testing without external dependencies.
`httptest` for HTTP Tests
The httptest package provides utilities for testing HTTP servers and clients without network connections. Includes httptest.Server, ResponseRecorder, and helpers for creating test requests. Essential for testing handlers, middleware, and HTTP services.
Benchmarks
Benchmarks measure code performance by timing repeated executions. Functions start with Benchmark and use testing.B parameter. Run with go test -bench=. to identify bottlenecks, compare implementations, and track performance changes over time.
Coverage
Test coverage measures code execution during testing using go test -cover and -coverprofile. Visualize with go tool cover -html to identify untested code paths. Helps maintain quality standards and guide testing efforts for more reliable applications.
Stage 33: Web Development
Web Development
Excellent for web development with built-in HTTP server support, efficient concurrency, rich ecosystem. Standard net/http package provides powerful tools for servers, requests/responses, RESTful APIs. Performance, simple deployment (single binary), and concurrency make it ideal for scalable web apps.
net/http (standard)
Standard library package for HTTP client/server functionality. Provides HTTP server with routing, middleware support, client for making requests. Handles TLS, HTTP/2, cookies, multipart forms. Foundation for web development without external frameworks.
gRPC & Protocol Buffers
gRPC is a high-performance RPC framework using Protocol Buffers for serialization. Provides streaming, authentication, load balancing, and code generation from .proto files. Excellent for microservices with type safety, efficient binary format, and cross-language compatibility.
Stage 34: ORMs & DB Access
ORMs & DB Access
Go offers multiple database access approaches: raw SQL with database/sql, ORMs like GORM/Ent, and query builders. Choose based on complexity needs - raw SQL for performance, ORMs for rapid development, query builders for balance. Consider connection pooling and migrations.
pgx
pgx is a pure Go PostgreSQL driver providing both database/sql compatibility and native PostgreSQL features. Offers better performance than lib/pq, includes arrays, JSON support, connection pooling, and PostgreSQL-specific features like LISTEN/NOTIFY.
GORM
Popular Object-Relational Mapping library for Go. Provides database abstraction with struct-based models, automatic migrations, associations, and query building. Supports multiple databases (MySQL, PostgreSQL, SQLite, SQL Server). Features hooks, transactions, and connection pooling.
Stage 35: Logging
Logging
Essential for monitoring, debugging, maintaining production applications. Standard log package and slog (Go 1.21+) for structured logging. Popular libraries: Zap (high-performance), Zerolog (zero-allocation), Logrus (feature-rich). Use appropriate log levels and structured messages.
Zerolog
Zerolog is a zero-allocation JSON logger focusing on performance and simplicity. Provides structured logging with fluent API, various log levels, and no memory allocations during operations, making it ideal for high-throughput production applications.
Zap
Zap is a high-performance structured logging library by Uber offering both structured and printf-style APIs. Features include JSON/console formats, configurable levels, sampling, and production-optimized performance through careful memory management.
gin
Popular HTTP web framework emphasizing performance and productivity. Lightweight foundation for APIs/web services with minimal boilerplate. Fast routing, middleware, JSON validation, error management, built-in rendering. Clean API for RESTful services. Includes parameter binding, uploads, static files.
echo
High-performance, minimalist web framework focusing on ease and speed. Provides routing, middleware, data binding, validation, rendering. Features automatic TLS, HTTP/2, WebSocket support. Built-in middleware for CORS, JWT, logging, compression. Popular for RESTful APIs and microservices.
fiber
Fiber is an Express-inspired web framework built on fasthttp for exceptional performance. Provides familiar API with middleware, routing, templates, and WebSocket support. Popular for high-performance REST APIs and microservices requiring speed and simplicity.
beego
Beego is a full-stack web framework providing MVC architecture, ORM, session management, caching, and admin interface generation. Follows convention over configuration with extensive tooling for rapid development of enterprise applications requiring comprehensive features.
Stage 36: Realtime Communication
Realtime Communication
Realtime communication in Go enables instant bidirectional updates using WebSockets, Server-Sent Events, and messaging patterns. Go's concurrency makes it ideal for handling multiple connections. Essential for chat apps, live dashboards, and interactive applications requiring immediate synchronization.
Melody
Melody is a minimalist WebSocket framework for Go providing simple session management, message broadcasting, and connection handling. Features include rooms, automatic ping/pong, message limits, and clean integration with existing web frameworks for real-time apps.
Centrifugo
Centrifugo is a real-time messaging server providing WebSocket services for Go applications. It offers channels, presence info, message history, and Redis scalability. Supports WebSocket, Server-Sent Events, and HTTP streaming while handling complex real-time patterns.
go vet
Built-in tool analyzing Go source code for suspicious constructs likely to be bugs. Checks for unreachable code, incorrect printf formats, struct tag mistakes, and potential nil pointer dereferences. Automatically run by go test.
goimports
Tool automatically managing Go import statements by adding missing imports and removing unused ones while formatting code. More convenient than manual import management, integrates with editors for automatic execution on save.
go generate
The go generate command executes commands specified in //go:generate directives to generate Go source code. Used for code generation from templates, string methods, embedded resources, and running tools like protobuf compilers for build automation.
Build Tags
Build tags control file inclusion using //go:build directives based on conditions like OS, architecture, or custom tags. Enable conditional compilation for platform-specific code, feature flags, and environment-specific builds without runtime overhead.
go run
Compiles and executes Go programs in one step without creating executable files. Useful for testing, development, and running scripts. Takes Go source files as arguments. Convenient for quick execution during development without build artifacts.
go build
Compiles Go packages and dependencies into executable binaries. Supports cross-compilation for different OS/architectures via GOOS/GOARCH. Includes build constraints, custom flags, optimization levels. Produces statically linked binaries by default. Essential for deployment and distribution.
go install
Compiles and installs packages and dependencies. Creates executables in $GOPATH/bin for main packages. Use go install package@version to install specific versions of tools. Commonly used for installing CLI tools system-wide.
go fmt
Automatically formats Go source code according to official style guidelines. Standardizes indentation, spacing, alignment for consistent code style. Opinionated and non-configurable, eliminating formatting debates. Essential for clean, readable, community-standard code.
go mod
Command-line tool for module management. go mod init creates module, go mod tidy cleans dependencies, go mod download fetches modules. Manages go.mod and go.sum files. Essential commands for dependency management and version control.
go test
Command for running tests in Go packages. Automatically finds and executes functions starting with Test. Supports benchmarks (Benchmark), examples (Example), and sub-tests. Includes coverage analysis, parallel execution, and various output formats. Essential for TDD and quality assurance.
go clean
Removes object files and cached files from build process. Options include -cache for build cache and -modcache for module downloads. Useful for troubleshooting build issues, freeing disk space, and ensuring clean builds.
go doc
Prints documentation for Go packages, types, functions, and methods extracted from specially formatted comments. Use go doc package or go doc package.Function to view specific documentation. Essential for exploring APIs and verifying documentation formatting.
go version
Displays the currently installed Go version, target OS, and architecture. Essential for verifying installation, troubleshooting environment issues, and ensuring compatibility across different development environments and teams.
revive
Fast, configurable Go linter providing rich formatting and many rules for code analysis. Drop-in replacement for golint with better performance, configurable rules, and various output formats. Helps maintain consistent code quality across projects.
staticcheck
State-of-the-art Go linter catching bugs, performance issues, and style problems through static analysis. Provides more comprehensive checking than go vet with very few false positives. Detects unused code, incorrect API usage, and subtle bugs.
golangci-lint
Fast, parallel runner for multiple Go linters including staticcheck, go vet, and revive. Provides unified configuration, output formatting, and performance optimization. Streamlines code quality workflows through a single comprehensive tool.
pprof
Built-in profiling tool for analyzing program performance. Profiles CPU usage, memory allocation, goroutines, blocking operations. Import net/http/pprof for web interface or use go tool pprof for analysis. Essential for performance optimization and bottleneck identification.
trace
The Go trace tool captures execution traces showing goroutine execution, system calls, GC, and scheduling. Generate traces with runtime/trace package, analyze with go tool trace. Provides web interface for diagnosing concurrency issues and performance bottlenecks.
Race Detector
Runtime tool detecting data races in concurrent programs using the -race flag. Tracks memory accesses and reports conflicts with detailed information including stack traces. Essential for finding concurrency bugs during development and testing.
govulncheck
Go's official vulnerability scanner checking code and dependencies for known security vulnerabilities. Reports packages with vulnerabilities from Go database, provides severity info and remediation advice. Essential for maintaining secure applications.
Building Executables
The go build command compiles source code into standalone native executables with static linking. Creates self-contained binaries including all dependencies, requiring no Go installation on target systems. Control builds with various optimization flags.
Cross-compilation
Build executables for different OS and architectures using GOOS and GOARCH environment variables. Example: GOOS=linux GOARCH=amd64 go build creates Linux binaries. Enables multi-platform development without separate build environments.
Memory Mgmt. in Depth
Deep memory management involves understanding garbage collection, escape analysis, allocation patterns, and optimization techniques. Covers stack vs heap allocation, memory pooling, reducing allocations, and GC interaction for high-performance applications.
Escape Analysis
Compile-time optimization determining whether variables are allocated on stack (fast) or heap (GC required). Variables that "escape" their scope need heap allocation. Use go build -gcflags="-m" to view decisions. Understanding helps minimize heap allocations and reduce GC pressure.
Reflection
Reflection allows runtime inspection and manipulation of types and values using the reflect package. Enables dynamic method calls and type examination but has performance overhead. Used in JSON marshaling, ORMs, and frameworks.
Unsafe Package
The unsafe package bypasses Go's type and memory safety for direct memory manipulation and pointer arithmetic. Powerful but dangerous - can cause crashes and vulnerabilities. Used for systems programming and performance-critical code. Use with extreme caution.
Build Constraints & Tags
Special comments controlling which files are included when building. Use //go:build directive for platform-specific code, environment builds, or feature toggles. Common for different OS/architectures or debug vs production builds. Essential for portable Go applications.
CGO Basics
CGO allows Go programs to call C code and vice versa using special comments. Enables C library integration but disables cross-compilation, reduces performance, and complicates deployment. Useful for legacy integration but pure Go is preferred.
Compiler & Linker Flags
Build flags control compilation and linking. Common flags include -ldflags for linker options, -gcflags for compiler settings, -tags for build tags, and -race for race detection. Help optimize builds, reduce binary size, and embed build information.
Plugins & Dynamic Loading
Go's plugin system allows loading shared libraries (.so files) at runtime using the plugin package. Built with go build -buildmode=plugin. Enables modular architectures but has limitations: Unix-only, version compatibility issues, and complexity.
Questions about the Go Roadmap
Is the Go Roadmap free?
Yes. All 172 lessons in this roadmap are free to read on Bibha AI Learning Labs, with no account and no payment. Signing in is optional: it lets you mark lessons as done and keep your progress, and it opens the AI tutor, which runs on your own API key.
How long does the Go Roadmap take?
There is no fixed duration. It has 172 lessons in 36 stages, and the time it takes depends on how many hours you give it each week. Nothing is locked, so you can skip what you already know, and your progress is saved once you sign in.
Where should I start the Go Roadmap?
Start with stage 1, Introduction to Go, and work down in order. The stages are numbered in the order the roadmap suggests, but every lesson is open, so if you already know Introduction to Go you can go straight to Variables & Constants or anything after it. Each lesson links to free resources for going deeper.
Can I learn Go in Hindi?
The lessons are written in English. Once you sign in, you can ask the AI tutor on any lesson to explain it in Hindi or Hinglish. It answers from that lesson’s own text, so the explanation stays on the syllabus. The tutor runs on your own Google, OpenAI or Anthropic key.