Comparativa entre Go y MoonBit

En está ocasión haremos una comparativa entre el lenguaje de programación Go y Moonbit, el lenguaje orientado a I.A.

Go es un lenguaje de programación diseñado para ser rápido, eficiente, concurrente y fácil de aprender. Compilado y con tipado estático, destaca en el desarrollo backend, sistemas en la nube y redes gracias a su gestión automática de memoria y alto rendimiento.

Por el otro lado, MoonBit es una cadena de herramientas de lenguaje de programación nativo de IA para computación en la nube y edge. Además se compila a WebAssembly, JavaScript y C.

Observemos la siguiente tabla comparativa.

Comparativa Go y MoonBit

Característica	Go	MoonBit
Creador	Ken Thompson, Robert Pike y Robert Griesemer	Zhang Hongbo
Paradigma	Multiparadigma	Programación asíncrona basado en corrutinas, similar a Kotlin
Tipado	Estático	Estático
Extensión	.go	.mbt
Nivel de abstracción	Alto	Alto
Tipo de ejecución	Compilado	Compilado
Ideal para	Microservicios, aplicaciones concurrentes, etc.	Orientado a la I.A. y aplicaciones en tiempo real

Ambos lenguajes comparten ciertas características y poseen su propias peculiaridades. No obstante, la mejor forma de comparar estos lenguajes es realizando algunos ejemplos.

Para más detalles puedes ver esto: https://docs.moonbitlang.com/en/latest/tutorial/for-go-programmers/index.html

Creando proyectos con Go y MoonBit

Empezaremos creando un sencillo proyecto con Go.

1. Creamos un directorio y nos ubicamos en el:

$ mkdir holamundo
$ cd holamundo

2. Inicializamos el módulo:

$ go mod init example.com\holamundo

3. Creamos un programa ``main.go`` con el siguiente contenido:

package main

import "fmt"

func main() {
  fmt.Println("¡Hola, mundo en Go!")
}

La estructura del proyecto lucirá así:

holamundo/
   go.mod
   main.go

Construimos:

$ go build

Esto creará un ejecutable.

Salida:

¡Hola, mundo en Go!

Ahora con MoonBit.

1. Creamos el proyecto:

$ moon new holamundo
$ cd holamundo

El directorio principal y archivos quedarán de esta forma:

holamundo/
├── cmd
│   └── main
│       ├── main.mbt
│       └── moon.pkg
├── holamundo_test.mbt
├── config.mbt
├── holamundo.mbt
├── moon.mod.json
└── moon.pkg

El contenido del archivo ``main.mbt`` es el siguiente:

fn main {
  println("¡Hola, mundo en MoonBit!")
}

Ahora ejecutamos:

$ moon run cmd\main\main.mbt

Salida:

¡Hola, mundo en MoonBit!

Tomemos un ejercicio de Project Euler: calcular la suma de todos los múltiplos de 3 o 5 menores que 1000.

En Go sería de este modo:

main.go

package main

import  "fmt"

func main() {
    vect := make([]int, 1000)
    for i := 0; i < 1000; i++ {
        vect[i] = i + 1
    }

    sum := 0
    for _, v := range vect {
        if v%3 == 0 && v%5 == 0 {
            sum += v
        }
    }

    fmt.Println("Suma:", sum)
}

Construimos y ejecutamos:

$ go build
$./main.exe

Salida:

Suma: 33165

En MoonBit sería así:

main.mbt

fn main {
    let vect = Array::new()

    for i = 0; i < 1000; i = i + 1 {
        vect.push(i + 1)
    }
    let sum = for i = 0, acc = 0; i < vect.length(); i = i + 1 {
        let v = vect[i]
        if v % 3 == 0 && v % 5 == 0 {
            continue i + 1, acc + v
        }
    } else { acc }

    println("Suma: ")
    println(sum)
}

Por el momento es todo. Continuaremos con la comparativa en próximas entregas.

Enlaces:

https://tour.moonbitlang.com/
https://projecteuler.net/
https://docs.moonbitlang.com/en/latest/tutorial/for-go-programmers/index.html
https://alquimistadecodigo.blogspot.com/search?q=go
https://go.dev/
https://emanuelpeg.blogspot.com/search?q=go

