liveBook · Manning

Go

Also called Golang

Go is a statically typed, compiled, general-purpose programming language with garbage collection and built-in support for concurrency.

How 11 Manning books explain it

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.

Read how Go in Practice, Second Edition explains Go →

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.

Read how Go in Action, Second Edition explains Go →

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.

Read how Learn Go with Pocket-Sized Projects explains Go →

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.

Read how Go by Example explains Go →

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.

Read how Logs and Telemetry explains Go →

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.

Read how Learn Concurrent Programming with Go explains Go →

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.

Read how Cloud Observability in Action explains Go →

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.

Read how Hacking Cryptography explains Go →

Also covered in

What to know first

Related concepts

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.