domingo, 22 de marzo de 2026

Una comparativa entre C# y Beef

Como vimos en una entrega anterior, Beef es un lenguaje de programación similar a C#. Con la peculiaridad que al instalarlo nos provee de su propio IDE.

Observemos un ejemplo. El clásico programa "Hola, mundo" escrito en Beef(lang):

HolaMundo.bf 

using System;

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

Cualquier despistado diría que está escrito en C#, pero no nos confiemos en lo que vemos. Ahora observemos el mismo programa escrito en C#.

Program.cs

using System;

class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Hola, mundo en C#!");
    }
}

La diferencia entre un programa y el otro es casi nula. Para hacer una comparativa entre estos dos lenguajes nos enfocaremos en:

  1. Paradigma que usan.
  2. Características más importantes.
  3. Tipos de datos que manejan.
  4. Sus estructuras de control.
  5. Funciones y procedimientos.
  6. Estructuras de datos.
  7. Manejo de errores.

Comparativa entre C# y Beef

1. Paradigma.

  • Ambos lenguajes son multiparadigma. 
  • Lo que sugiere que puedes crear programas con paradigma estructurado, funcional y orientado a objetos.

2. Principales características.

De C#:

  • Orientado a Objetos (POO). 
  • Seguridad de Tipos (Strongly Typed).
  • Multiplataforma.
  • Gestión Automática de Memoria.
  • Orientado a Componentes.
  • Integración con .NET. 
  • Sintaxis Moderna y Limpia. 
  • Interoperabilidad. 
  • Programación Asíncrona. 
  • LINQ (Language Integrated Query).

De Beef:

  • Sintaxis y Estructura. 
  • Alto Rendimiento. 
  • Productividad del Desarrollador. 
  • Gestión de Memoria. 
  • Características Modernas. 
  • Seguridad en Depuración. 
  • Compilación e IDE.

3. Tipos de datos.

Observemos una tabla comparativa.

Categoría C# Beef
Booleano bool bool
Enteros con signo sbyte, short, int, long, nint int8, int16, int32, int64, int
Enteros sin signo byte, ushort, uint, ulong, nuint uint8, uint16, uint32, uint64, uint
Punto flotante float, double, decimal float, double
Caracteres char char8, char16, char32
Cadenas string No hay tipo nativo, se usan arrays de char*
Referencia / Objeto object, dynamic, delegate structs (colecciones definidas por el usuario)
Especiales void, nullable types (ej. int?) void

C# es más rico que Beef en tipos de referencia y abstracciones de alto nivel.

Categoría C# Beef
Booleano 
// C#
bool flag = true;
 
// Beef
bool flag = true;
Enteros con signo 
// C#
int x = -42;
long y = 123456789;
 
// Beef
int32 x = -42;
int64 y = 123456789;
Enteros sin signo 
// C#
uint a = 42;
byte b = 255;
 
// Beef
uint32 a = 42;
uint8 b = 255;
Punto flotante 
// C#
float pi = 3.14f;
double e = 2.718;
decimal money = 99.99m;
 
// Beef
float pi = 3.14f;
double e = 2.718;
Caracteres 
// C#
char letter = 'A';
 
// Beef
char16 letter = 'A';
Cadenas 
// C#
string name = "Carlos";
 
// Beef
char8* name = "Carlos";
Referencia / Objeto 
// C#
object obj = new object();
delegate void MyDelegate();
 
// Beef
struct Point { int x; int y; }
Point p = .(10, 20);
Especiales 
// C#
void DoSomething() { }
int? maybe = null;
 
// Beef
void DoSomething() { }

4. Estructuras de control.

Observemos la siguiente tabla comparativa entre C# y Beef.

Estructura C# Beef
Condicional if/else 
// C#
if (x > 10)
{
    Console.WriteLine("Mayor a 10");
}
else
{
    Console.WriteLine("Menor o igual a 10");
}
 
// Beef
if (x > 10)
{
    Console.WriteLine("Mayor a 10");
}
else
{
    Console.WriteLine("Menor o igual a 10");
}
switch / match 
// C#
switch (day)
{
    case 1: Console.WriteLine("Lunes"); break;
    case 2: Console.WriteLine("Martes"); break;
    default: Console.WriteLine("Otro día"); break;
}
 
// Beef
switch (day)
{
    case 1: Console.WriteLine("Lunes"); break;
    case 2: Console.WriteLine("Martes"); break;
    default: Console.WriteLine("Otro día"); break;
}
Bucle for 
// C#
for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}
 
// Beef
for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}
Bucle while 
// C#
while (x < 10)
{
    x++;
}
 
