Aprendizaje Go Programación

1. Introducción a Go

• ¿Qué es Go (Golang)?
• Historia y filosofía de diseño de Go
• Go como lenguaje de programación para web y sistemas
• Características clave:
  • Tipado estático
  • Simplicidad y legibilidad
  • Compilación rápida
  • Concurrencia integrada
  • Recogida de basura (garbage collection)
  • Compilación multiplataforma
• Casos de uso comunes de Go
• Ventajas y limitaciones de Go
• Comparación de Go con C/C++, JavaScript, Ruby, Python y Java
• Comprensión del ecosistema de Go
• Vista general de la biblioteca estándar de Go
• Módulos de Go y gestión de dependencias
• Anatomía de una aplicación en Go
• Práctica aplicada (Hands-on): Examinar y ejecutar un programa simple en Go

2. Configuración del entorno de desarrollo de Go

• Instalación de Go
• Comprensión de la cadena de herramientas (toolchain) de Go
• Configuración de variables de entorno
• Elección de un IDE o editor de código
• Uso de la línea de comandos con Go
• Creación de un espacio de trabajo (workspace) en Go
• Comprensión de la estructura de un proyecto en Go
• Inicialización de un proyecto con Módulos de Go
• Uso de go mod init
• Gestión de dependencias con go get
• Actualización e inspección de dependencias
• Formateo de código fuente con gofmt
• Ejecución de programas con go run
• Construcción de aplicaciones con go build
• Instalación de aplicaciones de Go
• Compilación cruzada de aplicaciones
• Práctica aplicada (Hands-on): Crear y configurar un proyecto de Go dentro de un contenedor

3. Variables, constantes y tipos en Go

• Declaración de variables
• Tipos explícitos versus tipos inferidos
• Declaraciones cortas de variables
• Constantes
• Valores cero (zero values)
• Alcance y ciclo de vida de las variables
• Tipos de datos primitivos:
  • Enteros
  • Números de coma flotante
  • Números complejos
  • Booleanos
  • Cadenas de texto (Strings)
• Conversiones de tipos
• Trabajo con Unicode y UTF-8
• Runes y bytes
• Asignación múltiple de variables
• Comprensión de la seguridad de tipos
• Ejercicio: Construir un pequeño programa de procesamiento de datos por línea de comandos

4. Operadores y expresiones

• Operadores aritméticos
• Operadores de comparación
• Operadores lógicos
• Operadores de asignación
• Incremento y decremento
• Prioridad de operadores
• Trabajo con cálculos de enteros y coma flotante
• Evitar errores comunes de conversión de tipos
• Ejercicio: Implementar lógica de cálculos y validación

5. Fechas, horas y formato

• Uso del paquete time
• Creación y manipulación de fechas
• Obtención de la hora actual
• Zonas horarias y ubicaciones
• Análisis (parsing) de fechas y horas
• Formateo de fechas y horas
• Cálculo de duraciones
• Trabajo con marcas de tiempo de Unix
• Manejo de tiempos de espera (timeouts)
• Ejercicio: Agregar marcas de tiempo y cálculos de duración a una aplicación

6. Arreglos, matrices (slices), mapas y estructuras (structs)

Arreglos

• Declaración de arreglos
• Inicialización de arreglos
• Iteración sobre arreglos
• Arreglos multidimensionales

Matrices (Slices)

• Comprensión de la diferencia entre slices y arreglos
• Creación de slices
• Adición de elementos (Append)
• Copiar slices
• Longitud y capacidad de slices
• Creación de slices a partir de slices (Slicing)
• Piezas comunes al trabajar con slices

Mapas

• Creación de mapas
• Adición y eliminación de entradas
• Verificación de la existencia de una clave
• Iteración sobre mapas
• Mapas que contienen datos complejos

Estructuras (Structs)

• Definición de estructuras

• Campos de la estructura

• Inicialización de estructuras

• Estructuras anidadas

• Estructuras anónimas

• Métodos de estructura

• Etiquetas de estructura para JSON

