Go

Every Go program starts with a package declaration, an import block and a main function, and the Ruby book says that a reader who can read those three things can read any Go program.[4] A package named main is an executable, every file in a directory belongs to the same package, and the file extension is required, where PHP's is a convention.[5] Visibility is one rule: a capitalised identifier is exported and a lowercase one is private; a module groups packages, and the Ruby book calls go.mod Go's Gemfile and go.sum its lockfile.[4]

The compiler enforces style and hygiene. Gofmt has no options, uses tabs for indentation and spaces for alignment, and, in the darker-corners book's judgement, saves man-years of argument about things that hardly matter; the opening brace must end its line, a side effect of the lexer rather than of gofmt, and a trailing comma is mandatory in a multi-line literal so that lines can be reordered without touching their neighbours.[3] Go 101 gives the two reasons for the line-break rules: faster compilation and code that looks the same whoever wrote it.[8] A program with an unused import or local variable does not compile, a deliberate trade of convenience for build speed and clarity, and an underscore import runs a package only for its side effects, as with the profiling package that exposes HTTP endpoints.[3]

The visual guide walks the toolchain: go run compiles to a temporary executable, go build writes one, go install places a command on the path, go test with the triple-dot pattern tests every package below the directory where the bare command tests only one, and go vet finds suspicious constructs without proving correctness; its layout puts the executable under cmd and reusable logic under internal, where code outside the tree cannot import it.[7] A pure-Go program usually needs no installed runtime, but the guide warns that "Go binaries are static" is not universally true: cgo, system libraries and some build modes add dynamic dependencies, so a release process records the target platform, whether cgo is enabled, build tags and compiler version.[7]

Go 101 counts seventeen built-in basic types: one boolean, eleven integers, two floating-point, two complex and one string, with byte and rune as aliases of uint8 and int32.[8] A variable declared without a value gets its type's zero value, 0, false or the empty string, where most languages would give null, and a defined type is distinct from its underlying type while an alias type, added in Go 1.9, is interchangeable with it.[6] The sized integers are close to the hardware on purpose, and the introductory programming book shows what that costs: adding 10 to 250 in an eight-bit unsigned integer wraps to 4, which it sets beside the 1996 Ariane 5 explosion from a 64-bit value forced into 16 bits.[14]

The darker-corners book catalogues what surprises people who already know the syntax. A short declaration inside a nested block creates a new variable, so an error assigned there is lost by the enclosing return; operator precedence has five levels against C's ten, so one shifted left by one plus one is three in Go and four in C; and iota is the index of a constant within its block, not a counter that restarts.[3] A slice is a pointer, a length and a capacity; passing or re-slicing one shares the array, so a function can change its caller's data until an append past capacity allocates a new array and the copies part, and a four-byte slice of a file read into memory keeps the whole file alive.[3] A string is a sequence of bytes that need not be UTF-8, its length is in bytes, indexing gives bytes and the range loop gives runes; the book counts one accented character as seven bytes and four runes, and its benchmark shows a string builder about three thousand times faster than repeated concatenation.[3] Production Go shows the same from the other side: ranging over a string that mixes Latin and Chinese characters yields indexes that jump from 3 to 6.[1] Map iteration order is randomised, though the printing functions and the JSON encoder sort the keys.[2]

Go Details and Tips 101 goes lower. A zero-size field placed last in a struct is padded, because taking its address would otherwise point past the struct's memory block and keep a neighbour alive; ranging over an array iterates a copy unless the element variable is omitted; a set is a map to the empty struct, a trick credited to Tailscale; and a deferred call's arguments are evaluated when it is registered, while a deferred function can change named results after the return statement.[2] The interview book's first chapters drill the same ground: the zero value of a map, iota, the slice header, what append does to aliasing, and how to measure struct padding instead of guessing.[26]

Go is not object-oriented, the Ruby book says: no classes, no inheritance, no exceptions, and in their place structs, composition and error values checked after each call, the if err != nil that stands where a rescue block stood.[4] Errors wrap: the visual guide's first test checks that a wrapped hostname error still matches its cause.[7] Panic and recover remain for the unrecoverable,[6] and the beginner's book runs through custom error types, wrapping, and when panic is appropriate.[31] Interfaces are satisfied implicitly, and the generative-art book shows the pattern in the standard image package: an image is an interface with three methods, a drawable image adds a setter, and the pair resemble the reader and writer interfaces.[17] Functions are values: Learn Go covers closures, variadic functions, named returns and the init function that runs before main.[6]

Generics are the newest part. Generic Go, written against the proposal, explains the need, compares the feature with Java's, covers type erasure, templates and monomorphisation, solves each problem once with the old feature set and once with type parameters, and spends time on when not to use them.[34] Go Generics 101 covers the shipped feature's syntax, constraints, type inference, the operations allowed on values of a type parameter type, and the current restrictions; its author says it is mainly syntax and concepts until he has more experience to draw on.[33] By 2023 the introductions had a generics chapter each,[28] including the first-year programming book.[14]