// Beef
while (x < 10)
{
    x++;
}
Bucle do-while 
// C#
do
{
    x++;
} while (x < 10);
 
// Beef
do
{
    x++;
} while (x < 10);
foreach 
// C#
foreach (var item in list)
{
    Console.WriteLine(item);
}
 
// Beef
for (var item in list)
{
    Console.WriteLine(item);
}
break / continue 
// C#
for (int i = 0; i < 10; i++)
{
    if (i == 5) break;
    if (i % 2 == 0) continue;
    Console.WriteLine(i);
}
 
// Beef
for (int i = 0; i < 10; i++)
{
    if (i == 5) break;
    if (i % 2 == 0) continue;
    Console.WriteLine(i);
}

La sintaxis de estructuras de control en Beef es prácticamente idéntica a la de C#, lo que facilita la transición entre ambos lenguajes.

La diferencia más notable está en el uso de foreach : en C# existe como palabra reservada, mientras que en Beef se usa un for con iteración directa sobre colecciones.

Ambos lenguajes soportan break y continue dentro de bucles, así como switch con casos y default.

5. Funciones y procedimientos.

Concepto C# Beef
Función simple 
// C#
int Sumar(int a, int b)
{
    return a + b;
}
 
// Beef
int Sumar(int a, int b)
{
    return a + b;
}
Procedimiento (sin retorno) 
// C#
void MostrarMensaje(string msg)
{
    Console.WriteLine(msg);
}
 
// Beef
void MostrarMensaje(String msg)
{
    Console.WriteLine(msg);
}
Parámetros por referencia 
// C#
void Incrementar(ref int x)
{
    x++;
}
 
// Beef
void Incrementar(ref int x)
{
    x++;
}
Parámetros opcionales 
// C#
void Saludar(string nombre = "Invitado")
{
    Console.WriteLine($"Hola {nombre}");
}
 
// Beef
void Saludar(String nombre = "Invitado")
{
    Console.WriteLine("Hola " + nombre);
}
Funciones anónimas / lambdas 
// C#
Func cuadrado = x => x * x;
 
// Beef
function int(int) cuadrado = (x) => x * x;
Funciones dentro de estructuras/clases 
// C#
class Persona
{
    public void Hablar()
    {
        Console.WriteLine("Hola!");
    }
}
 
// Beef
struct Persona
{
    public void Hablar()
    {
        Console.WriteLine("Hola!");
    }
}

6. Estructuras de datos.

Observemos la siguiente tabla comparativa.

Estructura C# Beef
Arreglos 
// C#
int[] numeros = {1, 2, 3};
 
// Beef
int[] numeros = .(1, 2, 3);
Listas dinámicas 
// C#
List lista = new List();
lista.Add(10);
 
// Beef
List lista = new List();
lista.Add(10);
Diccionarios / Mapas 
// C#
Dictionary edades = new Dictionary();
edades["Ana"] = 25;
 
// Beef
Dictionary edades = new Dictionary();
edades["Ana"] = 25;
Conjuntos 
// C#
HashSet conjunto = new HashSet();
conjunto.Add(5);
 
// Beef
HashSet conjunto = new HashSet();
conjunto.Add(5);
Pilas (Stack) 
// C#
Stack pila = new Stack();
pila.Push(1);
 
// Beef
Stack pila = new Stack();
pila.Push(1);
Colas (Queue) 
// C#
Queue cola = new Queue();
cola.Enqueue(2);
 
// Beef
Queue cola = new Queue();
cola.Enqueue(2);
Estructuras definidas por el usuario 
// C#
struct Punto
{
    public int X;
    public int Y;
}
 
// Beef
struct Punto
{
    public int X;
    public int Y;
}

7. Manejo de errores.

Observemos la siguiente tabla comparativa.

Concepto C# Beef
Bloque básico try-catch 
// C#
try
{
    int x = int.Parse("abc");
}
catch (FormatException ex)
{
    Console.WriteLine("Error de formato: " + ex.Message);
}
 
// Beef
try
{
    int x = int.Parse("abc");
}
catch (Exception ex)
{
    Console.WriteLine("Error: " + ex.Message);
}
try-catch-finally 
// C#
try
{
    var file = File.Open("data.txt", FileMode.Open);
}
catch (IOException ex)
{
    Console.WriteLine("Error de E/S: " + ex.Message);
}
finally
{
    Console.WriteLine("Liberando recursos...");
}
 
// Beef
try
{
    var file = File.Open("data.txt", FileMode.Open);
}
catch (Exception ex)
{
    Console.WriteLine("Error: " + ex.Message);
}
finally
{
    Console.WriteLine("Liberando recursos...");
}
Lanzar excepciones 
// C#
throw new InvalidOperationException("Operación inválida");
 
