viernes, 1 de mayo de 2026

Vibe Coding: cuando el programador es un espectador (2da parte)

El Vibe Coding ha venido a cambiar el mundo de la programación.

Hacer que cualquier persona, programador o no, pueda crear aplicaciones completas en cuestión de horas o minutos es una realidad. Pero también un arma de doble filo.

Para quienes nunca han programado les hará creer que son programadores (spoiler, nunca lo serán).

Para quienes son programadores les hará cuestionar bastantes cosas. El síndrome del impostor cobrará más víctimas.

Lo que un joven imberbe sin conocimientos sólidos de programación puede hacer con la I.A. (Github Copilot, ChatGPT, etc.) puede conmocionar hasta al programamdor más versado.

Últimamente las empresas han optado por emplear herramientas de I.A. en sus equipos de trabajo. Desde programadores, gente de recursos humanos, administradores, contadores, etc. han visto que su forma de trabajo debe adaptarse a las "nuevas tecnologías". Quien no lo haga posoblemente sea reemplazado por quien si lo haga.

Los empresarios relamen sus labios creyendo que con la I.A. se ahorrarán mucho dinero. Algunos hasta están considerando emplear solo I.A. para no tener que pagar a los muchos empleados que "gastan recursos" de sus empresas.

Y no solo empresas de la tecnología. Empresas relacionadas con los alimentos, con la manufactura, etc. están considerando la posibilidad de reemplazar a los empleados humanos por empleados robóticos asistidos por I.A.

Pero volvamos al Vibe Coding, el nuevo "paradigma de programación basado en vibraciones".

Un paradigma donde el "programador" (espectador) escribe prompts para que el agente o asistente virtual "haga su trabajo".

Si el resultado es el adecuado, el trabajo está hecho.

Si no lo es, se le indicará los cambios o ajustes a realizar para que el trabajo este concluido de acuerdo a sus requerimientos.

Para el solicitante serán horas o hasta días (incluso semanas) de trabajo realizado.

Para las empresas una excusa para exigir mayor productividad a los empleados y, por ende, mayores ganancias a la empresa.

Si no da ganancias (mayores ganancias) inmediatas, habrá problemas.

El empleador tendrá la convicción de que la I.A. debe ahorrar horas, días, semanas, meses y años de trabajo. Si no es así, ¿para qué pagar costosas licencias para los empleados?

Pues le prometieron que "aumentaría la productividad".

Pero no nos perdamos.

Volvemos a la promesa primordial no escrita del Vibe Coding: cualquiera puede programar.

Cualquiera puede ser "programador" si le da prompts correctos a una I.A. Si están bien escritos, el asistente hará el trabajo. Si no lo están, intentamos de nuevo hasta que quede el trabajo.

"Créame una aplicación que lea archivos CSV desde una simple página HTML con Javascript".

"Créame una aplicación que lea un RSS y envíe correos a todos mis contactos".

"Créame un vídeo juego tipo Pacman para instalarlo en mi celular".

"Ayúdame a escribir un correo urgente a mi jefe."

"Ayúdame a hacer mi tarea".

Incluso ya hay cursos para "Ingeniería de prompts" donde se les enseñará al "programador" a crear prompts que ejecute la I.A.

El futuro no es prometedor para quienes están estudiando carreras relacionas a la informática. ¿Cómo competir con un tipo que usa I.A. hasta para preguntar la hora?

El programador de antes creaba sus "búnkers" de código para cualquier ocasión.

El "programdor" de ahora tendrá miles de prompts por si acaso de.

El futuro está llegando...

Enlaces:

https://codemonkeyjunior.blogspot.com/2026/04/vibe-coding-cuando-el-programador-es-un.html
https://www.enriquedans.com/2025/12/el-espejismo-del-vibe-coding-cuando-la-relajacion-progresiva-convierte-al-programador-en-espectador.html

viernes, 24 de abril de 2026

Vibe Coding: cuando el programador es un espectador

 

El año 2025 cambió el mundo de la programación.

