La historia del lenguaje Go

Go nació en una pizarra de Google, en 21 de septiembre de 2007, porque C++ tardaba demasiado en compilar. En noviembre de 2025 el lenguaje cumplió 16 años de código abierto. En septiembre de 2026 la serie estable es la 1.27.1. Docker, Kubernetes, Terraform, todo go lo que instalas en Linux, desciende de esa reunión de tres personas.

Por qué un lenguaje nuevo

Google a finales de los años 2000: servidores en C++ y Java, builds de tres cuartos de hora,concurrencia a pulso, dependencias que no cerraban. Rob Pike describió el encargo en Go at Google: Language Design in the Service of Software Engineering: no era moda lingüística, era ingeniería de software a escala. Compilar rápido, tipado estático, hablar con la red sin un framework de hilos, y un único binario.

El FAQ oficial cierra el origen: Robert Griesemer, Rob Pike y Ken Thompson empezaron a esbozar metas en la pizarra el 21 de septiembre de 2007. En pocos días se convertía en plan. En enero de 2008 Ken ya tenía un compilador que emitía C. En mayo, Ian Lance Taylor, por cuenta propia, empezaba un frontend GCC. Russ Cox entró a finales de 2008 y sacó el prototipo del laboratorio.

Unix, Plan 9, CSP

Los tres currículos explican el gusto de la lengua. Ken Thompson co-creó Unix y el lenguaje B. Pike vino de Plan 9 y de Inferno, co-inventó UTF-8 con Thompson, y pasó décadas en lenguajes concurrentes — Newsqueak, Alef, Limbo — todos en la línea del CSP de Tony Hoare (1978). Griesemer vino de compilador: HotSpot de Java, V8. Go hereda el minimalismo Unix, los canales del CSP y la testarudez de un runtime que compila en segundos.

El nombre surgió en el correo de Pike del 25 de septiembre de 2007: “go”. Corto, verbo, dominio fácil. “Golang” es el apodo de búsqueda — el golang.org existía porque go.org no estaba libre. El sitio canónico hoy es go.dev.

La idea central: goroutines y canales

Antes de seguir la cronología, conviene ver qué hace la lengua de forma diferente — porque no es la sintaxis, es el modelo de concurrencia.

Una goroutine no es un hilo del sistema. Es una función que el runtime de Go planifica sobre un puñado de hilos reales, con pila inicial de pocos kilobytes que crece bajo demanda. Por eso lanzas diez mil de ellas sin pensarlo dos veces — lo que con pthread sería irresponsable:

go processar(pedido)   // é isso. Não há pool, não há executor, não há Future.

La comunicación entre ellas es la otra cara del diseño y viene directamente del CSP de Tony Hoare: en lugar de compartir memoria y protegerla con mutex, pasas el dato por un canal. El lema de la comunidad lo resume: “no te comuniques compartiendo memoria; comparte memoria comunicando”.

resultados := make(chan string)

for _, host := range hosts {
    go func(h string) {
        resultados <- checar(h)      // envia pelo canal
    }(host)
}

for range hosts {
    fmt.Println(<-resultados)        // recebe, bloqueando até chegar
}

Y el select es el epoll del lenguaje: espera en varios canales a la vez, incluyendo uno de timeout.

select {
case r := <-resultados:
    fmt.Println(r)
case <-time.After(2 * time.Second):
    fmt.Println("estourou o tempo")
}

Es ese conjunto — goroutine barata, canal, select, y un binario estático sin VM — lo que explica por qué prácticamente toda herramienta de infraestructura de la última década eligió Go. No es el lenguaje más expresivo; es el que todo un equipo lee igual el lunes.

10 de noviembre de 2009

Go se convirtió en proyecto público ese día. La mascota — el gopher azul de ojos enormes — vino con el lanzamiento. Renée French, que ya había dibujado al conejo del Plan 9 (y está casada con Pike), adaptó un gopher de una camiseta de la WFMU. Se llamó Gordon durante un tiempo; desde 2010 es simplemente “the Go gopher”. Las GopherCon de todo el mundo surgieron de ahí.