• Práctica aplicada (Hands-on): Modelar usuarios, productos y datos de aplicación usando structs, slices y mapas

7. Lógica condicional y bucles

• Enunciados if
• else y else if
• Declaraciones de variables dentro de condiciones
• Bucles for
• Bucles infinitos
• Condiciones de bucle
• break y continue
• Iteración con range
• Bucles anidados
• Enunciados switch
• Switch basados en expresiones
• Casos múltiples
• Casos por defecto (default)
• Type switches
• Ejercicio: Implementar lógica de validación y procesamiento de la aplicación

8. Funciones

• Definición de funciones
• Parámetros de función
• Valores de retorno
• Varios valores de retorno
• Valores de retorno con nombre
• Funciones variádicas
• Funciones anónimas
• Valores de función
• Cierres (Closures)
• Recursión
• Pasaje de funciones como argumentos
• Funciones que devuelven errores
• Diseño de funciones pequeñas y reutilizables
• Ejercicio: Refactorizar código existente en funciones reutilizables

9. Punteros y conceptos de memoria

• ¿Qué es un puntero?
• Operadores de dirección y desreferencia
• Punteros y parámetros de función
• Receptores de puntero
• Punteros a estructuras
• Punteros nulos (Nil pointers)
• Cuándo usar punteros
• Semántica de valor versus referencia
• Comprensión de la gestión de memoria y la recogida de basura de Go
• Errores comunes con punteros
• Práctica aplicada (Hands-on): Modificar datos de la aplicación usando punteros

10. Creación de una aplicación web en Go

• Vista general de las capacidades web de Go
• Introducción al paquete net/http
• Creación de un servidor HTTP
• Solicitudes y respuestas HTTP
• Métodos HTTP
• URLs de solicitud y parámetros de consulta
• Encabezados HTTP
• Códigos de estado HTTP
• Fundamentos de enrutamiento
• Creación de manejadores (handlers)
• Manejo de datos de formularios
• Servicio de archivos estáticos
• Trabajo con plantillas HTML
• Variables y estructuras de control en plantillas
• Estructuración de una aplicación web
• Práctica aplicada (Hands-on): Construir un servidor web básico en Go

11. Construcción de un servicio web RESTful

• Fundamentos de la arquitectura REST
• Diseño de puntos finales (endpoints) de API
• GET, POST, PUT, PATCH y DELETE
• Trabajo con JSON
• Codificación y decodificación de JSON
• Validación de solicitudes
• Códigos de estado HTTP
• Respuestas de error
• Parámetros de consulta y parámetros de ruta
• Estructuras de respuesta de API
• Separación de los manejadores de la lógica de negocio
• Práctica aplicada (Hands-on): Construir una API REST CRUD

12. Runtime de Go, compilación y construcciones de proyecto

• Comprensión del compilador de Go
• Proceso de construcción (build) de Go
• go run
• go build
• go install
• go test
• Banderas de construcción (Build flags)
• Configuración específica del entorno
• Construcción para diferentes sistemas operativos y arquitecturas
• Producción de binarios independientes
• Gestión de la configuración de la aplicación
• Ejercicio: Compilar la aplicación para múltiples plataformas

13. Trabajo con archivos y la web

• Apertura y cierre de archivos
• Lectura de archivos
• Escritura en archivos
• Creación de directorios
• Metadatos de archivos
• E/S (I/O) con búfer
• Trabajo con flujos (streams)
• Lectura y escritura de archivos JSON
• Clientes HTTP
• Realización de solicitudes HTTP salientes
• Manejo de errores de cliente HTTP
• Tiempos de espera y cancelación
• Procesamiento de respuestas de API
• Práctica aplicada (Hands-on): Recuperar datos de una API externa y persistirlos localmente

14. Manejo de errores y depuración

