Go
Go is a statically typed, compiled, garbage-collected programming language with built-in support for concurrency.
Go in Practice, Second Edition
Go is a statically typed, compiled, open-source programming language designed for systems programming and large-scale software development.
- How it is used
- Builds services and system-level processes while supporting development through an integrated toolchain.
- How deep it goes
- Defines the language, works through a runnable HTTP server and tool commands, then addresses design, errors, and advanced facilities.
- Examples
- Uses an HTTP hello-world server, a tested string-reversal program, and a Java-to-Go comparison of inheritance and interfaces.
- What you can do after
- Build it from scratch: initialize a Go module, run and build a small HTTP service, and test its functions.
Go in Action, Second Edition
Go is an open-source, statically typed programming language designed for efficient compilation, execution, concurrency, and software development tooling.
- How it is used
- Positions Go as a practical choice for building concurrent software with fast development cycles, type checking, and standardized tooling.
- How deep it goes
- Explains compiler constraints and traces a concurrent HTTP request through goroutines, channels, cancellation, memory reclamation, and deployment.
- Examples
- Uses a runnable word counter, a recipe domain model, and an HTTP request life cycle.
- What you can do after
- Build it from scratch: create a small Go program and handle function errors explicitly.
Learn Go with Pocket-Sized Projects
Go is a statically typed programming language designed for readable, maintainable, compiled software, especially concurrent and networked systems.
- How it is used
- Builds readable backend services, APIs, cloud tools, and command-line applications.
- How deep it goes
- Develops Go through progressively larger runnable projects, from basic syntax to cloud-ready services, while limiting detailed goroutine coverage.
- Examples
- Uses a hello-world-style program, table-driven tests, APIs with microservices, and WebAssembly and TinyGo projects.
- What you can do after
- Build it from scratch: progress from a small tested Go program toward a cloud-ready service.
Go by Example
Go is a statically typed, compiled programming language designed for simplicity, efficient execution, and reliable software development.
- How it is used
- Builds command-line tools, clients, servers, and distributed network programs with a standard library and concurrency model.
- How deep it goes
- Introduces compilation, typing, concurrency, interfaces, and package design, while deferring detailed mechanics and concurrent programming.
- Examples
- Uses a greeting executable run with go mod init and go run ., plus a static-binary compilation diagram.
- What you can do after
- Apply it via the go tool to create and run a packaged executable, then choose leaner package and abstraction boundaries.
Logs and Telemetry
Go is a statically typed compiled programming language designed for efficient systems and network software development.
- How it is used
- Uses Go to implement custom Fluent Bit input and output plugins for specialized integrations.
- How deep it goes
- Explains Go plugin integration through bindings, cgo mapping, shared objects, loading, reloads, and platform-build limits.
- Examples
- Uses specialized video-transcoder error handling and organization-specific naming conventions as plugin use cases.
- What you can do after
- Apply it via Fluent Bit Go bindings to build, load, and update native input or output plugins.
Learn Concurrent Programming with Go
Go is a statically typed, compiled programming language designed for simplicity, readability, and efficient execution, including built-in support for concurrency.
- How it is used
- Uses Go to teach concurrent execution, communication, synchronization, race conditions, and concurrency patterns.
- How deep it goes
- Introduces operating-system concurrency, goroutines, channels, CSP, shared memory, and synchronization before deferring advanced topics.
- Examples
- Uses an overloaded payroll system, large employee calculations, goroutine coordination, and channel-based communication as practical illustrations.
- What you can do after
- Build concurrent programs that coordinate executions through goroutines, channels, or classic synchronization primitives.
100 Go Mistakes and How to Avoid Them
Go is a statically typed, compiled programming language designed for simplicity, concurrency, and efficient software development.
- How it is used
- Deploys a deliberately focused language across APIs, automation, databases, command-line interfaces, and cloud software.
- How deep it goes
- Explains design trade-offs and common control-structure and concurrency mistakes, while deferring detailed treatment to concrete cases.
- Examples
- Uses channel blocking bugs, range-loop misunderstandings, efficient tests, and profiling and linting practices as concrete learning cases.
- What you can do after
- Apply it more productively by choosing concurrency approaches carefully and using tests, libraries, profilers, and linters.
Read how 100 Go Mistakes and How to Avoid Them explains Go →
Shipping Go: Develop, deliver, discuss, design, and go again
A statically typed, compiled programming language designed for concise syntax, concurrency, and efficient software development.
- How it is used
- Uses Go as the concrete language for turning a small product into a shippable increment.
- How deep it goes
- Explains Go through project setup and workflow examples, stopping short of language internals or detailed syntax.
- Examples
- Uses a Hello API repository, Go 1.18 setup, a Makefile, PATH initialization, and README installation commands.
- What you can do after
- Builds and documents a repeatable Go project setup using a Makefile and README.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains Go →
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
A statically typed compiled programming language designed for general-purpose software development.
- How it is used
- Uses Go for Terratest module tests and as the development language when beginning Terraform provider work.
- How deep it goes
- Walks through test-file structure, module initialization and test results, but limits the introduction to small tests rather than full Go applications.
- Examples
- Shows an assertion-based Go test, passing and failing test output, and commands that initialize a module and fetch dependencies.
- What you can do after
- Apply it via Terratest and Go’s testing package to create and run small Terraform-module tests.
Read how Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu explains Go →
Cloud Observability in Action
Go is a statically typed compiled programming language designed for efficient systems and network software development.
- How it is used
- Uses Go to build HTTP services and generate application signals for observability workflows.
- How deep it goes
- Demonstrates runnable services and profiling commands but stops short of explaining Go language semantics.
- Examples
- Uses an echo service, curl load generation, and a pprof-enabled program with quickTask and slowTask functions.
- What you can do after
- Build and operate small Go HTTP services, then inspect their runtime behavior with pprof and observability tools.
Hacking Cryptography
Go is a statically typed, compiled programming language designed for simplicity, portability, and efficient software development.
- How it is used
- Uses Go to prototype cryptographic algorithms, execute attacks, and connect implementation details with engineering consequences.
- How deep it goes
- Demonstrates implementations and vulnerabilities through runnable examples, while deferring the mathematical theory underlying cryptographic algorithms.
- Examples
- Uses runnable code listings, exercises, and a rainbow table implementation for cracking hashed passwords.
- What you can do after
- Builds and runs practical Go implementations while recognizing vulnerabilities and choosing tested cryptographic implementations for production.
Related concepts
- programming languagekind of · A programming language is a formal language with defined syntax and semantics for expressing computations and instructions that computers can execute or interpret.
- goroutineuses · A goroutine is a lightweight function execution unit managed by the Go runtime that runs concurrently with other program activity.
- native executableproduces · A native executable is a directly runnable program compiled into machine code for a specific operating-system and processor architecture.
- channeluses · A channel is a medium, mechanism, or pathway through which information or messages are conveyed between participants or endpoints.
- garbage collectionuses · Garbage collection is an automated memory- or storage-management process that identifies objects or data no longer reachable or needed and reclaims or deletes them.
- multiple return valuesuses · Multiple return values are function results in which a single invocation provides more than one distinct value.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.