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/

Determinar el biotipo de una persona en C

En una pasada entrega vimos cómo calcular el biotipo de una persona en Java. Ahora lo haremos usando el lenguaje de programación C.

Pero, ¿Qué es el biotipo de una persona?

Es la forma característica de un animal o planta. Es el aspecto general de un sujeto de acuerdo a sus características somáticas o morfológicas y se basa en los datos que refleja su estructura corporal, en todo lo que se ve y se puede medir de su cuerpo.

Se refiere a las características corporales, como la estructura ósea, la musculatura y la predisposición al metabolismo, que influyen en la salud, el rendimiento físico y la respuesta a la dieta o ejercicio.

Establece que hay una relación entre las características físicas y la personalidad. Esto ya lo habiamos mencionado en la entrega pasada.

Para el programa en C:

1. Crearemos un archivo de encabezado: biotipo.h 
2. Un archivo donde tendremos las funciones necesarias para los cálculos: biotipo.c 
3. Un programa main: main.c

Existen varios biotipos, pero el general comprende estos tres:

• Ectomorfo: Cuerpo delgado, extremidades largas, dificultad para ganar peso o masa muscular, metabolismo rápido. En otras palabras, sería Longitipo
•  Mesomorfo: Cuerpo atlético, facilidad para ganar músculo, estructura ósea equilibrada, metabolismo eficiente. En otras palabras, sería Normotipo.
•  Endomorfo: Cuerpo con mayor tendencia a acumular grasa, estructura más ancha, metabolismo más lento. En otras palabras, sería Braquitipo.

El programa comprenderá dos "hashmap", hechos con estructuras. Uno para los pesos y el otro para las estaturas.

biotipos.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Estructura para simular el HashMap (clave-valor)
typedef struct {
    char *clave;
    double valor;
} ParClaveValor;

// Listas de pares clave-valor para peso y estatura
ParClaveValor mapaPeso[] = {
    {"85.54", 3.0}, {"83.79", 2.75}, {"82.04", 2.5}, {"80.29", 2.25},
    {"78.54", 2.0}, {"76.79", 1.75}, {"75.04", 1.5}, {"73.29", 1.25},
    {"71.54", 1.0}, {"69.79", 0.75}, {"68.04", 0.50}, {"66.29", 0.25},
    {"64.54", 0.0}, {"62.79", -0.25}, {"61.04", -0.50}, {"59.29", -0.75},
    {"57.54", -1.0}, {"55.79", -1.25}, {"54.04", -1.50}, {"52.29", -1.75},
    {"50.54", -2.0}, {"45.79", -2.25}, {"47.04", -2.5}, {"45.29", -2.75},
    {"43.54", -3.0}
};

ParClaveValor mapaEstatura[] = {
    {"1.87", 3.0}, {"1.86", 2.75}, {"1.85", 2.50}, {"1.83", 2.23},
    {"1.82", 2.0}, {"1.81", 1.75}, {"1.79", 1.50}, {"1.78", 2.25},
    {"1.77", 1.0}, {"1.75", 0.75}, {"1.74", 0.50}, {"1.73", 0.25},
    {"1.71", 0.0}, {"1.7", -0.25}, {"1.69", -0.50}, {"1.67", -0.75},
    {"1.66", -1.0}, {"1.65", -1.25}, {"1.63", -1.50}, {"1.62", -1.75},
    {"1.61", -2.0}, {"1.59", -2.25}, {"1.58", -2.50}, {"1.57", -2.75},
    {"1.55", -3.0}
};

// Tamaños de los mapas
const int TAMANO_PESO = sizeof(mapaPeso) / sizeof(mapaPeso[0]);
const int TAMANO_ESTATURA = sizeof(mapaEstatura) / sizeof(mapaEstatura[0]);

