LLVM: una herramienta para crear compiladores

LLVM (Low Level Virtual Machine) es una infraestructura de compiladores que permite transformar y optimizar código de distintos lenguajes de programación. No es un compilador único, sino un conjunto de herramientas que sirven para crear compiladores, analizadores y optimizadores de código.

En este blog ya hemos hablado, burdamente, de lo que conforma un lenguaje de programación. Sin embargo, sería importante recordar algunos detalles.

Un compilador es un programa que traduce el código que escribes (por ejemplo en C, Rust o Java) a un lenguaje que la computadora entiende directamente: el código máquina. Ejemplo, tú escribes una receta en español, el compilador la traduce al "idioma" de la computadora para que pueda cocinarla.

Un analizador de código es la parte del compilador que lee y entiende tu código fuente. Verifica que lo que escribiste tenga sentido (sintaxis correcta, variables bien usadas, etc.). Es como un profesor que revisa tu redacción y te dice si las frases están bien construidas antes de publicarlas.

Un optimizador de código es una herramienta que mejora el código para que sea más rápido o consuma menos recursos. Reorganiza instrucciones, elimina pasos innecesarios y aprovecha mejor el hardware. Llanamente, el optimizador busca el camino más corto y rápido para llegar a algo.

Estos tres se relacionan de esta manera:

• Analizador: entiende tu código y lo valida. 
• Compilador: traduce ese código a instrucciones que la máquina entiende. 
• Optimizador: pule esas instrucciones para que se ejecuten de la mejor manera posible.

LLVM al ser un conjunto de bibliotecas y herramientas que permiten construir compiladores y optimizadores no está limitado a un lenguaje específico; se usa en C, C++, Rust, Swift, Julia, Haskell, entre otros. Está diseñado como bloques reutilizables (frontends, optimizadores, backends).

¿Para qué sirve LLVM?

• Compilación: Convierte código fuente en código máquina optimizado. 
• Optimización: Mejora el rendimiento del código en tiempo de compilación y ejecución. 
• Portabilidad: Permite que un mismo lenguaje se ejecute en múltiples plataformas. 
• Experimentación: Ideal para investigadores y desarrolladores que quieren crear nuevos lenguajes o probar técnicas de optimización.
• Ejemplo real: El compilador Clang (para C/C++/Objective-C) está construido sobre LLVM.

¿Qué hace LLVM?

1. Traduce código a un lenguaje intermedio (LLVM IR) que es más fácil de analizar y optimizar. 
2. Optimiza ese código para que sea más rápido y eficiente. 
3. Genera código máquina para distintas arquitecturas (x86, ARM, etc.), lo que permite que tu programa corra en diferentes dispositivos.

LLVM es como el motor universal que hace funcionar muchos lenguajes modernos (Rust, Swift, Julia, Haskell).

Como desarrollador, puedes usarlo para compilar, optimizar y experimentar con lenguajes modernos o incluso crear el tuyo propio.

Probando LLVM

Vamos a comenzar instalandolo:

Linux:

$ sudo apt update
$ sudo apt install llvm clang

Windows:

$ choco install llvm

Vamos a crear un sencillo programa que verifique si un número entero es mayor a 100.

mayor.c

#include <stdio.h>

int main() {
    printf("\t Determinar si un número es mayor a 100 \n");

    int numero = 120;
    if (numero > 100) {
        printf("El número es mayor que 100\n");
    } else {
        printf("El número es menor o igual a 100\n");
    }

    return 0;
}

Compilams con la herramienta ``clang``:

$ clang mayor.c -o mayor

Creará un ejecutable:

$ ./mayor

Salida:

El número es mayor que 100

Ahora usaremos LLVM para ver el código intermedio (LLVM IR):

$ clang -S -emit-llvm mayor.c -o mayor.ll

Esto genera un archivo ``mayor.ll`` con el Intermediate Representation (IR). En ese archivo verás instrucciones más “básicas” que LLVM entiende, por ejemplo:

define i32 @main() {
entry:
  %numero = alloca i32, align 4
  store i32 120, i32* %numero, align 4
  %0 = load i32, i32* %numero, align 4
  %cmp = icmp sgt i32 %0, 100
  br i1 %cmp, label %if.then, label %if.else
  ...
}

Optimizamos el código:

$ clang -S -emit-llvm mayor.c -o mayor.ll

Esto genera una versión optimizada del IR, eliminando redundancias y mejorando el rendimiento.

Enlaces:

https://llvm.org/
https://codemonkeyjunior.blogspot.com/2024/02/lo-que-conforma-un-lenguaje-de.html
https://clang.llvm.org/
https://es.wikipedia.org/wiki/LLVM
https://www.reddit.com/r/ProgrammingLanguages/comments/kl7n03/what_is_meant_by_llvm_and_a_language_frontend/
https://aosabook.org/en/index.html

Genie Framework: un framework para Julia

Genie Framework es:

un marco de código abierto con todo lo que necesita para crear rápidamente aplicaciones web centradas en datos y listas para producción con Julia.

