Comparativa entre Go y MoonBit

En está ocasión haremos una comparativa entre el lenguaje de programación Go y Moonbit, el lenguaje orientado a I.A.

Go es un lenguaje de programación diseñado para ser rápido, eficiente, concurrente y fácil de aprender. Compilado y con tipado estático, destaca en el desarrollo backend, sistemas en la nube y redes gracias a su gestión automática de memoria y alto rendimiento.

Por el otro lado, MoonBit es una cadena de herramientas de lenguaje de programación nativo de IA para computación en la nube y edge. Además se compila a WebAssembly, JavaScript y C.

Observemos la siguiente tabla comparativa.

Comparativa Go y MoonBit

Característica	Go	MoonBit
Creador	Ken Thompson, Robert Pike y Robert Griesemer	Zhang Hongbo
Paradigma	Multiparadigma	Programación asíncrona basado en corrutinas, similar a Kotlin
Tipado	Estático	Estático
Extensión	.go	.mbt
Nivel de abstracción	Alto	Alto
Tipo de ejecución	Compilado	Compilado
Ideal para	Microservicios, aplicaciones concurrentes, etc.	Orientado a la I.A. y aplicaciones en tiempo real

Ambos lenguajes comparten ciertas características y poseen su propias peculiaridades. No obstante, la mejor forma de comparar estos lenguajes es realizando algunos ejemplos.

Para más detalles puedes ver esto: https://docs.moonbitlang.com/en/latest/tutorial/for-go-programmers/index.html

Creando proyectos con Go y MoonBit

Empezaremos creando un sencillo proyecto con Go.

1. Creamos un directorio y nos ubicamos en el:

$ mkdir holamundo
$ cd holamundo

2. Inicializamos el módulo:

$ go mod init example.com\holamundo

3. Creamos un programa ``main.go`` con el siguiente contenido:

package main

import "fmt"

func main() {
  fmt.Println("¡Hola, mundo en Go!")
}

La estructura del proyecto lucirá así:

holamundo/
   go.mod
   main.go

Construimos:

$ go build

Esto creará un ejecutable.

Salida:

¡Hola, mundo en Go!

Ahora con MoonBit.

1. Creamos el proyecto:

$ moon new holamundo
$ cd holamundo

El directorio principal y archivos quedarán de esta forma:

holamundo/
├── cmd
│   └── main
│       ├── main.mbt
│       └── moon.pkg
├── holamundo_test.mbt
├── config.mbt
├── holamundo.mbt
├── moon.mod.json
└── moon.pkg

El contenido del archivo ``main.mbt`` es el siguiente:

fn main {
  println("¡Hola, mundo en MoonBit!")
}

Ahora ejecutamos:

$ moon run cmd\main\main.mbt

Salida:

¡Hola, mundo en MoonBit!

Por el momento es todo. Continuaremos con la comparativa en próximas entregas.

Enlaces:

https://tour.moonbitlang.com/
https://projecteuler.net/
https://docs.moonbitlang.com/en/latest/tutorial/for-go-programmers/index.html
https://alquimistadecodigo.blogspot.com/search?q=go
https://go.dev/
https://emanuelpeg.blogspot.com/search?q=go

GCP: optimizando consultas y sentencias en BigQuery

BigQuery nos permite realizar las siguientes operaciones:

1. Consulta de datos: Puedes ejecutar consultas SQL complejas para extraer datos de tus conjuntos de datos y realizar análisis avanzados.
2. Análisis de datos en tiempo real: BigQuery admite consultas en tiempo real sobre datos de streaming, lo que te permite analizar y visualizar datos en tiempo real a medida que llegan.
3. Análisis geoespacial: BigQuery incluye funciones y operaciones para realizar análisis geoespaciales, como cálculos de distancia, intersecciones espaciales y agrupaciones geográficas.
4. Operaciones de agregación: Puedes realizar operaciones de agregación como SUM, AVG, COUNT, MAX y MIN en tus datos para resumir la información y obtener insights.
5. Procesamiento de texto: BigQuery proporciona funciones y operadores para procesar datos de texto, como búsquedas de patrones, análisis de sentimientos y extracción de entidades.
6. Integración con herramientas de análisis y visualización: Puedes integrar BigQuery con herramientas de análisis y visualización de datos populares como Google Data Studio, Tableau y Power BI para crear paneles interactivos y visualizaciones de datos.
7. Machine Learning: BigQuery ML te permite construir y entrenar modelos de aprendizaje automático directamente en tus datos almacenados en BigQuery, sin necesidad de moverlos a otro lugar.
8. Carga y exportación de datos: Puedes cargar datos en BigQuery desde archivos locales, Google Cloud Storage, servicios de streaming como Pub/Sub y otras fuentes de datos. También puedes exportar datos desde BigQuery a diferentes formatos de archivo y servicios de almacenamiento.
9. Seguridad y control de acceso: BigQuery ofrece controles de acceso granulares y opciones de cifrado para proteger tus datos y garantizar la conformidad con las normativas de privacidad.
10. Administración y monitoreo: BigQuery proporciona herramientas para administrar y monitorear tus recursos, consultas y cargas de trabajo, como el tablero de control de BigQuery y Cloud Monitoring.

Sin embargo, también tiene ciertos limitantes como lo pueden ser:

