O que é Go e para o que foi projetado?

Question

Accepted Answer

**Go** (Golang) é uma linguagem statically-typed, compilada criada no Google, projetada para **simplicidade, compilação rápida e concorrência integrada**. Sua filosofia é ser pequena e explícita — poucos recursos, fácil de ler, produtiva em grande escala.

## Um pequeno 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
```

## Características principais

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

## O modelo de concorrência — o destaque do Go

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

Go torna a concorrência uma funcionalidade first-class, fácil de usar com **goroutines** (threads extremamente baratas — você pode executar milhões) e **channels** (para comunicação segura). Esta é uma razão principal pela qual Go é escolhido para servidores e sistemas em rede.

## A filosofia de simplicidade

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

## Para o que Go é usado

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

## Por que isso importa

A combinação de simplicidade do Go, compilação rápida, performance nativa, fácil implantação em single-binary e, especialmente, **first-class concurrency** (goroutines/channels) o torna uma escolha top para infraestrutura em nuvem, serviços backend e ferramentas DevOps — grande parte da stack de nuvem moderna (Docker, Kubernetes) é escrita em Go.

Compreender sua filosofia de design — simplicidade deliberada em vez de riqueza de recursos, explicititude em vez de magia, concorrência integrada na linguagem — explica por que o código Go parece e se sente diferente de outras linguagens e por que se destaca em sistemas escaláveis e em rede.

Este fundamento contextualiza tudo mais sobre trabalhar com Go.