// Función para buscar el valor asociado a una clave en el mapa
double buscarValor(ParClaveValor mapa[], int tamano, const char *clave) {
    for (int i = 0; i < tamano; i++) {
        if (strcmp(mapa[i].clave, clave) == 0) {
            return mapa[i].valor;
        }
    }
    return -999.0; // Valor por defecto si no se encuentra la clave
}

// Función para obtener el peso (equivalente a getPeso en Java)
double obtenerPeso(const char *peso) {
    return buscarValor(mapaPeso, TAMANO_PESO, peso);
}

// Función para obtener la estatura (equivalente a getTalla en Java)
double obtenerEstatura(const char *estatura) {
    return buscarValor(mapaEstatura, TAMANO_ESTATURA, estatura);
}

int main() {
    char peso[10], estatura[10];
    double valorPeso, valorEstatura, desviacion;

    // Solicitar entrada al usuario
    printf("Tu peso es de (ejemplo: 56.00): ");
    fgets(peso, sizeof(peso), stdin);
    peso[strcspn(peso, "\n")] = 0; // Eliminar el salto de línea

    printf("Tu estatura es de (ejemplo: 1.55): ");
    fgets(estatura, sizeof(estatura), stdin);
    estatura[strcspn(estatura, "\n")] = 0; // Eliminar el salto de línea

    // Obtener los valores asociados a peso y estatura
    valorPeso = obtenerPeso(peso);
    valorEstatura = obtenerEstatura(estatura);

    printf("valor peso: %.1f\n", valorPeso);
    printf("valor estatura: %.1f\n", valorEstatura);
    // Verificar si se encontraron los valores
    if (valorPeso == -999.0 || valorEstatura == -999.0) {
        printf("Error: Peso o estatura no válidos. Asegúrate de ingresar valores dentro del rango permitido.\n");
        return 1;
    }

    // Calcular la desviación
    desviacion = valorPeso - valorEstatura;

    // Determinar el biotipo y mostrar el resultado
    if (desviacion < 0) {
        printf("Tu biotipo es: longitipo. Largo. Delgado. De apariencia frágil. \n");
    } else if (desviacion > 0) {
        printf("Tu biotipo es: braquitipo. Sobrepeso. Acumula grasas. Puede ganar musculatura si realiza ejercicio.\n");
    } else {
        printf("Tu biotipo es: normotipo. Fuerte. Atlético. Musculoso\n");
    }

    return 0;
}

Compilación y ejecución:

$ gcc -o biotipos.exe biotipos.c
$ ./biotipos.exe

Salida:

Tu peso es de (ejemplo: 56.00): 43.54
Tu estatura es de (ejemplo: 1.55): 1.61
valor peso: -3.0
valor estatura: -2.0
Tu biotipo es: longitipo. Largo. Delgado. De apariencia frágil.

El programa requiere ciertos ajustes para permitir otras entradas de estatura y peso.

Enlaces:

https://codemonkeyjunior.blogspot.com/2013/03/determinar-el-biotipo-de-una-persona-en.html

Un programa en varios lenguajes de programación (2da parte)

En una entrega anterior vimos como resolver un ejercicio de programación (determina si una cadena de caracteres tiene una longitud distinta de 0) usando diversos lenguajes de programación.

Para probar estos ejemplos puedes ir a este sitio:

https://codapi.org/

En está ocasión resolveremos el siguiente problema:

Si enumeramos todos los números naturales menores de 10 que sean múltiplos de 3 o 5, obtenemos 3, 5, 6 y 9. La suma de estos múltiplos es 23. Halla la suma de todos los múltiplos de 3 o 5 menores de 1000.

Un ejercicio propuesto en la página de Project Euler: https://projecteuler.net/

En Dlang:

multipos3o5.d

void main()
{
    import std.stdio : writefln;
    const MAX = 1000;
    int counter = 1;
    int suma = 0;
    while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           writefln("Suma = %d, Counter: %d",suma,counter);
        }
        ++counter;
    }
    writefln("Suma final= %d",suma);
}

En C:

multiplos3o5.c

#include <stdio.h>
const int MAX = 1000;