Herramientas como ChatGPT, Google Gemini, Claude Code, etc. prometían hacer más rápido y mejor el trabajo de cualquier programador.

Y no solo eso, también el trabajo de cualquier contador, administrador, abogado y hasta psicólogo. Es más, hasta en la industria manufacturera está planeando el uso de robots con inteligencia artificial para sustituir la mano de obra humana.

Andrés Oppenheimer lo mencionaba en su libro ("¡Sálvese quien pueda!"), el 47% de los empleos corren el riesgo de ser reemplazados por la automatización. Y no es exageración. Quien mueve los hilos del mundo poco le interesa si lo aceptamos o no. Es una realidad: la I.A. no viene para ayudar al humano, lo viene a sustituir

No a corto plazo, pero si lo hará.

Empresas que antes estaban renuentes al uso de I.A. en sus instalaciones ahora hasta cursos o capacitaciones ofrecen en sus instalaciones. Los empleado están obligados al uso de estás herramientas para optimizar su trabajo y hacerlo más rápido (pues hay métricas que cumplir). La orden esta dada: ¡Quien no se adapte a las nuevas herramientas de I.A. esta a punto de desaparecer!

Cualquiera puede ser reemplazado. No solo programadores, también directivos. administradores, recepcionista, etc. que no la sepan usar o se nieguen a hacerlo o que "estén de más".

Las empresas se frotan las manos. Vislumbran un futuro donde no requerirán pagar miles o centenares de empleados. Mucho dinero ahorrado.

"¿Para qué pagar a todo un equipo si tenemos I.A.?"
"Si tenemos que pagar cuentas de Github Copilot, Claude Code, etc., ¿para qué contratar más programadores?"

Los directivos exigirán mejores resultados a quienes les den las licencias. Exigirán menos errores y más aciertos. Lo que antes te llevaba una semana ahora lo querrán en horas. Su argumento será: "con la I.A. te debes tardar menos".

Empresas como IBM temblaron cuando se afirmó que Claude Code podría hacer en menor tiempo y de mejor manera el trabajo de miles de sus empleados.

Empresas como Oracle prescindieron de miles de sus empleados debido al uso de automatización e I.A.

Microsoft no tarda en hacer lo mismo. 

2026 es un año de cambios.

Los programadores se convertirán en espectadores si no hacen algo al respecto.

¿Habrá que hacer leyes para proteger nuestro trabajo?


La industria del doblaje ya lo hizo. Se adelantaron a la visión de empresarios que veían a la I.A. como una forma de ahorrarse mucho dinero. ¿Nosotros tendremos que hacer algo similar?

Las empresas son libres de hacer lo que mejor les parezca, pero deberían considerar que quien paga sus productos o servicio son personas de carne y huesos, no máquinas o I.A.

 Imagina un mundo donde todo está automatizado. Donde no se necesiten humanos para dar servicios o vender productos. Ese mundo solo es para privilegiados. Para personas que tienen la vida arreglada. 

Quizás un plan a futuro (la famosa agenda 2030).

Donde solo individuos privilegiados vivan en un Edén tecnológico.

¿Qué pasará con los demás?

¿Deberán adaptarse o morir?


Enlaces:


sábado, 18 de abril de 2026

Hablemos de Micronaut y Helidon

En la entrega anterior hablamos de Quarkus (Supersonic Subatomic Java), el cual es un framework cuya filosofía es trabajar en Cloud y forma de trabajo nos recuerda a Spring Boot (sin decir que los "copia").

Ahora hablaremos de Micronaut y Helidon.

Micronaut es un framework moderno, basado en JVM y de pila completa para la creación de aplicaciones modulares, de microservicios y sin servidor, fácilmente comprobables.

Para instalarlo hay varias formas: https://micronaut.io/download/

Helidon es una colección de bibliotecas Java para escribir microservicios que se ejecutan en un núcleo web rápido impulsado por Netty. Es pequeño, rápido y divertido de usar.

Tiene dos versiones:

  • Helidon SE. 
  • Helidon MP.

