Code monkey: dlang

Mostrando entradas con la etiqueta dlang. Mostrar todas las entradas

sábado, 4 de abril de 2026

WebAssembly con Dlang

WebAssembly es un lenguaje de bajo nivel, similar a ensamblador, diseñado para ser rápido de cargar y ejecutar en navegadores modernos. Su objetivo es permitir que aplicaciones escritas en distintos lenguajes se ejecuten en la web con velocidad casi nativa.

Los formatos que soporta son:

.wasm: un formato binario ejecutable.
.wat: un formato formato de texto legible.

Se complementa con JavaScript; permite invocar funciones WASM desde JS y viceversa. Y como vimos en este blog, también puedes optar por usar un lenguaje como Grain cuya compilación es directa a WASM.

¿Cuál es el objetivo de WebAssembly?

El objetivo de WebAssembly es compilar código escrito en lenguajes como Rust, C o C++ (entre otros) y transformarlo en un módulo .wasm que puede ejecutarse en navegadores o en entornos como Node.js con rendimiento cercano al nativo.

Flujo típico de trabajo con WebAssembly:

Escribimos nuestro código en un lenguaje soportado (ej. Rust, C, C++, Go, AssemblyScript).
Compilamos ese código a WebAssembly y se generará un archivo .wasm.
Cargamos el módulo en tu aplicación web usando JavaScript.
Ejecutamos las funciones exportadas desde el módulo .wasm como si fueran algo nativo.

¿Y qué con Dlang?

Dlang es un lenguaje similar al mítico y poderoso C. No solo en su sintaxis sino en su filosofía.

Dlang permite generar código WASM mediante la herramienta LDC.

Creando código WASM con Dlang

Crearemos una sencilla función llamada ``suma_wasm.d``.

extern(C): 

double suma(double a, double b) { return a + b; }

void _start() {}

Compilamos para generar el código WASM:

$ ldc2 -mtriple=wasm32-unknown-unknown-wasm -betterC suma_wasm.d

Ahora crearemos una página HTML para cargar el código WASM generado (suma_wasm.wasm).

index.html

<html>
  <head>
    <script>
      const request = new XMLHttpRequest();
      request.open('GET', 'suma_wasm.wasm');
      request.responseType = 'arraybuffer';
      request.onload = () => {
        console.log('respuesta recibida');
        const bytes = request.response;
        const importObject = {};
        WebAssembly.instantiate(bytes, importObject).then(result => {
          console.log('iniciado');
          const { exports } = result.instance;
          const r = exports.suma(33, 10.88);
          console.log('r = ' + r);
        });
      };
      request.send();
      console.log('solicitud enviada');
    </script>
  </head>
  <body>
    Código D desde WebAssembly
  </body>
</html>

Ahora ejecutaremos este comando para abrir la página web:

$ python -m http.server 8000

Abrimos un navegador en la ruta: http://localhost:8000

Salida:

solicitud enviada
respuesta recibida
iniciado
r = 43.88

WebAssembly permite que aplicaciones complejas escritas en lenguajes de alto nivel como D, C/C++, Rust, etc. se ejecuten en aplicaciones web a través de un compilado .wasm.

Imaginemos que hemos creado una aplicación para gestionar datos complejos en Rust o Java y la queremos ejecutar como una aplicación web. Con WebAssembly es posible. Se podrá compialr ese código y generar un archivo .wasm que podrá ser cargado en una página web.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://dlang.org/
https://webassembly.org/
https://wiki.dlang.org/Generating_WebAssembly_with_LDC
https://alquimistadecodigo.blogspot.com/2026/04/webassembly-con-rust.html

sábado, 7 de diciembre de 2024

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/

sábado, 30 de noviembre de 2024

Lenguaje de programación D: katas

Dlang o D es un lenguaje de programación similar al clásico C. Mucha de su sintaxis nos recordará a dicho lenguaje. En esta entrega haremos varios ejercicios con funciones. Para instalar este lenguaje ve a este sitio:

https://dlang.org/

Si solo quieres probar el lenguaje, ve este sitio:

https://run.dlang.io/

Para compilar y ejecutar un programa en Dlang(D):

dmd programa.d

Ejercicios en Dlang

