¿Qué es Go?

¿Qué es Go y por qué existe?

Go (también conocido como Golang) es un lenguaje de programación de código abierto creado por Google en 2007 y publicado oficialmente en 2009. Sus creadores fueron tres figuras legendarias del mundo de la computación: Robert Griesemer, Rob Pike y Ken Thompson — el mismo Ken Thompson que co-creó Unix y el lenguaje C. Esto ya dice mucho sobre las ambiciones del proyecto.

Go nació de una frustración concreta: en 2007, Google estaba compilando enormes bases de código en C++ que tardaban 45 minutos en compilar. Los ingenieros pasaban más tiempo esperando compilaciones que programando. Además, C++ tenía una complejidad creciente, Java requería demasiado boilerplate, y Python era demasiado lento para sistemas de alto rendimiento. La pregunta que se hicieron fue: ¿puede existir un lenguaje que sea tan rápido como C, tan fácil de leer como Python, y que tenga concurrencia incorporada desde el principio?

La respuesta fue Go.

Las características que definen a Go

1. Compilado y rápido

Go compila directamente a código máquina nativo, igual que C o Rust. No hay máquina virtual, no hay intérprete. El resultado es un binario ejecutable único que puedes distribuir sin instalar ningún runtime. A diferencia de C++, la compilación en Go es extremadamente rápida — proyectos grandes compilan en segundos, no en minutos.

# Compilar y ejecutar en un paso
go run main.go

# Compilar a un binario
go build -o mi-app main.go

# Compilar para otra plataforma (cross-compilation)
GOOS=linux GOARCH=amd64 go build -o mi-app-linux main.go

2. Tipado estático con inferencia

Go es de tipado estático: el compilador conoce el tipo de cada variable en tiempo de compilación. Esto elimina toda una clase de errores que solo aparecen en tiempo de ejecución en lenguajes dinámicos. Sin embargo, Go incluye inferencia de tipos, lo que significa que no tienes que escribir el tipo en cada declaración:

// Declaración explícita
var nombre string = "Go"

// Con inferencia (más común)
nombre := "Go"
version := 1.26     // float64 inferido
activo := true       // bool inferido

3. Concurrencia como ciudadano de primera clase

Esta es la característica más revolucionaria de Go. La concurrencia no es una biblioteca que añades después — está integrada en el lenguaje con goroutines y channels. Una goroutine es como un hilo de ejecución, pero extremadamente liviana: puedes tener millones de goroutines en un solo programa con pocos megabytes de memoria.

// Lanzar una goroutine es tan simple como escribir "go"
go func() {
    fmt.Println("Esto se ejecuta en paralelo")
}()

4. Gestión de memoria automática (GC)

Go tiene recolector de basura (garbage collector), pero está altamente optimizado para minimizar las pausas. A diferencia de Java, el GC de Go está diseñado para latencias de microsegundos, no milisegundos. Obtienes la seguridad de memoria sin gestión manual y sin las pausas largas de otros lenguajes GC.

5. Interfaz explícita e implícita

En Go, los tipos implementan interfaces automáticamente si tienen los métodos requeridos. No necesitas declarar implements InterfaceName como en Java o C#. Esto hace que el código sea más flexible y desacoplado.

6. Biblioteca estándar excepcional

La biblioteca estándar de Go es una de las más completas que existe. Viene con soporte nativo para HTTP, JSON, criptografía, compresión, bases de datos SQL, pruebas, y mucho más. Puedes construir un servidor web completo sin instalar ninguna dependencia externa.

Go 1.26: novedades destacadas

Go 1.26 (lanzado en 2026) continúa la tradición de mejoras incrementales y estabilidad:

• Iteradores en la biblioteca estándar: iter package con Seq y Seq2 para iteración genérica.
• Mejoras en range over integers: sintaxis for i := range 10 más fluida (introducida en Go 1.22).
• net/http con ServeMux mejorado: pattern matching con métodos HTTP (GET /users/{id}), introducido en Go 1.22.
• Mejoras en el compilador: compilaciones más rápidas, mejor code inlining, menor tamaño de binarios.
• Generics maduros: desde Go 1.18, los genéricos han sido refinados continuamente.

Dónde se usa Go en el mundo real

Go no es un lenguaje académico — es el lenguaje que impulsa parte de la infraestructura crítica de internet:

Docker: La herramienta de contenedores más popular del mundo está escrita completamente en Go. Sin Go, la era de los contenedores habría sido más difícil.

Kubernetes: El orquestador de contenedores estándar de la industria, también escrito en Go. Maneja millones de contenedores en producción.

Terraform: La herramienta de infraestructura como código de HashiCorp, completamente en Go.

Prometheus y Grafana: El stack de monitorización más popular en el mundo cloud-native.

Dropbox: Migraron partes críticas de su sistema de Python a Go, logrando mejoras de rendimiento masivas.

Uber: Usa Go extensivamente para sus microservicios de alta concurrencia.

Cloudflare: Gran parte de su edge network y herramientas internas están en Go.

Instalando Go 1.26

En macOS

# Con Homebrew
brew install go

# Verificar instalación
go version
# go version go1.26.0 darwin/arm64

En Linux

# Descargar el archivo tar
wget https://go.dev/dl/go1.26.0.linux-amd64.tar.gz

# Extraer e instalar
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.26.0.linux-amd64.tar.gz

# Agregar al PATH en ~/.bashrc o ~/.zshrc
export PATH=$PATH:/usr/local/go/bin

# Verificar
go version

En Windows

Descarga el instalador .msi desde go.dev/dl y sigue las instrucciones. El instalador configura automáticamente el PATH.

Tu primer programa en Go

Crea un directorio para tu proyecto y un archivo main.go:

mkdir hola-go
cd hola-go

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Println("¡Hola, Go 1.26!")
    fmt.Printf("Sistema operativo: %s\n", runtime.GOOS)
    fmt.Printf("Arquitectura: %s\n", runtime.GOARCH)
    fmt.Printf("Versión de Go: %s\n", runtime.Version())
    fmt.Printf("CPUs disponibles: %d\n", runtime.NumCPU())
}

Para ejecutarlo:

go run main.go
# ¡Hola, Go 1.26!
# Sistema operativo: darwin
# Arquitectura: arm64
# Versión de Go: go1.26.0
# CPUs disponibles: 8

Inicializar un módulo Go

En proyectos reales, siempre inicializas un módulo Go:

go mod init github.com/tuusuario/mi-proyecto

Esto crea el archivo go.mod que gestiona las dependencias de tu proyecto. Es el equivalente al package.json de Node.js o al pyproject.toml de Python.

La filosofía de Go: menos es más

Go deliberadamente excluye características que tienen otros lenguajes: no hay herencia de clases, no hay sobrecarga de operadores, no hay excepciones tradicionales (usa valores de error explícitos), no hay genéricos complejos al estilo C++. Esta "austeridad" es intencional.

La filosofía de Go es que el código debe ser obvio. Cuando lees código Go, no hay magia, no hay implicit conversions inesperadas, no hay comportamientos sorpresivos. Lo que ves es lo que hace. Esto hace que el código sea extremadamente fácil de mantener, auditar y escalar en equipos grandes.

Rob Pike lo resume así: "Clarity is better than cleverness." (La claridad es mejor que la astucia.)

En la próxima lección exploraremos el sistema de tipos de Go en profundidad: variables, constantes, tipos básicos y la forma idiomática de declarar y convertir tipos.