DEV Community: Roberto Morais

Cómo Go implementa goroutines y qué pasa bajo el capó

Roberto Morais — Wed, 16 Jul 2025 18:00:00 +0000

¡Hola, colegas Go-geeks! 🚀

En este artículo vamos a destripar el pilar de la concurrencia en Go: las goroutines. Mucho se habla de lo fáciles que son de usar, pero… ¿qué sucede realmente cuando escribes go f()? ¿Cómo gestiona Go miles (¡o millones!) de esas “ligeras” hebras sin petar el sistema operativo?

Veremos:

El modelo M:N de goroutines vs. hilos OS.
Las estructuras internas: G, M y P.
El scheduler: work-stealing, parking/unparking.
Costes reales y ejemplos de benchmark.
Consejos prácticos y recomendaciones.

1. ¿Por qué goroutines y no hilos “a pelo”?

En lenguajes tradicionales (Java, C++), cada hilo OS consume decenas de kilobytes o más de stack, y el cambio de contexto es caro. Go introdujo en 2009 un modelo más ligero:

Goroutine: hebra del lenguaje, con un stack inicial de apenas 2 KB (que crece y decrece dinámicamente).
Hilo OS: recurso del sistema que maneja la ejecución real en CPU.
Scheduler M:N: multiplexa M hilos OS para ejecutar N goroutines.

Esta capa intermedia permite lanzar miles de goroutines sin arruinar tu RAM o explotar el scheduler del kernel.

2. G, M y P: las tres siglas mágicas

El runtime de Go gira alrededor de tres estructuras clave:

Símbolo	Nombre	Rol principal
G	Goroutine	Contiene estado de la goroutine: stack, programa, args.
M	Machine (hilo OS)	Representa un hilo del sistema operativo.
P	Processor (contexto)	Guarda la “capacidad de ejecutar”: una cola de G listos.

G (goroutine)
- Estructura runtime.g: puntero al PC, stack, estado (running, runnable, waiting…).
- Stack dinámico: empieza en ~2 KB y se expande hasta varios MB si hay recursión profunda.
M (machine)
- Estructura runtime.m: mapea a un hilo real del SO.
- Cada M puede ejecutar cero o una P a la vez.
P (processor)
- Estructura runtime.p: puente entre G y M.
- Contiene una cola local de goroutines (runqueue) y acceso a la cola global.

Cuando arranca tu programa, Go crea GOMAXPROCS Ps (por defecto igual al número de CPUs), y un pool inicial de Ms crece o desciende según la carga.

3. El corazón del scheduler M:N

3.1 Asignación de G a M vía P

Una nueva goroutine se inserta en la cola local de la P que la lanzó.
Si la P está siendo ejecutada por un M, éste saca una G de su cola y la ejecuta.
Cuando la cola local se vacía, la P “roba” trabajo de otras Ps (work-stealing) o de la cola global.

3.2 Work-stealing

Cada P mantiene un array circular de tamaño fijo (256) para su cola local.
Si tu P no tiene Gs, revisa otra P (aleatoria o en ronda) para “robar” la mitad de su cola.
Esto equilibra la carga sin necesidad de bloqueo global casi siempre.

3.3 Parking y unparking

Cuando una G se bloquea (por ejemplo, lectura de canal, bloqueo en syscall, sleep):

Se marca como waiting y se mueve a la cola de espera adecuada.
El M que la ejecutaba “desvincula” la P y busca otra P con trabajo o crea una nueva M si no hay Ps libres y estamos bajo el límite.
Cuando el evento (IO, timer, canal) se dispara, la G se re-activa: va a la cola del P que la despierte (a veces la global).

4. Consejos prácticos y “gotchas” de rendimiento

Evita goroutines “huérfanas”: siempre acompáñalas de un contexto o WaitGroup, o acaban vivas consumiendo memoria.

No blockees tu P: llamadas de bloqueo largas (ej. IO sin usar el paquete net/http de Go) pueden consumir un M completo; mejor usa las primitivas del runtime o goroutines dedicadas.

Tweak de GOMAXPROCS: por defecto vale runtime.NumCPU(). Jugar con este valor puede mejorar throughput en programas IO-bound vs CPU-bound.

Perfilado: usa go test -bench y pprof para ver cuántas goroutines están vivas y analizar cuellos de botella.

Conclusión

Las goroutines no son magia negra, sino el resultado de un diseño cuidadoso en el runtime de Go.
Con un scheduler M:N, work-stealing y stacks dinámicos, Go te permite escribir código concurrente simple y eficiente sin renunciar al rendimiento.

Si te ha molado el viaje al interior del runtime, ¡dale ❤️, comenta tus dudas y comparte tus propios benchmarks! Y, por supuesto, sigue explorando: el recolector de basura, el modelo de memoria y el linker de Go tienen aún más secretos por descubrir.

Si prefieres un soporte visual, por aquí te dejo un video hablando de la concurrencia en Go:

¡Nos leemos en el próximo artículo! 👋

🚀 Buenas prácticas de caching en Go para APIs rápidas y eficientes

Roberto Morais — Sun, 08 Jun 2025 18:04:15 +0000

El caching puede ser el superpoder secreto de tus aplicaciones escritas en Go. Implementarlo bien marca la diferencia entre una API que responde en milisegundos y otra que colapsa bajo carga. Pero no todo es cuestión de poner un map[string]interface{} en memoria y listo. Vamos a hablar de buenas prácticas reales para cachear datos de forma eficiente y escalable en Go.

