Vibe Coding: programando vía I.A.

2025 se ha vuelto el año de la Inteligencia Artificial. Herramientas para diseño gráfico, arquitectura, generación de imágenes, audio y vídeo, editores de código que la integran (VsCode, FireBase, etc.) y demás.

Empresas que estaban reacias en implementarla ahora hasta solicitan que sus desarrolladores tengan algún tipo de especialidad o certificación como Github Copilot.

¿Qué consecuencias tendrá la implementación de herramientas I.A. en las empresas?

¿Significará que el programador quedará obsoleto?

¿Debo ser experto en Github Copilot antes de tener buenas bases de programación?

¿Será mejor buscar cómo convertirme en Youtuber o Influencer (gente que vive de sus seguidores y no trabaja)?

Preguntas y preguntas que debemos plantearnos seriamente.

Como dijimos en un post anterior, quien se duerma en sus laureles es probable que si sea reemplazado. Pero no por una I.A. sino por un programador que se actualice constantemente. Que tome cursos para mejorar sus habilidades y tener otros conocimientos. Y además sepa usar las herramientas I.A. como Github Copilot. Que sepa plantear problemas y sepa lo que quiera como resultado.

Solo el programador que no conozca el lenguaje con el que quiere trabajar será el primero en desaparecer.

Si dice que sabe Java y Spring Boot, pero en realidad no sabe y espera volverse experto en 3 días estará perdido, acabado. Si le dan el trabajo, se volverá loco al ver que por sí solo Java es un universo por aprender. Entenderá (a la mala) que hacer microservicios solo es una parte de Spring framework. Es más que hacer peticiones GET, POST, PUT y DELETE.

La I.A. no le hará la vida más fácil. Se la puede complicar. Si no conoce el lenguaje que dijo conocer al 100% verá las respuestas de copilot, grok etc. como un lenguaje indescifrable e incomprensible.

Solo el programador que sí conoce un lenguaje y que ha desarrollado aplicaciones de la vida real sobrevivirá en un mundo repleto de herramientas con I.A.

Sabrá cómo pedir y qué resultados debe arrojar. Le ahorrará el trabajo en las configuraciones, en el código que es tedioso realizar.

El trabajo de semanas podrá realizarse en días u horas (dependiendo de la complejidad, no todo es magia).

Además podrá documentar el código de su proyecto en tan solo unos minutos.

Podrá crear guías o manuales de usuario.

Podrá crear test unitarios antes del despliegue a producción.

Podrá usar herramientas como Doker y Kubernetes y ahorrarse mucho trabajo en su administración.

El Vibe Coding es una realidad, nos guste o no. Si la sabemos aprovechar será de mucha ayuda.

Si no, entonces el tiempo lo dirá.

Enlaces:

https://codemonkeyjunior.blogspot.com/2025/03/como-ser-un-mejor-programador-en-un.html
https://codemonkeyjunior.blogspot.com/2025/07/las-leyes-no-escritas-de-la.html
https://codemonkeyjunior.blogspot.com/2025/06/vibe-coding-la-programacion-via-ia-el.html
https://alquimistadecodigo.blogspot.com/2023/03/chatgpt-usando-una-ia-como-asistente.html
https://codemonkeyjunior.blogspot.com/2025/04/firebase-studio-el-visual-studio-code.html

Conociendo Akka

¿Qué es Akka?

Es una plataforma (o framework) inspirado por Erlang que busca el desarrollo simple de aplicaciones escalables y multihilo.

Permite crear servicios transaccionales, duraderos y en tiempo real que distribuyen lógica y datos de forma conjunta.

Se puede usar con Java o Scala distintivamente.

Donde la concurrencia no se basa en la memoria compartida entre varios hilos y los métodos de sincronización (como en Java) sino que está basado en el sistema Actor-Modelo para ello.

Donde un actor es un objeto con el que puedes interactuar enviándole mensajes: cada actor puede procesar mensajes y enviarle mensajes a otros actores. Además de que los actores pueden tener un estado interno pero la comunicación sólo ocurre pasando mensajes y nunca a través de estructuras compartidas.