En este blog ya hemos escrito sobre Julia:

Un lenguaje de programación enfocado al cálculo, estadística y la matemática en general.

La documentación oficial nos dice:

Genie Framework es un potente framework web integral para el lenguaje de programación Julia, ideal para crear interfaces de usuario interactivas, API y aplicaciones web de producción. Ofrece un enfoque sencillo y de bajo código que facilita el desarrollo web a los usuarios de Julia, incluso a aquellos sin experiencia previa en desarrollo web.

Existen dos versiones:

• Genie Builder, la profesional. 
• Open Source, la de uso libre.

La versión Open Source tiene tres componentes principales:

1. Genie.jl: proporciona herramientas de backend y frontend para que puedas crear aplicaciones web y APIs completas basadas en tu código Julia. 
2.  Stipple.jl: Para una interactividad en tiempo real y una interfaz de usuario completa, como la que se necesita en un panel de control, proporciona una capa de interfaz de usuario reactiva. 
3.  SearchLight.jl: Para la persistencia de la base de datos, el ORM de Genie, que se puede añadir en cualquier momento.

¿Necesito tener Julia Language instalado en mi máquina? Sí, se necesita. Podemos descargarlo desde este enlace:

https://julialang.org/downloads/

Si usas Windows puedes obtenerlo de la Microsoft Store o abrir una terminal y pegar esto:

winget install --name Julia --id 9NJNWW8PVKMN -e -s msstore

Comencemos creando un directorio y posicionarnos sobre el mismo:

1 2	$ mkdir proyecto $ cd proyecto

Crear el proyecto con Julia:

1	$ julia --project

Dentro del REPL de Julia, agregamos el Framework:

1	pkg> add GenieFramework

Este comando instala Genie.jl, Stipple.jl y sus dependencias en su proyecto.

Creamos un archivo ``app.jl``. Escribimos lo siguiente:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

module App using GenieFramework @genietools @app begin @in name = "Genie" end function ui() [ h1("Mi primera aplicacion Genie") input("Introduce tu nombre", :nombre) p("Hola, {{message}}!") ] end @page("/", ui) end

Salimos del modo Pkg pulsando la tecla Retroceso. Luego, en el REPL de Julia, cargamos y ejecutamos la aplicación:

1 2 3

using GenieFramework Genie.loadapp() up()

Abrimos el navegador en la ruta:

http://localhost:8000

¡Hemos creado nuestra primera aplicación con Genie Framework!

Enlaces:

https://genieframework.com/
https://codemonkeyjunior.blogspot.com/search?q=julia

Julia en ejemplos no. 3: Creando "clases"

Retomando los ejemplos de código en Julia en esta ocasión conoceremos como crear estructuras Type. Semejantes  a las clases de lenguajes como C, Python y Java.

 ¿Cómo creo una "clase"?
Con la siguiente sintaxis:

type Nombre_Tipo
  ...
  ...
end

Ejemplo. Crear una "clase" en Julia introduciendo valores  y mostrarlas en pantalla.

Definiremos entonces:

• Una estructura Type con el nombre de "Objeto"
• Un método llamado "propiedades"
• Un método para mostrar las "propiedades"
• Una función externa que nos permita introducir datos

 #la "clase" Objeto
type Objeto
    propiedades::Function
 
#constructor
    function Objeto()
        this = new()
 #método para imprimir valores
        function ObtenerDatos(altura::Int64,ancho::Int64,grosor::Int64)
            println("Objeto{alto:",altura,"ancho:",ancho,"grosor:",grosor,"}")
        end

        this.propiedades = ObtenerDatos

        return this
    end
end

#función externa para introducir datos
function entrada(prompt::String="")
   print(prompt)
   chomp(readline())
end

#bloque principal del programa
begin
    objeto = Objeto()#instancia
    altura = int(entrada("Introduce altura:"))
    ancho = int(entrada("Introduce ancho:"))
    grosor = int(entrada("Introduce grosor:"))
    objeto.propiedades(altura,ancho,grosor)
end

Ejecución del código: julia Clase.jl

Links
http://chrisvoncsefalvay.com/2015/02/14/types-and-inheritance.html
https://thenewphalls.wordpress.com/2014/02/19/understanding-object-oriented-programming-in-julia-part-1/

Julia en ejemplos no.2

En este ejemplo vamos veremos como introducir datos y crearemos una función para calcular el área de un triángulo equilátero.

1. Función para leer datos
2. Función para calcular área
3. Cuerpo principal del programa

#función para leer datos
function entrada(prompt::String="")
   print(prompt)
   chomp(readline())
end

#función para calcular área
function area(b,h)
  return (b*h) / 2.0
end

#cuerpo  principal del programa
begin
  run(`clear`)
  base=float(entrada("Introduce base:"))
  altura=float(entrada("Introduce altura:"))
  println("area obtenida: ",area(base,altura))
end


¿Cómo ejecuto el script?
julia nombreDeTuprograma.jl

