---
title: "01 — Meeting Go — A Language Built for Boring, Scalable Backends"
uid: meeting-go
tags: ["golang", "installation", "roadmap:golang", "backend", "fundamentals", "go-command"]
excerpt: "Go is a deliberately small, statically typed, compiled language built so large teams can write boring, concurrent backend services that compile fast and deploy as one binary."
date: 2026-08-13T03:28:13+0000
source: https://www.aveshina.my.id/en/blog/meeting-go
---

"Just another backend option" was how I filed Go, and the description undersold the design philosophy. The idea that everything else hangs off: **Go is a deliberately small, statically typed, compiled language built so large teams can write concurrent backend services that compile fast, ship as a single binary, and stay readable years later.** [1] It is not trying to be expressive or clever. It is trying to be boring at scale, and that is the whole pitch.

The framing that landed for me is the _constraints_, not the features. Go was designed at Google for a specific pain: huge codebases, thousands of engineers, slow C++/Java builds, and a language surface so big that no two engineers wrote the same idiom. The response was a language with one way to format code, one looping construct, one way to do dependencies, and concurrency baked into the runtime [2]. Every "missing" feature — no inheritance, no generics for the first decade, no exceptions — is a deliberate cut to keep large teams converging on the same code.

## Why Go earns its niche

The honest answer to "why use Go" is that it is exceptional at a specific shape of problem, not at everything [3]:

- **Single binary deployment.** go build produces one statically linked executable. No runtime to install on the server, no node_modules, no JVM. Copy the file, run it. This alone is why ops teams love it.
- **Built-in concurrency.** Goroutines and channels are part of the language, not a library. Spinning up 100,000 concurrent workers is a one-liner, which is why Go dominates network services.
- **Fast compilation.** Large Go projects compile in seconds, not minutes. The feedback loop stays tight even as the codebase grows.
- **Comprehensive standard library.** net/http, encoding/json, crypto, testing — a production web server often needs zero external dependencies [4].
- **Simple surface.** The language spec is small enough to hold in your head. New engineers become productive in days, not weeks.

Where it does _not_ shine: GUIs, data science, browser code, anything needing deep metaprogramming. Go is a backend, CLI, and systems language. Knowing that boundary is the first real thing I learned about it.

## A short history, because the cuts make sense in context

Go was created at Google in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson — three engineers with deep systems backgrounds (Unix, Plan 9, C) [2]. They were frustrated that building a large Google service meant waiting 45 minutes for a C++ build and reading code no two people wrote the same way. Go was announced publicly in 2009, hit version 1.0 in 2012 with a promise of backward compatibility that has held ever since, added modules for dependency management in Go 1.11 (2018), and finally added generics in Go 1.18 (2022) [1].

That history explains the language's personality. The 1.0 compatibility guarantee — code written in 2012 still compiles unchanged — is why libraries and tooling trust the ecosystem. The late arrival of generics is why so much idiomatic Go still reads as if generics do not exist. The Unix pedigree is why the standard library feels like it was designed by people who build operating systems.

## Setting up the environment

Go's setup is deliberately boring. Download the installer from go.dev, run it, and the binary lands on PATH automatically [5]. There is no version manager dance like nvm or pyenv unless you want one — most teams just install the latest stable and move on. Two checks confirm it worked:

```
go version
```

```
go version go1.22.0 darwin/arm64
```

For an editor, VS Code with the official Go extension, or GoLand, give you formatting-on-save, autocomplete, and inline test running [5]. The tooling is centralized — gopls, the language server, handles every editor the same way, so the experience is consistent regardless of what you write in.

## Hello World — the whole structure in one file

The traditional first program teaches you the four parts every Go program has:

