viernes, 6 de marzo de 2026

WebSockets: un canal permanente para enviar y recibir datos

Los WebSockets son un protocolo que permite comunicación bidireccional en tiempo real entre cliente y servidor, a diferencia de HTTP que funciona en modo solicitud-respuesta.

Es como un canal permanente, donde ambos lados (cliente y servidor) pueden enviar datos en cualquier momento.

Son útiles en cualquier escenario donde se requiera interacción instantánea:

  • Chats y mensajería: WhatsApp Web, Slack, Discord. 
  • Juegos online: sincronización de movimientos en tiempo real. 
  • Colaboración en documentos: Google Docs, Notion, donde ves cambios de otros usuarios al instante.
  • Notificaciones en vivo: alertas de bolsa, actualizaciones deportivas, sistemas de monitoreo. 
  • Aplicaciones financieras: transmisión de precios de criptomonedas o acciones en tiempo real. 
  • IoT y dashboards: dispositivos que envían datos continuamente a una interfaz web .

Entre las ventajas principales encontramos:

  • Baja latencia: no hay que abrir y cerrar conexiones constantemente. 
  • Menor consumo de recursos: menos overhead que múltiples peticiones HTTP. 
  • Escalabilidad: ideal para aplicaciones con miles de usuarios conectados simultáneamente.  
  • Flexibilidad: permite enviar datos en ambos sentidos (cliente ↔ servidor).