// Beef
throw new Exception("Operación inválida");
Excepciones personalizadas 
// C#
class MiExcepcion : Exception
{
    public MiExcepcion(string msg) : base(msg) { }
}
 
// Beef
struct MiExcepcion : Exception
{
    public this(String msg) : base(msg) { }
}

Ejemplo. Crear un procedimiento donde se calcule el nuevo salario de una persona. Si el empleado es casado, tiene un salario menor a $30000.00 se le de un aumento del 0.05, en caso contrario solo será del 0.01.

En Beef: 

        static void CalculoSalario()
	{
	        Console.WriteLine("\t [ Calculando nuevo salario en Beef  ]");
	        int edad = 0;
		String nombre = scope String();
		String edo_civil = scope String();
		double salario_bruto = 0;
		double salario_neto = 0;

		Console.WriteLine("Introduce tu nombre:");
		Console.ReadLine(nombre); // escribe en el buffer 'nombre'

		Console.WriteLine("Introduce tu edad:");
		String edadStr = scope String();
		Console.ReadLine(edadStr);
		edad = int.Parse(edadStr);

		Console.WriteLine("Introduce tu estado civil:");
		Console.ReadLine(edo_civil);

		Console.WriteLine("Introduce tu salario bruto:");
		String salarioStr = scope String();
		Console.ReadLine(salarioStr);
		salario_bruto = double.Parse(salarioStr);

		if (salario_bruto < 30000)
		{
		    if (edo_civil == "casado")
		    {
		        salario_bruto += salario_bruto * 0.05;
		    }
		    else
		    {
		        salario_bruto += salario_bruto * 0.01;
		    }

		    if (edad > 40)
		    {
		        salario_bruto += salario_bruto * 0.05;
		    }
		    else
		    {
		        salario_bruto += salario_bruto * 0.01;
		    }
		}

		salario_neto = salario_bruto;
		Console.WriteLine("Salario neto: {0}", salario_neto);
	}

En C#:

public static void CalculoSalario()
    {
        Console.WriteLine("\t [ Calculando nuevo salario en C# ]");
        int edad = 0;
        string nombre = "";
        string edo_civil = "";
        double salario_bruto = 0;
        double salario_neto = 0;

        Console.WriteLine("Introduce tu nombre:");
        nombre = Console.ReadLine();

        Console.WriteLine("Introduce tu edad:");
        string edadStr = Console.ReadLine();
        edad = int.Parse(edadStr);

        Console.WriteLine("Introduce tu estado civil:");
        edo_civil = Console.ReadLine();

        Console.WriteLine("Introduce tu salario bruto:");
        string salarioStr = Console.ReadLine();
        salario_bruto = double.Parse(salarioStr);

        if (salario_bruto < 30000)
        {
            if (edo_civil == "casado")
            {
                salario_bruto += salario_bruto * 0.05;
            }
            else
            {
                salario_bruto += salario_bruto * 0.01;
            }

            if (edad > 40)
            {
                salario_bruto += salario_bruto * 0.05;
            }
            else
            {
                salario_bruto += salario_bruto * 0.01;
            }
        }

        salario_neto = salario_bruto;
        Console.WriteLine("Salario neto: {0}", salario_neto);
      
    }

Salida:

         [ Calculando nuevo salario en C# ]
Introduce tu nombre:
Thomas Muller
Introduce tu edad:
34
Introduce tu estado civil:
casado
Introduce tu salario bruto:
29000
Salario neto: 30754.5

Como hemos visto, Beef es un lenguaje de programación que toma inspiración del lenguaje C#. Tanto su sitaxis como tipos de datos. Paradigma y esencia.

Sin embargo, C# es mucho más rico, más completo. Si tuvieras que elegir un lenguaje para crear un nuevo proyecto, C# sería mejor opción, pero Beef no se queda atrás, apenas comienza.

Continuaremos con esta serie de lenguajes de programación.

Enlaces:

https://www.beeflang.org/
https://dotnet.microsoft.com/es-es/languages/csharp
https://codemonkeyjunior.blogspot.com/2026/02/beef-y-c3-dos-lenguajes-de-programacion.html



By en
Etiquetas: , , ,

No hay comentarios:

Publicar un comentario

Suscribirse a: Enviar comentarios (Atom)

Una comparativa entre C# y Beef

Como vimos en una entrega anterior , Beef es un lenguaje de programación similar a C# . Con la peculiaridad que al instalarlo nos provee...

Etiquetas

Archivo del blog