Wat is Go en waarvoor is het ontworpen?

Question

Accepted Answer

**Go** (Golang) is een statically-typed, compiled taal gemaakt bij Google, ontworpen voor **eenvoud, snelle compilatie en ingebouwde concurrency**. De filosofie is klein en expliciet zijn — weinig functies, gemakkelijk te lezen, productief op schaal.

## Een klein Hello World

```go
package main

import "fmt"

func main() {
    fmt.Println("Hello, World")
}
// `go run main.go` to run, or `go build` to make a single native binary
```

## Kernkarakteristieken

```text
✓ Compiled to native code — fast execution, single static binary (easy deployment)
✓ Statically typed — type safety, errors caught at compile time
✓ FAST compilation — builds in seconds even for large projects
✓ Built-in concurrency — goroutines & channels as language primitives
✓ Garbage collected — automatic memory management
✓ Deliberately SIMPLE — small language spec, few keywords, one obvious way
✓ Great standard library + tooling (go fmt, go test, go mod built in)
```

## Het concurrency-model — Go's opvallendste feature

```go
go doWork()         // launch a goroutine — a lightweight concurrent task
ch := make(chan int) // a channel for communicating between goroutines
```

Go maakt concurrency een first-class, gemakkelijk te gebruiken functie met **goroutines** (extreem goedkope threads — je kunt er miljoenen draaien) en **channels** (voor veilige communicatie). Dit is een kernreden waarom Go wordt gekozen voor servers en netwerkgebaseerde systemen.

## De eenvoudsfilosofie

```text
Go deliberately OMITS features common elsewhere (no inheritance, no exceptions,
no generics until 1.18, minimal syntax) to keep code simple and uniform.
→ "Less is more": easy to read others' code, fast onboarding, consistent style.
```

## Waarvoor Go wordt gebruikt

```text
✓ Cloud infrastructure & DevOps — Docker, Kubernetes, Terraform are written in Go
✓ Backend APIs & microservices — fast, concurrent, easy to deploy
✓ CLI tools, network services, distributed systems
```

## Waarom het belangrijk is

Go's combinatie van eenvoud, snelle compilatie, native performance, gemakkelijke single-binary deployment, en vooral **first-class concurrency** (goroutines/channels) maakt het een topkeuze voor cloud infrastructure, backend services en DevOps tooling — veel van de moderne cloud stack (Docker, Kubernetes) is in Go geschreven.

De ontwerpfilosofie ervan begrijpen — doelbewuste eenvoud boven feature rijkdom, explicititeit boven magie, concurrency ingebouwd in de taal — verklaart waarom Go-code anders eruitziet en voelt dan andere talen en waarom het uitblinkt in schaalbare, netwerkgebaseerde systemen.

Deze basis vormt het kader voor alles wat anders over werken in Go gaat.