🔍 1. Antes de cachear, mide y clasifica

Antes de meter cualquier cosa al caché, párate a pensar:

¿Cuánto pesa lo que vas a cachear?
¿Con qué frecuencia se accede?
¿Vale la pena mantenerlo en memoria?

La clave está en identificar el hot data (datos que se acceden con frecuencia) y diferenciarlo del cold data (datos que casi nunca se usan). Cachear absolutamente todo es una receta para quedarte sin RAM, y lo peor: para perder el control del rendimiento.

Consejo: Si los datos fríos aún son importantes, considera archivarlos en almacenamiento más barato o comprimirlos.

🧠 2. ¿Caché local o distribuido?

Aquí entra un dilema común:

¿Guardo los datos en memoria local del proceso o uso algo como Redis?

➕ Caché local:

Ultra rápido (lectura en nanosegundos).
Fácil de implementar (sync.Map, map, o librerías como golang-lru).
Pero... no es escalable por sí solo.

En un entorno con múltiples instancias (por ejemplo, corriendo en Kubernetes), los datos cacheados en un pod no están disponibles en otro, lo que puede generar inconsistencias.

➕ Caché distribuido (ej: Redis, Memcached):

Acceso uniforme para todos los servicios.
Ideal cuando necesitas compartir estado entre múltiples instancias.
Pero... implica más complejidad y algo más de latencia.

✅ Alternativas mixtas:

Sticky sessions: enrutar siempre al mismo pod (con cuidado).
Replicar el caché en cada instancia: más consumo de memoria, pero muy resiliente.

🧩 3. Aprovecha el cache de la CPU

Este es un punto que pocas veces se discute, pero puede marcar una diferencia interesante en apps de alto rendimiento.

La forma en que organizas los datos en memoria afecta cómo los cachea la CPU (L1, L2, L3). En estructuras grandes, si los campos que más usas están dispersos o mal alineados, el acceso será más lento.

Tips para Go:

Agrupa campos que se usen juntos en structs.
Reduce estructuras grandes o complejas si solo necesitas una parte.
Evita punteros innecesarios en ciclos críticos.

🧹 4. No olvides la limpieza (eviction)

Tu caché debería tener una política clara para no crecer sin control. Las más comunes son:

LRU (Least Recently Used): elimina el dato menos usado recientemente.
LFU (Least Frequently Used): elimina el que menos veces se ha accedido.
TTL (Time-To-Live): datos con fecha de caducidad.

En Go hay buenas librerías para esto, como:

import lru "github.com/hashicorp/golang-lru"

cache, _ := lru.New(128) // caché de máximo 128 entradas
cache.Add("key", "value")

Esto evita que se acumulen datos innecesarios y mantiene la memoria bajo control.

🧠 Conclusión

Implementar caching bien en Go no es solo cuestión de rendimiento, es cuestión de diseño. Estas son algunas recomendaciones clave:

Mide y clasifica los datos antes de cachear.
Usa caché local cuando el rendimiento lo exige, pero ten cuidado en entornos distribuidos.
Optimiza tus estructuras para que la CPU no sufra.
Siempre, siempre, establece una política de limpieza.

¿Has implementado alguna estrategia de caching en Go? ¿Redis, local, algún patrón interesante? Me encantaría leerlo en los comentarios 🚀

🧪 Uber Mock: El sucesor natural de GoMock que deberías conocer

Roberto Morais — Sat, 07 Jun 2025 17:16:50 +0000

Desde que el repositorio oficial golang/mock fue archivado, muchos desarrolladores de Go han estado buscando alternativas para continuar generando mocks sin tener que reescribir medio proyecto.

Ahí es donde entra Uber Mock.

¿Qué es Uber Mock?

Uber Mock es un fork directo de GoMock, mantenido activamente por el equipo de ingeniería de Uber. Después de que el repositorio original fuera archivado, Uber decidió continuar el desarrollo de forma oficial, manteniendo compatibilidad total con la API existente.

En la práctica, es como si el mantenimiento de golang/mock se hubiera trasladado a un nuevo hogar.

✅ Ventajas de Uber Mock

1. Migración sin dolor

La API es idéntica a la de golang/mock. Si ya tienes un proyecto con mocks generados usando mockgen, lo único que necesitas hacer es cambiar el import:

- import "github.com/golang/mock/gomock"
+ import "go.uber.org/mock/gomock"

Y listo. Tus tests seguirán funcionando como antes.

2. Mantenimiento activo

Uber lo actualiza regularmente con bug fixes, mejoras internas y compatibilidad con nuevas versiones de Go. Esto es clave si no quieres que tus dependencias se queden obsoletas.

3. Probado en producción

No es un proyecto experimental. Está en uso dentro de la infraestructura de Uber y en miles de otros proyectos que confiaban en golang/mock. La comunidad lo ha adoptado rápidamente como la alternativa de facto.

4. Compatibilidad total

Uber Mock funciona con el código generado por mockgen, las interfaces existentes, y todo el ecosistema que giraba en torno a golang/mock. Si tu proyecto tiene una gran base de tests, esto es un alivio.

⚠️ Posibles contras a tener en cuenta

Ninguna herramienta es perfecta. Uber Mock también tiene sus limitaciones:

• Dependencia externa

