Czym jest Go i do czego został zaprojektowany?

Question

Accepted Answer

**Go** (Golang) to statically-typed, kompilowany język stworzony w Google, zaprojektowany dla **prostoty, szybkiej kompilacji i wbudowanej concurrency**. Jego filozofią jest bycie małym i jawnym — mało funkcji, łatwe do czytania, wydajne na dużą skalę.

## Mały 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
```

## Kluczowe cechy

```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)
```

## Model concurrency — wyróżniająca cecha Go

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

Go sprawia, że concurrency jest funkcją first-class, łatwo używaną z **goroutines** (niezwykle tanie wątki — możesz uruchomić miliony) i **channels** (do bezpiecznej komunikacji). To jest główna przyczyna, dla której Go jest wybierane do serwerów i systemów sieciowych.

## Filozofia prostoty

```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.
```

## Do czego Go się używa

```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
```

## Dlaczego to ważne

Kombinacja prostoty Go, szybkiej kompilacji, natywnej wydajności, łatwego wdrażania w postaci single-binary oraz zwłaszcza **first-class concurrency** (goroutines/channels) czyni go najlepszym wyborem do infrastruktury chmurowej, usług backend i narzędzi DevOps — większość nowoczesnego stosu chmurowego (Docker, Kubernetes) jest napisana w Go.

Zrozumienie jego filozofii projektowania — celowa prostota zamiast bogatego zestawu funkcji, jawność zamiast magii, concurrency wbudowana w język — wyjaśnia, dlaczego kod Go wygląda i czuje się inaczej niż w innych językach oraz dlaczego doskonale sprawdza się w skalowalnych, sieciowych systemach.

Ta podstawa stanowi ramy dla wszystkiego innego dotyczącego pracy w Go.