Go

Every file starts with a package clause; `main` builds an executable.

Entry point — only in package `main`, takes no args, returns nothing.

Grouped import block — the idiomatic form for multiple packages.

Identifier visibility is set by the FIRST letter's case, not a keyword.

Declare with explicit type, or let the value infer it.

Short variable declaration — declare + infer + assign, inside functions only.

Multiple assignment; blank identifier `_` discards a value.

Compile-time constant; cannot be reassigned.

iota — an auto-incrementing constant generator for enums and bit flags.

Runs at package load, before main; multiple per file/package allowed, in declaration order.

byte = uint8, rune = int32 (a Unicode code point).

Numeric and boolean primitives; the default float is float64.

Named type — a distinct type sharing an underlying one.

Struct — a typed collection of fields; Go's main data aggregate.

Struct tags — metadata strings read by reflection (encoding/json, etc.).

Multiple same-typed fields declared on one line.

Embedding — promote an embedded type's fields and methods.

Function type — functions are first-class values in Go.

Method with a VALUE receiver — operates on a copy of u.

Pointer receiver — mutate the original and avoid copying.

Interface — a set of method signatures, satisfied IMPLICITLY by any type with those methods.

The empty interface — holds any value; `any` is its 1.18+ alias and the preferred spelling.

Type assertion — extract a concrete type from an interface, safely.

Compile-time assertion that *File satisfies io.Writer.

Array — FIXED length, part of its type; copied on assignment.

Slice — a growable, reference-like view over a backing array. The everyday list type.

Grow a slice — you MUST reassign the result; append may move the backing array.

Allocate a slice: len 5, cap 10 (pre-size to avoid reallocs).

Copy elements; returns the number copied (min of the two lengths).

Map — an unordered hash table. Reading a missing key returns the value's zero.

Create an empty, writable map (nil maps can't be written to).

The C-style for — Go's ONLY loop keyword; covers every loop form.

range — iterate slices/arrays (index,value), maps (key,value), strings (byte-index, rune), channels.

if with an initializer — scope a value to just the if/else.

switch — no fallthrough by default; cases can be expressions or types.

defer schedules a call to run when the surrounding FUNCTION returns (LIFO order).

Labeled break/continue to control nested loops.

The core error idiom — errors are values returned alongside results, checked explicitly.

Wrap an error with context using the %w verb — preserves the underlying error.

Inspect a wrapped error chain: Is matches a sentinel; As extracts a typed error.

Create a simple error; assign to a package var for a sentinel.

Combine multiple errors into one (1.20+); Is/As see all of them.

panic unwinds the stack; recover (in a deferred func) stops it. For TRULY exceptional cases only.

Start a goroutine — a function running concurrently on the Go runtime scheduler.

Channel — a typed, synchronized conduit between goroutines. Send `ch <- v`, receive `v := <-ch`.

Receive form that reports closure: ok is false once the channel is closed and drained.

Directional channels — send-only / receive-only in a signature.

select — wait on multiple channel operations; runs one ready case (random if several).

Mutex — guard shared state when channels don't fit. Lock/Unlock around the critical section.

Anonymous function / closure — captures variables from its enclosing scope by reference.

context.Context — carries cancellation, deadlines, and request-scoped values across API boundaries.

Root contexts: Background at the top of main/requests; TODO as a placeholder.

Generic function (1.18+) — type parameters in [] keep static types instead of falling back to any.

Constraint interface — a UNION of allowed types; `~` includes types whose underlying type matches.

Generic type — a reusable container parameterized by T.

Create a module — writes go.mod with the module path (its import prefix).

Sync go.mod/go.sum with the imports actually used — add missing, drop unused.

Add or upgrade a dependency to a specific version or the latest.

Run all tests in the module. Test files end in _test.go; funcs are TestXxx(t *testing.T).

run = compile+execute a temp binary; build = produce a binary; install = put it in GOBIN.

gofmt enforces the one true formatting; go vet catches likely bugs the compiler misses.