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

MoonBit en un vistazo

MoonBit es una cadena de herramientas de lenguaje de programación nativo de IA para computación en la nube y edge. Se compila a WebAssembly, JavaScript y C.

Es muy similar a lenguajes como Python y sobre todo a Go

Ambos lenguajes (MoonBit y Go) son similares en:

• Típicos estáticos con inferencia de tipos.
• Lenguajes compilados con compilación rápida.
• Seguridad en memoria, aunque con mecanismos ligeramente diferentes.
• Orientado a la computación moderna con excelentes herramientas.

Aunque ya vimos algo sobre este lenguaje, hoy veremos cómo instarlo y algunos ejemplos de uso.

Instalando MoonBit

Instalando en Linux:

$ curl -fsSL https://cli.moonbitlang.com/install/unix.sh | bash

Instalando en Windows:

$ Set-ExecutionPolicy RemoteSigned -Scope CurrentUser; irm https://cli.moonbitlang.com/install/powershell.ps1 | iex

Verificamos la instalación:

$ moon version

Podemos ver la ayuda:

$ moon help

Para quienes usan Visual Studio Code, se puede descargar un plugin del lenguaje:

https://marketplace.visualstudio.com/items?itemName=moonbit.moonbit-lang

Programando en MoonBit

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

holamundo.mbt

fn main {
  println("Hola, mundo.")
}

Ejecución:

$ moon run holamundo.mbt

Salida:

Hola, mundo.

Ejemplo 2. Tipos de datos en MoonBit. Aquí veremos los tipos de datos. 

tipos.mbt

fn main{
  let int : Int = 42
  let uint : UInt = 42
  let int64 : Int64 = 42
  let double : Double = 42
  let float : Float = 42
  let bigint : BigInt = 42
  let cadena : String = "FERROCARRIL"
  let c : Char = 'A'
  let verdadero : Bool = true
  println("\t Tipos de datos en MoonBit.")
  println(int)
  println(uint)
  println(int64)
  println(double)
  println(float)
  println(bigint)
  println(cadena)
  println(c)
  println(verdadero)
}

Ejecución:

$ moon run tipos.mbt

Salida:

         Tipos de datos en MoonBit.
42
42
42
42
42
42
FERROCARRIL
A
true

Ejemplo 3. Programa que nos muestre ejemplo de sentencias condicionales.

condicional.mbt

fn main{
  println("\t Condicionales en MoonBit.")
  let mut bandera: Bool = 23 > 22
  
  if bandera{
    println("Fue verdadero.")
    bandera = false
  }

  if bandera{
    println("Esto no se vera en pantalla.")
  }else{
    println("Esto si se vera en pantalla.")
  }

  let resultado = if "A" == "A"{
    "Esto fue verdadero."
  }else{
    "Esto fue falso."
  }
  println(resultado)
  println(fibonacci(5))
}
// Aqui usamos algo similar a switch
fn fibonacci(n : Int) -> Int {
  match n {
    0 => 0
    1 | 2 => 1
    _ => fibonacci(n - 1) + fibonacci(n - 2)
  }
}

Ejecución:

$ moon run condicional.mbt

Salida:

         Condicionales en MoonBit.
Fue verdadero.
Esto si se vera en pantalla.
Esto fue verdadero.
5

Ejemplo 4. Sumar los primeros 100 números pares. Con esto veremos un ejemplo de sentencias iterativas.

iterativas.mbt

fn main{

println("\t Sumar los primeros 100 números pares en MoonBit.")
let suma = for i = 1, acc = 0; i <= 100; i = i + 1 {
  if i % 2 == 0 {
    continue i + 1, acc + i
  }
} else {
  acc
}

   println(suma)

}

Ejecución:

$ moon run iterativas.mbt

Salida:

         Sumar los primeros 100 números pares en MoonBit.
2550

Ejemplo 5. Programa que tenga funciones para suma, resta, multiplicación y división de números enteros.

funciones.mbt

fn main{
  println("\t Funciones en MoonBit.")
  let a: Int = 3
  let b: Int = 2
  println(suma(a, b))
  println(resta(a, b))
  println(producto(a, b))
  println(division(a, b))
}

fn suma(x: Int, y: Int)-> Int {
  x + y
}

fn resta(x: Int, y: Int)-> Int {
  x - y
}

fn producto(x: Int, y: Int)-> Int {
  x * y
}

fn division(x: Int, y: Int)-> Int {
  x / y
}

Ejecución:

$ moon run tipos.mbt

Salida:

         Funciones en MoonBit.
5
1
6
1

Ejemplo 6. Un programa que use estructuras.

estructuras.mbt

struct Persona {
  nombre : String
  apellidos: String
  edad : Int
}

struct Punto{
  x:Int
  y:Int
}

fn main{
  println("\t Estructuras en MoonBit.")
  let thomas = Persona::{ nombre: "Thomas", apellidos: "Muller", edad: 30 }
  let p: Punto = {x: 23, y:43}

  println(thomas.nombre)
  println(thomas.apellidos)
  println(thomas.edad)

  println(" --------------- ")
  println(p.x)
  println(p.y)
}

Ejecución:

$ moon run estructuras.mbt

Salida:

        Estructuras en MoonBit.
Thomas
Muller
30
 ---------------
23
43

Conclusiones:

Hemos instalado MoonBit en nuestro sistema.

Hemos creado algunos programas para conocer lo básico del lenguaje.

En próximas entregas continuaremos con este tema.

Enlaces:

https://www.moonbitlang.com/
https://codemonkeyjunior.blogspot.com/2025/11/moonbit-un-lenguaje-orientado-la-ia.html

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

Lenguajes que deberíamos aprender

No todo en la vida es C, C++, C#, Java o Python. Existen también otros lenguajes que deberíamos aprender. Por ejemplo, lenguajes como Rust, Crystal, Haxe, Elixir y/o Go pueden sorprender a más de uno. Crear servicior REST en cuestión de sólo unos minutos comparado con lenguajes como Java, PHP y/o C#.

Definir clases:

#Clase en Ruby
class Modelo
  #
end

#Clase en Python
class Modelo:
  pass

#Clase en Crystal, noten lo parecido a Ruby
class Modelo

end

Instancias:

#Ruby
modeloRuby = Modelo.new 

#Python
modeloPython = Modelo()

#Crystal
modeloCrystal = Modelo.new

Links:
https://crystal-lang.org/

Conociendo Kotlin

Kotlin es un lenguaje dependiente de la Máquina Virtual Java (JVM); empresas como Google han adoptado este lenguaje porque promete ofrecer compatibilidad e interoperabilidad con proyectos hechos con le lenguaje Java. Kotlin es muy similar a otros lenguajes de programación como Scala y Go (e incluso Typescript). Al igual que Java posee tipos clase (Byte, Short, Int, Float, Double, Boolean, Char). Además podemos importar librerías de Java sin ningún problema. Para declarar una variable modificable usamos var, para declarar una variable no modificable usamos val (similar a Scala).

¿Tipado estático?
El tipado estático puede parecer engorroso a algunos programadores, pero tener que definir el tipo de variables a usar tiene la ventaja de que a la hora de la compilación verificará si existe algún problema. (Supongamos que en un lenguaje dinámico donde no es necesario declarar el tipo de variable a usar necesitamos listar, en una llamada a un método especial, cadenas de texto ("strings") y le pasamos una lista con datos tipo Boolean, etc. y nos provoca un error).


Un programa escrito en Kotlin debe llevar la extensión *.kt

 main.kt

package com.codemonkey

fun main() {
    println("Programando en Kotlin!!!")
}

 Tipos de variables main.kt

//Enteros:
var byte:Byte = 0;
var short:Short = 120;
var int:Int = 40;
var long:Long = 12000000;

//Reales
var float:Float = 2.30f;
var double:Double = 12.654;

//Booleano
var verdadero:Boolean = true;

//Caracter
var character:Char = '\u0000';

//Cadenas
var cadenaStr:String = "Codemonkey Junior";


//Array
var numeros:Array<Int> = arrayOf(0,9,8,7,6,5);

//Lista
var miLista:List<String> =listOf("java","kotlin","ceylon","groovy","scala"); 

Imprimimos los datos a pantalla:

//Imprimimos los valores:
     println("Tipos de datos:");
     println("byte:${byte}");
     println("short:${short}");
     println("int:${int}");
     println("long:${long}");
     println("float:${float}");
     println("double:${double}");
     println("boolean:${verdadero}");
     println("char:${character}");
     println("String:${cadenaStr}");

Compilamos y creamos el jar:
$ kotlinc main.kt -include-runtime -d main.jar
Ejecutamos:
$ java -jar main.jar

También existe la manera de crear y compilar proyectos Kotlin usando Gradle. Para eso debemos definir nuestro archivo gradle.build

gradle.build

buildscript {
    ext.kotlin_version = '1.3.10'

    repositories {
        mavenCentral()
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

apply plugin: 'kotlin'
apply plugin: 'application'

mainClassName = "com.codemonkey.Main"

repositories {
    mavenCentral()
}

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
}

compileKotlin {
    kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

Modificamos nuestro código:

package com.codemonkey

object Main {
   @JvmStatic
   fun main(args:Array<String>){
       //Enteros:
     var byte:Byte = 0;
     var short:Short = 120;
     var int:Int = 40;
     var long:Long = 12000000;
     
     //Reales
     var float:Float = 2.30f;
     var double:Double = 12.654;
     
     //Booleano
     var verdadero:Boolean = true;
     
     //Caracter
     var character:Char = '\u0000';
     
     //Cadenas
     var cadenaStr:String = "Codemonkey Junior";
     
     //Arrays
     var numeros:Array<Int> = arrayOf(0,9,8,7,6,5);
     //Lista
     var miLista:List<String> =listOf("java","kotlin","ceylon","groovy","scala"); 

     //Imprimimos los valores:
     println("Tipos de datos:");
     println("byte:${byte}");
     println("short:${short}");
     println("int:${int}");
     println("long:${long}");
     println("float:${float}");
     println("double:${double}");
     println("boolean:${verdadero}");
     println("char:${character}");
     println("String:${cadenaStr}");

   }
}

Listar Arrays

  println();
     for(numero in numeros){
       println(" "+numero);
     }
     println();
     for(elemento in miLista){
       println("${elemento}")
     }

Para compilar, construir nuestro proyecto tecleamos:
$ gradle build

Para listar las tareas disponibles usamos:
$ gradle -q task
 
Usaremos run para correr el proyecto:

$ gradle run

Links de interés
https://codemonkeyjunior.wordpress.com/2018/11/18/gradle-kotlin/
https://hackernoon.com/top-5-kotlin-programming-courses-for-java-and-android-programmers-49e842b8af1a
https://rubentejera.com/por-que-usar-kotlin/
https://emanuelpeg.blogspot.com/2019/01/propiedades-y-campos-en-kotlin.html

Poner código en blogger
http://hilite.me/