Donde una máquina virtual JVM pueden correr millones de actores a la vez construyendo una jerarquía padre (supervisor)-hijo con los padres monitorizando el comportamietno de los hijos. Permitiendo una forma sencilla splitear nuestros actores entre varios nodos de un cluster.

Un sencillo ejemplo con Akka

Iniciaremos creando unproyecto con Maven:

$ mvn archetype:generate -DgroupId=com.codemonkey -DartifactId=akka-hello-world -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Nos ubicamos en el directorio creado:

$ cd akka-hello-world

Editamos el archivo pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.codemonkey</groupId>
    <artifactId>akka-hello-world</artifactId>
    <version>1.0</version>
    <dependencies>
        <dependency>
            <groupId>com.typesafe.akka</groupId>
            <artifactId>akka-actor-typed_2.13</artifactId>
            <version>2.6.21</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.12.1</version>
                <configuration>
                    <source>21</source>
                    <target>21</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Construimos el proyecto:

$ mvn clean install -X

Observemos la clase principal.

HelloWorld.java

package com.codemoneky;

import akka.actor.typed.ActorSystem;
import akka.actor.typed.Behavior;
import akka.actor.typed.javadsl.AbstractBehavior;
import akka.actor.typed.javadsl.ActorContext;
import akka.actor.typed.javadsl.Behaviors;
import akka.actor.typed.javadsl.Receive;

public class HelloWorld extends AbstractBehavior<String> {

    public static Behavior<String> create() {
        return Behaviors.setup(HelloWorld::new);
    }

    private HelloWorld(ActorContext<String> context) {
        super(context);
    }

    @Override
    public Receive<String> createReceive() {
        return newReceiveBuilder()
                .onMessage(String.class, this::onMessage)
                .build();
    }

    private Behavior<String> onMessage(String message) {
        System.out.println("Mensaje recibido: " + message);
        return this;
    }

    public static void main(String[] args) {
        ActorSystem<String> system = ActorSystem.create(HelloWorld.create(), "HelloWorldSystem");
        system.tell("Hola Mundo");
        // Termina el sistema después de enviar el mensaje
        system.terminate();
    }
}

Esta clase mostrará un mensaje "Hola Mundo".

Compilamos el proyecto:

$ mvn compile

Ejecutamos:

$ mvn exec:java -Dexec.mainClass="com.codemonkey.HelloWorld"

¡Hemos creado nuestra primera aplicación con Akka!

En pocas palabras, Akka sirve para construir aplicaciones concurrentes, distribuidas y escalables en Java o Scala. Basado en el modelo de actores, facilita la gestión de procesos paralelos, comunicación asíncrona y sistemas tolerantes a fallos. Es ideal para aplicaciones en tiempo real, como chats, streaming, o microservicios, ya que simplifica la concurrencia y permite manejar grandes volúmenes de datos o usuarios de forma eficiente.

Enlaces:

https://akka.io/
https://emanuelpeg.blogspot.com/2022/09/por-que-usar-akka.html
https://www.bairesdev.com/blog/introduction-to-akka-an-open-source-library/
https://scalac.io/technologies/akka/
https://unpocodejava.com/2013/02/19/que-es-akka/

NoSQL alternativas a las BD relacionales (2da parte)

 

NoSQL (Not only SQL) es un término que se refiere a bases de datos no relacionales. Una base de datos NoSQL almacena sus datos en un formato no tabular. Entre las más famosas están:

• MongoDB. 
• Redis. 
• Neo4j (orientada a grafos). 
• CouchDB.
• Cassandra.
• Entre otras más.

MongoDB.

Es un sistema de base de datos NoSQL, orientado a documentos y de código abierto.

Redis.

Es un motor de base de datos en memoria, basado en el almacenamiento en tablas de hashes (clave/valor) pero que opcionalmente puede ser usada como una base de datos durable o persistente.

Neo4j.

Es un software libre de Base de datos orientada a grafos, implementado en Java.

CouchDB.