Ahora dependes del mantenimiento de Uber, lo cual no es crítico (es una empresa que cuida su stack), pero no es lo mismo que un repositorio oficial de la comunidad Go.

• Falta de features modernas

Herramientas como Mockery han evolucionado más en términos de DX (developer experience). Por ejemplo, generación más sencilla, compatibilidad con tipos genéricos, y una CLI más amigable.

• Sintaxis algo verbosa

Si ya usabas GoMock, sabes que los tests pueden volverse algo pesados de leer. Esto sigue igual. Uber Mock no ha hecho grandes cambios en la ergonomía de uso.

🤔 ¿Deberías migrar?

Si ya usabas golang/mock, sí. Uber Mock es la ruta natural: no cambias tu código, no rompes nada, y sigues recibiendo updates.

Si estás empezando un proyecto nuevo, podrías comparar con otras opciones como:

Mockery: generación a partir de anotaciones o CLI.
Testify: más sencillo, aunque con menor control sobre los mocks.
Hand-written mocks: para los más minimalistas.

💬 ¿Ya lo estás usando?

¿Te tocó migrar desde golang/mock? ¿Estás explorando otras opciones como Mockery? ¿O prefieres evitar los mocks y testear a otro nivel?

¡Te leo en los comentarios! 👇

🔌 Introducción al Model Context Protocol (MCP) con Go y Claude Desktop

Roberto Morais — Tue, 22 Apr 2025 14:17:38 +0000

¿Te gustaría conectar tus herramientas y datos directamente con modelos de lenguaje como Claude? El Model Context Protocol (MCP) es una solución emergente que permite a los desarrolladores integrar aplicaciones y datos con modelos de lenguaje de manera estandarizada y eficiente.

🤖 ¿Qué es el Model Context Protocol (MCP)?

El MCP es un protocolo abierto desarrollado por Anthropic que estandariza la forma en que las aplicaciones proporcionan contexto a los modelos de lenguaje (LLMs). Piensa en MCP como un puerto USB-C para aplicaciones de inteligencia artificial, proporcionando una manera uniforme de conectar modelos de lenguaje con diversas fuentes de datos y herramientas.

Con MCP, puedes permitir que un modelo de lenguaje interactúe directamente con tu sistema de archivos, bases de datos, APIs y más, sin necesidad de interfaces humanas como botones o cuadros de búsqueda.

✅ Ventajas de MCP

Estándar abierto: Facilita la integración de modelos de lenguaje con diversas aplicaciones y datos.
Flexibilidad: Permite a los desarrolladores construir herramientas personalizadas que los modelos de lenguaje pueden utilizar.
Eficiencia: Reduce la necesidad de interfaces intermedias, permitiendo una comunicación directa entre modelos y aplicaciones.
Comunidad activa: Existe una comunidad creciente de desarrolladores contribuyendo con implementaciones y ejemplos.

⚠️ Consideraciones y desafíos

Seguridad: Al permitir que los modelos de lenguaje interactúen directamente con sistemas y datos, es crucial implementar medidas de seguridad adecuadas.
Gestión de permisos: Es necesario definir claramente qué acciones puede realizar el modelo de lenguaje.
Madurez del protocolo: Aunque MCP está ganando tracción, todavía está en desarrollo activo y puede experimentar cambios.

🧪 Ejemplo básico: Crear un servidor MCP en Go

A continuación, se muestra un ejemplo simple de cómo crear un servidor MCP en Go utilizando la biblioteca mcp-go:

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/mark3labs/mcp-go/mcp"
    "github.com/mark3labs/mcp-go/server"
)

func main() {
    s := server.New()

    // Definir una herramienta simple que responde con "Hola, mundo"
    tool := mcp.Tool{
        Name:        "saludar",
        Description: "Devuelve un saludo",
        Parameters:  map[string]mcp.ToolParameter{},
    }

    s.AddTool(tool, func(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
        return &mcp.CallToolResult{
            Content: []mcp.Content{
                mcp.NewTextContent("¡Hola, mundo!"),
            },
        }, nil
    })

    fmt.Println("Servidor MCP en ejecución...")
    if err := s.Run(); err != nil {
        log.Fatal(err)
    }
}

Este servidor define una herramienta llamada "saludar" que, cuando es llamada por el modelo de lenguaje, responde con "¡Hola, mundo!".

🖥️ Integración con Claude Desktop

Claude Desktop es una aplicación que permite a los modelos de lenguaje interactuar con tu entorno de escritorio. Al configurar un servidor MCP como el anterior, puedes extender las capacidades de Claude para que realice tareas personalizadas en tu sistema.

🎥 Aprende más en mi video de YouTube

Si deseas una guía paso a paso sobre cómo configurar un servidor MCP en Go e integrarlo con Claude Desktop, te invito a ver mi video:

En el video, cubro:

Creación de un servidor MCP funcional.
Integración con Claude Desktop para aprovechar al máximo tus herramientas personalizadas.

Espero que este artículo te haya proporcionado una visión clara sobre el Model Context Protocol y cómo puedes comenzar a utilizarlo con Go y Claude Desktop. Si tienes preguntas o deseas compartir tus experiencias, ¡no dudes en comentar!

🚀 ¡Go 1.24 ya está aquí! 🚀

Roberto Morais — Tue, 11 Feb 2025 21:28:43 +0000

La nueva versión de Go trae mejoras increíbles que harán nuestro código más eficiente, limpio y rápido. Aquí te cuento las novedades más destacadas:

✅ Nueva función testing.B.Loop para benchmarks

Adiós al clásico for i := 0; i < b.N; i++, ahora testing.B.Loop se encarga de todo, mejorando la precisión y evitando optimizaciones no deseadas.

✅ Implementación de mapas con “Swiss Table”

Los mapas en Go ahora son más rápidos y usan menos memoria. Si trabajas con estructuras grandes, esta optimización puede marcar la diferencia.

✅ Alias de tipos genéricos

Una mejora clave para la mantenibilidad y reutilización del código, facilitando la creación de abstracciones más limpias.

✅ Nueva directiva tool en go.mod

Ahora podemos gestionar herramientas externas dentro del go.mod, asegurando que todos los devs de un proyecto usen la misma versión de herramientas como linters y generadores de código.

✅ Salida JSON en go build y go test

Perfecto para integraciones con CI/CD, permitiendo análisis automatizado de errores y generación de informes detallados.

✅ Nueva etiqueta omitzero en JSON

Evita incluir valores cero en la serialización JSON, haciendo las respuestas más limpias y reduciendo el tamaño de los datos.

✅ Optimización del rendimiento

Go 1.24 introduce mejoras en la asignación de memoria, gestión de concurrencia y optimización de mutexes, haciendo que nuestras aplicaciones sean aún más eficientes.

📌 ¿Cuál de estas novedades crees que tendrá mayor impacto en tu día a día? ¡Déjame tu opinión en los comentarios! 👇

🚀 ¿Aún usas Docker Desktop? 🐳

Roberto Morais — Mon, 27 Jan 2025 21:03:22 +0000

¡Es hora de cambiar y optimizar tu flujo de trabajo! 💻

Si trabajas con Docker en macOS, seguramente has notado que Docker Desktop puede ser un devorador de recursos. Esto se traduce en ralentización del sistema, consumo excesivo de batería y una experiencia menos fluida. Pero, ¿sabías que hay alternativas más rápidas y eficientes que pocos usan? 🤔

Te presento algunas de las mejores opciones:

🔹 Para macOS: OrbStack

1️⃣ Velocidad: Inicia en solo 2 segundos ⚡. Emulación rápida de x86 y optimización de red y sistema de archivos.

2️⃣ Ligereza: Reduce el uso de CPU y disco, además de prolongar la vida de tu batería 🔋.

3️⃣ Simplicidad: Interfaz amigable y fácil de usar. Gestiona contenedores, imágenes y volúmenes desde la barra de menú.

4️⃣ Potencia: Compatible con Docker, Kubernetes y distribuciones Linux.

🔹 Para Windows: Rancher Desktop

Rancher Desktop es una opción potente y gratuita para quienes trabajan en Windows:

✅ Soporte para contenedores Docker y Kubernetes.

✅ Basado en K3s, una distribución ligera de Kubernetes.

✅ Herramientas fáciles de usar para gestionar contenedores y clústeres.

✅ Compatible con WSL2, lo que mejora la experiencia de Linux en Windows.

🔹 Otra alternativa: Podman

Podman es una excelente opción multiplataforma para quienes buscan un enfoque diferente:

✅ Sin Daemon: A diferencia de Docker, no requiere un servicio en segundo plano para ejecutarse.

✅ Compatible con los comandos de Docker, facilitando la migración.

✅ Ideal para entornos que requieren una mayor seguridad y control sobre contenedores.

✅ Soporte nativo para rootless (contenedores sin privilegios de administrador).

🌍 No importa el sistema operativo que uses, hay alternativas que pueden mejorar tu experiencia de desarrollo:

macOS: OrbStack.
Windows: Rancher Desktop.
Linux/Multiplataforma: Podman.

💡 Si quieres un entorno de desarrollo más rápido y eficiente, te recomiendo probar estas herramientas. ¡Tu equipo y tu productividad te lo agradecerán!

Aquí te dejo un vídeo de YouTube en el que habló sobre estas alternativas.

Y cuéntame, ¿cuál es tu experiencia con Docker Desktop? ¿Has probado alguna de estas alternativas? ¡Déjalo en los comentarios! 👇

Fundamentos de Go: Variables, Constantes, Estructuras de Control y Datos

Roberto Morais — Sat, 04 Jan 2025 18:12:33 +0000

¡Hola a todos! En este módulo del curso de Go, vamos a explorar los fundamentos del lenguaje. Ya hemos configurado el entorno de desarrollo y hemos escrito nuestro primer programa, pero ahora es el momento de aprender a trabajar con variables, operadores, estructuras de control y estructuras de datos fundamentales.

Declaración de Variables en Go

En Go, podemos declarar variables de dos maneras diferentes. La primera es utilizando la palabra clave var, seguida del nombre de la variable y luego el tipo de dato que almacenará. Por ejemplo:

    var name string
    var age int

Para guardar un dato en la variable, escribimos el nombre de la variable seguido del símbolo = y el valor que queremos almacenar. Para acceder al valor de la variable, simplemente referenciamos su nombre.

La segunda forma de declarar variables es utilizando la inferencia de tipos, que permite a Go deducir el tipo de la variable basado en el valor asignado. Para esto, usamos := después del nombre de la variable:

    name := "Roberto"
    age := 30

Constantes en Go

Las constantes se declaran utilizando la palabra clave const y su valor no puede cambiar durante la ejecución del programa. Go tiene tipos de datos comunes como:

Strings: texto (string)
Enteros: números enteros (int)
Flotantes: números decimales (float)
Booleanos: verdadero o falso (bool)

En cuanto a los flotantes, Go ofrece dos tipos: float32 y float64. Por defecto, se asigna float64, que representa de 15 a 17 dígitos significativos, mientras que float32 representa de 6 a 9.

Conversión de Tipos en Go

Go permite la conversión de tipos explícita cuando es necesario. Por ejemplo, podemos convertir un int a float64 utilizando la función float64:

    A := 5
    B := float64(A)

También es posible convertir de un string a un int, pero no se puede hacer directamente. Para ello, utilizamos la función Atoi del paquete strconv.

    import "strconv"

    number, err := strconv.Atoi("123")

En este caso, number contendrá el número convertido y err contendrá cualquier error que pueda ocurrir durante la conversión.

Operadores en Go

Go soporta varios operadores. Los más comunes son:

Operadores Aritméticos: para sumar, restar, multiplicar, dividir o obtener el resto de una división.
Operadores Lógicos: AND, OR, NOT.
Operadores de Comparación: igual a, diferente de, menor que, mayor que, etc.

Estructuras de Control en Go

Las estructuras de control son esenciales para dirigir cómo se ejecuta tu programa. Vamos a ver cómo usar condicionales para manejar diferentes situaciones en tu código.

Condicionales If

La estructura If es simple. Se escribe la palabra If seguida de la condición y el bloque de código que se ejecutará si la condición se cumple:

    if age >= 18 {
        fmt.Println("Eres mayor de edad.")
    } else {
        fmt.Println("Eres menor de edad.")
    }

En este caso, si age es 18 o más, se ejecutará el primer bloque. Si es menor, se ejecutará el bloque del else.

Else-If

También podemos usar Else-If para realizar verificaciones adicionales:

    if age >= 18 {
        fmt.Println("Eres mayor de edad.")
    } else if age > 0 {
        fmt.Println("Eres menor de edad.")
    } else {
        fmt.Println("Edad no válida.")
    }

Switch

La estructura Switch es una forma concisa de manejar múltiples condiciones:

    switch day {
    case "Monday":
        fmt.Println("Inicio de semana.")
    case "Friday":
        fmt.Println("Fin de semana.")
    default:
        fmt.Println("Día regular.")
    }

Bucles en Go

El bucle For es el principal bucle en Go y puede actuar como un bucle típico o como un bucle estilo While. Aquí hay un ejemplo de un bucle tradicional:

    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }

También puedes usar For como un While indicando solo la condición:

    i := 0
    for i < 5 {
        fmt.Println(i)
        i++
    }

Recuerda que puedes usar Break para salir de un bucle prematuramente o Continue para saltar una iteración.

Estructuras de Datos en Go

Las estructuras de datos más importantes en Go son arrays, slices y maps. Vamos a empezar con los arrays.

Arrays

Los arrays en Go tienen un tamaño fijo y todos sus elementos deben ser del mismo tipo:

    var arr [5]int
    arr[0] = 1
    arr[1] = 2

Los arrays tienen un límite; no puedes agregar elementos en índices fuera de ese límite.

Slides

Los slices son más flexibles que los arrays, ya que pueden crecer o reducir su tamaño dinámicamente:

    var slice []int
    slice = append(slice, 1, 2, 3)

Puedes crear sub-slices de manera eficiente utilizando el nombre del slice seguido de corchetes:

    subSlice := slice[1:3]

Maps

Los maps almacenan pares clave-valor y son útiles para asociar datos de manera rápida:

    ages := make(map[string]int)
    ages["Roberto"] = 32
    fmt.Println(ages["Roberto"])

Resumen

En resumen, hemos cubierto cómo manejar variables y constantes, usar operadores, implementar control de flujo y trabajar con arrays, slices y maps. Estos son los bloques de construcción de cualquier programa en Go. En el próximo módulo, nos adentraremos en funciones y estructuras, así que no te lo pierdas.

Para más información y recursos, puedes unirte a nuestra comunidad en Discord o convertirte en miembro de nuestro canal en YouTube.

Curso de Golang Para Principiantes: Instalación y Configuración del Entorno de Desarrollo

Roberto Morais — Fri, 03 Jan 2025 09:41:39 +0000

Bienvenidos al primer módulo de nuestro curso de Go, donde comenzaremos desde cero explorando qué es Go, por qué deberías aprenderlo y cómo configurar tu entorno de desarrollo. Si eres nuevo en Go, este artículo es el punto de partida perfecto. Vamos a sumergirnos en el fascinante mundo de Golang.

¿Qué es Go?

Go, también conocido como Golang, es un lenguaje de programación moderno creado por Google en 2007 y lanzado al público en 2009. Sus principales desarrolladores fueron Robert Griesemer, Rob Pike y Ken Thompson. Es un lenguaje de código abierto, compilado y tipado, diseñado para ser eficiente, simple y fácil de aprender.

¿Por qué aprender Go?

Go es ideal para construir aplicaciones altamente concurrentes y escalables, desde microservicios hasta grandes sistemas distribuidos. Su rendimiento es comparable al de C o C++, pero con una sintaxis mucho más simple y gestión automática de memoria. A lo largo de este curso, veremos cómo Go facilita la gestión de la concurrencia y cómo nos ayuda a escribir programas rápidos y robustos, desde aplicaciones web hasta sistemas en la nube.