Ejercicio 1. Crear funciones para sumar, restar, multiplicar y dividir dos números enteros.

basicas.d

import std.stdio;

int sumar(int x, int y)
{
    return x + y;
}

int restar(int x, int y)
{
    return x - y;
}

int multiplicar(int x, int y)
{
    return x * y;
}

int dividir(int x, int y)
{
    if (y == 0)
    {
        return x;
    }
    return x / y;
}

void main(string[] args)
{
    int x = 45;
    int y = 21;

    int suma = sumar(x, y);
    int resta = restar(x, y);
    int producto = multiplicar(x, y);
    int division = dividir(x, y);
    writeln("\t === Operaciones aritméticas básicas ===");
    writef("La suma de %d y %d es: %d\n", x, y, suma);
    writef("La resta de %d y %d es: %d\n", x, y, resta);
    writef("La multiplicación de %d y %d es: %d\n", x, y, producto);
    writef("La división de %d y %d es: %d\n", x, y, division);
}

D nos permite crear funciones "tipo flecha", por lo que podemos editar el código y quedaría de la siguiente manera:

import std.stdio;

int sumar(int x, int y)=> x+y;

int restar(int x, int y)=>x-y;

int multiplicar(int x, int y)=>x*y;

int dividir(int x, int y)=>y==0?0:x/y;

void main(string[] args)
{
    int x = 45;
    int y = 21;

    int suma = sumar(x, y);
    int resta = restar(x, y);
    int producto = multiplicar(x, y);
    int division = dividir(x, y);
    writeln("\t === Operaciones aritméticas básicas ===");
    writef("La suma de %d y %d es: %d\n", x, y, suma);
    writef("La resta de %d y %d es: %d\n", x, y, resta);
    writef("La multiplicación de %d y %d es: %d\n", x, y, producto);
    writef("La división de %d y %d es: %d\n", x, y, division);
}

Ejercicio 2. Programa que calcule el factorial de un número entero.

factorial.d

import std.stdio;

int factorial(int num)
{
    if (num == 0)
    {
        return 1;
    }
    return num * factorial(num - 1);
}

void main(string[] args)
{
    int numero = 6;
    writeln("\t === Factorial de un número ===");
    writef("El factorial de %d es: %d\n", numero, factorial(numero));
}

El clásico programa del Factorial de un número en Dlang.

Ejercicio 3. Crear un programa que divida un número entre 2. Si el resultado del residuo de esa división es 0, el programa terminará. En otro caso el programa se ciclará.

ciclar.d

import std.stdio;

void mientras(int num)
{
    const int MAX = 100;
    while(num  < MAX ){
        writef("Número : %d\n", num);
        if(num%2==0){
            break;
        }else{
           continue;
        }
        ++num;
    }
}

void main(string[] args)
{
    int numero = 8;
    mientras(numero);
}

La entrada es 8. Si se divide entre 2 dará un residuo de 0 y entonces el programa terminará. Si fuese un número cuya división diera un residuo distinto de 0, entonces el programa se ciclará (un ciclo infinito). Será necesario matar el proceso.

Nota: El operador continue es una instrucción que se utiliza en programación para omitir la iteración actual de un bucle y pasar a la siguiente. En este caso, provocará que se muestre constanteente la entrada que no termina el ciclo, creando un ciclo infinito. Este ejercicio solo es didáctico y no tiene otro propósito.

Ejercicio 4. Este es un ejercicio propuesto en la página de Project Euler:

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.

multiplos3o5.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);
}

Como detalles:

// Se puede crear una constante de esta forma:
const int MAX = 1000;

// Y de esta:
const MAX = 1000;

Además podemos hacer importaciones desde el cuerpo del método principal del programa (main).

Ejercicio 5. Crear una clase llamada Punto con propiedades x, y de tipo ``int``. Agregaremos una clase hija denominada PuntoColor, con un campo color de tipo ``string``.

clases.d

 import std.stdio : writeln;

void main()
{    
    Punto myPunto = new Punto(3,4);
    writeln("x:", myPunto.x);
    writeln("y:", myPunto.y);
    PuntoColor myPuntoColor = new PuntoColor("Rojo");
    writeln("color:", myPuntoColor.color);
}

