1 Introducing Go

This chapter introduces Go as a pragmatic response to modern software demands: ubiquitous multicore hardware, the need for scalable concurrency, and collaborative development in an open-source world. It frames Go as a language and ecosystem designed to balance development speed with performance, combining a simple, opinionated syntax with robust tooling and a powerful runtime. Aimed at developers with experience in other languages, the chapter sets expectations for a practical journey through Go’s core ideas and the rationale behind its design, to help readers evaluate Go for their stacks.

The text highlights Go’s fast compilation and streamlined dependency management that narrow the productivity gap with dynamic languages, while preserving the safety and performance of a statically typed, compiled language. It emphasizes strong type safety to prevent a class of runtime errors, and presents Go’s integrated concurrency model: lightweight goroutines, channels for safe communication, and a runtime scheduler that makes scalable concurrency approachable—often leveraged transparently through the standard library. Together, these choices let developers write readable, maintainable programs that efficiently utilize modern hardware.

Go’s type system encourages composition over inheritance, enabling simple data-first designs with methods on structs, implicit interfaces for flexible polymorphism, and, more recently, generics for reusable, type-safe algorithms and data structures. The chapter also underscores Go’s low-latency, concurrent garbage collector, tuned for high-throughput services and continuously improving with each release. Finally, it outlines the book’s practical focus—syntax, testing, concurrency primitives, modules, fuzzing, and generics—so readers learn not just how Go works, but why its trade-offs lead to faster, more reliable software.

Working hard? (via XKCD)

A Common Dynamic Typing Exception

Many Goroutines Execute On a Single OS Thread

Channels Pass Data Between Goroutines

Inheritance Vs. Composition

• Go is a modern general-purpose language with powerful built-in concurrency features.
• Go is fast, and compiles quickly, leading to reduced development overhead.
• Go has a simple, easy-to-use type system with implicit interface implementation and generic programming features.
• Go is memory-safe and garbage collected, freeing the programmer from both the tedium and the worry of manual memory management.

FAQ