OpenCode: un agente para escribir código

OpenCode es una alternativa Open Source a herramientas como Claude Code.

Está disponible como interfaz de terminal, aplicación de escritorio o extensión de IDE. Sirve para acelerar el desarrollo de software al generar, analizar, editar y corregir código. Permite multisesiones, se conecta con Github Copilot, entre otras cosas más.

Puedes usarlo a la par con ChatGPT Plus/Pro, Github Copilot, etc. mediante una subscripción. Aunque no necesitas necesariamente una subscripción para usar OpenCode. Además te permite personalizarlo.

En pocas palabras, con OpenCode podrás crear código de manera fácil desde una terminal.

¿Cómo instalo OpenCode?

Requisitos:

• Emulador de terminal moderno: WezTerm, Alacritty, Ghostty o Kitty. 
• Claves API: Debes tener credenciales de los proveedores de LLM que quieras usar (ej. OpenAI, Anthropic, Google Gemini). 
• Sistema operativo compatible: macOS, Linux o Windows (con WSL recomendado).

Existen varias formas de hacerlo.

En entornos Linux:

$ curl -fsSL https://opencode.ai/install | bash

Con Node JS:

# npm
$ npm install -g opencode-ai

# bun
$ bun install -g opencode-ai

# pnpm
$ pnpm install -g opencode-ai

# yarn
$ yarn global add opencode-ai

En entornos Mac OS:

$ brew install anomalyco/tap/opencode

Con un instalador .exe (Windows):

https://opencode.ai/download

Verificamos la instalación:

$ opencode --version

OpenCode necesita conectarse a modelos de IA. Puedes configurar tus credenciales en el archivo de configuración:

$ opencode config set 
$ openai_api_key=TU_API_KEY
$ opencode config set anthropic_api_key=TU_API_KEY
$ opencode config set gemini_api_key=TU_API_KEY

Seleccionamos un modelo por defecto:

$ opencode config set default_model=openai:gpt-4

Podemos abrirlo de manera interactiva:

$ opencode 

También escribiendo un prompt de manera directa:

$ opencode "Escribe un script en Python que calcule la serie de Fibonacci"

Conclusiones:

OpenCode (y herramientas similares) ayudará a los programadores a hacer su trabajo más rápido y a otros les hará creer que son programadores sin serlo (como lo hizo Visual Basic en su momento).

La I.A. ya llegó. Lo que imaginabamos o veíamos en series o películas de ciencia ficción se ha vuelto una realidad. El programador pronto pasará a ser un espectador (lo queramos o no) que solicita X o Y cosa para que un asistente virtual nos sirva lo solicitado.

El futuro es la automatización del trabajo. No ayudar al trabajador a hacer su trabajo más rápido. No, no es el caso.

2026 mostrará la otra cara de la I.A. una que casi nadie quiere ver: el desplazamiento del humano por un agente virtual.

Quien se duerma en sus laureles pronto será reemplazado. Ese es el plan a futuro. Solo un tonto no lo verá de ese modo.

Enlaces:

https://opencode.ai/
https://lapascalinaatomica.blogspot.com/2026/02/fortran-oberon-y-pascal-frente-la-ia.html

Crystal: la hermana "cool" de Ruby

Hace tiempo que hablamos sobre este lenguaje de programación que comparte mucha similitud con Ruby.

Como mencionamos anteriormente, Crystal posee una sintaxis similar a Ruby. Sin embargo, es un lenguaje que promete ser mucho más rápido y eficiente. Además de otras peculiaridades que lo hacen digno de no pasar inadvertido.

Veamos un ejemplo.

server.cr

# Un servidor HTTP básico
require "http/server"

server = HTTP::Server.new do |context|
  context.response.content_type = "text/plain"
  context.response.print "Hola, mundo, obtenemos #{context.request.path}!"
end

address = server.bind_tcp(8080)
puts "Escuchando desde el puerto: http://#{address}"

# Invocamos el bloque hasta que el proceso finaliza
server.listen

En pocas palabras se trata de una aplicación HTTP que muestra el clásico "Hola, mundo". Echémoslo a andar. Pero antes de hacer nada comencemos con su instalación.

Instalación en Linux

Abrimos una terminal y tecleamos lo siguiente:

$ curl -fsSL https://crystal-lang.org/install.sh | sudo bash
$ apt install crystal

Instalación en Windows