• Debes ser cuidadoso por el uso, ya que las cuotas pueden restringir ciertas operaciones iterativas. 
• Si operas sobre una misma tabla, puede haber bloqueos (lo que evitará un buen almacenamiento de tu información). 
• No permite subconsultas como en Informix o herramientas similares. 
• El tamaño de una fila no puede superar los 10MB.
• Etc.

Y es ahí donde entran las optimizaciones con CTEs (Common Table Expressions) o WITH en las consultas. Imaginemos el siguiente bloque de código:

/*
   Este bloque es para actualizar la información de
 la tabla2 desde la tabla1.
*/

begin
declare fecha_origen date default '2026-04-13';
declare fecha_actual date default '2026-05-09';

for record 
in(select user, info_process from
 `mydataset.tabla1` 
where date_process = fecha_origen) 
do
  update `mydataset.tabla2` 
set user = record.user, 
info_process = record.info_process, 
date_process= fecha_actual 
where date_process = fecha_origen ;
end for;

end;

El bloque realiza la operación de actualización correctamente, pero no es lo más óptimo. Pues debemos cuidar los recursos.

Rehacemos el bloque pero usando la cláusula de WITH. Esto nos permitirá la optimización del bloque y ahorraremos tiempo y recursos valiosos.

Tenemos entonces lo siguiente:

/*
   Este bloque es para actualizar la información de
 la tabla2 desde la tabla1.
*/

begin
declare fecha_origen date default '2026-04-13';
declare fecha_actual date default '2026-05-09';

update `mydataset.tabla2` as tab_up 
set user = src.user, 
info_process = src.info_process, 
date_process= fecha_actual 
from(
   select id, user, info_process 
   FROM `mydataset.tabla1` where date_process = fecha_origen 
) as src where  tab_up.id = src.id 
 and  tab_up.date_process = fecha_origen ;

end;

Aunque no empleamos la cláusula, seguimos su misma lógica: optimizar la consulta.

¿Qué pasaría si quisieramos hacer una inserción?

Tomando en cuenta el siguiente bloque:

/*
   Este bloque es para actualizar la información de
 la tabla2 desde la tabla1.
*/

begin
declare fecha_actual date default '2026-05-09';

for record 
in(select valor_mensual from
 `mydataset.tabla1` 
where date_process = fecha_actual and importe < 99.9) 
do
  
insert into `mydataset.tabla2`(valor_mensual) value (record.valor_mensual); 

end for;

end;

El bloque trabaja casi perfectamente, pero no es óptimo el uso de recursos.

Rehacemos el bloque con la lógica de WITH:

/*
   Este bloque es para actualizar la información de
 la tabla2 desde la tabla1.
*/

begin
declare fecha_actual date default '2026-05-09';


insert into `mydataset.tabla2`(valor_mensual) 
with source as(
  select t.valor_mensual from `mydataset.tabla1` t
  where t.date_process = fecha_actual and t.importe < 99.9
) select * from source;



end;

Como se puede observar si usamos la cláusula WITH y no solo su lógica como en el ejemplo del bloque UPDATE.

Y cómo es lógico, también lo podemos aplicar a las consultas con SELECT. Miremos una consulta no optimizada y comparémosla con una que sí lo está:

declare fecha_actual date default '2026-05-09';
declare importe_max float64;
set importe_max = 99.9;

select user, date_process, importe, valor_mensual
 `mydataset.tabla2`
where date_process = (
   select date_process
 `mydataset.tabla1`where date_process = fecha_actual 
) and importe = (
  select importe
 `mydataset.tabla1`where importe < importe_max 
);

Optimizada:

DECLARE fecha_actual DATE DEFAULT DATE '2026-05-09';
DECLARE importe_max FLOAT64 DEFAULT 99.9;

WITH filtro_fecha AS (
  SELECT date_process
  FROM `mydataset.tabla1`
  WHERE date_process = fecha_actual
),
filtro_importe AS (
  SELECT importe
  FROM `mydataset.tabla1`
  WHERE importe < importe_max
)
SELECT user, date_process, importe, valor_mensual
FROM `mydataset.tabla2`
WHERE date_process IN (SELECT date_process FROM filtro_fecha)
  AND importe IN (SELECT importe FROM filtro_importe);

¿Y qué de las operaciones de borrado?

Sin optimizar:

begin
declare fecha_actual date default '2026-05-09';

for record 
in(select valor_mensual from
 `mydataset.tabla1` 
where date_process = fecha_actual and importe < 99.9) 
do
  
delete from `mydataset.tabla2`where valor_mensual = record.valor_mensual
 and date_process = fecha_actual;

end for;

end;

Optimizada:

DECLARE fecha_actual DATE DEFAULT DATE '2026-05-09';

WITH valores_a_borrar AS (
  SELECT valor_mensual
  FROM `mydataset.tabla1`
  WHERE date_process = fecha_actual
    AND importe < 99.9
)
DELETE FROM `mydataset.tabla2`
WHERE date_process = fecha_actual
  AND valor_mensual IN (SELECT valor_mensual FROM valores_a_borrar);

Como hemos visto, el uso de la cláusula WITH nos permite evitar subconsultas repetitivas y hace el código más legible y eficiente.

Seguiremos hablando de este tema en próximas entregas.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/04/gcp-google-cloud-bigquery.html
WITH statements in BigQuery SQL (Youtube)

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