Determinar el biotipo de una persona en Go(lang)

Continuando con esta serie de programas que calculan el biotipo de una persona ahora veremos como implementarlo en Go.

Go (antes Golang) es un poderoso lenguaje de prgramación que nos recuerda a Python, C/C++ y a su hermano lejano Rust.

biotipos.go

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    // Diccionario de pesos
    pesoDict := map[string]float32{
        "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,
    }

    // Diccionario de estaturas
    estaturaDict := map[string]float32{
        "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,
    }

    // Entrada del usuario
    reader := bufio.NewReader(os.Stdin)
    fmt.Print("Tu peso es de (ejemplo: 56.00): ")
    peso, _ := reader.ReadString('\n')
    peso = strings.TrimSpace(peso)

    fmt.Print("Tu estatura es de (ejemplo: 1.55): ")
    estatura, _ := reader.ReadString('\n')
    estatura = strings.TrimSpace(estatura)

    // Obtener valores
    valorPeso, pesoOk := pesoDict[peso]
    if !pesoOk {
        valorPeso = -999.0
    }
    valorEstatura, estaturaOk := estaturaDict[estatura]
    if !estaturaOk {
        valorEstatura = -999.0
    }

    if valorPeso == -999.0 || valorEstatura == -999.0 {
        fmt.Println("Error: Peso o estatura no válidos. Asegúrate de ingresar valores dentro del rango permitido.")
        return
    }

    desviacion := valorPeso - valorEstatura

    if desviacion < 0 {
        fmt.Println("Tu biotipo es: longitipo. Largo. Delgado. De apariencia frágil.")
    } else if desviacion > 0 {
        fmt.Println("Tu biotipo es: braquitipo. Sobrepeso. Acumula grasas. Puede ganar musculatura si realiza ejercicio.")
    } else {
        fmt.Println("Tu biotipo es: normotipo. Fuerte. Atlético. Musculoso.")
    }
}

El programa no dista de tener mucha diferencia con respecto al hecho en C y Python. Salvo algunas de sus peculiaridades.

El programa pedirá peso y talla y obtendrá el biotipo de una persona.

Dar formato:

$ go fmt biotipo.go

Construir:

$ go build biotipo.go

Ejecutar:

$ ./biotipo.exe

Solo ejecutar:

$ go run biotipo.go
Tu peso es de (ejemplo: 56.00): 73.29
Tu estatura es de (ejemplo: 1.55): 1.65
Tu biotipo es: braquitipo. Sobrepeso. Acumula grasas. Puede ganar musculatura si realiza ejercicio.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://go.dev/
https://codemonkeyjunior.blogspot.com/2025/02/calcular-el-biotipo-de-una-persona-en.html
https://alquimistadecodigo.blogspot.com/2020/02/go-el-lenguaje-de-programacion-de-google.html
https://alquimistadecodigo.blogspot.com/2021/09/go-un-lenguaje-moderno.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/

Top 10 Programming Languages 2024 | Best Programming Languages To Learn (Youtube)

Lenguajes que deberías aprender en el 2024 (de menor a mayor importancia):

1. Swift 
2. Typescript 
3. Ruby 
4. Go (GoLang) 
5. Kotlin 
6. Python 
7. JavaScript 
8. Rust 
9. Java 
10. C#

Enlaces:

https://medium.com/@coffeeandtips.tech/programming-language-trends-for-2024-what-developers-need-to-know-3a103fe0ff0e

Comparación de la concurrencia de Erlang y Go (en Inglés)

Go tiene un sistema de concurrencia inspirado en el artículo Comunicando Procesos Secuenciales de CAR Hoare. El sistema de concurrencia de Erlang tiene más en común con el modelo Actor de Carl Hewitt. Vamos a explorar brevemente los artículos académicos que forman la base de estos dos lenguajes, y luego compararemos y contrastaremos las primitivas de concurrencia entre Erlang y Go usando demostraciones en vivo y código de muestra.