Julia en ejemplos no. 1

¿Qué es Julia?
Se trata de un lenguaje de programación parecido a R, diseñado para fines científicos (matemáticas, estadística,etc.).  Descarga: Julia Lang

Posee un REPL, basta teclear julia en la terminal y aparecerá.

Julia en ejemplos

Guardar un archivo con la extensión *.jl llamado ejemplos.jl

0.Ejecutar código
julia ejemplos.jl  

1. Imprimir un mensaje
print("La programación parece ser muy sencilla...")

2. Definir variables y constantes
variable_entera=36
const CONSTANTE=200
variable_cadena="La generación de los 80's era la que tenia la mejor música"

3.  Iniciar instrucciones
begin
   #instrucciones del programa
end

4. Definir una función
#esta no devuelve nada
function  imprimirMensaje(){
   print("Julia es un lenguaje similar a R")
}

function doble(n){
  return n*n
}

5. Definir y recorrer un vector
vect=[] #vector vacío
vect=[32,54,10,45] #posiciones 1: 32, 2:54, 3:10, 4:45

for v in vector
    println(v)
end

6. Condiciones
vect=["Juan","Paco","Maria","Ernesto","Rosa"]

#imprimira Paco
for v in vector
   if v == "Paco"
     println(v)
   end
end

7. Ejecutar un comando del sistema run(comando)
#en este caso un comando de Linux
run(`clear`) #limpiar pantalla

8. Try-Catch
try 
   funcion_noexistente()
catch e
   println("el error es: ",e)
end

9.  Introducir datos
 function entrada(prompt::String="")
    print(prompt)
    chomp(readline())
  end

begin
  run(`clear`)
  nombre=entrada("¿Como te llamas?:")
  edad=int(entrada("¿Cuantos años tienes?:"))
  println("Hola ",nombre," tienes ",edad, " años")
  print("tipos: nombre[",typeof(nombre),"] - edad[",typeof(edad),"]")
end

Un vistazo a ... Julia

En está ocasión vamos hacer algunos ejemplos con Julia un lenguaje que a primera vista parece tomar inspiración de Python.

Instalación:

# Descargamos la última versión https://julialang.org/downloads/
# Desempaquetamos
tar -xvzf julia-1.8.2-linux-x86_64.tar.gz
# Movemos a la carpeta /opt
sudo mv julia-1.8.2/ /opt/
# Creamos un enlace
sudo ln -s /opt/julia-1.8.2/bin/julia /usr/local/bin/julia
# Verificamos la instalación
julia

¿Cómo guardo un programa en Julia?
Con la extensión *.jl

¿Cómo ejecutó el programa?
julia miPrograma.jl

Este lenguaje posee un REPL.

Teclea una operación, por ejemplo una suma.

1. Mostrar una cadena
#esto es un comentario
cadena="Hola esta es una simple cadena"
println("contenido de la cadena: ",cadena)


2. Comparar dos cadenas
cadena="cL4v3S3cR3t4"

if cadena == "claveSecreta"
   println("Correcto");
else
   println("Verifica");

end

3. Aqui obtenemos el consumo de combustible, teniendo en cuenta que la velocidad es de 120

begin
velocidad=120
consumo=0.0

if velocidad>80
  consumo=10.0;
elseif velocidad>100
  consumo=12.0;
elseif velocidad>120
  consumo=15.0;
else
  consumo=0.0;
end

println("consumo: ",float(consumo),"\n");

end

4. Obtener salario bruto y neto (hacemos uso del manejo de excepciones con try-catch)
#variables de entrada
horas=240
extras=0
tasa=0.34
#lo que queremos obtener
salarioBruto=0.0
salarioNeto=0.0

try
 
  if horas<=38
    extras=0
  else
    extras=horas-38
    horas=38
  end

  salarioBruto=horas*tasa+extras*tasa*1.5
  if salarioBruto<=300
    salarioNeto=salarioBruto
  else
    salarioNeto=salarioBruto*0.9
  end

  if salarioBruto == salarioNeto
    println("salario bruto y neto: ",salarioBruto)
  else
    println("salario bruto: ",salarioBruto)
    println("salario neto: ",salarioNeto)
  end

catch e
 println("error: ",e)
end

Nuevos lenguajes de programación: Nimrod, Dylan, y Julia

Julia
Parecido a R, es un lenguaje enfocado al cálculo, estadística y la matemática en general.

http://julialang.org/

Nimrod
Un lenguaje que a primera vista nos recuerda a Scala o Python. Y no, no tiene nada que ver con Nimrod de los X Men.

https://github.com/Araq/Nimrod/wiki
http://steved-imaginaryreal.blogspot.mx/2013/09/nimrod-return-of-pascal.html
http://stackoverflow.com/questions/tagged/nimrod
http://nimrod-lang.org/download.html


Dylan
Una mezcla entre Ruby y Python, al menos a mi parecer.Y si, el nombre esta basado en Bob Dylan.

http://opendylan.org/books/dpg/
https://github.com/dylan-lang