class Punto{
   public int x;
   public int y;
    
   
    this(int x, int y) {
        writeln("Se ha creado una instancia de la clase Punto");
        this.x = x;
        this.x = x;
    }
}

class PuntoColor: Punto{
   public string color;
    this(string color){
      super(0,0);
      writeln("Se ha creado una instancia de la clase PuntoColor");
      this.color = color;
    }
}

Dlang es un lenguaje de programación que ha aprendido de los errores y aciertos de otros lenguajes como C, Java y C++, entre otros más.

Hasta otra entrega más.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/06/el-lenguaje-de-programacion-d.html
https://projecteuler.net/

domingo, 23 de junio de 2024

El lenguaje de programación D

Según el sitio oficial, el lenguaje D es:

Un lenguaje de programación de propósito general con escritura estática, acceso a nivel de sistemas y sintaxis similar a C.

Después de la creación del lenguaje C muchos otros lenguajes como C++ o C# proclamaban ser el real sucesor. Sin embargo, el lenguaje D aprendió de los error de C++ y clama ser el real sucesor de C.

En primer lugar:

Conserva la esencia de C/C++.
Capaz de hacer código de bajo nivel como C/C++.
Omite algunos aspectos de C/C++.
Conserva la herencia, pero solo la simple.
Uso de plantillas como C++.
Soporta la programación funcional.
Manejo de memoria (recolección de basura).
Interacción con la API de C.

Para probar este lenguaje sin tener que instalarlo debes visitar este sitio:

https://tour.dlang.org/

Ejemplo. Crear el hola, mundo en D.

holamundo.d

import std.stdio;

void main(string[] args)
{
    writeln("Hola, mundo en D");
}

A primera vista es similar a un programa hecho en C.

Ejemplo. Sumar dos números enteros.

suma.d

import std.stdio;

/*
  Sumar dos números en lenguaje D
*/

void main(string[] args)
{
    int x = 0;
    int y = 21;
    
    if(x == 0){
        x = 31;
    }
    
    int suma = x + y;
    writef("La suma de %d y %d es: %d", x,y,suma);

}

Declarar variables es de manera idéntica a la que se hace en C.

Tipos de datos básicos en D:

bool, byte, ubyte, char
short, ushort, wchar
int, uint, dchar
long, ulong
float, double, real

Ejemplo. Mostrar el elemento 2 de un arreglo de cadenas.

saludo.d

import std.stdio;

void main(string[] args)

{
    string[] nombre = ["Miguel","Oscar","Karla"];
    writef("Hola, %s", nombre[2]);

}

Ejemplo. Uso de sentencias condicionales (if, switch)

seleccion.d

import std.stdio : writeln;


void main(string[] args)
{
    if (1 == 1)
        writeln("Esto siempre será verdadero");

    int c = 5;
    switch(c) {
        case 0: .. case 9:
            writeln(c, " entre 0 y 9");
            break; 
        case 10:
            writeln("10");
            break;
        default: 
            writeln("Ningún caso");
            break;
    }
}

En D existen estas sentencias de flujo de control selectivas:

if-else
switch

Ejemplo. Obtener la media de una matriz de números.

recorrer.d

import std.stdio : writefln;



void main() {

    auto arr = [

        [5, 15],      // 20

        [2, 3, 2, 3], // 10

        [3, 6, 2, 9], // 20

    ];



    foreach (i, row; arr)

    {

        double total = 0.0;

        foreach (e; row)

            total += e;



        auto avg = total / row.length;

        writefln("Promedio [row=%d]: %.2f", i, avg);

    }

}

Continuaremos con este tema en próximas entregas.

Enlaces:

https://dlang.org/
https://tour.dlang.org/
http://www.dsource.org/

https://ddili.org/ders/d.en/

sábado, 4 de abril de 2026

WebAssembly con Dlang

Creando código WASM con Dlang

sábado, 7 de diciembre de 2024

Un programa en varios lenguajes de programación (2da parte)

sábado, 30 de noviembre de 2024

Lenguaje de programación D: katas

Ejercicios en Dlang

domingo, 23 de junio de 2024

El lenguaje de programación D

Jai un lenguaje de programación inspirado en C++

Etiquetas

Archivo del blog

Enlaces de interés

Buscar este blog