Here is a 100-step roadmap of exercises, categorized by "Belt Level," to take you from zero to architectural hero.

<h4>Phase 1: The White Belt (Syntax & Basics)</h4>

<h5>Focus: Getting comfortable with the "Go way" of doing simple things.</h5>

<ul>
<li>    Hello, Go: Print "Hello, World" and run it via go run.

<li>    Variables: Declare variables using var vs := for all basic types.

<li>    Constants: Create typed and untyped constants.

<li>    The For Loop: Write a loop that counts from 1 to 100.

<li>    FizzBuzz: The classic—if divisible by 3 (Fizz), 5 (Buzz), or both.

<li>    Conditionals: Use if/else with a short statement (e.g., if count := 10; count > 5).

<li>    Switch Basics: A switch statement to identify the day of the week.

<li>    Basic Functions: Create a function that takes two ints and returns the sum.

<li>    Multiple Returns: A function that returns both a quotient and a remainder.

<li>    Named Returns: Rewrite the previous function using named return parameters.

<li>    Pointers 101: Write a function that increments an integer using a pointer.

<li>    The nil Check: Write a function that returns an error if a pointer is nil.

<li>    Arrays: Declare an array of 5 strings and print the 3rd element.

<li>    Slices: Create a slice from an array.

<li>    Append: Use append to dynamically grow a slice of integers.

<li>    Slice Capacity: Use len() and cap() to watch a slice grow in a loop.

<li>    Range: Use for range to iterate over a slice and print indices and values.

<li>    Maps: Create a map of state codes to state names (e.g., "NY": "New York").

<li>    Map Lookup: Check if a key exists in a map using the "comma ok" idiom.

<li>    Deleting: Remove an entry from a map.</li>
</ul>

<h4>Phase 2: The Yellow Belt (Data & Control)

<h5>Focus: Managing data structures and error handling.</h5>

<ul>
<li>    Structs: Define a User struct with Name, Email, and Age.

<li>    Embedded Structs: Create an Admin struct that embeds the User struct.

<li>    Methods: Add a Greet() method to your User struct.

<li>    Pointer Receivers: Add a method UpdateEmail() that modifies the struct.

<li>    JSON Encoding: Convert a struct instance into a JSON string.

<li>    JSON Decoding: Parse a JSON string into a Go struct.

<li>    Custom Errors: Create a custom error type that implements the error interface.

<li>    Defer: Write a function that opens a file and uses defer to close it.

<li>    Variadic Functions: Create a function that sums an arbitrary number of integers.

<li>    Slicing Slices: Take a slice and create a "sub-slice" using [low:high].

<li>    Make vs New: Write a script demonstrating the difference between make() and new().

<li>    String Manipulation: Use the strings package to split a CSV line.

<li>    String Building: Use strings.Builder to efficiently join 1,000 strings.

<li>    Byte Slices: Convert a string to a []byte and back.

<li>    Type Casting: Convert an int to a float64 and calculate a percentage.

<li>    Blank Identifier: Use _ to ignore specific return values from a function.

<li>    Sorting: Sort a slice of integers using the sort package.

<li>    Custom Sorting: Sort a slice of User structs by Age.

<li>    Math/Rand: Generate a random number between 1 and 100.

<li>    Time: Print the current time in "2006-01-02" format.</li>
</ul>

<h4>Phase 3: The Blue Belt (Interfaces & Engineering)</h4>

<h5>Focus: Decoupling code and writing testable logic.</h5>

<li>    The Interface: Define a Shape interface with an Area() method.

<li>    Implementing Interfaces: Create Circle and Square structs that satisfy Shape.

<li>    Empty Interface: Write a function that accepts interface{} and uses a type switch.

<li>    Type Assertions: Manually assert that an interface value is a specific struct.

<li>    Dependency Injection: Pass an interface into a function instead of a concrete struct.

<li>    Reader Interface: Use io.Reader to read data from a string.

<li>    Writer Interface: Use io.Writer to write data to a buffer.

<li>    Decorators: Wrap a Reader to count how many bytes are read.

<li>    Mocking: Write a unit test for a function by passing in a "mock" interface.

<li>    Table-Driven Tests: Write a test suite for a calculator using a slice of anonymous structs.

<li>    Unit Testing: Use the testing package to test a string reversal function.

<li>    Benchmarking: Use go test -bench to measure the speed of a function.

<li>    Project Layout: Organize a project into /cmd and /internal folders.

