What Is Golang? The Go Language Explained with Examples

Go is a statically typed, compiled programming language created at Google. It produces a single native binary, compiles in seconds, has garbage collection, and has concurrency built into the language through goroutines and channels. Its main home is server-side software: APIs, network services, and the command-line and cloud tools that run them.

Here is a complete Go program. Press Run.

package main

import (
	"fmt"
	"strings"
)

func main() {
	languages := []string{"Go", "Python", "Rust"}

	for i, name := range languages {
		fmt.Printf("%d: %s has %d letters\n", i, name, len(name))
	}

	fmt.Println(strings.ToUpper("compiled, typed, garbage collected"))
}

Every Go program starts in package main at func main(). := declares a variable and infers its type (here []string, a slice of strings). range walks the slice and hands you an index and a value. fmt and strings come from the standard library, which is large enough that many programs import nothing else.

Go vs Golang: The Name

The language is called Go. "Golang" is a nickname from the project's first website, golang.org (the site now lives at go.dev). People kept using it because searching the web for "go" returns everything except the language. The official documentation says "Go", but "golang" is the term almost everyone types into a search box, and both mean the same thing. There is no separate "Golang" product or dialect.

Who Made Go and Why

Robert Griesemer, Rob Pike and Ken Thompson started designing Go at Google in 2007. It was released as open source in November 2009, and Go 1.0 shipped in March 2012.

The motivation was practical. Google's large C++ and Java codebases took a long time to build, dependency graphs were hard to manage, and multicore machines and networked services were the norm but writing concurrent code was error-prone. Go's design answers those problems directly:

• Fast builds. Imports are explicit, unused imports are a compile error, and the compiler does not reparse headers, so large programs build in seconds.
• Simple language. Few keywords, one loop (for), no inheritance, no exceptions. Code written by different people tends to look alike, which helps reviews in a large team.
• Concurrency as a language feature. Starting a concurrent task is one keyword, go, and channels let tasks communicate.
• Easy deployment. The output is one binary you copy to a server. It is usually statically linked; with cgo enabled, packages such as net can link against the system C library, and CGO_ENABLED=0 turns that off.

Go 1.0 also came with the Go 1 compatibility promise: programs written for Go 1.0 continue to compile and run with later 1.x releases. In practice that means upgrading the toolchain rarely breaks your code, and it is a big reason teams trust Go for long-lived services.

What Golang Is Used For

Go is strongest where a program talks to a network, runs for a long time, and needs to be easy to ship:

It is a weaker fit for GUI desktop apps, mobile apps, browser front ends, and numerical or machine-learning work, where other ecosystems have much better libraries.

Key Features, with Code

Static types with inference

Every variable has a type fixed at compile time, but you rarely write it out. := infers it:

package main

import "fmt"

func main() {
	count := 3         // int
	price := 9.99      // float64
	name := "keyboard" // string
	inStock := true    // bool

	fmt.Printf("%T %T %T %T\n", count, price, name, inStock)

	total := float64(count) * price
	fmt.Printf("%d x %s = %.2f\n", count, name, total)
}

Go never converts between numeric types silently. count * price does not compile, because one is int and the other float64; you write float64(count) yourself. This rules out silent truncation and precision bugs.

Errors are values

Go has no exceptions. A function that can fail returns an error as its last result, and the caller checks it:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"42", "forty-two"}

	for _, s := range inputs {
		n, err := strconv.Atoi(s)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("parsed:", n*2)
	}
}

The if err != nil pattern is the most recognizable line in Go code. It is verbose, and that is the point: every place a program can fail is visible where it happens. See error handling for wrapping and inspecting errors.

Goroutines and channels

A goroutine is a function running concurrently with the rest of the program. It costs a few kilobytes of stack, so running thousands of them is normal. Channels pass values between goroutines safely:

package main

import "fmt"

func square(n int, results chan<- string) {
	results <- fmt.Sprintf("%d squared is %d", n, n*n)
}

func main() {
	results := make(chan string)

	for n := 1; n <= 3; n++ {
		go square(n, results)
	}

	for range 3 {
		fmt.Println(<-results)
	}
}

The three goroutines run concurrently, so the three lines can print in any order. Run it a few times and you may see different orders. main receives exactly three values, so it waits for all of them before exiting.

Interfaces without "implements"

A type satisfies an interface just by having the right methods. There is no implements keyword:

package main

import (
	"fmt"
	"math"
)

type Shape interface {
	Area() float64
}

type Rect struct{ W, H float64 }
type Circle struct{ R float64 }

func (r Rect) Area() float64   { return r.W * r.H }
func (c Circle) Area() float64 { return math.Pi * c.R * c.R }

func main() {
	shapes := []Shape{Rect{W: 3, H: 4}, Circle{R: 1}}
	for _, s := range shapes {
		fmt.Printf("%T area: %.2f\n", s, s.Area())
	}
}

Rect and Circle never mention Shape, yet both can be stored in a []Shape. This lets you define an interface in the package that uses it, long after the concrete types were written.

One toolchain

The go command does everything: go run compiles and runs, go build makes a binary, go test runs tests, go fmt formats code, go vet catches suspicious constructs, and go mod manages dependencies. There is one official formatting style, enforced by gofmt, so Go projects do not argue about braces or indentation.

What Go Deliberately Leaves Out

Some features common in other languages are missing on purpose:

• No classes or inheritance. You use structs, methods, interfaces, and embedding.
• No exceptions. Errors are returned values. panic exists, but it is for bugs, not ordinary failures.
• No ternary operator. You write an if/else.
• No while keyword. for covers every loop.
• No function overloading or default arguments.
• Generics only since Go 1.18, and deliberately limited compared with C++ templates or Java generics.

Honest Trade-offs

Verbosity. Explicit error checks and the lack of shortcuts like the ternary operator make Go code longer than equivalent Python or Kotlin. Reading it is easy; writing it takes more lines.

Garbage collection. Go's collector has low pause times, but it is still a garbage collector. For hard real-time systems or code where every allocation matters, C, C++ or Rust give you more control.

Nil values. Go has nil pointers, maps, slices and interfaces. A nil pointer dereference is a runtime panic, and the compiler does not prevent it the way Rust's type system does.

A small type system. No sum types, no enums (you build them with constants and iota), and generics that cover common cases but not advanced type-level programming.

Ecosystem gaps. Libraries for web services, databases and cloud APIs are excellent. For GUIs, scientific computing and machine learning, Python, C++ or Julia have far more.

Go Compared with Other Languages

Choose Go when you want compiled performance and simple deployment without the learning curve of Rust or the ceremony of Java.

Is Go Worth Learning?

If you write backend services, command-line tools, or anything in the cloud infrastructure space, yes. Go is the language much of that ecosystem is written in, and reading its source is part of the job. The language is small, so the investment is modest: the core syntax takes days, and idiomatic concurrency and error handling take a few weeks of practice.

To start writing Go locally, install Go, then work through the hello world page, which explains every line of a first program.