Existen varias formas de instalarlo, pero se recomienda instalar la herramienta CLI: https://helidon.io/docs/v4/about/cli

Ambos frameworks comparten similitudes y diferencias entre otras herramientas como Quarkus/RESTEasy y Spring Boot.

Observemos la siguiente tabla comparativa:

Característica Helidon Micronaut
Origen Desarrollado por Oracle Desarrollado por Object Computing, Inc. (OCI)
Arquitectura Dos sabores: Helidon SE (funcional, ligero) y Helidon MP (basado en MicroProfile) Diseñado desde cero para microservicios, con fuerte soporte a inyección de dependencias y AOP
Modelo de programación Funcional (SE) y MicroProfile (MP) Basado en anotaciones, DI y configuración simplificada
Soporte Cloud-Native Kubernetes-native, integración con GraalVM Optimizado para GraalVM y entornos serverless
Tiempo de arranque Muy rápido, especialmente con Helidon SE Extremadamente rápido, diseñado para aplicaciones serverless
Consumo de memoria Bajo, ideal para microservicios en contenedores Bajo, con optimizaciones para entornos de alta densidad
Compatibilidad Java EE, MicroProfile, integración con APIs estándar Compatibilidad con Spring, soporte para múltiples lenguajes JVM
Ventajas principales - Simplicidad con Helidon SE
- Estándares MicroProfile
- Integración nativa con Oracle Cloud
- Arranque ultrarrápido
- Bajo consumo de memoria
- Ecosistema activo y flexible
Similitudes - Ambos soportan GraalVM
- Orientados a microservicios cloud-native
- Bajo consumo de recursos
- Integración con Kubernetes y contenedores

Empezando con Micronaut

Con Chocolatey:

$ choco install micronaut

Con SDKMAN!:

$ sdk update
$ sdk install micronaut

Verificamos la instalación:

$ mn

Empezando con Helidon

Con Powershell:

$ PowerShell -Command Invoke-WebRequest -Uri "https://helidon.io/cli/latest/windows/helidon.exe" -OutFile "C:\Windows\system32\helidon.exe"

Con Linux bash:

$ curl -L -O https://helidon.io/cli/latest/linux/helidon
$ chmod +x ./helidon
$ sudo mv ./helidon /usr/local/bin/

Verificamos:

$ helidon version

Hemos instalado tanto Helidon como Micronaut.

Hola, mundo con Micronaut

1. Iniciamos un proyecto:

$ mn create-app hello-world

Nos ubicamos en el directorio creado.

2. Modificamos la clase ``HolaController.java``:

package com.inforhomex.app.controller;

import com.inforhomex.app.resource.HolaResource;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.MediaType;

/**
 * Clase controller de la aplicación.
 */
@Controller("/hola")
public class HolaController implements HolaResource{
	
    @Override
	@Get(produces = MediaType.TEXT_PLAIN)
    public String getSaludo(){
        return "¡Hola, mundo en Micronaut!";
    }
}

3. Construimos:

$ mvn clean install

4. Ejecutamos:

$ ./mvnw mn:run

Abrimos el navegador en la ruta: http://localhost:8080/hola

Salida:

¡Hola, mundo en Micronaut!

Hola, mundo con Helidon

1. Iniciamos un proyecto:

$ helidon init
$ cd holamundo-se

2. Modificamos la clase ``Main.java``, específicamente en este método:

 static void routing(HttpRouting.Builder routing) {
        routing
               .register("/greet", new GreetService())
               .get("/simple-greet", (req, res) -> res.send("Hola, mundo!")); 
    }

3. Construimos:

$ mvn clean package

4. Ejecutamos:

Abrimos el navegador en la ruta: http://localhost:8080/simple-greet

Salida:

Hola, mundo!

Continuaremos con este tema en próximas entregas.

Enlaces:


https://alquimistadecodigo.blogspot.com/2023/03/micronaut.html
https://alquimistadecodigo.blogspot.com/2025/04/helidon-instalando-el-cli.html