Es una base de datos NoSQL que emplea JSON para almacenar los datos, JavaScript como lenguaje de consulta por medio de MapReduce y HTTP como API.

Cassandra.

Es un software NoSQL distribuido y basado en un modelo de almacenamiento «tabular», de código abierto que está escrito en Java.

NoSQL según https://nosql-database.org/, se refiere a bases de datos "no relacionales" o "no solo SQL": sistemas de almacenamiento de datos que no se basan en el formato tradicional de tablas de filas y columnas de las bases de datos relacionales. Y ofrecen modelos flexibles como documentos, pares clave-valor, gráficos o columnas anchas, según cómo se estructuren y accedan los datos.

Su objetivo no es reemplazar a SQL por completo. Más bien, aborda limitaciones específicas de los sistemas relacionales, especialmente al trabajar con datos no estructurados, grandes volúmenes o arquitecturas distribuidas.

Algunas de las diferencias más importantes entre una BD relacional y una no relacional son:

Estructuras de datos:

• Las bases de datos SQL utilizan un esquema fijo con tablas, filas y columnas. La estructura debe definirse con antelación y cada registro sigue el mismo formato. 
• Las bases de datos NoSQL son flexibles en cuanto a esquemas. Los datos pueden almacenarse como documentos JSON, pares clave-valor o gráficos, lo que permite que cada entrada tenga un aspecto diferente.

Escalabilidad:

• Las bases de datos SQL suelen escalarse verticalmente, lo que implica añadir más potencia a un solo servidor (CPU, RAM, etc.). 
• Las bases de datos NoSQL están diseñadas para el escalado horizontal: distribuyen los datos entre varios servidores para gestionar tráfico intenso y grandes conjuntos de datos.

Lenguaje de consulta:

• El lenguaje de consulta estructurado (SQL) se utiliza en bases de datos SQL para interactuar con los datos. 
• Las variantes de las bases de datos NoSQL dependen del tipo: MongoDB permite el envío de un lenguaje de consulta similar a SQL y también ejecuta consultas completas desde el shell, mientras que Cassandra utiliza su lenguaje de consulta CQL (Cassandra Query Language) integrado.

Transacciones:

• Los sistemas SQL ofrecen una sólida conformidad con ACID (atomicidad, consistencia, aislamiento y durabilidad), lo que garantiza una estricta fiabilidad de los datos. 
•  Los sistemas NoSQL varían: algunos admiten ACID a nivel de documento, pero muchos se centran en el rendimiento y la disponibilidad, y en ocasiones solo ofrecen consistencia eventual.

Tipos de BD NoSQL

Bases de datos basadas en documentos. Como MongoDB o CouchDB.

Bases de datos basadas en de clave-valor. Como Redis o DynamoDB.

Bases de datos basadas en almacenaje de columnas anchas. Como Cassandra o HBase.

Bases de datos basadas en grafos. Como Neo4j o ArangoDB.

Las bases de datos NoSQL surgen de la necesidad de resolver los problemas dejados por las bases de datos relaciones. Como lo pueden ser las complejas consultas (JOIN, INNER JOIN, etc.), la inflexibilidad de los datos y hasta su integridad.

Enlaces:

https://www.mongodb.com/
https://neo4j.com/
https://cassandra.apache.org
https://es.wikipedia.org/wiki/NoSQL
https://redis.io/
https://couchdb.apache.org/
https://nosql-database.org/
https://mkyong.com/tutorials/java-mongodb-tutorials/

Eclipse Vert.x

Vert.x es un framework políglota que se ejecuta en la JVM. Permite crear microservicios basados en el paradigma de programación reactiva.

¿Qué es la programación reactiva?

Se trata de un paradigma que se centra en los flujos de datos y la propagación del cambio.

Se enfoca en reaccionar a cambios en el flujo de datos de forma asíncrona y eficiente. En lugar de ejecutar instrucciones de manera secuencial, los sistemas reactivos responden automáticamente cuando ocurre un evento, como una nueva entrada de datos o una actualización en tiempo real,