A goroutine is a lightweight execution context scheduled by the Go runtime, distinct from the thread the kernel schedules; the visual guide's analogy is a restaurant in which goroutines are orders, threads are cooks and cores are workstations, so adding orders creates a queue, not capacity, and it adds that a goroutine is cheaper than a thread but not free, so production systems bound their creation, and that the garbage collector reclaims memory but not file descriptors, connections or goroutines blocked on work that never arrives.[7] Learn Go's last chapter covers goroutines, channels, select, the sync package and context,[6] the beginner's book adds wait groups, mutexes, once and semaphores,[31] and Go 101 gives the subject seven articles, from channel use cases and closing channels gracefully to memory-order guarantees and common concurrent mistakes.[8]

The distributed-systems book turns the primitives into a model: a goroutine is a service, a channel is a network and the context is the kill switch, so timeouts, cancellation, backpressure and graceful shutdown among goroutines are the same patterns as among services; its first example is a page-view counter on an atomic integer, correct on one machine and wrong by design the moment a second server joins.[9] The backpressure manual describes the failure the other way round, a service that accepts everything and moves its backlog into an unbounded channel, a goroutine per request or a retry storm.[23] The lightest treatment is A Language a Day, which demonstrates each of its twenty-one languages' concurrency with Sleep Sort.[29]

Go Optimizations 101 covers using less CPU and memory, making fewer allocations, controlling where they happen and reducing garbage-collector pressure, all for the official compiler and runtime, and opens by saying that most of a codebase should not be optimised at all; it uses neither unsafe pointers nor cgo and does not teach the profiler.[35] The tips book records a compiler limit: a package-level array larger than two gigabytes fails to compile, though a heap-allocated one may be bigger.[2] Production Go advises against the plus operator for string building in a hot path,[1] and the darker-corners benchmark quantifies it.[3] The interview questions name the runtime's levers: the memory limit setting, escape analysis, object pools, the race detector and the profiler.[26] A 2026 introduction ends by profiling its HTTP service under load,[32] and the visual guide warns that concurrency can add contention and memory pressure as easily as speed, so throughput and tail latency are measured rather than assumed.[7]

Production Go's stated goal is a production-ready service, which it defines as the implementation plus reliable deployment, monitoring and iteration; its chapters cover strings and Unicode, concurrency, testing, tooling, security and going into production with continuous delivery, logging, monitoring and alerting.[1] The distributed-systems book lists the practices it treats as baseline: configuration from the environment, structured JSON logs to standard output, health checks for the orchestrator, graceful handling of the termination signal so rolling deployments drop no requests, and metrics and traces; it takes the standard library where the ecosystem has settled, pattern routing in the HTTP package over a framework, and names its departures, pgx for PostgreSQL and a pure-Go Kafka client.[9] The 2026 introduction ends with a concurrent server with structured logging and graceful shutdown, containerised and packaged as a static binary.[32]

The lighter books build the same thing smaller. Go, from the beginning reaches a web API through the standard HTTP package and its multiplexer, after JSON and before logging and SQLite.[30] A textbook from Sapienza University gives Go one chapter of seven in a full-stack course, between designing APIs with OpenAPI and a Vue.js front end.[27] REST HOW TOs builds the client side first, then the server side with GET, POST, PUT, DELETE and OPTIONS.[38] A 2019 book deploys one todo-list API twice on IBM Cloud, on Cloud Foundry and on Cloud Functions, to show the two models side by side.[41] On the wire, Data Serialization in Go takes the standard JSON package as the baseline for every format, grew out of its author's CouchDB client and an unanswered question about embedding a struct with a custom marshaler, and is organised into basics, a toolbox, recipes and other formats; its preface says many sections are still unfinished.[25] The microservices book lists the compatibility rules for protocol buffers: adding or removing a field is safe, renumbering or reusing a field number is not, and renaming breaks JSON clients but not protobuf ones.[10]

Distributed Systems in Go begins with the cost of distribution. It restates the eight fallacies of distributed computing with a Go reading of each, puts a function call at about five nanoseconds against two hundred microseconds for an HTTP call on the same host, and names four measurable reasons to distribute, capacity, fault tolerance, independent deployment and different scaling curves, with "microservices are the standard" explicitly not among them; its fifteen chapters, from a queue between two services through middleware, JWT authentication, Kafka, gRPC with retries and circuit breakers, fan-out and sagas to observability and testing, each end by moving the pattern into a shared platform module.[9] Advent of Go Microservices, from 2020, builds one view-counting service a chapter a day: protobuf messages, a service scaffolded with Twirp first and gRPC second, with the trade-offs listed, HTTP 1.1 and JSON on one side and streaming and wire-compatibility promises on the other, under a local Drone CI pipeline run from a Makefile.[10]