Abrimos una terminal y tecleamos lo siguiente:

$ scoop install git
$ scoop bucket add crystal-preview https://github.com/neatorobito/scoop-crystal
$ scoop install vs_2022_cpp_build_tools crystal

Podemos validar la instalación tecleando:

$ crystal --version

Ejecutamos el script:

$ crystal server.cr

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

Salida:

Hola, mundo, obtenemos /Thomas!

En lenguajes como Java tendríamos que haber creado un proyecto completo para realizar esta actividad.

Ahora veamos cómo consumir una API pública (https://api.chucknorris.io/).

get_chiste.cr

require "http/client"
require "json"

response = HTTP::Client.get("https://api.chucknorris.io/jokes/random")
json = JSON.parse(response.body)

value = json["value"]
put "Chiste sobre Chuck Norris: #{value || "Ninguno"}"

Ejecutamos el script:

$ crystal get_chiste.cr

Salida:

Chiste: Chuck Norris attended last year's Nobel Prize ceremony wearing an all-white snakeskin pimp suit with matching widebrim hat and feather.

Al ser una salida aleatoria el resultado puede variar.

Notas importantes

Crystal nos permite compilar nuestros scripts y con ello crear ejecutables.

Compilando el ejemplo anterior:

$ crystal build get_chiste.cr

Con esto nos creará los siguientes archivos:

gc.dll
get_chiste.cr
get_chiste.exe
get_chiste.pdb
iconv-2.dll
libcrypto-3-x64.dll
libssl-3-x64.dll
zlib1.dll

O si solo preferimos la ejecución de estas dos formas:

$ crystal programa.cr
# O de esta otra forma:
$ crystal run programa.cr

Los "nuevos" lenguajes como Crystal, Ballerina, Go y Rust han aprendido lo mejor de los lenguajes clásicos y han olvidado lo malo de ellos.

Prometen ser la panacea universal y aliviarnos de las complejidades y otras cuestiones que hacian del desarrollo una actividad, en ocasiones, tediosa y complicada.

Continuaremos con esta serie sobre nuevos lenguajes y herramientas.

Enlaces:

https://crystal-lang.org/
https://codemonkeyjunior.blogspot.com/2024/09/crystal-un-lenguaje-de-programacion.html
https://api.chucknorris.io/
https://emanuelpeg.blogspot.com/2026/01/crystal-el-lenguaje-de-programacion-que.html

gRPC y GraphQL en una comparativa

gRPC y GraphQL son dos de los protocolos de comunicación más utilizados actualmente en el desarrollo de APIs.

GraphQL es ideal cuando el cliente necesita controlar qué datos obtiene, evitando cargas innecesarias. Consultas flexibles y un solo endpoint para múltiples recursos.

gRPC destaca en rendimiento, streaming y comunicación entre microservicios gracias a su formato binario y contratos estrictos. Con una comunicación bidireccional y streaming.

Comparativa entre gRPC y GraphQL

He aquí una tabla comparativa entre estos dos protocolos de comunicación:

Aspecto	GraphQL	gRPC
Modelo de comunicación	Basado en consultas declarativas; el cliente define qué datos necesita.	Basado en llamadas a procedimientos remotos (RPC) con contratos definidos en archivos .proto.
Formato de datos	JSON, fácil de leer y depurar.	Protocol Buffers (binario), más eficiente en tamaño y velocidad.
Orientación	Optimizado para APIs orientadas a frontends y aplicaciones con múltiples vistas.	Optimizado para comunicación entre microservicios y sistemas distribuidos de alto rendimiento.
Similitudes	Ambos buscan mejorar la eficiencia respecto a REST, soportan tipado fuerte y facilitan la evolución de APIs.
Pros	- Flexibilidad en consultas. - Evita el overfetching y underfetching. - Gran ecosistema y soporte en frontend.	- Alto rendimiento y baja latencia. - Streaming bidireccional. - Contratos estrictos con Protobuf.
Contras	- Mayor complejidad en servidores. - Problemas de caché. - Curva de aprendizaje para consultas avanzadas.	- Menos legible para humanos (binario). - Requiere más configuración inicial. - Ecosistema más orientado a backend que frontend.
Casos de uso ideales	Aplicaciones web y móviles que requieren flexibilidad en datos.	Microservicios, sistemas distribuidos y aplicaciones de tiempo real.

GraphQL en un ejemplo

Miremos la siguiente imagen que muestra un ejemplo del uso de GraphQL.

El flujo nos dice que:

• El cliente (una app web o móvil) envía una consulta específica. 
• El servidor GraphQL responde solo con los datos solicitados, evitando el overfetching. 
• Además se usa JSON como formato de respuesta, y el cliente controla qué campos necesita.

gRPC en un ejemplo

Ahora miremos un ejemplo de uso de gRPC.

El flujo nos dice que:

• El cliente (normalmente otro microservicio) realiza una llamada RPC. 
• El servidor gRPC responde con datos serializados en Protocol Buffers, optimizados para velocidad y eficiencia. 
• El contrato entre ambos está definido en archivos .proto, lo que garantiza tipado fuerte y evolución controlada.

Lenguajes de programación más utlizados para ambos protocolos

Lenguaje	Uso en GraphQL	Uso en gRPC
JavaScript / TypeScript	Muy popular en frontend y backend con frameworks como Apollo Server y Express.	Soporte limitado; se usa más en clientes que en servidores.
Python	Usado con librerías como Graphene y Ariadne.	Bien soportado con gRPC Python; útil en ciencia de datos y microservicios.
Java	Compatible con librerías como graphql-java.	Muy usado en backend empresarial con soporte oficial de gRPC.
Go	Menos común en GraphQL, aunque existen librerías como gqlgen.	Uno de los lenguajes más eficientes para gRPC; ideal para microservicios.
C++	Raramente usado en GraphQL.	Alto rendimiento en sistemas embebidos y backend con gRPC.
.NET (C#)	Compatible con HotChocolate y GraphQL.NET.	Soporte oficial de gRPC en .NET Core; muy usado en entornos Windows.
Ruby	Popular en startups con graphql-ruby.	Soporte limitado para gRPC.

Como se puede observar:

• Go, Java y .NET son excelentes opciones para gRPC. 
• JavaScript/TypeScript y Python son ideales para GraphQL.

Conclusiones:

Ambos son alternativas modernas a REST, pero su elección depende del contexto: GraphQL para flexibilidad en frontends y gRPC para eficiencia en backends distribuidos.

Enlaces:

https://alquimistadecodigo.blogspot.com/2024/04/un-vistazo-grpc-una-alternativa-soap-y.html
https://alquimistadecodigo.blogspot.com/2024/05/graphql-en-un-vistazo.html
https://unpocodejava.com/2019/01/23/que-es-grpc/
https://alquimistadecodigo.blogspot.com/2024/05/grpc-protobuff-protocol-buffers.html
https://learn.microsoft.com/es-es/dotnet/architecture/cloud-native/grpc
https://learn.microsoft.com/es-es/dotnet/architecture/cloud-native/grpc

RESTEasy: un REST de manera fácil

RESTEasy es, en pocas palabras, una implementación de JAX-RS; un framework para crear servicios web RESTful.

Permite crear servicios REST usando anotaciones como @Path, @GET, @POST, etc., sobre clases e interfaces Java. También permite crear clientes RESTful, pues provee frameworks para realizar esa tarea.

Ayuda al desarrolllador web a crear APIs que se comunican a través de HTTP, facilitando la creación de microservicios y servicios web ligeros en el ecosistema Java.

Se puede integrar con Quarkus y Wildfly.

Para mayor información puedes consultar este sitio: https://docs.resteasy.dev/7.0/userguide/

Empezando con RESTEasy

Existen dos formas recomendadas:

• La manera clásica: con Jakarta EE 10 y Wildfly. 
• La moderna y recomendada: con Quarkus y RESTEasy Reactive.

Nosotros elegiremos Quarkus con RESTEasy Reactive (Quarkus REST) para crear un sencillo servicio.

Tenemos dos opciones para crear el proyecto.

Con Quarkus CLI:

$ quarkus create app mx.inforhomex:hola-quarkus-rest --extension=rest

Si no contamos con la herramienta, la podemos instalar con estos comandos:

Linux:

$ 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

Usando SDKMAN!:

$ sdk install quarkus

Windows:

$ 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"

La otra alternativa para crear el proyecto es con Maven:

$ mvn io.quarkus.platform:quarkus-maven-plugin:3.15.1:create -DprojectGroupId=mx.inforhomex -DprojectArtifactId=hola-quarkus-rest -Dextensions=rest

Una vez creado el proyecto nos ubicaremos en el directorio principal.

$ cd hola-quarkus-rest

Abrimos y editamos la clase ``GreetingResource.java`` para que luzca de esta forma:

package mx.inforhomex;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import java.util.HashMap;

@Path("/saludar")
public class GreetingResource {

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public HashMap<String, Object> saludar() {
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("message","Hola, mundo desde Quarkus REST");
        map.put("active",true);
        map.put("id",1202029L);
        return map;
    }
}

Ejecutamos con Quarkus:

$ quarkus dev

O con Maven:

$ ./mvnw quarkus:dev

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

Si todo va bien, veremos esta salida:

{active=true, id=1202029, message=Hola, mundo desde Quarkus REST}

¡Hemos creado nuestro primer proyecto con RESTEasy y Quarkus!

En próximas entregas hablaremos de Quarkus, un fuerte contendiente de Spring Boot.

Enlaces:

https://resteasy.dev/
https://docs.resteasy.dev
https://codemonkeyjunior.blogspot.com/2026/01/un-vistazo-jakartaee.html
https://es.quarkus.io/

LangChain4j

LangChain4j es una librería para Java que unifica y simplifica la integración de modelos de lenguaje (LLM) y stores vectoriales en tus aplicaciones. Ofrece APIs unificadas para múltiples proveedores (OpenAI, Vertex AI, etc.) y stores (Pinecone, Milvus, etc.), además de un toolbox con patrones comunes como plantillas de prompts, memoria conversacional, RAG, agentes y function calling

Se usa en escenarios empresariales para construir asistentes con RAG, moderación y reglas de entrada/salida, manteniendo control sobre datos e infraestructura.

En pocas palabras, es una opción similar a Spring AI del que hablaremos en otra ocasión.

Sus principales características son:

• API unificada que permite interactuar con diversos proveedores. 
• Integración con frameworks como Sprinc Boot, Quarkus y Helidon. 
• Memoria de conversación. 
• Soporte RAG. 
• Function Calling.

¿Qué se puede hacer con esta herramienta?

• Extracción y tratamiento de texto. 
• Chatbots. 
• Agentes de IA. 
• Etc.

Empezando con LangChain4j

OpenAI es una empresa de investigación y despliegue de IA y es la opción más directa y estable para probar LangChain4j. Iniciemos con un proyecto Java.

Requisitos:

• Tener el JDK instalado (última versión). 
• Tener Maven instalado (última versión). 
• Tener una cuenta OpenAI (https://openai.com)

1. Creamos el proyecto con Maven y nos ubicamos en el directorio generado:

$ mvn archetype:generate -DgroupId=com.inforhomex -DartifactId=demo-langchain4j -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false
$ cd demo-langchain4j

2. Agregamos las dependencias necesarias en el archivo ``pom.xml``

<dependencies>
  <!-- Núcleo LangChain4j -->
  <dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j</artifactId>
    <version>0.31.0</version>
  </dependency>

  <!-- Cliente OpenAI -->
  <dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai</artifactId>
    <version>0.31.0</version>
  </dependency>
</dependencies>

3. Ahora editaremos la clase App.java

package com.inforhomex;


import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;

public class App {
    public static void main(String[] args) {
        ChatLanguageModel model = OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .modelName("gpt-4o-mini")
            .build();

        String respuesta = model.generate("Explica qué es LangChain4j en 2 frases.");
        System.out.println(respuesta);
    }
}

4. Obtener la API KEY OPENAI. Vamos a este sitio: https://platform.openai.com/account/api-keys

Una vez logeados debemos ir a la sección de API keys y crear una nueva. Deberá crearte una cadena encriptada de aproximandamente 165 caracteres. Guardala en un bloc de notas o cualquier otro editor.

5. Crear la variable de entorno.

Linux:

$ export OPENAI_API_KEY="tu_api_key_aquí"

Windows (Powershell):

$ setx OPENAI_API_KEY "tu_api_key_aquí"

5. Construimos nuestro proyecto Java con Maven:

$ mvn clean install -X

O con este otro comando:

$ mvn clean package

6. Hacer ejecutable nuestro proyecto, para ello modificamos el archivo ``pom.xml``:

<?xml version="1.0" encoding="UTF-8"?>
<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.inforhomex</groupId>
  <artifactId>demo-langchain4j</artifactId>
  <version>1.0</version>

  <name>demo-langchain4j</name>
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
  </properties>

  <dependencies>

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-simple</artifactId>
  <version>2.0.12</version>
</dependency>


    <!-- Cliente OpenAI -->
    <dependency>
      <groupId>dev.langchain4j</groupId>
      <artifactId>langchain4j-open-ai</artifactId>
      <version>0.31.0</version>
    </dependency>

    <!-- Núcleo LangChain4j -->
    <dependency>
      <groupId>dev.langchain4j</groupId>
      <artifactId>langchain4j</artifactId>
      <version>0.31.0</version>
    </dependency>
  </dependencies>

  <repositories>
    <repository>
      <id>central</id>
      <url>https://repo.maven.apache.org/maven2</url>
    </repository>
  </repositories>

  <build>
    <plugins>
      <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>3.3.0</version>
            <configuration>
                <mainClass>com.inforhomex.App</mainClass>
            </configuration>
        </plugin>

        <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <version>3.3.0</version>
      <configuration>
        <archive>
          <manifest>
            <mainClass>com.inforhomex.App</mainClass>
          </manifest>
        </archive>
      </configuration>
    </plugin>

    </plugins>
  </build>
</project>

7. Ejecutamos el proyecto:

$ mvn exec:java -Dexec.mainClass=com.inforhomex.App

Si tines problemas con tu OPEN AI KEY puedes escribir:

$ mvn compile exec:java -Dexec.mainClass=com.inforhomex.App -DOPENAI_API_KEY=AQUI_TU_OPENAI_KEY

Si todo va bien, deberá mostrarte una respuesta.

Conclusión: Hemos visto como hacer una consulta usando LangChain4j desde una aplicación Java.

Continuarmos con este tema en próximas entregas.

Enlaces:

https://github.com/langchain4j/langchain4j
https://www.linkedin.com/pulse/langchain4j-el-poder-de-la-ia-conversacional-para-java-fabian-aguero-vmv2f/
https://medium.com/mitb-for-all/langchain4j-building-generative-ai-applications-in-java-670ec3d6167d
https://adictosaltrabajo.com/2024/03/05/langchain4j-potenciando-tus-aplicaciones-java-con-inteligencia-artificial-ia-y-modelos-de-lenguaje-de-gran-escala-llm-primeros-pasos/
https://www.reddit.com/r/java/comments/14ff6ie/seekeng_feedback_langchain4j_a_library_for_easy/?tl=es-419
https://www.baeldung.com/maven-java-main-method

Claude Code: un nuevo enfoque de la programación por pares

Claude Code es una herramienta de inteligencia artificial creada por Anthropic que funciona directamente en la terminal. Sirve para acelerar el desarrollo de software al generar, analizar, editar y corregir código, además de gestionar flujos de trabajo como pruebas y Git sin salir del entorno local.

En pocas palabras,  un asistente de codificación agéntico que vive en tu terminal.

Sirve para:

• Generar fragmentos de código a partir de ideas. 
• Leer y analizar proyectos completos. 
• Editar y corregir errores automáticamente. 
• Ejecutar pruebas y generar pull requests. 
• Manejar flujos de trabajo de Git y búsqueda semántica en tu base de código.

En pocas palabras, Claude Code convierte tu terminal en un entorno de desarrollo inteligente, ayudando a programadores a trabajar más rápido y con menos fricción.

Claude Code y otras herramientas similares

Claude Code se diferencia de ChatGPT, DeepSeek y Microsoft Copilot principalmente en su enfoque: está diseñado para vivir en la terminal y actuar como un par programador que entiende, edita y gestiona proyectos completos de código, mientras que los otros asistentes tienen un alcance más general o están integrados en aplicaciones específicas

Diferencias principales:

• Claude Code vs ChatGPT: Claude Code está especializado en desarrollo dentro de la terminal, mientras que ChatGPT es más generalista y se usa para múltiples tareas (escribir, aprender, programar, etc.). 
• Claude Code vs DeepSeek: DeepSeek busca ofrecer potencia similar a GPT-4 a menor costo, pero no está diseñado específicamente para integrarse en flujos de desarrollo como Claude Code. 
• Claude Code vs Microsoft Copilot: Copilot se integra en aplicaciones de Microsoft y GitHub, mientras que Claude Code vive en la terminal y gestiona proyectos completos con búsqueda semántica y edición directa. 
• Claude Code vs Claude (IA general): Claude general es un modelo conversacional seguro y con gran capacidad de contexto; Claude Code es su versión enfocada en programación y terminal.

Tabla comparativa de asistentes de programación

Herramienta	Enfoque	Entorno principal	Integración con código/proyectos	Git y flujos CI/CD	Búsqueda semántica en repos	Testing desde el asistente	Contexto largo	Ecosistema y extensiones	Casos ideales
Claude Code (Anthropic)	Asistente dev en terminal	CLI / Terminal	Analiza, edita y corrige proyectos completos	Opera comandos Git y genera PRs	Sí (en el repositorio local)	Sí (ejecuta y guía pruebas)	Alto (modelos Claude)	Integración con herramientas dev; menos enfoque en Office	Desarrollo ágil en terminal, refactoring guiado
ChatGPT (OpenAI)	Asistente generalista	Web / API / Extensiones	Genera y explica código; no gestiona repos locales por sí mismo	Limitado (requiere herramientas externas)	Parcial (via plugins/extensiones)	Orientado a guía, no a ejecución directa	Alto (dependiendo del plan/modelo)	Amplio ecosistema de plugins y terceros	Ideación, documentación, aprendizaje y prototipado
DeepSeek	IA de alto rendimiento y costo eficiente	Web / API	Genera/analiza código; integración depende del usuario	Limitado (vía scripts/SDK del usuario)	No nativo	No nativo	Variable según modelo	SDKs y comunidad creciente	Precio/rendimiento para tareas de código y análisis
Microsoft Copilot (incl. GitHub Copilot)	Compleción y asistencia en IDE + productividad Microsoft	VS Code / IDEs / Office / Windows	Completa y sugiere código en tiempo real	Fuerte con GitHub (PRs, repos, acciones)	Parcial (dependiendo de extensiones)	Limitado (más enfoque en IDE que en ejecución)	Medio–alto (según variante)	Integración profunda en ecosistema Microsoft	Trabajo en IDE, repos GitHub, Office y flujos empresariales
Claude (conversacional general)	IA conversacional segura y con gran contexto	Web / API	Genera y revisa código; no gestiona terminal directamente	Limitado (requiere herramientas externas)	Parcial (vía integraciones)	No nativo	Muy alto (modelos más recientes)	Integraciones via API y herramientas de terceros	Análisis de documentos extensos, diseño y revisión técnica

Como mencionamos en entregas pasadas el Vibe Coding o "codificación por sensaciones" ha cambiado como el desarrollador trabajará en el futuro. No sabemos a ciencia cierta si seremos simples observadores o incluso reemplazados.

Enlaces:

https://claude.com/product/claude-code
https://claude.ai
https://alquimistadecodigo.blogspot.com/2015/04/pair-programming.html
https://www.elladodelmal.com/2025/03/que-es-el-vibe-coding.html
https://www.enriquedans.com/2025/12/el-espejismo-del-vibe-coding-cuando-la-relajacion-progresiva-convierte-al-programador-en-espectador.html
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

Moonbit en un vistazo

MoonBit es una cadena de herramientas de lenguaje de programación nativo de IA para computación en la nube y edge. Se compila a WebAssembly, JavaScript y C.

Es muy similar a lenguajes como Python y sobre todo a Go

Ambos lenguajes (MoonBit y Go) son similares en:

• Típicos estáticos con inferencia de tipos.
• Lenguajes compilados con compilación rápida.
• Seguridad en memoria, aunque con mecanismos ligeramente diferentes.
• Orientado a la computación moderna con excelentes herramientas.

Aunque ya vimos algo sobre este lenguaje, hoy veremos cómo instarlo y algunos ejemplos de uso.

Instalando MoonBit

Instalando en Linux:

$ curl -fsSL https://cli.moonbitlang.com/install/unix.sh | bash

Instalando en Windows:

$ Set-ExecutionPolicy RemoteSigned -Scope CurrentUser; irm https://cli.moonbitlang.com/install/powershell.ps1 | iex

Verificamos la instalación:

$ moon version

Podemos ver la ayuda:

$ moon help

Para quienes usan Visual Studio Code, se puede descargar un plugin del lenguaje:

https://marketplace.visualstudio.com/items?itemName=moonbit.moonbit-lang

Programando en MoonBit

Ejemplo 1. El clásico "Hola, mundo".

holamundo.mbt

fn main {
  println("Hola, mundo.")
}

Ejecución:

$ moon run holamundo.mbt

Salida:

Hola, mundo.

Ejemplo 2. Tipos de datos en MoonBit. Aquí veremos los tipos de datos. 

tipos.mbt

fn main{
  let int : Int = 42
  let uint : UInt = 42
  let int64 : Int64 = 42
  let double : Double = 42
  let float : Float = 42
  let bigint : BigInt = 42
  let cadena : String = "FERROCARRIL"
  let c : Char = 'A'
  let verdadero : Bool = true
  println("\t Tipos de datos en MoonBit.")
  println(int)
  println(uint)
  println(int64)
  println(double)
  println(float)
  println(bigint)
  println(cadena)
  println(c)
  println(verdadero)
}

Ejecución:

$ moon run tipos.mbt

Salida:

         Tipos de datos en MoonBit.
42
42
42
42
42
42
FERROCARRIL
A
true

Ejemplo 3. Programa que nos muestre ejemplo de sentencias condicionales.

condicional.mbt

fn main{
  println("\t Condicionales en MoonBit.")
  let mut bandera: Bool = 23 > 22
  
  if bandera{
    println("Fue verdadero.")
    bandera = false
  }

  if bandera{
    println("Esto no se vera en pantalla.")
  }else{
    println("Esto si se vera en pantalla.")
  }

  let resultado = if "A" == "A"{
    "Esto fue verdadero."
  }else{
    "Esto fue falso."
  }
  println(resultado)
  println(fibonacci(5))
}
// Aqui usamos algo similar a switch
fn fibonacci(n : Int) -> Int {
  match n {
    0 => 0
    1 | 2 => 1
    _ => fibonacci(n - 1) + fibonacci(n - 2)
  }
}

Ejecución:

$ moon run condicional.mbt

Salida:

         Condicionales en MoonBit.
Fue verdadero.
Esto si se vera en pantalla.
Esto fue verdadero.
5

Ejemplo 4. Sumar los primeros 100 números pares. Con esto veremos un ejemplo de sentencias iterativas.

iterativas.mbt

fn main{

println("\t Sumar los primeros 100 números pares en MoonBit.")
let suma = for i = 1, acc = 0; i <= 100; i = i + 1 {
  if i % 2 == 0 {
    continue i + 1, acc + i
  }
} else {
  acc
}

   println(suma)

}

Ejecución:

$ moon run iterativas.mbt

Salida:

         Sumar los primeros 100 números pares en MoonBit.
2550

Ejemplo 5. Programa que tenga funciones para suma, resta, multiplicación y división de números enteros.

funciones.mbt

fn main{
  println("\t Funciones en MoonBit.")
  let a: Int = 3
  let b: Int = 2
  println(suma(a, b))
  println(resta(a, b))
  println(producto(a, b))
  println(division(a, b))
}

fn suma(x: Int, y: Int)-> Int {
  x + y
}

fn resta(x: Int, y: Int)-> Int {
  x - y
}

fn producto(x: Int, y: Int)-> Int {
  x * y
}

fn division(x: Int, y: Int)-> Int {
  x / y
}

Ejecución:

$ moon run tipos.mbt

Salida:

         Funciones en MoonBit.
5
1
6
1

Ejemplo 6. Un programa que use estructuras.

estructuras.mbt

struct Persona {
  nombre : String
  apellidos: String
  edad : Int
}

struct Punto{
  x:Int
  y:Int
}

fn main{
  println("\t Estructuras en MoonBit.")
  let thomas = Persona::{ nombre: "Thomas", apellidos: "Muller", edad: 30 }
  let p: Punto = {x: 23, y:43}

  println(thomas.nombre)
  println(thomas.apellidos)
  println(thomas.edad)

  println(" --------------- ")
  println(p.x)
  println(p.y)
}

Ejecución:

$ moon run estructuras.mbt

Salida:

        Estructuras en MoonBit.
Thomas
Muller
30
 ---------------
23
43

Conclusiones:

Hemos instalado MoonBit en nuestro sistema.

Hemos creado algunos programas para conocer lo básico del lenguaje.

En próximas entregas continuaremos con este tema.

Enlaces:

https://www.moonbitlang.com/
https://codemonkeyjunior.blogspot.com/2025/11/moonbit-un-lenguaje-orientado-la-ia.html