int main() {
    int counter = 1;
	int suma = 0;
    
	 while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           printf("Suma = %d, Counter: %d\n",suma,counter);
        }
        ++counter;
    }
	printf("Suma final = %d\n",suma);
    return 0;
}

En Python:

multiplos3o5.py

MAX = 1000;
counter = 1
suma = 0
while counter < MAX:
    if counter%3== 0 or counter%5==0:
        print(f"Suma: {suma}, Counter: {counter}")
        suma = suma + counter
    counter = counter + 1   
print(f"Suma final: {suma}")

En Java:

Multiplos3o5.java

package com.test.main;

public class Main {
    public static final int MAX = 1000;
    public static void main(String[] args) {
        int counter = 1;
        int suma = 0;
        while(counter < MAX){
            if(counter%3==0 ||counter%5==0){
                suma+=counter;
                System.out.printf("Suma: %d, Counter: %d\n",counter,suma);
            }
            ++counter;
        }
        System.out.printf("Suma final: %d\n",suma);
    }
}

En Javascript:

multiplos3o5.js

const MAX = 1000;
let counter = 1;
let suma = 0;
    
	while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           console.log(`Suma = ${suma}, Counter: ${counter}`);
        }
        ++counter;
    }
	console.log(`Suma final = ${suma}`);

En Clojure:

multiplos3o5.clj

(def MAX 1000)

(defn calcular-suma []
  (loop [counter 1 suma 0]
    (if (< counter MAX)
      (if (or (zero? (mod counter 3)) (zero? (mod counter 5)))
        (do
          (println "Suma:" suma ", Counter:" counter)
          (recur (inc counter) (+ suma counter)))
        (recur (inc counter) suma))
      (do
        (println "Suma final:" suma)
        suma))))

(calcular-suma)

Clojure es un lenguaje muy distinto a la mayoría. Como emplea la misma sintaxis de LISP, el cual es un lenguaje orientado a expresiones.

En Ada Language Programming:

multiplos3o5.adb

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

procedure Suma_Multiplos is
   MAX     : constant Integer := 1000;
   Counter : Integer := 1;
   Suma    : Integer := 0;
begin
   while Counter < MAX loop
      if (Counter mod 3 = 0) or (Counter mod 5 = 0) then
         Put_Line("Suma: " & Integer'Image(Suma) & ", Counter: " & Integer'Image(Counter));
         Suma := Suma + Counter;
      end if;
      Counter := Counter + 1;
   end loop;

   Put_Line("Suma final: " & Integer'Image(Suma));
end Suma_Multiplos;

En Rust:

multiplos3o5.rs

fn main() {
    const MAX: i32 = 1000;
    let mut counter = 1;
    let mut suma = 0;

    while counter < MAX {
        if counter % 3 == 0 || counter % 5 == 0 {
            suma += counter;
            println!("Suma = {}, Counter: {}", suma, counter);
        }
        counter += 1;
    }

    println!("Suma final = {}", suma);
}

En Odin:

multiplos3o5.odin

package main

import "core:fmt"

MAX :: 1000;

main :: proc() {
    counter: int = 1;
    suma: int = 0;

    for counter < MAX {
        if counter % 3 == 0 || counter % 5 == 0 {
            suma += counter;
            fmt.printf("Suma = %d, Counter: %d\n", suma, counter);
        }
        counter += 1;
    }

    fmt.printf("Suma final = %d\n", suma);
}

En Go:

multiplos3o5.go

package main

import "fmt"

func main() {
    const MAX = 1000
    counter := 1
    suma := 0

    for counter < MAX {
        if counter%3 == 0 || counter%5 == 0 {
            suma += counter
            fmt.Printf("Suma = %d, Counter = %d\n", suma, counter)
        }
        counter++
    }

    fmt.Printf("Suma final = %d\n", suma)
}

Continuaremos ampliando la lista de ejemplos.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/02/un-programa-en-varios-lenguajes.html
https://projecteuler.net/