What is Go?

Go (often called Golang, mostly so search engines can tell it apart from the word "go") is an open-source programming language created at Google in 2009 by Robert Griesemer, Rob Pike, and Ken Thompson. It was designed to solve a very specific, very unglamorous problem: large codebases with lots of engineers were becoming slow to build, hard to reason about, and full of subtle concurrency bugs. Go's answer was to strip things down rather than pile features on.

A reaction to complexity

At the time, the realistic choices for backend systems were C++ (fast, but slow to compile and easy to shoot yourself in the foot with) or Java (safer, but verbose and heavy). Go's designers wanted the speed of a compiled language with the simplicity and safety of a scripting language, without dragging along decades of legacy features.

The result is a language with a deliberately small surface area: no classes, no inheritance, no generics for its first decade, no exceptions. That's not an oversight — it's the point. Go trades expressive power for readability and consistency. Any Go developer can open any Go codebase and mostly understand it immediately, because there aren't ten different ways to write the same thing.

What Go actually looks like

package main

import "fmt"

func main() {
	fmt.Println("Hello, Go!")
}

Every Go file belongs to a package, every executable program needs a main package with a main function, and fmt (short for "format") is the standard library package for printing and formatting text. There's no build configuration to write before this runs — the toolchain is built in.

Compiled, statically typed, and fast

Go compiles directly to a single native binary — no virtual machine, no runtime to install on the server, no "it works on my machine but not in production" dependency mismatches. That binary starts in milliseconds and needs nothing but itself to run. This is a big part of why Go became the default language for infrastructure tooling: Docker, Kubernetes, Terraform, and Prometheus are all written in Go.

Go is also statically typed, so a whole category of bugs gets caught at compile time rather than in production. But unlike C++'s compiler, Go's compiler is famously fast — large projects compile in seconds, which keeps the feedback loop tight even at scale.

Concurrency as a first-class citizen

Go's other headline feature is goroutines — lightweight, cheap-to-create units of concurrent execution that are managed by the Go runtime instead of the operating system. Where spinning up thousands of OS threads would grind a server to a halt, spinning up thousands of goroutines barely registers. Combined with channels for passing data between them safely, Go makes concurrent programming dramatically less error-prone than in most languages that bolted concurrency on as an afterthought. This course covers both in the Concurrency section.

Where you'll see Go in the wild

Go has become the default choice for cloud infrastructure and networked backend services: APIs, microservices, CLIs, and DevOps tooling. Companies like Google, Uber, Twitch, Cloudflare, and Docker rely on it heavily. It's not trying to be everything to everyone — you won't reach for Go to build a mobile app UI or a data science notebook — but for "I need a fast, reliable service that talks over a network," it's one of the strongest options available.

The rest of this course builds Go up from the ground: installing the toolchain, writing your first program, and working through the syntax, data structures, and concurrency model that make Go what it is.