En el mundo de la programación, pocos lenguajes han logrado una adopción tan masiva en tan poco tiempo como Go. A menudo llamado Golang (debido a su dominio original, golang.org), este lenguaje nació de la necesidad de resolver problemas complejos en una era de sistemas distribuidos y multinúcleo.

1. El Origen: ¿Quién y Por Qué?

Go no nació en un garaje, sino en los pasillos de Google en 2007. Sus creadores no son precisamente novatos; hablamos de leyendas de la computación: Robert Griesemer, Rob Pike y Ken Thompson (este último, uno de los padres de Unix y el lenguaje C).

La motivación fue simple: frustración. Los ingenieros de Google sentían que los lenguajes que usaban (como C++ o Java) eran demasiado complejos, lentos de compilar y no estaban diseñados para aprovechar los procesadores modernos con múltiples núcleos.

2. Objetivos de Diseño: Menos es Más

El equipo de Go se propuso crear un lenguaje que combinara lo mejor de dos mundos:

• La eficiencia y seguridad de un lenguaje compilado (como C++).
• La facilidad de uso y velocidad de desarrollo de un lenguaje dinámico (como Python).

Sus pilares fundamentales:

• Simplicidad: Go tiene una sintaxis limpia. Se eliminaron características que suelen causar confusión, como la herencia de clases compleja o la sobrecarga de operadores.
• Concurrencia Nativa: A través de las Goroutines, Go permite ejecutar miles de tareas simultáneamente con un consumo de memoria mínimo.
• Compilación ultra rápida: Olvídate de esperar minutos; los programas en Go se compilan en segundos, generando un único archivo ejecutable sin dependencias externas.

3. ¿Para qué se utiliza Go hoy en día?

Si alguna vez has usado herramientas modernas de infraestructura, es muy probable que estés usando Go sin saberlo. Es el lenguaje detrás de:

• Docker y Kubernetes: Las piezas clave de la «contenedorización».
• Microservicios: Su ligereza lo hace ideal para arquitecturas escalables.
• Herramientas de Red: Por su manejo eficiente de protocolos y APIs.

4. ¿Vale la pena aprenderlo en 2026?

La respuesta es un rotundo sí. Mientras otros lenguajes se vuelven más pesados, Go se mantiene fiel a su minimalismo. Es uno de los lenguajes mejor pagados en la industria y la demanda de desarrolladores que entiendan la concurrencia en Go sigue creciendo.

Ejemplo Práctico: Hola Mundo

package main

import "fmt"

func main() {
    fmt.Println("¡Hola, Mundo desde mi blog!")
}

Comandos básicos:

Para ejecutarlo directamente:

go run hola.go

Salida:

¡Hola, Mundo desde mi blog!

Para compilar un binario:

go build hola.go

Pronto Iniciaremos un estudio sobre Golang desde Cero. Aprenderemos desde la sintaxis básica hasta la creación de microservicios escalables y mucho más. ¡No te lo pierdas!.

En este primer articulo se le mostrara como encriptar cadenas de texto usando el algoritmo aes-256-ctr de la librería crypto de nodeJS y la librería OpenSSL de PHP.

En el siguiente enlace se encuentra la documentación oficial de la librería crypto de nodeJS.

https://nodejs.org/api/crypto.html#cryptocreatecipherivalgorithm-key-iv-options

https://nodejs.org/api/crypto.html#cryptocreatedecipherivalgorithm-key-iv-options

/* crypto.js */

const crypto = require("crypto");

const algorithm = "aes-256-ctr";
const secretKey = "96c8f9d8d51c410532a781cfb37a73ab";
const iv = "d0229568bbc258c6";

const encrypt = (text) => {
    const cipher = crypto.createCipheriv(algorithm, secretKey, iv);
    const encrypted = Buffer.concat([cipher.update(text), cipher.final()]);
    return encrypted.toString("hex");
};

const decrypt = (hash) => {
    const decipher = crypto.createDecipheriv(algorithm, secretKey, iv);
    const decrpyted = Buffer.concat([decipher.update(Buffer.from(hash, "hex")), decipher.final()]);
    return decrpyted.toString();
};

module.exports = {
    encrypt,
    decrypt,
};

Implementación:

/* run.js */

const { encrypt, decrypt } = require("./crypto");

const cadena = "Soy un texto";

const encriptado = encrypt(cadena);
console.log(`Cadena Encriptado: => ${encriptado}`);

const desencriptado = decrypt(encriptado);
console.log(`Cadena Desencriptado: => ${desencriptado}`);

Salida:

Cadena Encriptado: => 684cc5e0d1956c4c470e9986
Cadena Desencriptado: => Soy un texto

<?php
$texto = 'Soy un texto';
$algorithm = 'aes-256-ctr';
$key = '96c8f9d8d51c410532a781cfb37a73ab';
$iv = 'd0229568bbc258c6';

$encrypted_data = bin2hex(openssl_encrypt($texto, $algorithm, $key, OPENSSL_RAW_DATA, $iv));
echo "Encrypted: ".$encrypted_data."\n";

$decrypted_data = openssl_decrypt(hex2bin($encrypted_data), $algorithm, $key, OPENSSL_RAW_DATA, $iv);
echo "Decrypted: ".$decrypted_data."\n";

$decrypted_data = openssl_decrypt(pack('H*', $encrypted_data), $algorithm, $key, OPENSSL_RAW_DATA, $iv);
echo "Decrypted: ".$decrypted_data."\n";

?>

Salida:

Encrypted: 684cc5e0d1956c4c470e9986
Decrypted: Soy un texto
Decrypted: Soy un texto

De este modo se puede enviar y recibir datos entre ambos lenguajes de forma segura, siempre y cuando el ( algoritmo – key – iv ) sean iguales en ambos lenguajes.

Happy Coding!