Es como suscribirse a un canal de noticias: no sabes cuándo llegarán nuevos artículos, pero cuando lo hagan, recibirás una notificación instantánea. Aborda las ineficiencias de los mecanismos de sondeo tradicionales, que buscan constantemente actualizaciones, incluso cuando no las hay. Esto puede generar un desperdicio de recursos y tráfico de red innecesario.

Al suscribirse a un flujo de datos, la programación reactiva garantiza que su código solo reciba notificaciones cuando haya nuevos datos disponibles, lo que mejora significativamente el rendimiento y la utilización de recursos.

Vert.x es similar a Node JS y se centra en los microservicios.

Es como una caja de herramientas mágica para construir aplicaciones que reaccionan rápido, como cuando juegas y el videojuego responde al instante cuando presionas un botón.

Además podremos usar estos lenguajes (ya que no es exclusivo para Java):

• Java, obviamente. 
• Kotlin. 
• Javascript. 
• Python. 
• Groovy. 
• Ruby. 
• Scala. 
• Clojure. 
• Y mezclar varios en una sola aplicación.

Veamos un ejemplo en Kotlin:

class Server : VerticleBase() {
  override fun start(): Future<*> {
    return vertx.createHttpServer()
      .requestHandler { req ->
        req.response()
          .putHeader("content-type", "text/plain")
          .end("¡Hola, mundo desde Vert.x!")
      }
      .listen(8080)
  }
}

Y en Java:

public class Server extends VerticleBase {
  public Future<?> start() {
    return vertx.createHttpServer()
      .requestHandler(req ->
        req.response()
          .putHeader("content-type", "text/plain")
          .end("¡Hola, mundo desde Vert.x!")
      )
      .listen(8080);
  }
}

Trabajando con Vert.x

Para trabajar con esta herramienta necesitamos:

• JDK en su versión 11 o más actual. 
• Maven 3. 
• Contar con la herramienta curl, HTTPie o cualquier herramienta que permita solicitudes HTTP.

La dependencia que usaremos será: vertx-web

Al generar el proyecto debemos descomprimirlo en algún directorio. La clase principal es:

MainVerticle.java

package com.inforhomex.aprendevertx.holamundo;

import io.vertx.core.Future;
import io.vertx.core.VerticleBase;

public class MainVerticle extends VerticleBase {

  @Override
  public Future<?> start() {
    return vertx.createHttpServer().requestHandler(req -> {
      req.response()
        .putHeader("content-type", "text/plain")
        .end("Hola, mundo desde Vert.x!");
    }).listen(8888).onSuccess(http -> {
      System.out.println("El servidor escucha desde el puerto 8888");
    });
  }
}

Construimos el proyecto con Maven:

$ mvn clean package

Entramos al directorio ``target`` y ejecutamos la aplicación:

$ java -jar holamundo-1.0.0-SNAPSHOT-fat.jar 

Abrimos el navegador en la url de hhtp://localhost:8888/

Salida:

Hola, mundo desde Vert.x! 

¡Hemos creado nuestro primera aplicación con Vert.x!

Concluyendo, al usar Vert.x se espera construir aplicaciones que reaccionan a los cambios, manteniendo tiempos de respuesta rápidos, alta escalabilidad y resiliencia.

Enlaces:

https://vertx.io/
https://www.arquitecturajava.com/introduccion-a-vertx/
https://solutionsarchitecture.medium.com/reactive-programming-in-java-a-simplified-guide-dd24d7f440d4
https://www.reddit.com/r/java/comments/nlzpkq/why_vertx_javas_library_for_reactiveasync/?tl=es-es

Gleam web dev with Wisp and Lustre (Youtube)

El creador de Wisp, Louis Pilfol, nos ofrece un vistazo a su framework desde su canal del Youtube (https://www.youtube.com/@lpil).

Recordemos que ya hemos hablado de el en este blog. Se trata de un nuevo framework para desarrollo web empleando el lenguagle Gleam. Un lenguaje inspirado en Elixir.

Enlaces:

http://codemonkeyjunior.blogspot.com/2025/04/wisp-un-nuevo-framework-para-gleam.html
https://gleam.run/