Mostrando entradas con la etiqueta moonbit. Mostrar todas las entradas
Mostrando entradas con la etiqueta moonbit. Mostrar todas las entradas

lunes, 18 de mayo de 2026

Comparativa entre MoonBit y Python

MoonBit es un lenguaje de programación relativamente nuevo; un lenguaje orientado a la I.A. Ideal para la computación en la nube y en el borde, que abarca WebAssembly, WebAssembly-GC, JavaScript y backends nativos.

Python es un lenguaje surgido en los 90's; un lenguaje multiparadigma. Cuya filosofía sugiere lo ágil y hace hincapié en la legibilidad del código.

Miremos la siguiente tabla comparativa:

Comparativa MoonBit y Python

Característica Python MoonBit
Creador Guido van Rossum Zhang Hongbo
Paradigma Multiparadigma Programación asíncrona basado en corrutinas, similar a Kotlin
Tipado Dinámico Estático
Extensión .py .mbt
Tipo ejecución Interpretado Compilado
Ideal para REST API, web, etc. Orientado a aplicaciones 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.

Comparando lenguajes de programación

Declaración de variables:

Comparativa MoonBit y Python

Aspecto Python MoonBit
Declaración
x = 10 # todo es asignación dinámica
let x = 10 (inmutable por defecto)
var y = 20 (mutable)
Tipado
# Dinámico, no requiere anotación.
# Ejemplo: 
s = "hola"
# Estático, inferido por el compilador.
# Ejemplo: 
let s: String = "hola"
Tipos básicos
int, float, bool, str, list, dict, tuple, None
Int, Float, Bool, String, Array, Option, Result
Mutabilidad Todas las variables son referencias mutables por defecto Control explícito con let (inmutable) y var (mutable)

Escribamos el clásico programa de "Hola, mundo" en ambos lenguajes.

holamundo.mbt

fn main() {
    print("Hola, mundo")
}

Ejecución:

$ moon run holamundo.mbt

En Python:

holamundo.py

def main():
    print("Hola, mundo")

if __name__ == "__main__":
    main()

Ejecución:

$ python holamundo.py

Miremos otro ejemplo. El clásico programa de "FizzBuzz".

En MoonBit:

fizzbuzz.mbt

fn fizzbuzz(n: Int) {
    for i in 1..n {
        if i % 15 == 0 {
            print("FizzBuzz")
        } else if i % 3 == 0 {
            print("Fizz")
        } else if i % 5 == 0 {
            print("Buzz")
        } else {
            print(i)
        }
    }
}

fn main() {
    fizzbuzz(20)
}

Ejecución:

$ moon run fizzbuzz.mbt

Salida:

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz

En Python:

fizzbuzz.py

def fizzbuzz(n: int):
    for i in range(1, n + 1):
        if i % 15 == 0:
            print("FizzBuzz")
        elif i % 3 == 0:
            print("Fizz")
        elif i % 5 == 0:
            print("Buzz")
        else:
            print(i)

if __name__ == "__main__":
    fizzbuzz(20)

Ejecución:

$ python fizzbuzz.py

Salida:

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz

Creación de proyectos en MoonBit y Python.

Aspecto MoonBit Python
Herramienta oficial moon new <project> crea estructura básica con src/, tests/, moon.mod No hay comando oficial, pero se recomienda estructura estándar con setup.py, requirements.txt, src/, tests/
Estructura típica
├── src/
├── tests/
└── moon.mod
        
├── src/
├── tests/
├── requirements.txt
├── setup.py
└── README.md
        
Gestión de dependencias moon add <package> (usa repositorio oficial) pip install <package> y se registra en requirements.txt
Ejecución moon run python main.py o pytest para pruebas

MoonBit apuesta por tipado estático, mutabilidad controlada y proyectos con estructura mínima pero clara.

Python es dinámico, flexible y tiene una comunidad enorme con convenciones más que reglas estrictas.

Ambos lenguajes tienen similitudes, pero obviamente MoonBit comparte mayor similitud con Go y no tanto con Python.

Python a su vez comparte mayor similitud a lenguajes como Mojo. Un lenguaje que comparte mucha de su sintexis.

