---

The Go Project

All programming languages reflect the programming philosophy of their creators, which often includes a significant component of reaction to the perceived shortcomings of earlier languages. The Go project was borne of frustration with several software systems at Google that were suffering from an explosion of complexity.

Simplicity

As Rob Pike put it, “complexity is multiplicative”: fixing a problem by making one part of the system more complex slowly but surely adds complexity to other parts. With constant pressure to add features and options and configurations, and to ship code quickly, it’s easy to neglect simplicity, even though in the long run simplicity is the key to good software.

Conceptual Integrity vs. Convenience

Simplicity requires more work at the beginning of a project to reduce an idea to its essence and more discipline over the lifetime of a project to distinguish good changes from bad or pernicious ones. With sufficient effort, a good change can be accommodated without compromising what Fred Brooks called the “conceptual integrity” of the design but a bad change cannot, and a pernicious change trades simplicity for its shallow cousin, convenience. Only through simplicity of design can a system remain stable, secure, and coherent as it grows.

What the Go Project Has

The Go project includes

• the language itself,
• its tools and standard libraries,

and last but not least,

• a cultural agenda of radical simplicity.

As a recent high-level language, Go has the benefit of hindsight, and the basics are done well: it has

• garbage collection,
• a package system,
• first-class functions,
• lexical scope,
• a system call interface, and
• immutable strings in which text is generally encoded in UTF-8.

What the Go Project Does Not Have

But it has comparatively few features and is unlikely to add more. For instance, it has

• no implicit numeric conversions,
• no constructors or destructors,
• no operator overloading,
• no default parameter values,
• no inheritance,
• no generics,
• no exceptions,
• no macros,
• no function annotations, and
• no thread-local storage.

The language is mature and stable, and guarantees backwards compatibility: older Go programs can be compiled and run with newer versions of compilers and standard libraries.

Go and its Type System

Go has enough of a type system to avoid most of the careless mistakes that plague programmers in dynamic languages, but it has a simpler type system than comparable typed languages. This approach can sometimes lead to isolated pockets of “untyped” programming within a broader framework of types, and Go programmers do not go to the lengths that C++ or Haskell programmers do to express safety properties as type-based proofs. But in practice Go gives programmers much of the safety and run-time performance benefits of a relatively strong type system without the burden of a complex one.

Contemporary System Design

Go encourages an awareness of contemporary computer system design, particularly the importance of locality.

• Its built-in data types and most library data structures are crafted to work naturally without explicit initialization or implicit constructors, so relatively few memory allocations and memory writes are hidden in the code.
• Go’s aggregate types (structs and arrays) hold their elements directly, requiring less storage and fewer allocations and pointer indirections than languages that use indirect fields.
• And since the modern computer is a parallel machine, Go has concurrency features based on CSP, as mentioned earlier. The variable-size stacks of Go’s lightweight threads or goroutines are initially small enough that creating one goroutine is cheap and creating a million is practical.

Go’s Standard Library

Go’s standard library, often described as coming with “batteries included,” provides clean building blocks and APIs for

• I/O,
• text processing,
• graphics,
• cryptography,
• networking, and
• distributed applications,
• with support for many standard file formats and protocols.

The libraries and tools make extensive use of convention to reduce the need for configuration and explanation, thus simplifying program logic and making diverse Go programs more similar to each other and thus easier to learn.

Go Tool

Projects built using the go tool use only file and identifier names and an occasional special comment to determine all the libraries, executables, tests, benchmarks, examples, platform-specific variants, and documentation for a project; the Go source itself contains the build specification.