Grandes empresas como Google, Uber y Dropbox utilizan Go para gestionar infraestructuras complejas. Así que si buscas un lenguaje que combine simplicidad, rendimiento y concurrencia, Go es la elección perfecta.

Instalación de Go

Para comenzar a programar en Go, lo primero que necesitamos hacer es instalarlo en nuestro sistema. Para ello, vamos a descargar e instalar Go desde su sitio web oficial go.dev.

En su sitio web, haremos clic en el botón de descarga. Aquí podemos descargar el instalador para los diferentes sistemas operativos como Windows, MacOS o Linux, dependiendo de tu sistema operativo. La instalación se llevará a cabo de una manera u otra, y puedes consultar las instrucciones para instalar en tu sistema operativo específico.

Instalación en Ubuntu

Si estás usando Ubuntu, aquí están los pasos para instalar Go. Primero, descarga el archivo tar.gz que se encuentra en el sitio web oficial. Una vez que hayas localizado este archivo en tu máquina, ejecuta los siguientes comandos:

sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.23.linux-amd64.tar.gz

Es recomendable ejecutar estos comandos con permisos de superadministrador para evitar problemas al eliminar o crear nuevas carpetas. Si no recibes ningún mensaje en tu terminal después de ejecutar estos comandos, significa que ambos se han ejecutado correctamente y ahora tienes Go instalado en tu computadora.

Configuración de Variables de Entorno

Ahora necesitamos agregar el ejecutable de Go a nuestra ruta. Para ello, editaremos el archivo .profile con el siguiente comando:

sudo vi $HOME/.profile

En este archivo, al final, añadiremos la siguiente línea:

PATH=$PATH:/usr/local/go/bin

Después de agregar esta línea, puedes ejecutar el comando go version en tu terminal para verificar que Go está instalado correctamente. Si no se reconoce el comando, puede que necesites cerrar y volver a abrir tu terminal.

Configuración de GOROOT y GOPATH

Ahora configuraremos dos variables de entorno: GOROOT y GOPATH. GOROOT permitirá que el compilador de Go y otras herramientas encuentren las bibliotecas estándar de Go, mientras que GOPATH es la ruta raíz del espacio de trabajo de Go, donde encontraremos las carpetas como src, pkg y bin.

Para esto, editaremos el archivo .bashrc de tu usuario:

nano $HOME/.bashrc

Al final de este archivo, añadiremos las siguientes líneas:

export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

Después de editar el archivo .bashrc, ejecuta el comando source $HOME/.bashrc para refrescar la configuración y tener acceso a las variables de entorno que acabamos de configurar.

IDE Recomendados

Ahora que tenemos Go instalado y configurado, hablemos sobre los IDEs que recomiendo. El primero es Visual Studio Code. Si instalas la extensión de Go desarrollada por el equipo de Google, tendrás mucha ayuda al desarrollar tus scripts en Go. Pero si prefieres un IDE real, te recomiendo GoLand, desarrollado por JetBrains. Este IDE es muy potente, aunque es de pago.

Creando tu Primer Script en Go

Una vez que tu entorno de desarrollo está correctamente configurado, vamos a crear nuestro primer script en Go. Lo primero que debemos hacer al comenzar a programar en Go es inicializar un módulo. Todos los programas de Go son módulos o paquetes, por lo que debemos lanzar el comando go mod init seguido del nombre de nuestro módulo.

go mod init example/hello

Normalmente, este nombre es la ruta donde se aloja el código del módulo, como por ejemplo: github.com/usuario/nombre_del_modulo. Después de ejecutar este comando, verás un mensaje en tu terminal y se creará un nuevo archivo llamado go.mod en tu carpeta. Este archivo contiene el nombre de nuestro módulo y la versión de compatibilidad con Go.

Creando el Archivo main.go

Ahora que tenemos nuestro módulo inicializado, crearemos un archivo llamado main.go. Todos los programas de Go comienzan con la declaración del paquete y el punto de entrada es la función main. En este ejemplo, primero declaramos que este programa pertenece al paquete main, luego importamos el paquete fmt, que es parte de la biblioteca estándar de Go y nos permite imprimir mensajes en la consola.

Finalmente, en la función main, utilizamos fmt.Println para mostrar el mensaje: "Hola Mundo". Aquí tienes un ejemplo de cómo debería verse:

package main

import "fmt"

func main() {
    fmt.Println("Hola Mundo")
}

Para ejecutar este programa, abre un terminal y ejecuta el comando:

go run main.go

Verás cómo aparece el mensaje "Hola Mundo" en tu terminal.

Compilación y Generación de Binarios

Si quieres compilar y generar el binario de tu aplicación, que sería el ejecutable de tu programa, debes ejecutar el comando:

go build

Esto generará un binario de tu aplicación, que en este caso se llamará "hello". Otra orden que puede interesarte es go install, que compila e instala los paquetes directamente en tu máquina.

Comentarios en Go

Una parte muy importante de escribir buen código es asegurarse de que sea comprensible para ti y para los demás. En Go, esto significa seguir las convenciones de estilo y escribir comentarios donde sea necesario. Go permite dos tipos de comentarios de una línea, escritos con // y comentarios de varias líneas escritos con /* y cerrados con */.