domingo, 12 de abril de 2026

Hablemos de Quarkus

Quarkus es un framework (creado por Red Hat) moderno de Java diseñado para optimizar aplicaciones en entornos de nube, contenedores y Kubernetes. Su principal ventaja es ofrecer tiempos de arranque ultrarrápidos y bajo consumo de memoria, lo que lo hace ideal para microservicios y arquitecturas serverless.

Diseñado para funcionar tanto en JVM tradicional como en compilaciones nativas con GraalVM. 

Compatible con librerías y estándares conocidos: Eclipse MicroProfile, Spring, RESTEasy (JAX-RS), Hibernate ORM (JPA), Apache Kafka, Infinispan, Camel, entre otros.

Su sistema de inyección de dependencias (CDI) y extensiones permite integrar fácilmente nuevas funcionalidades.

Lo podemos usar para:

  • Microservicios en Kubernetes: optimiza despliegues en contenedores con tiempos de arranque mínimos. 
  • Aplicaciones serverless: ideal para funciones que requieren ejecución rápida y eficiente. 
  • Aplicaciones reactivas y REST: soporta APIs modernas y comunicación asíncrona. 
  • Integración con bases de datos y mensajería: Hibernate, Kafka, PostgreSQL, entre otros. 
  • Desarrollo ágil: incluye un modo de desarrollo con recarga en caliente para iterar rápidamente.

Principales características:

  • Arranque ultrarrápido: aplicaciones listas en milisegundos. 
  • Consumo reducido de memoria: optimizado para entornos con recursos limitados. 
  • Compilación nativa con GraalVM: genera binarios ligeros y eficientes. 
  • Extensible: gran ecosistema de extensiones para añadir soporte a tecnologías populares. 
  • Developer Joy: herramientas integradas para mejorar la experiencia del desarrollador (live reload, CLI). 
  • Integración con la nube: pensado para Kubernetes, OpenShift y servicios cloud.

Para usar Quarkus lo puedes instalar de las siguientes formas:

Desde una terminal Linux, Mac OS, Windows (con WSL o Cygwin/MinGW):

$ curl -Ls https://sh.jbang.dev | bash -s - trust add https://repo1.maven.org/maven2/io/quarkus/quarkus-cli/
$ curl -Ls https://sh.jbang.dev | bash -s - app install --fresh --force quarkus@quarkusio

Con SDKMAN!:

$ sdk install quarkus

Con Powershell:

$ iex "& { $(iwr https://ps.jbang.dev) } trust add https://repo1.maven.org/maven2/io/quarkus/quarkus-cli/"
$ iex "& { $(iwr https://ps.jbang.dev) } app install --fresh --force quarkus@quarkusio"

Nota: También podemos crear un proyecto Quarkus usando Maven.

Verificamos la instalación:

$ quarkus --version

Emepzando con Quarkus

1. Vamos a abrir una terminal y tecleamos lo siguiente:

$ quarkus create && cd code-with-quarkus

Esto nos creará un proyecto y nos ubicará en el directorio principal.

2. Ejecutamos la aplicación:

$ quarkus dev

Si todo va bien, abrimos un navegador en la URL: http://localhost:8080/

Con esto hemos creado nuestra primera aplicación con Quarkus.

Este framework se podría considerar como el verdadero contendiente de Spring Boot dadas sus similitudes. Aunque existen otras alternativas como Helidon y Micronaut que no se quedan atrás.

En este blog ya hemos hablado de Quarkus indirectamente y vimos cómo es ideal para crear aplicaciones tipo REST.

En próximas entregas hablaremos un poco de Helidon y Micronaut.

Enlaces:

https://es.quarkus.io/
https://alquimistadecodigo.blogspot.com/2022/11/un-vistazo-quarkus-el-supersonic.html
https://code.quarkus.io/
https://alquimistadecodigo.blogspot.com/2023/01/quarkus-un-spring-boot-mejorado.html

lunes, 6 de abril de 2026