• El enfoque de Go hacia los errores
• Devolver errores desde funciones
• Verificación de errores
• Creación de errores personalizados
• Envoltura de errores (Wrapping)
• Agregación de contexto a errores
• errors.Is y errors.As
• Panic y recuperación (recovery)
• Cuándo usar panic
• Depuración de problemas comunes en Go
• Registro de actividad de la aplicación (Logging)
• Uso de herramientas de depuración de Go
• Ejercicio: Diagnosticar y corregir errores de aplicación introducidos deliberadamente

15. Interfaces y abstracción

• ¿Qué es una interfaz?
• Implementación implícita de interfaces
• Definición de interfaces
• Valores de interfaz
• Interfaces vacías / any
• Afirmaciones de tipo (Type assertions)
• Type switches
• Implementaciones por puntero versus por valor
• Diseño de interfaces pequeñas
• Inversión de dependencias
• Uso de interfaces para pruebas
• Reducción del acoplamiento de la aplicación
• Práctica aplicada (Hands-on): Introducir interfaces en la aplicación web de ejemplo

16. Paquetes y organización del proyecto

• Creación de paquetes
• Convenciones de nomenclatura de paquetes
• Identificadores exportados y no exportados
• Importación de paquetes
• Inicialización de paquetes
• Organización de capas de la aplicación
• Paquetes internos
• Gestión de dependencias con Módulos de Go
• Versión semántica
• Uso de paquetes de terceros
• Evitar dependencias circulares
• Diseño de proyectos de Go mantenibles
• Ejercicio: Refactorizar la aplicación en paquetes separados

17. Concurrencia con Goroutines

• ¿Qué es la concurrencia?
• Goroutines
• Iniciación de goroutines
• Comprensión de la ejecución concurrente ligera
• Desafíos de sincronización
• Estado compartido
• Condiciones de carrera (Race conditions)
• Uso de sync.WaitGroup
• Mutexes y mutexes de lectura/escritura
• Operaciones atómicas
• Práctica aplicada (Hands-on): Convertir una tarea secuencial en procesamiento concurrente

18. Canales (Channels)

• Comprensión de los canales
• Envío y recepción de valores
• Canales con búfer versus sin búfer
• Comportamiento bloqueante
• Cierre de canales
• Iteración sobre canales
• Canales direccionalizados
• Comunicación basada en canales
• Enunciados select
• Tiempos de espera y cancelación
• Patrones de piscina de trabajadores (worker-pool)
• Patrones de productor/consumidor
• Práctica aplicada (Hands-on): Construir un sistema de trabajadores concurrentes

19. Contexto y gestión de solicitudes

• Por qué los contextos son importantes en aplicaciones web
• context.Context
• Contexto de ámbito de solicitud
• Cancelación
• Límites de tiempo (Deadlines)
• Tiempos de espera (Timeouts)
• Propagación de contexto a través de las capas de la aplicación
• Cancelación de operaciones de base de datos o HTTP
• Evitar el mal uso del contexto
• Ejercicio: Agregar cancelación de solicitudes y tiempos de espera a la aplicación web

20. Pruebas de aplicaciones en Go

• Por qué las pruebas automatizadas son importantes
• Escritura de pruebas unitarias
• El paquete testing
• Funciones de prueba
• Convenciones de nomenclatura para pruebas
• Pruebas basadas en tablas
• Pruebas de errores
• Pruebas de manejadores HTTP
• Servidores de prueba HTTP
• Fijaciones de prueba (Fixtures)
• Cobertura de pruebas
• Benchmarks
• Pruebas de ejemplo
• Pruebas de interfaces con mocks o falsos (fakes)
• Práctica aplicada (Hands-on): Crear un conjunto de pruebas para la aplicación de ejemplo

21. Optimización de rendimiento

• Comprensión del rendimiento de las aplicaciones en Go
• Identificación de cuellos de botella
• Rendimiento de CPU versus memoria
• Estructuras de datos eficientes
• Reducción de asignaciones innecesarias
• Cadenas, bytes y búferes
• Gestión de goroutines
• Evitar la concurrencia excesiva
• Estrategias de caché
• Consideraciones de base de datos y red
• Perfiles de aplicaciones (Profiling)
• Benchmarks y pruebas de rendimiento
• Uso de herramientas de perfilado de Go
• Ejercicio: Perfilar y optimizar una aplicación deliberadamente ineficiente

