Scrolls
6 min read
On this page

Why Go

Go was born at Google in 2007, announced in 2009, and reached 1.0 in 2012. It was designed by Rob Pike, Ken Thompson, and Robert Griesemer -- people who had been writing systems software for decades and were tired of the complexity that had accumulated in languages like C++ and Java. Their answer was radical simplicity: strip everything down to what you actually need, and make that work extremely well.

The Philosophy: Simplicity Over Cleverness

Go's design philosophy can be summarized in one sentence: clear is better than clever. The language deliberately omits features that other languages consider essential -- no inheritance, no operator overloading, no function overloading, no implicit type conversions, no ternary operator. Every omission was intentional.

This philosophy extends to the toolchain. There is one formatter (gofmt), one testing framework (built-in), one build system (the go command), and one way to manage dependencies (go mod). You do not pick between tabs and spaces. You do not configure your linter to match your team's style. The decisions are made for you, and everyone writes Go that looks the same.

// Go code reads like pseudocode. No ceremony.
package main

import "fmt"

func main() {
    names := []string{"Alice", "Bob", "Charlie"}
    for _, name := range names {
        fmt.Printf("Hello, %s\n", name)
    }
}

What Makes Go Different

Fast Compilation

Go compiles to native binaries in seconds, not minutes. A 100,000-line Go project typically compiles in under 10 seconds. This was a primary design goal -- the creators were tired of waiting for C++ builds at Google.

Static Types Without the Boilerplate

Go is statically typed, but the := operator and type inference keep code concise. You get compile-time safety without writing type annotations on every line.

Garbage Collected

Go has a garbage collector with low, predictable latency. You do not manage memory manually, but you also do not pay the heavy GC pause costs that plagued early Java. Modern Go GC pauses are typically under a millisecond.

Built-in Concurrency

Goroutines and channels are first-class language features. Spinning up thousands of concurrent tasks is trivial and costs very little memory compared to OS threads.

func fetchAll(urls []string) []string {
    results := make(chan string, len(urls))

    for _, url := range urls {
        go func(u string) {
            resp, err := http.Get(u)
            if err != nil {
                results <- fmt.Sprintf("error: %s", err)
                return
            }
            defer resp.Body.Close()
            results <- fmt.Sprintf("%s: %d", u, resp.StatusCode)
        }(url)
    }

    var out []string
    for range urls {
        out = append(out, <-results)
    }
    return out
}

Single Binary Deployment

go build produces a single statically-linked binary. No runtime to install, no dependency hell, no Docker required (though Docker works great too). Copy the binary to the server, run it.

Where Go Shines

APIs & Microservices

Go's standard library includes a production-quality HTTP server. The net/http package can handle tens of thousands of concurrent connections out of the box. Most Go web services need nothing beyond the standard library and a router.

func main() {
    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        fmt.Fprintln(w, `{"status": "ok"}`)
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}

CLI Tools

Go's fast startup time, single binary output, and cross-compilation make it ideal for command-line tools. Docker, Kubernetes, Terraform, Hugo, and gh (GitHub CLI) are all written in Go.

DevOps & Infrastructure Tooling

The combination of static binaries, cross-compilation, and excellent networking makes Go the dominant language for infrastructure. If you are building something that runs on servers, talks to APIs, or manages cloud resources, Go is a strong default choice.

Network Services

Anything that handles many concurrent connections -- proxies, load balancers, message brokers -- plays to Go's strengths. Goroutines make the "one connection per goroutine" model practical.

Where Go Does Not Shine

GUI Applications

Go has no mature, widely-adopted GUI framework. If you need a desktop app with native look and feel, look at Swift (macOS), C# (Windows), or Kotlin (cross-platform with Compose).

Machine Learning

The ML ecosystem lives in Python. TensorFlow and PyTorch have Go bindings, but they are thin wrappers at best. If you are training models, use Python. If you are serving a trained model behind an API, Go is fine for the serving layer.

Highly Dynamic Applications

If your problem requires heavy metaprogramming, runtime code generation, or duck typing, Go will fight you. Python or Ruby would be a better fit.