Todavía no era Go 1. Había dos compiladores: el gc (la línea Plan 9, 6g/8g) y el gccgo de Taylor. La biblioteca estándar copiaba el gusto del Plan 9 — el paquete fmt incluido el nombre.

Go 1.0 y la promesa

28 de marzo de 2012: Go 1.0. El contrato que aseguró la adopción: un programa escrito para Go 1 sigue compilando en cualquier 1.x. No habrá un Go 2 que rompa el mundo. Las empresas apostaron. El ritmo pasó a ser semestral (febrero y agosto, con retraso de días, no de años).

Hitos que importan en Linux:

• 1.5 (agosto de 2015): el compilador pasa a estar escrito en Go (self-hosting); GC concurrente.
• 1.11 (agosto de 2018): módulos, aún experimentales. Adiós a GOPATH como prisión.
• 1.13 (2019): módulos oficiales; errors.Is / %w.
• 1.16 (2021): //go:embed, módulos por defecto.
• 1.18 (15 de marzo de 2022): genéricos — parámetros de tipo. La solicitud más antigua del FAQ.
• 1.21 (2023): GOTOOLCHAIN baja por sí solo la versión que el go.mod pide; min/max; paquetes slices e maps.
• 1.22 (2024): variable de bucle por iteración (fin del clásico bug del for); enrutamiento mejorado en net/http.
• 1.25 (agosto de 2025): el recolector Green Tea aparece como experimento (10–% menor coste de recolección en muchos servicios).
• 1.26 (10 de febrero de 2026): el Green Tea se convierte en el recolector por defecto; modernizers no go fix.
• 1.27 (agosto de 2026; 1.27.1 el 28 de agosto): métodos genéricos — propuesta de Griesemer aprobada en marzo de 2026 —, el nuevo motor de JSON (encoding/json/v2) y criptografía poscuántica en la biblioteca estándar. También se añade la opción de desactivar Green Tea.

La infra de internet

Docker (2013) es Go. Kubernetes también. Terraform, Prometheus, el cliente de Git, la mitad de las CLI de nube. Un binario estático, sin VM, sin node_modules de 400 MB — eso vendió la lengua a quien opera Linux. En el ranking TIOBE de 2026 Go oscila cerca del puesto 12; en GitHub y en los repositorios de infraestructura, el peso es otro.

La competencia es la carta: go func(), canales, select. No es Erlang, no es Java con pool de hilos. Es CSP que cabe en un syslog.

Lo que Go rechazó

Sin herencia de tipos, sin excepciones al estilo throw, sin macros, sin sobrecarga de métodos. Los genéricos llegaron tarde y estrechos. Los métodos genéricos solo en 2026. La FAQ aún dice: si echas de menos X, quizá Y ya lo cubra. Pike, en 2023 (What We Got Right, What We Got Wrong), admite lo que pesó: el gopher acertó; el GOPATH tardó en morir; la comunicación del “porqué” llegó en 2013, cuatro años después del lanzamiento.

Las quejas que quedaron, y que valen para quien va a decidir el stack:

• if err != nil en cada línea. La ausencia de excepciones deja el error explícito — y deja también un tercio del archivo repitiendo la misma verificación. Es el debate más antiguo de la comunidad, y ninguna propuesta de azúcar sintáctico ha pasado hasta hoy.
• nil sigue existiendo. Puntero nulo, mapa nulo, interfaz nula que no es nula: Go no siguió el camino del Option que el Rust tomó, y el panic por desreferencia sigue siendo el error más común en producción.
• Recolector de basura es recolector de basura. Green Tea redujo bastante el coste, pero quien necesita latencia predecible en el percentil 99,9 aún choca con él — y es justo ahí donde Rust entra en la conversación.
• La gobernanza corresponde a Google. Abierta, con propuestas públicas y revisión a la vista, pero la última palabra la tiene el equipo de la empresa. Es diferente de la fundación independiente que montaron Rust y Kubernetes.