Aunque Go favorece un código simple y auto-descriptivo, a veces es útil añadir un comentario explicando alguna función compleja en tu código.

Conclusión

En este módulo, hemos instalado Go en nuestra máquina, configurado el entorno de desarrollo y escrito el código para nuestro primer programa en Go. En el próximo módulo, exploraremos más a fondo los fundamentos de Go. ¡Nos vemos pronto!

Si deseas unirte a la comunidad de Golang y Docker, puedes hacerlo en nuestro servidor de Discord aquí.

Para más contenido sobre Golang y Docker, no dudes en unirte a mi canal de YouTube Roberto Morais - YouTube donde encontrarás tutoriales profundos y consejos útiles.

Lo nuevo en Golang 1.23: Mejoras en el lenguaje, compilador y herramientas

Roberto Morais — Tue, 17 Dec 2024 18:59:27 +0000

El 13 de agosto de 2024, el equipo de Go lanzó Golang 1.23, una versión que trae novedades importantes y mejoras enfocadas en la eficiencia, el compilador y el lenguaje en general. ¡Aquí te resumo lo más destacado de esta actualización!

🚀 Cambios en el Lenguaje

🔄 Iteradores en bucles for-range

Ahora, los bucles for-range soportan funciones iteradoras con las siguientes firmas:

func(func() bool)
func(func(K) bool)
func(func(K, V) bool)

Esto facilita la iteración sobre colecciones personalizadas y ofrece mayor flexibilidad al trabajar con estructuras de datos propias.

🧩 Alias de tipos genéricos (experimental)

Se introduce un soporte preliminar para alias de tipos genéricos. Aunque todavía está en fase experimental y debe habilitarse manualmente, esta funcionalidad promete simplificar la reutilización de tipos genéricos a medida que evoluciona el lenguaje.

🛠️ Novedades en Herramientas

📊 Telemetría opcional

Go 1.23 incluye un sistema de telemetría opcional que recopila estadísticas de uso y fallos del compilador. Esta información ayudará al equipo de Go a mejorar futuras versiones.

Activación: go telemetry on
Más detalles: Documentación sobre telemetría

🧑‍💻 Nuevas opciones del comando go

Se han añadido nuevas opciones al comando go que facilitarán la gestión de proyectos:

go env -changed: Muestra solo las variables de entorno modificadas.
go mod tidy -diff: Muestra los cambios necesarios como un diff sin modificar archivos.
go list -m -json: Incluye campos como Sum y GoModSum para gestionar dependencias.

⚡ Mejoras en el Compilador y Rendimiento

El compilador en Go 1.23 trae optimizaciones importantes:

Optimización de variables locales: Se ha reducido el uso de memoria gracias a mejoras en la superposición de espacios en la pila.
Optimización Guiada por Perfil (PGO): Mejora el tiempo de compilación y la eficiencia general en proyectos grandes.

Estas mejoras no solo aceleran el proceso de desarrollo, sino que también optimizan la ejecución de las aplicaciones en producción.

🔧 Mejoras en el Runtime

Se han optimizado los temporizadores (time.Timer y time.Ticker) para que sean recolectados por el garbage collector más rápidamente cuando pierden referencias. Esto mejora la gestión de recursos y la eficiencia del runtime.

📚 Actualizaciones en Bibliotecas Estándar

Varias bibliotecas estándar reciben mejoras:

crypto/x509: Ahora rellena automáticamente el campo Certificate.Leaf al cargar pares de claves, facilitando el uso de certificados.
Mejoras en go/types y os.

Estas actualizaciones están orientadas a mejorar la seguridad, el rendimiento y la experiencia de desarrollo con Go.

🗂️ Compatibilidad y Requisitos de Plataforma

Go 1.23 mantiene la compatibilidad hacia atrás, pero introduce cambios mínimos en los requisitos de algunas plataformas:

macOS: Se requiere macOS 11 Big Sur o superior.
Linux: Es la última versión compatible con kernel 2.6.32; futuras versiones requerirán al menos kernel 3.2.

🎯 Conclusión

La versión 1.23 de Go refuerza el compromiso del lenguaje con la eficiencia, flexibilidad y rendimiento. Las novedades en el compilador, el runtime y las herramientas aseguran que Go siga siendo una opción sólida para desarrolladores de todo el mundo.

¡Actualiza a Go 1.23 y prueba todas estas novedades! 🚀

Redes neuronales convolucionales (CNN) y redes neuronales recurrentes (RNN)

Roberto Morais — Mon, 16 Dec 2024 13:06:22 +0000

Las redes neuronales convolucionales (CNN) y las redes neuronales recurrentes (RNN) son dos tipos de redes neuronales artificiales que se utilizan ampliamente en el campo del aprendizaje profundo. Las CNN se utilizan principalmente para tareas de visión por computadora, mientras que las RNN se utilizan principalmente para tareas de procesamiento de lenguaje natural.

Las CNN se componen de capas convolucionales, que aplican filtros a la entrada para extraer características relevantes. Estas características se combinan luego en capas completamente conectadas para realizar la clasificación o la regresión.

Las RNN se componen de capas recurrentes, que mantienen un estado interno que les permite procesar secuencias de datos de manera eficiente.

Las CNN y las RNN son herramientas poderosas que se utilizan en una amplia variedad de aplicaciones, como el reconocimiento de imágenes, la traducción automática, el procesamiento de lenguaje natural y el análisis de sentimientos.

Recursos adicionales

