Go

Why Google built Go, what makes it different from other backend languages, and where it shines today.

Getting the Go toolchain set up and understanding how Go manages dependencies with modules.

Writing, running, and building a minimal Go program, and understanding the pieces that make it work.

Declaring variables, Go's built-in types, and how type inference keeps static typing from feeling verbose.

Declaring compile-time constants in Go and using iota to generate related values without repeating yourself.

Why Go never converts types implicitly, and the explicit conversions you'll reach for constantly.

Conditional logic in Go — no parentheses required, and a switch statement that doesn't fall through by default.

Go has exactly one looping construct — for — and it flexes to cover every loop shape other languages need separate keywords for.

Go's core collection types — fixed-size arrays, the far more common slices, and key-value maps.

Defining custom data types by grouping fields together, since Go has no classes.

Declaring functions in Go, and the multiple-return-value pattern that shapes idiomatic error handling.

Writing functions that accept a variable number of arguments, and the slice-spreading syntax that goes with them.

Functions that capture variables from their surrounding scope, and the practical patterns they enable.

Attaching behavior to types with methods, and Go's structurally-typed, implicitly-satisfied interfaces.

Go's explicit, value-based approach to errors — no exceptions, no try/catch, just a type and a convention.

Go's mechanisms for cleanup and exceptional situations — deferred execution, panics, and recovering from them.

Go's lightweight concurrency primitive, and why it's cheap enough to spin up by the thousand.

Typed pipes for passing values safely between goroutines, and the core pattern that makes Go's concurrency model distinctive.

Waiting for a group of goroutines to finish, and protecting shared state when channels aren't the right tool.

How Go organizes code into packages, and the conventional project layout most Go codebases follow.

The most widely used Go web frameworks, what sets each apart, and why Go is a favorite for high-concurrency backends.

A closing checklist of habits that separate idiomatic, maintainable Go from code that merely compiles.

Fast to learn and fast to build with, versus slower to learn but with total control over memory and performance.