LLVM: una herramienta para crear compiladores

LLVM (Low Level Virtual Machine) es una infraestructura de compiladores que permite transformar y optimizar código de distintos lenguajes de programación. No es un compilador único, sino un conjunto de herramientas que sirven para crear compiladores, analizadores y optimizadores de código.

En este blog ya hemos hablado, burdamente, de lo que conforma un lenguaje de programación. Sin embargo, sería importante recordar algunos detalles.

Un compilador es un programa que traduce el código que escribes (por ejemplo en C, Rust o Java) a un lenguaje que la computadora entiende directamente: el código máquina. Ejemplo, tú escribes una receta en español, el compilador la traduce al "idioma" de la computadora para que pueda cocinarla.

Un analizador de código es la parte del compilador que lee y entiende tu código fuente. Verifica que lo que escribiste tenga sentido (sintaxis correcta, variables bien usadas, etc.). Es como un profesor que revisa tu redacción y te dice si las frases están bien construidas antes de publicarlas.

Un optimizador de código es una herramienta que mejora el código para que sea más rápido o consuma menos recursos. Reorganiza instrucciones, elimina pasos innecesarios y aprovecha mejor el hardware. Llanamente, el optimizador busca el camino más corto y rápido para llegar a algo.

Estos tres se relacionan de esta manera:

  • Analizador: entiende tu código y lo valida. 
  • Compilador: traduce ese código a instrucciones que la máquina entiende. 
  • Optimizador: pule esas instrucciones para que se ejecuten de la mejor manera posible.

LLVM al ser un conjunto de bibliotecas y herramientas que permiten construir compiladores y optimizadores no está limitado a un lenguaje específico; se usa en C, C++, Rust, Swift, Julia, Haskell, entre otros. Está diseñado como bloques reutilizables (frontends, optimizadores, backends).

¿Para qué sirve LLVM?

  • Compilación: Convierte código fuente en código máquina optimizado. 
  • Optimización: Mejora el rendimiento del código en tiempo de compilación y ejecución. 
  • Portabilidad: Permite que un mismo lenguaje se ejecute en múltiples plataformas. 
  • Experimentación: Ideal para investigadores y desarrolladores que quieren crear nuevos lenguajes o probar técnicas de optimización.
  • Ejemplo real: El compilador Clang (para C/C++/Objective-C) está construido sobre LLVM.

¿Qué hace LLVM?

  1. Traduce código a un lenguaje intermedio (LLVM IR) que es más fácil de analizar y optimizar. 
  2. Optimiza ese código para que sea más rápido y eficiente. 
  3. Genera código máquina para distintas arquitecturas (x86, ARM, etc.), lo que permite que tu programa corra en diferentes dispositivos.

LLVM es como el motor universal que hace funcionar muchos lenguajes modernos (Rust, Swift, Julia, Haskell).

Como desarrollador, puedes usarlo para compilar, optimizar y experimentar con lenguajes modernos o incluso crear el tuyo propio.

Probando LLVM

Vamos a comenzar instalandolo:

Linux:

$ sudo apt update
$ sudo apt install llvm clang

Windows:

$ choco install llvm

Vamos a crear un sencillo programa que verifique si un número entero es mayor a 100.

mayor.c

#include <stdio.h>

int main() {
    printf("\t Determinar si un número es mayor a 100 \n");
int numero = 120; if (numero > 100) { printf("El número es mayor que 100\n"); } else { printf("El número es menor o igual a 100\n"); } return 0; }

Compilams con la herramienta ``clang``:

$ clang mayor.c -o mayor

Creará un ejecutable:

$ ./mayor

Salida:

El número es mayor que 100

Ahora usaremos LLVM para ver el código intermedio (LLVM IR):

$ clang -S -emit-llvm mayor.c -o mayor.ll

Esto genera un archivo ``mayor.ll`` con el Intermediate Representation (IR). En ese archivo verás instrucciones más “básicas” que LLVM entiende, por ejemplo:

define i32 @main() {
entry:
  %numero = alloca i32, align 4
  store i32 120, i32* %numero, align 4
  %0 = load i32, i32* %numero, align 4
  %cmp = icmp sgt i32 %0, 100
  br i1 %cmp, label %if.then, label %if.else
  ...
}

Optimizamos el código:

$ clang -S -emit-llvm mayor.c -o mayor.ll

Esto genera una versión optimizada del IR, eliminando redundancias y mejorando el rendimiento.

Enlaces:

https://llvm.org/
https://codemonkeyjunior.blogspot.com/2024/02/lo-que-conforma-un-lenguaje-de.html
https://clang.llvm.org/
https://es.wikipedia.org/wiki/LLVM
https://www.reddit.com/r/ProgrammingLanguages/comments/kl7n03/what_is_meant_by_llvm_and_a_language_frontend/
https://aosabook.org/en/index.html

sábado, 4 de abril de 2026

WebAssembly con Dlang

WebAssembly es un lenguaje de bajo nivel, similar a ensamblador, diseñado para ser rápido de cargar y ejecutar en navegadores modernos. Su objetivo es permitir que aplicaciones escritas en distintos lenguajes se ejecuten en la web con velocidad casi nativa.

Los formatos que soporta son:

  • .wasm: un formato binario ejecutable. 
  •  .wat: un formato formato de texto legible.

Se complementa con JavaScript; permite invocar funciones WASM desde JS y viceversa. Y como vimos en este blog, también puedes optar por usar un lenguaje como Grain cuya compilación es directa a WASM.

¿Cuál es el objetivo de WebAssembly?

El objetivo de WebAssembly es compilar código escrito en lenguajes como Rust, C o C++ (entre otros) y transformarlo en un módulo .wasm que puede ejecutarse en navegadores o en entornos como Node.js con rendimiento cercano al nativo.

Flujo típico de trabajo con WebAssembly:

  1. Escribimos nuestro código en un lenguaje soportado (ej. Rust, C, C++, Go, AssemblyScript). 
  2. Compilamos ese código a WebAssembly y se generará un archivo .wasm
  3. Cargamos el módulo en tu aplicación web usando JavaScript. 
  4. Ejecutamos las funciones exportadas desde el módulo .wasm  como si fueran algo nativo.

¿Y qué con Dlang?

Dlang es un lenguaje similar al mítico y poderoso C. No solo en su sintaxis sino en su filosofía.

Dlang permite generar código WASM mediante la herramienta LDC.

Creando código WASM con Dlang

Crearemos una sencilla función llamada ``suma_wasm.d``.

extern(C): 

double suma(double a, double b) { return a + b; }

void _start() {}

Compilamos para generar el código WASM:

$ ldc2 -mtriple=wasm32-unknown-unknown-wasm -betterC suma_wasm.d

Ahora crearemos una página HTML para cargar el código WASM generado (suma_wasm.wasm).

index.html

<html>
  <head>
    <script>
      const request = new XMLHttpRequest();
      request.open('GET', 'suma_wasm.wasm');
      request.responseType = 'arraybuffer';
      request.onload = () => {
        console.log('respuesta recibida');
        const bytes = request.response;
        const importObject = {};
        WebAssembly.instantiate(bytes, importObject).then(result => {
          console.log('iniciado');
          const { exports } = result.instance;
          const r = exports.suma(33, 10.88);
          console.log('r = ' + r);
        });
      };
      request.send();
      console.log('solicitud enviada');
    </script>
  </head>
  <body>
    Código D desde WebAssembly
  </body>
</html>

Ahora ejecutaremos este comando para abrir la página web:

$ python -m http.server 8000

Abrimos un navegador en la ruta: http://localhost:8000

Salida:

solicitud enviada
respuesta recibida
iniciado
r = 43.88

WebAssembly permite que aplicaciones complejas escritas en lenguajes de alto nivel como D, C/C++, Rust, etc. se ejecuten en aplicaciones web a través de un compilado .wasm.