<li>    Go Modules: Initialize a module and add a 3rd party dependency (e.g., logrus).

<li>    Environment Variables: Use os.Getenv to configure a mock database URL.

<li>    Flag Package: Create a CLI tool that accepts a --name argument.

<li>    I/O Utility: Read an entire file into memory using os.ReadFile.

<li>    Streaming I/O: Read a massive file line-by-line using bufio.Scanner.

<li>    Regular Expressions: Validate an email address using the regexp package.

<li>    Log Levels: Implement a logger that distinguishes between Info, Warning, and Error.</li>
</ul>

<h4>Phase 4: The Brown Belt (Concurrency)</h4>

<h5>Focus: Master the "Go" in Golang-Goroutines and Channels.</h5>

<ul>
<li>    Goroutine Basics: Launch a function using the go keyword.

<li>    WaitGroup: Use sync.WaitGroup to wait for three goroutines to finish.

<li>    Unbuffered Channels: Send a string from one goroutine to another.

<li>    Buffered Channels: Create a channel with a capacity of 3 and fill it without blocking.

<li>    Channel Closing: Close a channel and detect it on the receiving end.

<li>    Select Statement: Use select to handle multiple channel inputs.

<li>    Timeouts: Use select with time.After to timeout a slow operation.

<li>    The Worker Pool: Create 5 workers that process jobs from a shared channel.

<li>    Mutex: Use sync.Mutex to prevent a race condition when incrementing a counter.

<li>    RWMutex: Use sync.RWMutex to allow multiple readers but one writer.

<li>    Atomic Operations: Use sync/atomic for high-performance counter increments.

<li>    The Race Detector: Run a program with go run -race to find a bug.

<li>    Once: Use sync.Once to ensure a setup function only runs one time.

<li>    Directional Channels: Write a function that only accepts a "read-only" channel (<-chan).

<li>    Pipeline Pattern: Connect three channels where each stage transforms the data.

<li>    Fan-Out: Send one piece of data to multiple worker goroutines.

<li>    Fan-In: Consolidate results from multiple channels into a single output channel.

<li>    Context Basics: Use context.Background() to pass metadata.

<li>    Context Cancellation: Cancel a long-running goroutine using context.WithCancel.

<li>    Context Deadlines: Automatically stop a database query after 500ms using WithTimeout.</li>
</ul>

<h4>Phase 5: The Black Belt (Senior/Architect)</h4.

<h5>Focus: Production-grade systems, performance, and internal mechanics.</h5>

<ul>
<li>    HTTP Server: Build a basic REST API using net/http.

<li>    Middleware: Create an HTTP middleware that logs the execution time of every request.

<li>    Graceful Shutdown: Capture os.Signal to shut down a server without dropping active connections.

<li>    SQL Integration: Use database/sql to query a Postgres or SQLite database.

<li>    Prepared Statements: Prevent SQL injection using placeholders.

<li>    Database Transactions: Implement a multi-step "Balance Transfer" with Rollback logic.

<li>    Reflection: Write a function that prints the field names of any struct passed to it.

<li>    The Unsafe Package: Access a struct's private fields (just to see how it works).

<li>    Generics: Write a generic Map function that works for any slice type.

<li>    Functional Options: Implement a "NewServer" constructor using the Functional Options pattern.

<li>    CGO: Call a simple C function from your Go code.

<li>    Profiling: Use pprof to identify a CPU bottleneck in a loop.

<li>    Memory Profiling: Identify a memory leak using go tool pprof --alloc_objects.

<li>    Embedding Static Files: Use //go:embed to include a text file in your binary.

<li>    Custom Marshaller: Implement MarshalJSON for a struct to hide sensitive fields.

<li>    The Circuit Breaker: Implement a pattern that stops calling a failing API after X errors.

<li>    Rate Limiting: Use golang.org/x/time/rate to limit API requests per second.

<li>    Plugin System: Build a system where Go can load .so files at runtime.

<li>    The Scheduler: Write a technical blog post (or notes) explaining how M:P:N scheduling works in Go.

<li>    The Microservice: Build a small service that communicates via gRPC and Protobuf.
</ul>

<h4>How to approach this</h4>

<h5>Don't try to do all 100 in a weekend. Go is deceptive; it looks simple, but the "Senior" part comes from understanding why we prefer composition over inheritance and channels over shared memory.</h5>

<p>by <a href="https://Gemini.google.com" >Gemini</a>