Vibe Coding y el Prompt engineering

Según san Google, la Ingeniería de prompts (prompt engineering) es: el arte y la ciencia de estructurar, diseñar y optimizar las entradas (indicaciones) para guiar a la IA generativa y a los grandes modelos de lenguaje (LLM) hacia la producción de resultados precisos, relevantes y de alta calidad.

Esta "nueva ciencia" actúa como un puente entre la intención humana y la comprensión de la IA, siendo una habilidad crucial para mejorar el rendimiento en tareas como la generación de texto, el razonamiento y la codificación.

En otras palabras, es una "ingeniería" que ayuda al usuario a escribir sus prompts.

Si buscas en plataformas como Udemy verás varios cursos sobre ésto.

En otros tiempos nuestros profesores y profesionales de antaño se reirían de está definición y "ciencia".

La idea de que cualquiera puede programar puede ser peligroso y deberíamos desconfiar.

Es cierto, gente sin estudios o especialización pueden lanzarse a "crear" software en cuestión de minutos. Creer ser programador sin serlo.

Crear una aplicación para lectura de datos climatológicos o hasta tu propio videojuego puede ser muy seductor. Más si contamos el hecho de que no todos cuentan con los conocimientos básicos necesarios para hacerlo por su cuenta. "Que lo haga Claude Code por mí", dirán muchos.

Pongamos un ejemplo sobre la mesa.

Un programador, dependiendo de muchos factores, puede tardar en crear una aplicación con determinada tecnología. Pasar un tiempo considerable haciendo pruebas y corrigiendo detalles. No olvidar la documentación. Eso lleva tiempo y esfuerzo.

Una persona, profesionista o no, sin conocimientos sólidos (o nulos) en programación puede "crear" la misma aplicación y de paso pedirle a su agente IA que le haga las pruebas, corrección de vulnerabilidades y su correspondiente docuementación. Eso ahorra tiempo y esfuerzo.

No importa si se tiene el conocimiento o no. El trabajo ya está hecho.

Esto a la larga traerá problemas. No solo a los programadores sino también a los que creen serlo porque ChatGPT o cualquier otra herramienta les hizo el trabajo.

¿Qué tal si la burbuja se rompe en el futuro?

¿Qué pasaría si en el futuro el uso de I.A. se restringue o aumenta su precio por su uso?

¿El "ingeniero de prompts" será capaz de continuar su trabajo sin el asistente virtual ?

¿Qué pasa si el código generado requiere revisión o remediación de vulnerabiliades?

¿Qué hacer con un código compuesto por miles de miles de líneas de código que el "ingeniero de prompts" no comprende?

¿Esperemos a que nuestro asistente virtual baje de precio?

La Ingeniería de prompts es algo que en otras épocas no pasaría. Nadie pagaría licencias para que su empleado "pida cosas" y se las hagan.

Cuando es "gratis" es por que hay un coste de por medio.

Cuando una tecnología de está naturaleza es liberada no es para beneficiar a la humanidad, es todo lo contrario.

Lo estamos viendo hoy en día.

Estudiantes de primaria, secundaria y preparatoria que piden a ChatGPT que les hagan la tarea.

Universitarios que no saben escribir un simple ensayo, porque "se aburren". Mejor que lo haga ChatGPT.

Profesionistas que oxidan sus conocimientos y dejan que un asistente les haga el trabajo, además urge y "era para ayer".

La idiocracia es el futuro.

La Ingeniería del prompts en su momento fue "algo novedoso" y "vanguardista", impulsado incluso por empresas educativas como Platzi, Udemy, etc. que ahora se ven afectadas económicamente por la creciente ola de uso de herramientas de I.A. por encima de los cursos.

Su ideología "ha cambiado", ahora señalan que no debemos confiar ciegamente en las repuestas de la I.A. Cuando en su momento decían que "era el futuro de la programación y que todos lo deberíamos estar usando".

Como dijimos anteriormente... el futuro está llegando.

Enlaces:

https://www.enriquedans.com/2025/11/cuando-el-software-se-escribe-a-ojo-por-que-el-vibe-coding-seduce-y-por-que-conviene-desconfiar.html
https://www.enriquedans.com/2026/04/la-impopularidad-de-la-inteligencia-artificial-ya-no-se-puede-maquillar.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 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

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:

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

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

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

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

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