Introduction to Go
Learn what Go is, who created it and why, its core philosophy, and write your first line of Go code.
Introduction
Go, often called Golang, is an open-source programming language designed to make building reliable, fast software as simple as possible. It compiles straight to a single native binary, runs with the speed of a compiled language like C, but reads with the clarity of a scripting language.
This lesson introduces what Go is, why it was created, the philosophy that shapes every design decision in the language, and gives you your very first taste of actual Go code.
- What Go is and what kind of language it is (compiled, statically typed, garbage collected).
- Who created Go at Google, and the frustrations that led to it.
- The core philosophy of simplicity that guides Go's design.
- The key features that make Go stand out from other languages.
- What a minimal Go program looks like.
What is Go?
Go is an open-source, statically typed, compiled programming language. "Statically typed" means every variable's type is known at compile time, catching a whole class of bugs before your program ever runs. "Compiled" means your source code is translated directly into machine code, producing a single, fast, standalone executable file with no external runtime or interpreter required.
Go was also designed from day one with concurrency as a first-class citizen — a huge deal in a world of multi-core processors and networked services. Instead of bolting threading onto the language as an afterthought, Go gives you goroutines and channels as built-in tools for writing programs that do many things at once.
Who Created Go, and Why
Go was created at Google, starting in September 2007, by three highly respected systems programmers: Robert Griesemer, Rob Pike, and Ken Thompson. Rob Pike and Ken Thompson had already co-created influential technologies — Ken Thompson co-created Unix and the B programming language (a predecessor of C), and Rob Pike was a key figure behind Plan 9 and UTF-8.
The language was announced publicly in November 2009 and reached its stable Go 1.0 release in March 2012. Google's engineers were frustrated with the tools available at the time for building large-scale server software: C++ builds were painfully slow at Google's scale, dependency management was messy, and existing languages either sacrificed performance for simplicity or sacrificed simplicity for performance. Go was designed to give up neither.
The Problem Go Was Built to Solve
At Google's scale, a single C++ service could take many minutes — sometimes tens of minutes — to compile because of sprawling header-file dependency chains. Engineers were burning enormous amounts of time waiting on builds instead of writing code. On top of that, C++'s feature set had grown so large and complex over the decades that even experienced engineers struggled to reason about all of it at once.
Go's creators set out to design a language that compiled in seconds even for huge codebases, that stayed small and simple enough to hold in your head, and that made concurrent, networked programming — the bread and butter of modern server software — feel natural instead of bolted on.
Core Philosophy
Every feature Go has — and every feature Go deliberately leaves out — traces back to a small set of guiding principles.
- Simplicity over cleverness — Go has a deliberately small language specification with no hidden magic.
- Readability matters more than brevity — Go code should look the same no matter who wrote it, enforced by the built-in `gofmt` formatter.
- Fast compilation — even massive projects should build in seconds, not minutes.
- Concurrency as a first-class citizen — goroutines and channels are part of the language itself, not a library bolted on afterward.
- One way to do things — Go avoids offering ten different ways to solve the same problem.
Key Features at a Glance
Compiled & Fast
Compiles directly to native machine code — no virtual machine, no interpreter.
Statically Typed
Types are checked at compile time, catching bugs before they ever run.
Garbage Collected
Automatic memory management without the manual bookkeeping of C or C++.
Built-in Concurrency
Goroutines and channels make concurrent programs simple to write and reason about.
Single Binary Output
Ships as one self-contained executable — no dependency installs on the target machine.
Enforced Formatting
The `gofmt` tool means every Go codebase looks and feels consistent.
Your First Taste of Go
No introduction to a language is complete without seeing actual code. Here is the smallest complete Go program — one that prints a greeting to the screen.
package main
import "fmt"
func main() { fmt.Println("Hello, Go!")}Click Run to see what this code prints.
Don't worry about understanding every line yet — `package main`, `import`, and `func main()` are all covered in detail in later lessons. For now, just notice how short and readable it is: there is no boilerplate class wrapper, no unnecessary ceremony, just exactly what you need to print a line of text.
Where Go Is Used Today
Go has become one of the dominant languages for cloud infrastructure and backend systems. Some of the most important tools in modern software infrastructure are written in Go.
| Project | What It Is |
|---|---|
| Docker | The container platform that popularized containerized deployment. |
| Kubernetes | The industry-standard container orchestration system. |
| Terraform | Infrastructure-as-code tool used to provision cloud resources. |
| Prometheus | A widely used monitoring and alerting toolkit. |
| Hugo | One of the fastest static site generators available. |
Common Mistakes
- Assuming Go is "just another scripting language" — it is a compiled, statically typed language much closer to C in performance.
- Confusing "Go" the language with "Golang" — they are the same thing; "golang" simply comes from the domain name golang.org.
- Expecting object-oriented features like classes and inheritance — Go deliberately takes a different approach, covered in later lessons.
- Skipping the philosophy section and jumping straight to syntax — understanding *why* Go is simple makes the syntax choices click much faster.
Best Practices
- Read Go code with the expectation that it should be boring and predictable — that is a feature, not a limitation.
- Get comfortable running small snippets early; Go's fast compile times make experimentation cheap.
- Install `gofmt`-aware tooling (most editors do this automatically) so your code always matches idiomatic style.
- When stuck, check the official Go documentation at go.dev — it is unusually clear and example-driven.
Frequently Asked Questions
Yes. The language is officially named "Go," but because go.org was unavailable, its website used golang.org, and the nickname "Golang" stuck in casual use.
Yes. Go has been open source since its public announcement in 2009 and is developed under a BSD-style license.
No. Go was specifically designed to be approachable, with a small, simple syntax. Prior programming experience helps, but is not required.
Backend and infrastructure tooling are Go's biggest strengths, but it is also used for CLI tools, DevOps automation, networking software, and even some desktop and embedded applications.
Key Takeaways
- Go (Golang) is an open-source, statically typed, compiled language created at Google.
- It was created by Robert Griesemer, Rob Pike, and Ken Thompson starting in 2007, to solve slow builds and language complexity at scale.
- Go's core philosophy is simplicity, readability, fast compilation, and built-in concurrency.
- A minimal Go program is short and requires very little boilerplate.
- Go powers major infrastructure projects like Docker, Kubernetes, and Terraform.
Summary
You now know what Go is, who built it, why it exists, and what its guiding philosophy is. You have also seen your very first line of runnable Go code. Next, you will dig deeper into Go's history — from the frustrations that sparked its creation to the major milestones that shaped the language you'll be learning.