Go (Golang) — Intermedio

Dirigido a desarrolladores que ya conocen la sintaxis y los fundamentos de Go y quieren consolidar un estilo de programación idiomático y profesional. A lo largo de las 8 horas del curso se trabaja la organización interna de paquetes, el modelado de contratos mediante interfaces implícitas, la gestión robusta de errores con wrapping contextual, la introducción a la concurrencia con goroutines y channels, la elección razonada de estructuras de datos, el acceso a bases de datos relacionales desde la biblioteca estándar, y la escritura de suites de tests table-driven; al finalizar, el participante será capaz de entregar un módulo Go bien estructurado, concurrente, testeado y listo para integrarse en un entorno de producción.

1. Explicar cómo las convenciones de nombres, visibilidad y separación de responsabilidades determinan la calidad de un paquete Go (conceptual).
2. Distinguir el modelo de interfaces implícitas de Go frente a jerarquías de tipos explícitas y argumentar su elección según el contexto de diseño (conceptual).
3. Seleccionar la estructura de datos —slice, map u otras— más adecuada para un problema dado, justificando el cambio en términos de semántica y legibilidad (conceptual-procedimental).
4. Aplicar los patrones idiomáticos de manejo de errores (errors.Is, errors.As, wrapping con %w) para diseñar módulos que preserven el contexto de fallo sin suprimir información (procedimental).
5. Implementar concurrencia básica con goroutines y channels, verificando la ausencia de race conditions mediante go race (procedimental).
6. Construir suites de tests table-driven que cubran rutas felices y de error para funciones con lógica de negocio no trivial (procedimental).
7. Integrar acceso a una base de datos relacional gestionando correctamente el ciclo de vida de la conexión y sus errores (procedimental).
8. Depurar un programa Go con comportamiento incorrecto utilizando go test -v, logging estructurado o dlv, identificando y corrigiendo la causa raíz, y combinando así las competencias del curso en un flujo de trabajo completo (integrador).

Bloque 1 — Diseño de paquetes e interfaces El curso abre con los principios que guían la organización interna de un paquete Go: convenciones de nombres exportados e internos, separación de responsabilidades y las decisiones de visibilidad que marcan la API pública. Sobre esa base se aborda el sistema de interfaces implícitas del lenguaje, contrastándolo con las jerarquías de herencia explícita habituales en otros lenguajes; se analizan casos reales en los que la composición de interfaces pequeñas resulta más mantenible y casos en que un tipo concreto es suficiente.

Bloque 2 — Estructuras de datos y manejo de errores Este bloque profundiza en la elección razonada entre slices, maps y otras estructuras de la biblioteca estándar, revisando las implicaciones de semántica de valor frente a referencia y el coste de las operaciones más comunes. A continuación se trabaja el manejo de errores idiomático: se explora el wrapping con %w, la inspección con errors.Is y errors.As, y los patrones para propagar contexto de fallo sin ocultar la causa original, prestando especial atención a los anti-patrones más frecuentes en código intermedio.

Bloque 3 — Concurrencia con goroutines y channels Se introduce el modelo de concurrencia de Go desde la perspectiva práctica: ciclo de vida de una goroutine, sincronización mediante channels con y sin buffer, y los patrones fan-out/fan-in básicos. El sub-bloque central es la detección y eliminación de race conditions con el detector de carreras integrado (go race), ejercitando escenarios intencionalmente defectuosos que el participante debe corregir.

Bloque 4 — Acceso a bases de datos y testing La integración con bases de datos relacionales se trata a través de database/sql y, como alternativa ligera, un ORM de uso extendido en el ecosistema Go; se ponen en práctica la apertura y cierre seguros de conexiones, el uso de pools y el tratamiento correcto de errores de consulta. El bloque cierra con la metodología de tests table-driven: estructura de la tabla de casos, subtests con t.Run, cobertura de rutas felices y de error, y uso de mocks o stubs sencillos para aislar dependencias externas.

Bloque 5 — Depuración y flujo de trabajo integrado El curso concluye con una sesión práctica de depuración en la que se combinan las herramientas vistas a lo largo de los bloques anteriores: go test -v para localizar fallos en tests, logging estructurado para trazar el estado del programa en ejecución, y dlv (Delve) para inspección interactiva de goroutines y variables. Los participantes reciben un programa con varios defectos introducidos deliberadamente y deben identificar y corregir la causa raíz de cada uno, integrando criterios de diseño, concurrencia, manejo de errores y testing en un único flujo de trabajo.

• Go 1.22 o superior instalado localmente (https://go.dev/dl/).
• Delve (dlv) instalado: go install github.com/go-delve/delve/cmd/dlv@latest.
• Editor con soporte Go: VS Code + extensión oficial Go (gopls) o GoLand; configuración mínima con formato automático (gofmt) y linting (staticcheck).
• Docker Desktop (o equivalente) para levantar una instancia local de PostgreSQL o SQLite como alternativa sin contenedor.
• Acceso a internet para descargar dependencias con go get durante los ejercicios prácticos.

• Sintaxis fundamental de Go: declaración de variables, tipos básicos, funciones, métodos y punteros (cubiertos en GO01).
• Uso básico de la herramienta go en línea de comandos: go build, go run, go test y gestión de módulos con go mod.
• Familiaridad con al menos un lenguaje de programación de propósito general y con los conceptos de función, bucle y control de flujo.
• Conocimientos elementales de SQL (SELECT, INSERT, UPDATE) para aprovechar el bloque de acceso a bases de datos.