Three short field manuals from 2026 treat one resilience pattern each, with the Go implementation in a companion repository. The rate-limiting manual calls the limiter a load-shedding contract that must fail before the dependency it protects does, and recommends a local token bucket by default and distributed quotas only when business policy needs global accuracy.[22] The backpressure manual traces an incident from a downstream slowdown to retries and useless autoscaling and asks a design review one question: when offered load exceeds capacity, what work is refused, dropped or cancelled, and which metric proves it.[23] The circuit-breaker manual gives the breaker's three states, orders deadline, breaker, attempt and retry, separates retryable failures from caller mistakes, and shows three 150-millisecond attempts with backoff adding up to 600 milliseconds inside a 500-millisecond objective.[24] At the architectural end, a 2026 book builds a portfolio-management system in Go to argue that when AI generates code faster than people can review it, explicit boundaries, domain models, dependency rules and machine-enforceable constraints are what keep a system coherent.[40]

Build Your Own Database in Go From Scratch codes a database in about three thousand lines, with the line count at each step, from a copy-on-write B+tree and an append-only key-value store through tables, range queries, secondary indexes, transactions and concurrency control to a SQL-like parser and interpreter.[13] Its introduction sets the principles first: durability is the fsync call and atomicity is all or nothing; a plain file overwrite fails both, an atomic rename survives a concurrent reader but not a power loss until the directory is synced too, and an append-only log needs a checksum per entry to detect a torn write; only the B+tree and the LSM-tree suit disk, where latency is three orders of magnitude above memory.[13] Code a database in 45 steps covers the same ground as test-driven puzzles, most under fifty lines, with no dependencies.[39]

Bitemporality in Go builds a different kind of database on top of SQLite. Its first chapter shows an employee transferred between departments by an update that loses the history, walks three cumbersome workarounds, and then gives each record four fields, when the database recorded and invalidated it and when it became and stopped being true in the world, so that a transfer effective on one date but recorded on another answers two different questions.[12] The author chose Go over Rust and C++ for its clarity in teaching, pins Go 1.24.0 and SQLite 3.49.0, and builds with Bazel and Protocol Buffers.[12] The distributed-systems book covers the client side, pgx, the repository pattern, type-safe SQL without an ORM and zero-downtime migrations.[9]

Go With Graphics works up from the standard image package: the decoders for JPEG, PNG and GIF are registered by underscore imports, and the colour at a pixel comes back as sixteen-bit alpha-premultiplied values, so a half-transparent white pixel reads as 127 in every channel until the image is drawn into a non-premultiplied type through the draw package; the resize chapter derives nearest-neighbour interpolation, which turns a five-pixel strip into jagged loss, and then bilinear interpolation from four weighted neighbours, and the later chapters cover edge detection, focal points, filters and watermarking.[11] Generative Art in Go defines its subject with Philip Galanter's 2003 paper, a system set in motion with some autonomy, and a dice-and-two-paints example in which the dice is the uncertainty every generative work needs; it then implements one sketch, called Squares, from the standard image and colour packages.[17]

Beginning Game Programming with Go builds a Vampire Survivors-style game, Gopher Survivor, in fourteen cumulative chapters on Ebitengine, an open-source 2D library by Hajime Hoshi that provides a window, a game loop, rendering, input and audio but no editor, physics engine or scripting layer; its case for Go in games is short compile times, one binary with no runtime to bundle, trivial cross-compilation and goroutines for asset loading, with the concession that 3D blockbusters belong to C++ and specialised engines.[16] A Go Developer's Notebook takes the exploratory route through virtual machines, Mandelbrot sets and caches,[15] and the first-year programming book closes with Eight Queens, Conway's Game of Life, the Tower of Hanoi and Blackjack.[14]

GoLang Cryptography for Developer, from 2018, is a cookbook with one runnable program per primitive; its sample covers Argon2, the 2015 Password Hashing Competition winner, with the hybrid key function as the default when unsure, DSA signing and verification with the standard library's four parameter sizes, and a Curve25519 key agreement.[18] One of its examples hashes the message with MD5 before signing, and its chapter list runs to RC4, Blowfish and triple DES beside AES and ChaCha20-Poly1305, so a reader takes the API shapes and checks the algorithm choices against the date.[18] A Go Developer's Notebook puts HTTP, TCP/IP, UDP and RSA into its free Hello World chapter, which its author offers as a free resource on networking and cryptography in Go.[15] For services, the distributed-systems book generates and validates JWTs with ECDSA and publishes keys through a JWKS endpoint,[9] and the visual guide's later parts, by its contents, cover deadline-aware TCP protocols, production HTTP clients and security.[7]