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:
- Paradigma que usan.
- Características más importantes.
- Tipos de datos que manejan.
- Sus estructuras de control.
- Funciones y procedimientos.
- Estructuras de datos.
- 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 |
// 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 |
// Beef List |
| Diccionarios / Mapas |
// C# Dictionary |
// Beef Dictionary |
| Conjuntos |
// C# HashSet |
// Beef HashSet |
| Pilas (Stack) |
// C# Stack |
// Beef Stack |
| Colas (Queue) |
// C# Queue |
// Beef Queue |
| 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