Continuaremos más adelante comparando más lenguajes.

Enlaces:

https://codemonkeyjunior.blogspot.com/2026/05/comparativa-entre-go-y-moonbit.html
https://docs.moonbitlang.com/en/latest/tutorial/for-go-programmers/index.html

sábado, 16 de mayo de 2026

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

sábado, 10 de enero de 2026

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

domingo, 16 de noviembre de 2025

MoonBit: un lenguaje orientado a la I.A.

Moonbit es un nuevo lenguaje de programación orientado a la I.A. y aplicaciones en tiempo real. Podemos probarlo en este sitio: https://try.moonbitlang.com/

El sitio luce como un Visual Studio Code:

Características destacadas de MoonBit:

  • Optimizado para WebAssembly (Wasm): Permite ejecutar código con rendimiento cercano al nativo en navegadores, la nube y dispositivos periféricos (edge). 
  • Multi-paradigma expresivo: Combina lo mejor de lenguajes dinámicos y estáticos, funcionales y prácticos. Esto lo hace flexible para distintos tipos de proyectos. 
  • Orientado a datos con sistema de tipos robusto: Su diseño facilita trabajar con estructuras complejas y asegura mayor confiabilidad en aplicaciones críticas. 
  • Soporte para múltiples backends: Puede compilarse a WebAssembly, JavaScript y otros entornos, lo que lo hace versátil para aplicaciones web y distribuidas. 
  • Plataforma integrada con IA: Incluye mecanismos para minimizar errores de modelos de lenguaje (como alucinaciones de LLMs), pruebas fáciles y salvaguardas de seguridad. 
  • Rápido y preparado para asincronía: Diseñado para ser fast, stable, async-ready, lo que lo hace ideal para aplicaciones modernas que requieren concurrencia. 
  •  Sintaxis simple y moderna.

Deberás descargarlo en este sitio: https://www.moonbitlang.com/download/

Después agregarlo al path de tu sistema.

Comencemos con un clásico "Hola, mundo" en este lenguaje.

holamundo.mb

fn main {
  let greeting =
    #|
    #|     (\(\
    #|     ( -.-)
    #|     o_(")(")
    #|     __  __     ____         __  ___                  ____  _ __
    #|    / / / /__  / / /___     /  |/  /___  ____  ____  / __ )(_) /_
    #|   / /_/ / _ \/ / / __ \   / /|_/ / __ \/ __ \/ __ \/ __  / / __/
    #|  / __  /  __/ / / /_/ /  / /  / / /_/ / /_/ / / / / /_/ / / /_
    #| /_/ /_/\___/_/_/\____/  /_/  /_/\____/\____/_/ /_/_____/_/\__/
    #|
  println(greeting)
}

Para ejecutarlo abrimos una terminal y tecleamos lo siguiente:

$ moon run holamundo.mb

A los programadores de Go/Kotlin/Rust les parecerá muy familiar su sintaxis. Los tipos de datos son: Int, Float, Double, String, Char, Bool, etc.

variables.mb

fn main {
  let a : Int = 10 
  let b = 20 
  let mut c = 0
  c = a + b
  println(c)
  let b: Bool = false
  println(b)
  let cad:String = "This is a simple String"
  println(cad)
  let x: Float = 23.9
  println(x)
  let y: Double = 239.76
  println(y)
}

Ejecución:

$ moon run variables.mb

Conclusiones: MoonBit es un lenguaje emergente diseñado para integrarse de forma nativa con WebAssembly y pensado para flujos de trabajo asistidos por IA. Puedes usar Visual Studio Code para integrar los plugins de este lenguaje.

Busca posicionarse como un lenguaje de nueva generación para aplicaciones web, cloud y edge, con un fuerte enfoque en IA y escalabilidad. Su integración con WebAssembly lo convierte en una opción prometedora para desarrolladores que quieran adelantarse a tendencias futuras

Continuaremos sobre este tema en próximas entregas.

Enlaces:

https://www.moonbitlang.com/


Pattern Matching en sencillas palabras (o no tanto)

El pattern matching es una técnica para comparar estructuras de datos contra un patrón y, si coincide, extraer valores o ejecutar lóg...

Etiquetas

Archivo del blog