22. Seguridad y prácticas de aplicaciones web robustas

• Validación de la entrada del usuario
• Manejo seguro de solicitudes HTTP
• Prevención de vulnerabilidades web comunes
• Manejo seguro de errores
• Conceptos de autenticación y autorización
• Gestión de secretos y configuración
• Comunicación HTTP segura
• Evitar información sensible en registros (logs)
• Gestión y actualización de dependencias
• Limites de recursos y tiempos de espera de solicitud
• Ejercicio: Revisar y reforzar la API de ejemplo

23. Registro (Logging) y observabilidad de aplicaciones

• Fundamentos del registro
• Registro estructurado
• Niveles de registro
• Registro de solicitudes
• Registro de errores
• Correlación y IDs de solicitud
• Monitoreo del comportamiento de la aplicación
• Métricas básicas
• Puntos finales de verificación de salud (Health-check endpoints)
• Diagnóstico de problemas de producción
• Práctica aplicada (Hands-on): Agregar registro estructurado y verificaciones de salud

24. Contenerización de la aplicación Go

• ¿Por qué usar contenedores?
• Aplicaciones Go y contenerización
• Escritura de un Dockerfile
• Construcciones multietapa (Multi-stage builds)
• Construcción de una imagen de ejecución mínima
• Gestión de la configuración a través de variables de entorno
• Redeado de contenedores
• Exposición de puertos de la aplicación
• Ejecución de la aplicación en un contenedor
• Pruebas de la aplicación contenerizada
• Práctica aplicada (Hands-on): Empaquetar la aplicación Go de ejemplo como un contenedor listo para producción

25. Implementación (Deployment)

• Preparación de una aplicación para producción
• Construcción de binarios de producción
• Configuración del entorno
• Implementación basada en contenedores
• Arquitectura de implementación
• Proxies inversos
• Consideraciones de HTTPS/TLS
• Verificaciones de salud de la aplicación
• Apagado gracioso (Graceful shutdown)
• Manejo de señales del sistema operativo
• Escala de aplicaciones web en Go
• Escalado horizontal versus vertical
• Solución de problemas básica de implementación
• Práctica aplicada (Hands-on): Implementar la aplicación web de ejemplo

26. Proyecto final (Capstone): Aplicación web completa en Go

Los participantes integran los conceptos desarrollando una aplicación completa.

El proyecto puede incluir:

• Inicialización del proyecto con Módulos de Go
• Organización de paquetes
• Enrutamiento HTTP
• Puntos finales de API REST
• Manejo de solicitudes y respuestas JSON
• Validación de entrada
• Manejo de errores
• Interfaces
• Procesamiento concurrente
• Comunicación con APIs externas
• Persistencia en archivo o base de datos
• Pruebas automatizadas
• Registro (Logging)
• Consideraciones de rendimiento
• Contenerización
• Configuración de producción
• Implementación

27. Revisión y mejores prácticas

• Revisión de la sintaxis central de Go
• Convenciones de codificación en Go
• Escritura de Go idiomático
• Mantenimiento de código simple
• Diseño de paquetes efectivo
• Mejores prácticas de manejo de errores
• Principios de diseño de interfaces
• Mejores prácticas de concurrencia
• Estrategias de prueba
• Consideraciones de rendimiento
• Mantenibilidad y legibilidad
• Errores comunes cometidos por nuevos desarrolladores de Go
• Enfoques recomendados para continuar el desarrollo en Go

28. Conclusión

• Revisión de los conceptos clave
• Revisión de la aplicación web completada
• Preguntas y discusión
• Resolución de problemas en escenarios comunes del mundo real
• Próximos pasos recomendados para el desarrollo en Go
• Recursos adicionales de bibliotecas y ecosistema de Go
• Mayor oportunidad para construir servicios Go de grado de producción