Nada de esto es casualidad. Go fue diseñado para que equipos grandes escriban servicios de red con poca ceremonia, no para ser el lenguaje más poderoso de la sala. Las renuncias son el producto.

En Linux, hoy

La serie estable en septiembre de 2026 es la 1.27.1, de 28 de agosto. El camino recomendado es el tarball de go.dev, porque el paquete de la distro suele quedarse una o dos versiones atrás:

# descobre a versão atual sem abrir o navegador
VER=$(curl -fsSL 'https://go.dev/VERSION?m=text' | head -n1)
echo "$VER"

# instala no lugar canônico
curl -fLO "https://go.dev/dl/${VER}.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "${VER}.linux-amd64.tar.gz"

# PATH permanente
echo 'export PATH=$PATH:/usr/local/go/bin' | sudo tee /etc/profile.d/go.sh
source /etc/profile.d/go.sh
go version

Para mantener varias versiones en paralelo — útil cuando un proyecto sigue atascado en una antigua — el propio Go lo resuelve, sin gestor externo:

go install golang.org/dl/go1.26@latest
go1.26 download
go1.26 version

Desde la 1.21, por cierto, el GOTOOLCHAIN lo hace solo: si el go.mod pide una versión que no tienes, el toolchain adecuado se descarga en el momento del build.

El howto completo está en Instalando Golang en Linux; el hermano de 2017, con el 1.8.3, quedó en Instalando Golang 1.8.3 en Linux.

Línea de tiempo

• 21 de septiembre de 2007 — Griesemer, Pike y Thompson garabatean los objetivos en la pizarra blanca de Google.
• 25 de septiembre de 2007 — en el correo electrónico de Pike, el lenguaje recibe nombre: go.
• Enero de 2008 — Ken Thompson tiene un compilador que genera C.
• Mayo de 2008 — Ian Lance Taylor empieza, por su cuenta, el frontend de GCC.
• Fin de 2008 — Russ Cox entra y saca el prototipo del laboratorio.
• 10 de noviembre de 2009 — el proyecto se abre; el gopher de Renée French viene incluido.
• 28 de marzo de 2012 — Go 1.0 y la promesa de compatibilidad que sostuvo la adopción.
• 2013 — Docker nace en Go y lleva el lenguaje a la infraestructura.
• 2014 — Kubernetes también; el cargo de Go, el go get, todavía dependía de GOPATH.
• Agosto de 2015 — la 1.5 se autoaloja (compilador escrito en Go) y获得 GC concurrente.
• Agosto de 2018 — la 1.11 trae los módulos, todavía experimentales; el GOPATH comienza a morir.
• 2019 — la 1.13 convierte los módulos en oficiales.
• 2021 — la 1.16 aporta //go:embed y módulos por defecto.
• 15 de marzo de 2022 — la 1.18 por fin incorpora generics.
• 2023 — la 1.21 trae GOTOOLCHAIN, min/max, slices e maps.
• 2024 — a 1.22 corrige el bug clásico de la variable de bucle.
• Agosto de 2025 — a 1.25 incorpora el recolector Green Tea como experimento.
• 10 de febrero de 2026 — a 1.26 convierte Green Tea en el estándar.
• Agosto de 2026 — a 1.27 ofrece métodos genéricos, JSON v2 y criptografía poscuántica.

Cierre

Tres personas, un tablero, una lengua que rechazó el peso y ganó la nube. Dieciséis años después del open source, el contrato de la 1.x sigue vigente y el gopher sigue siendo azul. La apuesta contraria, de la misma década, está en La historia del lenguaje Rust; el mapa completo, en Las 7 principales lenguajes. Y lo que Go construyó está en A história do Docker e A história do Kubernetes. Fuentes: FAQ, La dulce 16 de Go, Pike, diez años, wiki y notas de la versión en go.dev/doc/devel/release.

Gopher basado en la mascota oficial de Renee French, licencia CC BY 3.0.