Imaginemos que hemos creado una aplicación para gestionar datos complejos en Rust o Java y la queremos ejecutar como una aplicación web. Con WebAssembly es posible. Se podrá compialr ese código y generar un archivo .wasm que podrá ser cargado en una página web.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://dlang.org/
https://webassembly.org/
https://wiki.dlang.org/Generating_WebAssembly_with_LDC
https://alquimistadecodigo.blogspot.com/2026/04/webassembly-con-rust.html


jueves, 2 de abril de 2026

Grain, un lenguaje para WebAssembly

Grain es un lenguaje de programación funcional, moderno y de código abierto, diseñado principalmente para compilarse a WebAssembly (Wasm), lo que le permite funcionar eficientemente tanto en navegadores web como en servidores. Su objetivo es hacer accesibles las características avanzadas de los lenguajes funcionales, siendo fácil de aprender, fuertemente tipado y flexible.

¿Qué es WebAssembly?

  • Un formato de instrucciones binarias para una máquina virtual basada en pila. 
  • Diseñado como un destino de compilación portátil para lenguajes de programación, lo que permite su implementación en la web para aplicaciones cliente y servidor.

Características más importantes:

  • Eficiente y rápido. 
  • Seguro. 
  • Abierto y depurable. 
  • Parte de la plataforma web abierta.

Grain es una alternativa directa a la compilación de código wasm. Si quieres usar lenguajes como C o C++ tendrías que usar https://emscripten.org/. Si quieres usar Python podrás elegir entre https://pyodide.org/en/stable/, https://github.com/wasmerio/py2wasm o https://pygame-web.github.io/. Entre otras alternativas dependiende el lenguaje de programación (Java, C#, Kotlin, Scala, Go, etc.).

Grain posee sus propias herramientas para compilar código y su línea de comandos.

Lo puedes instalar en sistemas Mac OS, Linux y Windows.  Si no deseas instalarlo, puede visitar este sitio y probar el lenguaje: https://grain-lang.org/try/

Otra forma de obtenerlo es con Node (V22 como mínima versión). Primero clonamos el repositorio:

$ git clone https://github.com/grain-lang/grain
$ cd grain

Una vez clonado el repositorio y ubicandonos en el directorio ejecutamose estos comandos para su construcción:

$ npm ci
$ npm run compiler build

Validamos la instalación:

$ grain --version

¡Tenemos instalado Grain en nuestro sistema!

Ahora demos un vistazo al lenguaje.

Al ser un lenguaje fuertemente tipado posee tipos básicos como Number, Bool, String y Char. Observemos la siguiente tabla:

Tipo Descripción Ejemplo
Number Representa números enteros o decimales. let x: Number = 42
Bool Valores booleanos: verdadero o falso. let flag: Bool = true
String Secuencia de caracteres, texto. let msg: String = "Hola Grain"
Char Un solo carácter Unicode. let letter: Char = 'A'

Grain usa la palabra clave ``let`` para introducir nuevos valores con un nombre determinado, a los que se les llama enlaces:

module Main

let numero = 42
let bandera = true
let saludo = "Bienvenido a Grain!"
and letra = 'A'

Hola mundo en Grain

Probemos el clásico programa "Hola, mundo" en este lenguaje.

holamundo.gr

module HolaMundo

print("Hola, mundo en Grain")

Para compilar y ejecutarlo directamente tecleamos:

$ grain holamundo.gr

Con pasos separados:

$ grain compile holamundo.gr 
# Te creará un archivo `holamundo.gr.wasm`
$ grain run holamundo.gr.wasm

Notar que te crea un archivo WASM ejecutable.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://grain-lang.org/
https://webassembly.org/
https://alquimistadecodigo.blogspot.com/2026/04/webassembly-hola-mundo-en-python-con.html




Vibe Coding: cuando el programador es un espectador (2da parte)

El Vibe Coding ha venido a cambiar el mundo de la programación. Hacer que cualquier persona, programador o no, pueda crear aplicacione...

Etiquetas

Archivo del blog