Filosofía de Go: La simplicidad como ventaja

Go es un lenguaje diseñado bajo el principio de “do less, enable more” (haz menos, permite más). En lugar de ofrecer una lista interminable de características complejas que intentan resolver todos los problemas posibles, Go se enfoca en un conjunto reducido de herramientas potentes que se combinan de forma limpia.

¿Qué significa esto en la práctica? Significa que Go ha decidido omitir deliberadamente funciones que otros lenguajes consideran esenciales, como la herencia (una forma de crear jerarquías complejas entre objetos), la sobrecarga de operadores (cambiar el significado de símbolos como + para que funcionen con objetos personalizados) o las excepciones (mecanismos que interrumpen el flujo de un programa cuando ocurre un error). Incluso, durante mucho tiempo, Go no tuvo genéricos (capacidad de escribir funciones para cualquier tipo de dato), una característica que se añadió finalmente en la versión 1.18 [disponible desde Go 1.18].

Este diseño responde a una búsqueda de la ortogonalidad: la idea de que las piezas del lenguaje deben ser simples y no estorbarse entre sí. Al reducir las opciones, el lenguaje reduce la carga cognitiva, que es el esfuerzo mental necesario para entender qué hace un código. En equipos grandes, esto es fundamental: si hay una sola forma estándar de resolver un problema, el código de cualquier compañero será predecible y fácil de leer para ti. Deberías usar Go cuando la mantenibilidad y la claridad sean más importantes que la brevedad extrema o la “magia” sintáctica. Si intentas forzar patrones de otros lenguajes —como crear jerarquías de objetos profundas— terminarás con un código que pelea contra el lenguaje y es extremadamente difícil de depurar.

Este enfoque de “menos es más” se resume en los Go Proverbs, una serie de frases o lemas (como “Clear is better than clever” o “Lo claro es mejor que lo ingenioso”) formuladas por Rob Pike para guiar a los programadores hacia un estilo de código idiomático y eficiente.

package main

import (
	"errors"
	"fmt"
)

// AreaCalculator es una estructura (struct) que agrupa datos relacionados.
// En Go, usamos composición en lugar de herencia para definir comportamientos.
type AreaCalculator struct {
	width  float64
	height float64
}

// Calculate es un método asociado a AreaCalculator.
// En lugar de lanzar una excepción, devolvemos el resultado y un error explícito.
func (a AreaCalculator) Calculate() (float64, error) {
	if a.width <= 0 || a.height <= 0 {
		// Devolvemos un error si las dimensiones no son válidas.
		return 0, errors.New("las dimensiones deben ser mayores a cero")
	}
	return a.width * a.height, nil
}

func main() {
	// Caso de éxito: dimensiones válidas.
	rect := AreaCalculator{width: 10.5, height: 5.0}
	
	area, err := rect.Calculate()
	if err != nil {
		// Si err no es nil, algo salió mal. En Go, los errores se manejan así:
		// de forma explícita y cercana al lugar donde ocurre.
		fmt.Printf("Error de cálculo: %v\n", err)
		return
	}

	fmt.Printf("El área calculada es: %.2f\n", area)

	// Caso de error: dimensiones inválidas.
	invalidRect := AreaCalculator{width: -1, height: 10}
	_, err = invalidRect.Calculate()
	if err != nil {
		fmt.Printf("Error esperado: %v\n", err)
	}
}

Análisis del código

En el ejemplo anterior, observa cómo la estructura AreaCalculator define simplemente qué datos necesita nuestro modelo. No hay una jerarquía de clases de la que heredar; simplemente definimos los datos y los métodos que actúan sobre ellos.

Cuando llamamos a rect.Calculate(), no estamos rodeando el código con un bloque try/catch para capturar una posible excepción. En su lugar, la función devuelve dos valores: el resultado (float64) y un objeto de tipo error. Esta es la respuesta de Go a la simplicidad: los errores son valores comunes, no interrupciones mágicas del flujo.

Fíjate en la línea if err != nil. Esta comprobación es la columna vertebral de la filosofía de Go. Al obligarte a verificar el error inmediatamente después de que ocurre, el lenguaje te asegura que el flujo de ejecución sea transparente y que no se pasen por alto situaciones críticas. La claridad aquí es preferida sobre la brevedad de un bloque try que podría ocultar qué parte del código falló exactamente.

El error frecuente

Un error muy común cuando se viene de lenguajes como Java o Python es intentar ignorar los errores para que el código se vea “más limpio”. En Go, esto se hace usando el identificador en blanco _, que le dice al compilador que ignore un valor.

// El error frecuente: ignorar el error sistemáticamente
area, _ := rect.Calculate() // ¡Peligro!
fmt.Println(area)

Al usar _, estás silenciando el mecanismo de seguridad de Go. Si Calculate devuelve un error porque las dimensiones eran negativas, area será 0, pero tu programa continuará ejecutándose como si nada hubiera pasado, lo que puede causar errores lógicos mucho más difíciles de rastrear más adelante.

N° 3