Entre los riesgos y consideraciones a tomar tenemos:

  • Seguridad: al ser persistentes, requieren cifrado (wss://) para evitar ataques de interceptación. 
  • Escalabilidad: manejar miles de conexiones simultáneas exige servidores optimizados. 
  • Compatibilidad: aunque ampliamente soportados, algunos entornos antiguos pueden no tener soporte completo.

WebSockets

Iniciemos pues con los WebSockets. Haremos un sencillo ejemplo. Para ello necesitamos:

  • Tener Node instalado en nuestras máquinas. 
  • Tener conocimiento de Javascript y Node. 
  • Instalar Express y Socket.IO

¿Qué haremos? Una aplicación que nos muestre un ejemplo del uso de WebSockets, con ayuda de JS y Node.

1. Crearemos un directorio y nos ubicaremos en el:

$ mkdir websocket-demo
$ cd websocket-demo

2. Una vez dentro del directorio, crearemos un proyecto Node:

$ npm init -y

Esto nos generará el proyecto Node.

3. Instalar las dependencias (Express y Socket.IO) con ayuda de la herramienta ``npm``:

$ npm install express socket.io

Podemos validar la descarga con este comando:

$ npm list

Salida:

+-- express@5.2.1
`-- socket.io@4.8.3

4. Creando un servidor que escuche ``server.js``:

const express = require('express');
const http = require('http');
const { Server } = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = new Server(server);

app.use(express.static('public'));

io.on('connection', (socket) => {
  console.log('Un usuario se conectó');

  socket.on('chat message', (msg) => {
    console.log('Mensaje recibido: ' + msg);
    io.emit('chat message', msg);
  });

  socket.on('disconnect', () => {
    console.log('Un usuario se desconectó');
  });
});

server.listen(3000, () => {
  console.log('Servidor escuchando en http://localhost:3000');
});

5. Crearemos un cliente para hacer petciones al servidor:

public\index.html

<!DOCTYPE html>
<html>
<head>
  <title>Chat con Socket.IO</title>
</head>
<body>
  <h1>Chat sencillo</h1>
  <ul id="mensajes"></ul>
  <form id="form">
    <input id="input" autocomplete="off" /><button>Enviar</button>
  </form>
  <script src="/socket.io/socket.io.js"></script>
  <script>
    const socket = io();

    const form = document.getElementById('form');
    const input = document.getElementById('input');
    const messages = document.getElementById('mensajes');
form.addEventListener('submit', (e) => { e.preventDefault(); if (input.value) { socket.emit('chat message', input.value); input.value = ''; } }); socket.on('chat message', (msg) => { const item = document.createElement('li'); item.textContent = msg; messages.appendChild(item); }); </script> </body> </html>

6. Ejecutamos la aplicación:

$ node server.js

Si todo va bien veremos este mensaje:

Servidor escuchando en http://localhost:3000

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

Veremos lo siguiente:

Mandamos un mensaje y obtendremos una respuesta:

¡Hemos creado nuestra primera aplicación con WebSockets!

Continuaremos con estos temas en próximas entregas.

Enlaces:

https://en.wikipedia.org/wiki/WebSocket
https://socket.io/
https://expressjs.com/

martes, 24 de febrero de 2026

gRPC: una alternativa para servicios de alto rendimiento

gRPC (google Remote Procedure Calls) es un framework que nos sirve para realizar llamadas a procedimientos remotos.

Es de alto rendimiento. Multilenguaje (clientes y servidores). Además de tener un Streaming avanzado, lo que permite comunicaciones tipo: unary, server streaming, client streaming y streaming bidirectional.

Es ideal para microservicios gracias a su alto rendimiento, tipado fuerte y soporte multiplataforma.

Ya hemos hecho una comparativa entre otras alternativas como GraphQL:

gRPC y GraphQL

Usa Protocol buffers (*.proto) como mecanismo de serialización (y deserialización); el cual es un formato binario, más pequeño, rápido y sencillo que XML y JSON. Además de soportar diversos lenguajes como: Java, Python, Go, etc.

También usa HTTP/2 como protocolo de comunicación, el cual es una mejora del HTTP clásico. El cual prioriza solicitudes, permite la comprensión de encabezados, multiplexación (múltiples llamadas simultáneas) y tiene mayor seguridad.

Empezando con gRPC y .NET

Crearemos una aplicación Cliente-Servidor para mostrar el uso de gRPC. Como lenguaje base usaremos C# y la herramienta dotnet para crear los proyectos.

Quien ha trabajado con aplicaciones Cliente-Servidor podrá entender el flujo. Una aplicación Cliente hará solicitudes y el Servidor las atenderá.

Para este ejemplo necesitaremos crear:

  • Un proyecto servidor. 
  • Un proyecto cliente.

Empecemos con el Servidor

Creamos el proyecto servidor con soporte a gRPC:

$ dotnet new grpc -o GrpcServer
$ cd GrpcServer

Una vez ubicados en el directorio podemos ejecutarlo:

$ dotnet run

Abrimos el navegador en la ruta: http://localhost:5057

Si todo va bien, veremos un mensaje.

Continuemos con el Cliente

Creamos el proyecto cliente de tipo consola:

$ dotnet new console -o GrpcClient
$ cd GrpcClient

Una vez ubicados en el directorio del Cliente, copiamos el directorio y archivo Protos\greet.proto del proyecto Servidor al Cliente.

Editamos el archivo GrpcClient.csproj de para agregar el archivo copiado. De tal manera que quede de esta forma:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Google.Protobuf" Version="3.33.5" />
    <PackageReference Include="Grpc.Net.Client" Version="2.76.0" />
    <PackageReference Include="Grpc.Tools" Version="2.78.0">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
	
	<Protobuf Include="Protos\greet.proto" GrpcServices="Client" />

  </ItemGroup>

</Project>

El archivo Protos\greet.proto es el siguiente:

syntax = "proto3";

option csharp_namespace = "Greet";

package greet;


service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}


message HelloReply {
  string message = 1;
}

Este archivo *.proto define el contrato de comunicación entre Cliente y Servidor en gRPC, y permite a un Cliente enviar un nombre y recibir un saludo como respuesta.

Compilamos y ejecutamos el proyecto Cliente:

$ dotnet build
$ dotnet run

Si todo va bien, veremos algo como esto en el Cliente:

Respuesta del servidor: Hello Code Monkey Junior

Y en el Servidor:

Usando la configuración de inicio de C:\Users\HP\Documents\pruebasCSharp\pruebasGRPC\GrpcServer\Properties\launchSettings.json...
Compilando...
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5057
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: C:\Users\HP\Documents\pruebasCSharp\pruebasGRPC\GrpcServer
info: GrpcServer.Services.GreeterService[0]
      The message is received from Code Monkey Junior

Este solo es un ejemplo de gRPC. Aún falta saber más de Protobuf y HTTP/2 a profundidad.

Como mencionamos con gRPC podemos crear aplicaciones con diversos lenguajes de programación.

Por ejemplo, si tenemos un servidor creado en lenguaje de programación C# no habrá problema que clientes hechos en otros lenguajes como Java, Python, Go, etc. puedan realizar solicitudes y recibir respuestas.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://grpc.io/
https://protobuf.dev/
https://dotnet.microsoft.com
https://alquimistadecodigo.blogspot.com/2024/05/grpc-protobuff-protocol-buffers.html
https://alquimistadecodigo.blogspot.com/2024/05/grpc-en-java-y-protobuff.html

sábado, 21 de febrero de 2026

OpenClaw: un agente de IA en tu propia máquina

OpenClaw es un agente de Inteligencia Artificial de código abierto. Actúa como un asistente personal avanzado. Convirtiendo a las personas en meros "solicitantes de código" (broma).

Es una alternativa a herramientas como Claude Code u OpenCode.

Con la peculiaridad que se ejecuta en un entorno local.

Es una tecnología relativamente nueva que nació en enero del 2026.

Es importante saber que su configuración requiere un alto conocimiento sobre comandos Bash, Powershell, etc. además de otras habilidades más avanzadas (redes, sistemas operativos, arquitectura, etc.).

Se recomienda que no se instale en un entorno empresarial donde haya acceso a base de datos o información confidencial.

Este agente se conecta a diversos canales de comunicación como WhatsApp o Telegram, entre otros.

Este vídeo explica paso a paso cómo instalar y usar OpenClaw:

Se recomienda tener alto conocimiento en seguridad, ya que empresas como CISCO han descubierto vulnerabilidades importantes en esta herramienta. Además de la complejidad (que si existe) al instalar la herramienta en nuestro entorno local. Además de estar conciente de las vulnerabilidades de seguridad al instalar estas herramientas.

OpenClaw surge como una alternativa a herramientas como ChatGPT, DeepSeek, Grok, etc. Convirtiendo al Vibe Coding como una pauta a seguir en el 2026.

El programador poco a poco se esta convirtiendo en un espectador, un solicitador de código.

Enlaces:

https://codemonkeyjunior.blogspot.com/2026/01/claude-code-un-nuevo-enfoque-de-la.html
https://lapascalinaatomica.blogspot.com/2026/02/fortran-oberon-y-pascal-frente-la-ia.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
https://en.wikipedia.org/wiki/OpenClaw

domingo, 15 de febrero de 2026

Hablemos de GraalVM: una JVM políglota

GraalVM es una herramienta que nos ayuda a compilar y ejecutar aplicaciones poliglota con alto rendimiento. Emplear esta herramienta nos permite mejorar la velocidad de ejecución de un programa y reducir el consumo de memoria.

Soporta múltiples lenguajes de programación como: Java, Javascript, Python, Ruby, R, etc.

Se considera una opción "mejorada" de la JVM tradicional.

Con GraalVM tenemos el concepto de Native Images (imágenes nativas), lo que consiste en la creación de ejecutables nativos a partir de aplicaciones Java; permitiendo un arranque mucho más rápido y menor uso de memoria.

GraalVM y la JVM

Observemos la siguiente tabla comparativa entre GraalVM y la JVM.

Comparativa: GraalVM vs JVM HotSpot
Aspecto GraalVM JVM HotSpot
Arquitectura Diseño modular con compilador Graal y soporte poliglota. Optimizada para Java, con JIT clásico y soporte limitado a la JVM.
Lenguajes soportados Java, JavaScript, Python, Ruby, R, LLVM bitcode, entre otros. Principalmente Java y lenguajes basados en la JVM (Scala, Kotlin, Groovy).
Rendimiento Mejor optimización en tiempo de ejecución, menor consumo de memoria. Buen rendimiento para Java, pero menos eficiente en arranque y memoria.
Native Images Permite compilar aplicaciones a ejecutables nativos con arranque rápido. No soporta generación de binarios nativos directamente.
Tiempo de arranque Muy rápido gracias a Native Image, ideal para microservicios. Más lento, requiere inicialización completa de la JVM.
Casos de uso Microservicios, aplicaciones poliglota, optimización en la nube. Aplicaciones Java tradicionales, sistemas empresariales robustos.
Interoperabilidad Alta, permite mezclar lenguajes en una misma aplicación. Limitada a lenguajes JVM.

Para instalarlo deberás ir a este sitio: https://www.graalvm.org/downloads/

En tu sistema deberás crear la variable de JAVA_HOME y GRAALVM_HOME apuntando al directorio.

Abre una terminal y teclea:

$ java --version

Salida:

java 25.0.2 2026-01-20 LTS
Java(TM) SE Runtime Environment Oracle GraalVM 25.0.2+10.1 (build 25.0.2+10-LTS-jvmci-b01)
Java HotSpot(TM) 64-Bit Server VM Oracle GraalVM 25.0.2+10.1 (build 25.0.2+10-LTS-jvmci-b01, mixed mode, sharing)

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

HolaMundo.java

public class HolaMundo{
   public static void main(String[] args){
      String mundo = new String("mundo!!");
      System.out.printf("Hola, %s\n",mundo);
   }
}

Compilamos:

$ javac HolaMundo.java

Ejecutamos:

$ java HolaMundo

Salida:

Hola, mundo!!

Ahora creemos una imagen nativa.

$ native-image HolaMundo

El proceso de creación de la imagen nativa puede tardar un tiempo considerable.

Si todo va bien, tendremos un ejecutable llamado holamundo.exe.

Podemos crear un batch con el siguiente contenido:

ejecutable.bat

@echo off
echo Start Time: %time%
holamundo.exe
echo End Time: %time%

Lo ejecutamos y observamos el tiempo que tarda en ejecutarse:

Start Time: 10:55:17.00
Hola, mundo!!
End Time: 10:55:17.04

Ahora modifiquemos el bat:

ejecutable.bat

@echo off
echo Start Time: %time%
java HolaMundo
echo End Time: %time%

Lo ejecutamos y observamos la salida:

Start Time: 10:58:58.59
Hola, mundo!!
End Time: 10:58:58.92

La ejecución del .exe apenas duró unos 4 milisegundos. Mientras que el .class tuvo una duración de 33 milisegundos.

GraalVM puede ser una herramienta de gran ayuda para desarrolladores backend, pues permite optimizar el funcionamiento de las APIs y mejorar el consumo de recursos de memoria. Continuaremos con este tema en próximas entregas.

Enlaces:

https://www.graalvm.org/
https://csantanapr.medium.com/book-review-supercharge-your-applications-with-graalvm-9f330ec38c07
https://github.com/graalvm/graalvm-ce-builds/releases/

viernes, 13 de febrero de 2026

Minilux: un lenguaje de programación para la automatización

 

@lachicadesistemas nos muestra cómo creó su propio lenguaje de programación: minilux.

Minilux se trata de un lenguaje de programación que toma su inspiración de lenguajes como C, Rust y Python. El sitio oficial nos dice:

"Un lenguaje de programación simple para scripts, automatización y mucho más".

Minilux se creó como un proyecto de aprendizaje para comprender:

  • Diseño e implementación del lenguaje.
  • Análisis léxico y análisis sintáctico.
  • Construcción de intérpretes.
  • Programación en Rust.

El vídeo donde se explica el por qué de este lenguaje lo puedes ver en su sitio de Youtube.

Minilux en un vistazo

La extensión de un programa hecho en este lenguaje es *.mi

Es un lenguaje originalmente hecho en C y después en Rust.

Se enfoca en el desarrollo de scripts, como Python o Bash.

Necesitarás tener instalado Rust (y Cargo).

Para su instalación ve a este sitio: https://minilux.org/docs/installation/

Ejemplo. Un hola mundo en este lenguaje.

holamundo.mi

#!/usr/bin/env minilux
printf("Hola, Mundo!")

Actualmente solo puedes usarlo desde la extensión de Visual Studio Code o Antigravity.

A primera vista es un lenguaje de programación que puede servir para ciertas tareas de automatización como las que podrías hacer en lenguajes como Powershell, Bash y Python.

Enlaces:

https://minilux.org/
https://www.youtube.com/watch?v=3zzVG-6JQ64

sábado, 7 de febrero de 2026

Beef y C3, dos lenguajes de programación que evolucionan a C

En este 2026 la programación será cada vez más díficil de aprender y enseñar. La I.A. ha surgido como una herramienta útil para el desarrollador moderno, aunque también un lastre para quienes no quieren evolucionar (o morir en el intento). Es por eso que es necesario el estudio y práctica de la programación.

Existen dos lenguajes llamados Beef y C3 respectivamente que prometen ser la evolución directa al lenguaje mítico C.

Beef se siente como un híbrido entre C++ y C#, con tooling propio y características modernas (tuplas, pattern matching, mixins, reflexión, compilación en caliente). Es ideal para quienes buscan un lenguaje nativo con ecosistema completo y mayor productividad.

La documentación oficial nos dice:

"Beef es un lenguaje de programación de código abierto multiparadigma de alto rendimiento centrado en la productividad del desarrollador".

Beef soporta programación orientada a objetos, funcional y estructurada.

Enfocado a la alta productividad y rendimiento, con fuerte integración C/C++. Busca ser un lenguaje moderno para aplicaciones nativas con tooling propio (IDE, depurador, profiler).

C3 es más conservador. Se mantiene muy cerca de C, pero añade mejoras puntuales (contratos, macros más potentes, genéricos claros, mejor manejo de errores). Es atractivo para proyectos que ya usan C y quieren evolucionar sin perder compatibilidad.

La documentación oficial nos dice:

"C3 es una evolución, no una revolución: el C-like para programadores a quienes les gusta C".

El paradigma de C3 es ser imperativo y estructurado, con extensiones modernas (contratos, macros, genéricos).

Se conidera así mismo como una evolución ergonómica de C, manteniendo compatibilidad total con ABI de C. Su meta es mejorar la seguridad y expresividad sin perder la familiaridad para programadores de C.

Cada uno tiene sus propias características y peculiaridades.

Filosofía de Beef

Se basa en:

  • "Productividad sin sacrificar rendimiento". 
  • Ofrece compilación incremental, detección de fugas en tiempo real, generación de código en tiempo de compilación y un IDE dedicado.
  • Se centra en mejorar la experiencia del desarrollador.

Filosofía de C3

Se basa en:

  • "Una evolución, no una revolución"
  • Mantiene la simplicidad y cercanía a C, pero añade contratos, macros semánticos, reflexión y manejo de errores más seguro. 
  •  Busca ser C mejorado, no reemplazarlo.

Relación con C/C++

Beef:

  • Interoperabilidad directa con librerías C/C++ (estáticas y dinámicas).
  • Permite mezclar niveles de optimización en un mismo proyecto.
  • Sintaxis inspirada en C#, pero con bajo nivel similar a C++.

C3:

  • Compatibilidad ABI completa con C.
  • Puede integrarse en proyectos C/C++ sin esfuerzo.
  • Sintaxis muy cercana a C, con mejoras inspiradas en C++ pero sin su complejidad.

Instalación

Ambos lenguajes pueden ser instalados en plataformas Linux, Mac OS y Windows.

Este es el IDE de Beef

Hola mundo

Observemos el clásico programa de "Hola, mundo" escrito en ambos lenguajes.

Beef:

HolaMundo.bf

using System;

class Program
{
    public static void Main()
    {
        Console.WriteLine("Hola, mundo en Beef!");
    }
}

Como se puede observar, la extensión de un programa Beef es *.bf.

Beef puede usarse desde una terminal o desde su IDE.

Podemos crear un proyecto con los siguientes comandos:

$ beef new HolaMundo

Coloca el código en HolaMundo/src/HolaMundo.bf

Ejecuta el proyecto:

$ beef run

C3:

holamundo.c3

module hola_mundo;
import std::io;

fn void main()
{
io::printn("Hola, mundo en C3!");
}

La extensión de un programa en C3 no podría ser otro que *.c3.

Tiene una cercanía más expresiva a C.

Compilamos:

$ c3c compile holamundo.c3 -o holamundo

Ejecutamos:

$ holamundo.exe

Tipos de datos y estructuras de control básicas

Ejemplo 1. Crear un programa que muestre los tipos de datos y estructuras de control en ambos lenguajes. Para el caso de Beef usaremos su IDE. C3 será compilado y ejecutado desde terminal

Beef:

Program.bf

using System;

namespace HelloWorld;

class Program
{
    static void Main()
    {
        Console.WriteLine("\t [ Fundamentos de Beef ]");
		TestA();
		TestB();
    }

	static void TestA(){
		Console.WriteLine("\t [ Tipos de variables en Beef ]");
		int entero = 42;
		float flotante = 3.14f;
		double doble = 2.71828;
		bool booleano = true;
		char8 caracter = 'A';
		String texto = "Hola, mundo";

		Console.WriteLine($"Entero: {entero}");
		Console.WriteLine($"Flotante: {flotante}");
		Console.WriteLine($"Doble: {doble}");
		Console.WriteLine($"Booleano: {booleano}");
		Console.WriteLine($"Caracter: {caracter}");
		Console.WriteLine($"Texto: {texto}");

	}


	static void TestB(){
		Console.WriteLine("\t [ Estructuras de control en Beef ]");
		bool numeroV =  23 > 20;
		if(numeroV){
			Console.WriteLine("Verdadero: 23 > 20");
			numeroV = 300 < 100;
		}

		if(numeroV){
			Console.WriteLine("Verdadero: 300 < 10");
		}else{
			Console.WriteLine("Falso: 300 < 100");
		}

		int x = 3;
		if (x < 0)
		    Console.WriteLine("x es negativo");
		else if (x == 0)
		    Console.WriteLine("x es cero");
		else
		    Console.WriteLine("x es positivo");

		switch (x)
		{
		    case 1:
		        Console.WriteLine("x es uno");
		        break;
		    case 10:
		        Console.WriteLine("x es diez");
		        break;
		    default:
			    Console.WriteLine($"x no es ni 1 ni 10 es: {x}");    
		        break;
		}


	}


}

Salida:

         [ Fundamentos de Beef ]
         [ Tipos de variables en Beef ]
Entero: 42
Flotante: 3.14
Doble: 2.71828
Booleano: True
Caracter: A
Texto: Hola, mundo
         [ Estructuras de control en Beef ]
Verdadero: 23 > 20
Falso: 300 < 100
x es positivo
x no es ni 1 ni 10 es: 3

C3:

fundamentos.c3

module fundamentos;

import std::io;

fn void main()
{
    io::printn("\t [ Fundamentos en C3 ]");
    test_a();
    test_b();
}

fn void test_b()
{
   io::printn("\t [ Estructuras de control en C3 ]");
    int x = 10;

   
    if (x > 5){
        io::printn("x es mayor que 5");
    }
    
    if (x % 2 == 0){
        io::printn("x es par");
    }else{
        io::printn("x es impar");
    }
   
    if (x < 0){
        io::printn("x es negativo");
    }else if (x == 0){
        io::printn("x es cero");
    }else{
        io::printn("x es positivo");
    }
    
    switch (x) {
        case 1:
            io::printn("x es uno");
            break;
        case 10:
            io::printn("x es diez");
            break;
        default:
            io::printf("x no es ni 1 ni 10 es: %d\n", x);
            break;
    }
}

fn void test_a()
{
    io::printn("\t [ Tipos de datos en C3 ]");

    int entero = 42;
    float flotante = 3.14f;
    double doble = 2.71828;
    bool booleano = true;
    char caracter = 'A';
    ZString texto = (ZString)"Hola, mundo";


    io::printf("Entero: %d\n", entero);
    io::printf("Flotante: %f\n", flotante);
    io::printf("Doble: %f\n", doble);
    io::printf("Booleano: %s\n", booleano ? "true" : "false");
    io::printf("Caracter: %c\n", caracter);
    io::printf("Texto: %s\n", texto);
}

Compilación:

$ c3c compile fundamentos.c3 -o fundamentos

Salida:

         [ Fundamentos en C3 ]
         [ Tipos de datos en C3 ]
Entero: 42
Flotante: 3.140000
Doble: 2.718280
Booleano: true
Caracter: A
Texto: Hola, mundo
         [ Estructuras de control en C3 ]
x es mayor que 5
x es par
x es positivo
x es diez

Ejemplo 2. Crear un programa que muestre las estructuras de control iterativas como for, while y foreach.

Beef:

Program.bf

         using System;

namespace HelloWorld;

class Program
{
    static void Main()
    {
        Console.WriteLine("\t [ Fundamentos de Beef ]");
        TestA();
    }


    static void TestA()
    {
        Console.WriteLine("\t [ Estructuras de control iterativas en Beef ]");

	    // for
	    for (int x = 0; x < 5; x++){
			Console.WriteLine($"for: i = {x}");
		}
	        

	    // while
	    int j = 0;
	    while (j < 5)
	    {
	        Console.WriteLine($"while: j = {j}");
	        j++;
	    }

	    // do-while
	    int k = 0;
	    do repeat
	    {
	        Console.WriteLine($"do-while: k = {k}");
	        k++;
	    } while (k < 5);

	    
		int[] numeros = new int[] { 1, 2, 3, 4, 5 };
		// foreach para recorrerlo
		foreach (int n in numeros){
			Console.WriteLine($"foreach: n = {n}");
		}
		 
    }
}

Salida:

         [ Fundamentos de Beef ]
         [ Estructuras de control iterativas en Beef ]
for: i = 0
for: i = 1
for: i = 2
for: i = 3
for: i = 4
while: j = 0
while: j = 1
while: j = 2
while: j = 3
while: j = 4
do-while: k = 0
do-while: k = 1
do-while: k = 2
do-while: k = 3
do-while: k = 4
foreach: n = 1
foreach: n = 2
foreach: n = 3
foreach: n = 4
foreach: n = 5

C3:

fundamentos.c3

module fundamentos;

import std::io;

fn void main()
{
    io::printn("\t [ Fundamentos en C3 ]");
    test_a();
}

fn void test_a()
{
   io::printn("\t [ Estructuras de control iterativas en C3 ]");
    
    for (int i = 0; i < 5; i++){
        io::printf("for: i = %d\n", i);
    }
    
    int j = 0;
    while (j < 5) {
        io::printf("while: j = %d\n", j);
        j++;
    }

    
    int k = 0;
    do {
        io::printf("do-while: k = %d\n", k);
        k++;
    } while (k < 5);

    

   int[5] numeros = {1, 2, 3, 4, 5};
    for (int idx = 0; idx < numeros.len; idx++){
        io::printf("array[%d] = %d\n", idx, numeros[idx]);
   }

}

Compilación:

$ c3c compile fundamentos.c3 -o fundamentos

Salida:

         [ Fundamentos en C3 ]
         [ Estructuras de control iterativas en C3 ]
for: i = 0
for: i = 1
for: i = 2
for: i = 3
for: i = 4
while: j = 0
while: j = 1
while: j = 2
while: j = 3
while: j = 4
do-while: k = 0
do-while: k = 1
do-while: k = 2
do-while: k = 3
do-while: k = 4
array[0] = 1
array[1] = 2
array[2] = 3
array[3] = 4
array[4] = 5

En conclusión:

  • Si buscas un lenguaje moderno con tooling completo y sintaxis más expresiva, Beef es la apuesta. 
  •  Si prefieres una transición suave desde C, con mejoras de seguridad y ergonomía pero sin perder compatibilidad total, C3 es la opción.

Continuaremos con esta serie sobre lenguajes de programación.

Enlaces:

https://www.beeflang.org/
https://c3-lang.org/

WebSockets: un canal permanente para enviar y recibir datos

Los WebSockets son un protocolo que permite comunicación bidireccional en tiempo real entre cliente y servidor, a diferencia de HTTP que ...

Etiquetas

Archivo del blog