Go vs Rust vs Python

Choosing between these three comes up constantly, so here is a practical framework.

Choose Go When

  • You are building a web service, API, or microservice
  • You need good concurrency without complexity
  • You want fast compile times and simple deployment
  • Your team has mixed experience levels and you want a low learning curve
  • You are building infrastructure or DevOps tooling

Choose Rust When

  • You need zero-cost abstractions and maximum performance
  • You are writing systems software (OS components, embedded, game engines)
  • Memory safety without garbage collection is critical
  • You are willing to invest in a steep learning curve for long-term payoff

Choose Python When

  • You are doing data science, ML, or scientific computing
  • You are writing scripts or automation
  • You need the fastest possible prototyping speed
  • Library ecosystem matters more than runtime performance
Dimension          Go          Rust        Python
------------------------------------------------------
Compile speed      Fast        Slow        N/A (interpreted)
Runtime speed      Fast        Fastest     Slow
Learning curve     Low         High        Lowest
Concurrency        Excellent   Excellent   Limited (GIL)
Memory safety      GC          Ownership   GC
Deployment         Single bin  Single bin  Interpreter + deps
Ecosystem          Growing     Growing     Massive

A Note on the Comparison

These are guidelines, not rules. Plenty of teams use Python for web services (Django, FastAPI), Rust for CLIs, and Go for one-off scripts. The question is not which language can do the job -- they all can -- but which one makes the job easiest given your constraints.

If you are choosing a language for a new backend service and your team does not have strong opinions, Go is a safe default. It compiles fast, deploys easily, scales well, and new team members will be productive quickly.

The "Boring" Language That Gets Things Done

Go is often called "boring" and its fans consider that a compliment. Boring means predictable. Boring means a new team member can read the codebase on day one. Boring means your 3am production incident involves code you can understand while half-asleep.

Go does not have the expressiveness of Rust, the ecosystem of Python, or the type system of Haskell. What it has is a relentless focus on getting real work done with minimal friction. You write straightforward code, compile it instantly, deploy a single binary, and move on to the next problem.

// This is what most Go code looks like.
// No magic, no frameworks, just clear logic.
func processOrder(ctx context.Context, order Order) error {
    if err := validateOrder(order); err != nil {
        return fmt.Errorf("invalid order %s: %w", order.ID, err)
    }

    charge, err := billing.Charge(ctx, order.CustomerID, order.Total)
    if err != nil {
        return fmt.Errorf("charging customer %s: %w", order.CustomerID, err)
    }

    if err := inventory.Reserve(ctx, order.Items); err != nil {
        billing.Refund(ctx, charge.ID)
        return fmt.Errorf("reserving inventory: %w", err)
    }

    return notifications.SendConfirmation(ctx, order)
}

Common Pitfalls

  • Expecting Go to be like your previous language. Go intentionally lacks many features. Fighting the language instead of adapting to its idioms leads to frustration.
  • Reaching for frameworks immediately. Go's standard library is extensive. Before pulling in a web framework, try net/http with a lightweight router.
  • Dismissing Go for lacking generics. Generics arrived in Go 1.18 (March 2022). Most code does not need them, but they are there when you do.
  • Assuming garbage collected means slow. Go's GC is highly optimized for low-latency workloads. Benchmark before assuming performance will be a problem.
  • Ignoring the standard library. Packages like encoding/json, net/http, context, sync, and testing cover a huge amount of ground. Learn them before reaching for third-party alternatives.

Key Takeaways

  • Go was designed for simplicity, fast compilation, and practical software engineering at scale.
  • Its sweet spots are APIs, microservices, CLI tools, and infrastructure software.
  • Go produces single static binaries with no runtime dependencies.
  • Goroutines and channels make concurrent programming straightforward.
  • Go is not the right choice for GUIs, ML training, or highly dynamic applications.
  • Choose Go when you want a low learning curve, fast builds, and maintainable code across a team.
  • The language is deliberately "boring" -- and that is its greatest strength.