```
package main

import "fmt"

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

Four things to notice, because they never change [1][6]:

- package main declares this as an executable. Only package main with a func main() produces a binary; every other package is a library.
- import "fmt" brings in the formatting package from the standard library. Imports are explicit; unused imports are a compile error, not a warning.
- func main() is the entry point. No arguments, no return — the runtime calls it.
- fmt.Println is the standard output helper. Capital P means Println is exported (visible outside fmt); lowercase names are private to their package.

That capitalization rule — exported means capital, private means lowercase — is the single most important convention in Go. There are no public/private keywords. The first letter of an identifier decides its visibility.

## The go command — one tool for everything

Go does not have a separate build tool, test runner, formatter, and linter from competing vendors. The single go command handles the whole workflow [7]:

- go run main.go — compile and execute in one step, no binary left behind. For quick iteration.
- go build — compile into a standalone executable in the current directory.
- go test — discover and run every Test* function across the module.
- go fmt — rewrite your code to the one canonical format. Non-configurable, on purpose.
- go mod init / go mod tidy — manage dependencies.
- go vet — static checks for suspicious constructs.

The unification matters more than it sounds. There is no Makefile vs Bazel vs npm scripts debate — go is the build system, and a new contributor runs go build && go test on day one without reading any docs.

## How I use this

The practical payoff of the framing is a decision check. When I reach for a backend tool, I ask whether the problem is a network service, a CLI, or a distributed system that benefits from cheap concurrency and a single deployable. If yes, Go's tradeoffs pay off. If the problem is a CRUD web app with heavy HTML templating, a data pipeline, or anything browser-bound, I reach elsewhere — Go will work, but its strengths are wasted. The compatibility promise and single-binary deployment are the parts I keep regardless: even outside Go, I now value a tool whose build output is one file I can scp to a box and run.

## References

[1] The Go Authors, "Getting Started," Go Documentation, 2024. [Online]. Available: [https://go.dev/doc/tutorial/getting-started](https://go.dev/doc/tutorial/getting-started)

[2] The Go Authors, "Go Documentation," go.dev, 2024. [Online]. Available: [https://go.dev/doc/](https://go.dev/doc/)

[3] The Go Authors, "Why Go," Go Solutions, 2024. [Online]. Available: [https://go.dev/solutions/](https://go.dev/solutions/)

[4] Aarav Joshi, "Building Robust APIs with Go's Standard Library," dev.to, 2024. [Online]. Available: [https://dev.to/aaravjoshi/building-robust-apis-with-gos-standard-library-a-comprehensive-guide-3036](https://dev.to/aaravjoshi/building-robust-apis-with-gos-standard-library-a-comprehensive-guide-3036)

[5] The Go Authors, "Installation," Go Documentation, 2024. [Online]. Available: [https://go.dev/doc/install](https://go.dev/doc/install)

[6] M. Munyaka, "Getting Started with Go and the Web," dev.to, 2024. [Online]. Available: [https://dev.to/markmunyaka/getting-started-with-go-and-the-web-hello-world-nal](https://dev.to/markmunyaka/getting-started-with-go-and-the-web-hello-world-nal)

[7] The Go Authors, "Command Documentation," Go Documentation, 2024. [Online]. Available: [https://go.dev/doc/cmd](https://go.dev/doc/cmd)

```quiz
Q: What does `go build` produce?
- A directory of bytecode run by a Go runtime you must install separately
- A single statically linked native executable with no external runtime needed
correct: 1
explain: Go compiles to a standalone binary. All dependencies are linked in, so the target machine needs no Go installation — just copy and run.

Q: In Go, what determines whether an identifier (function, type, field) is exported from its package?
- A `public` or `private` keyword before the declaration
- The first letter of the identifier — capital means exported, lowercase means private
correct: 1
explain: Go has no access keywords. A name starting with an uppercase letter is exported; lowercase is unexported (private to the package).

Q: Which `package` declaration produces an executable binary?
- package main (with a func main())
- package app
- package lib
correct: 0
explain: Only `package main` containing a `func main()` is compiled into an executable. Any other package name compiles to a library.

Q: Why does Go ship with a single canonical formatter (`go fmt`) that is non-configurable?
- Because the maintainers never got around to adding options
- To eliminate formatting debates across large teams so all Go code reads the same way
correct: 1
explain: One canonical style is a deliberate cut to keep large codebases uniform. There is no configuration precisely so no team can diverge.

Q: Go's built-in concurrency primitive is the goroutine. Compared to OS threads, goroutines are…
- heavier, with megabyte stacks managed by the kernel
- lightweight, with small growable stacks managed by the Go runtime, so you can run hundreds of thousands
correct: 1
explain: Goroutines are multiplexed onto a small number of OS threads by the runtime, with tiny initial stacks that grow as needed. That is what makes massive concurrency cheap in Go.
```