Espero que esta publicación te haya resultado útil. Si tienes alguna pregunta, no dudes en dejar un comentario.

📝 Buen commit vs. Mal commit: Mejora tu árbol de Git

Roberto Morais — Thu, 12 Dec 2024 09:26:18 +0000

¿Te ha pasado que vuelves a un proyecto después de meses y encuentras un commit llamado "arreglar cosas"? 😬 Sí, a todos nos ha pasado. ¡Pero no tiene que ser así! Hoy quiero hablarte de la importancia de escribir buenos commits y cómo pueden hacer tu vida (y la de tu equipo) mucho más fácil.

🤔 ¿Por qué importa un buen commit?

Un commit no es solo un "guardar partida" en tu código; es como una entrada en el diario de tu proyecto. Describe qué hiciste, por qué lo hiciste y, si es necesario, cómo lo hiciste. Los commits bien escritos:

✅ Facilitan entender el historial del proyecto.
✅ Ayudan a resolver bugs más rápido.
✅ Mejoran la colaboración en equipo.

Y lo más importante: te hacen ver como un profesional que sabe lo que hace. 😎

🚨 Ejemplo de mal commit

git commit -m "cambios"

¿Cambios de qué? ¿Arreglaste algo? ¿Agregaste una funcionalidad? ¿Borraste medio repositorio? Nadie lo sabe. Ni siquiera tú lo sabrás en dos semanas. 😅

Otro clásico:

git commit -m "arreglo bug"

Bien por arreglar el bug, pero... ¿qué bug? ¿En qué parte? Sin contexto, no sirve de mucho.

💡 Ejemplo de buen commit

git commit -m "fix: corregir validación de emails en el formulario de registro"

🔍 Ahora sabemos exactamente qué se hizo y dónde. Si el bug regresa o surge algo relacionado, este commit será una brújula para encontrar la solución.

Otro ejemplo para nuevas funcionalidades:

git commit -m "feat: agregar funcionalidad para compartir enlaces en redes sociales"

Esto no solo dice qué se hizo, sino que usa un convención estándar como Conventional Commits.

🎯 Tips para buenos commits

Usa una convención clara:

feat: para nuevas funcionalidades.
fix: para correcciones de bugs.
refactor: para mejorar código sin cambiar funcionalidad.
docs: para cambios en documentación.

Escribe mensajes descriptivos y precisos:
Un buen commit responde a estas preguntas:

¿Qué cambiaste?
¿Por qué lo cambiaste?
Haz commits pequeños y específicos:
No mezcles una nueva funcionalidad con arreglos de bugs en el mismo commit. Divide y vencerás.

Incluye contexto si es necesario:
Si estás corrigiendo un bug complicado, puedes usar el mensaje extendido:

git commit -m "fix: corregir error de autenticación al usar OAuth" -m "El error ocurría porque el token expiraba antes de ser validado. Se implementó una lógica para manejar tokens expirados."

🛠️ Herramientas útiles

Si quieres automatizar o mantener consistencia:

Commitizen: Guía para escribir mensajes siguiendo convenciones.
Husky: Ejecuta hooks de Git para validar commits.

🚀 ¡Haz que tus commits hablen por ti!

Un buen mensaje de commit no solo ayuda a tus compañeros de equipo, sino también a tu yo del futuro. Escribir buenos commits es una inversión pequeña con un gran retorno en claridad y productividad.

¿Tienes algún truco o convención que uses para tus commits? ¡Déjamelo en los comentarios! 👇

💡 ¿Qué son las API REST y por qué son tan importantes? 💡

Roberto Morais — Mon, 09 Dec 2024 09:18:25 +0000

En el desarrollo web, es común escuchar términos como REST o API RESTfull. Pero, ¿qué significan exactamente? Una API REST es una interfaz que permite la comunicación entre sistemas usando las reglas del protocolo HTTP. Es como un traductor que facilita que diferentes aplicaciones hablen entre sí, ya sea una app móvil consultando un servidor o una aplicación web pidiendo datos a otro servicio.

🎯 Características clave de las API REST:

1️⃣ Basadas en recursos: Cada entidad (usuarios, productos, pedidos) se representa como un recurso que tiene una URL única, como https://miapp.com/api/users.

2️⃣ Uso de métodos HTTP: Se utilizan métodos como:

GET para obtener datos.
POST para crear un nuevo recurso.
PUT o PATCH para actualizar.
DELETE para eliminar.

3️⃣ Sin estado (stateless): Cada petición es independiente; el servidor no almacena información sobre el cliente entre solicitudes.

4️⃣ Formatos estándar: Los datos suelen enviarse en JSON, lo que hace que las APIs sean ligeras y fáciles de trabajar.

📚 Ejemplo básico de API REST:

👉 Supongamos que tienes una aplicación para gestionar libros:

URL: https://miapp.com/api/books
Método: GET
Respuesta:

[
  { "id": 1, "title": "Clean Code", "author": "Robert C. Martin" },
  { "id": 2, "title": "The Pragmatic Programmer", "author": "Andy Hunt" }
]

🌟 ¿Por qué usar REST?

REST es sencillo, escalable y funciona perfectamente con aplicaciones modernas, desde webs hasta microservicios. Es el estándar más usado hoy en día para construir APIs.

📢 Ahora dime, ¿has usado APIs REST en algún proyecto? ¿Qué tal fue tu experiencia?