Go
Go is a statically typed, compiled, general-purpose programming language with garbage collection and 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
- Uses Go to connect language design and tooling to maintainable, concurrent software development.
- How deep it goes
- Explains design trade-offs and develops practical programs, from compile-time type checks to error handling and concurrency patterns.
- Examples
- Uses a word-count utility, a recipe domain model, a key-value store interface, and an HTTP request lifecycle.
- What you can do after
- Build a basic word-count program from scratch and apply Go patterns for domain modeling, error handling, and concurrent work.
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
- Uses Go to build maintainable backend services, APIs, cloud applications, and other small projects.
- How deep it goes
- Progresses from syntax to cloud-ready service design, while spending limited time on goroutines and omitting cgo.
- Examples
- Uses hello-world programs, table-driven tests, cloud-ready services, and a TinyGo microcontroller project.
- What you can do after
- Builds Go applications from scratch, tests their behavior, and makes architectural decisions for 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.
Also covered in
- Learn Docker in a Month of Lunches, Second Edition
- gRPC Microservices in Go
- Writing for Developers: Blogs that get read
- Build and Orchestrator in Go (From Scratch)
- The Creative Programmer
What to know first
- exceptionAn exception is a runtime signal or value representing an abnormal condition that interrupts ordinary program flow and can be handled or propagated.
- software testingSoftware testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- concurrencyConcurrency is the structuring or execution of multiple computational activities so their progress overlaps in time, whether or not they run simultaneously.
Related concepts
- programming languagekind of · A programming language is a formal language with defined syntax and semantics for expressing computations and instructions that a computer can execute, interpret, or translate.
- goroutineuses · A goroutine is a lightweight function execution unit managed by the Go runtime that runs concurrently with other program activity.
- channeluses · A channel is a medium or logical pathway for conveying information, messages, or other content between sources and recipients.
- garbage collectionuses · Garbage collection is an automated process that identifies and reclaims or removes memory, data, or other items no longer reachable or needed by a system.
- native executableproduces · A native executable is a directly runnable program compiled into machine code for a specific operating-system and processor architecture.
- interpretercontrasts with · An interpreter is software that evaluates or executes a program or instruction representation according to its defined semantics.
Questions about Go
What is Go?
Go is a statically typed, compiled, general-purpose programming language with garbage collection and built-in support for concurrency.
Which Manning books explain Go?
Go in Practice, Second Edition, Go in Action, Second Edition, Learn Go with Pocket-Sized Projects, Go by Example, Logs and Telemetry, Learn Concurrent Programming with Go, 100 Go Mistakes and How to Avoid Them, Shipping Go: Develop, deliver, discuss, design, and go again and 3 more.
What should I know before learning Go?
Manning books that teach Go usually introduce exception, software testing, contract and concurrency first.
What is the difference between Go and interpreter?
Go is a statically typed, compiled, general-purpose programming language with garbage collection and built-in support for concurrency. An interpreter is software that evaluates or executes a program or instruction representation according to its defined semantics.
What is Go a kind of?
Go is a kind of programming language. A programming language is a formal language with defined syntax and semantics for expressing computations and instructions that a computer can execute, interpret, or translate.
What is Go also called?
Go is also called Golang.
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.










