53 – Creando el ejecutable más pequeño de Hola Mundo!

Empezamos con la manera más sencilla de implementar un Hola Mundo en Go. Para esto, usaremos la biblioteca estandar de Go `fmt`. Guardamos este código en un archivo llamado "main.go":

1
2
3
4
5
6
7

package main

import "fmt"

func main(){
  fmt.Println("Hola, Mundo!")
}

Para compilar este programa usaremos el siguiente comando:

1

go build main.go

Para ver el tamaño en disco de este binario usaremos `ls` con las flags "lah" para listarlo y mostrarlo en el formato "humano":

1
2

ls -lah ./main # 1.7 MB
./main #> Hola, Mundo!

Este pequeño programa de Go, de tan solo 7 SLOC (lineas de código) pesa cerca 1.7MB. Si no estan muy familiarizados con Go, es necesario explicarles que Go es un lenguaje desarrollado por Google y uno de los pilares de Go es estar linkeado "estáticamente" es decir, que el binario incluye todas las bibliotecas necesarias para correr en la arquitectura (y sistema operativo) elegido en la compilación. Esto significa que nuestro ejecutable de 1.7MB puede correr incluso en computadoras que no tienen instalado Go, lo cual es una gran ventaja.

En segundo lugar veremos uno de los lenguajes del momento: Rust. Para ello, primero crearemos un nuevo archivo con el nombre rust.rs y escribimos las siguientes 3 líneas:

1
2
3
4

// rust.rs
fn main() {
    println!("Hello, world!");
}

Como ven, Rust nuestro Hola Mundo es bastante elegante y sencillo. Esto, gracias a que println es un macro incluido en el lenguaje asi que no necesitamos importar ninguna biblioteca manualmente (internamente Rust SI incluye la biblioteca, por si acaso.)

Para compilarlo usamos:

1

rustc rust.rs

Nota: tambien podemos compilarlo con cargo build si es que usamos cargo new para crear nuestro proyecto pero para este post vamos a tratar de minimizar la cantidad de archivos que generamos

Esto produce un ejecutable en la carpeta targets/debug con el numbre de "rust", otra vez usaremos `ls` para ver cuanto pesa:

1
2

ls -lah ./rust #> 3.6MB
./rust #> Hola, Mundo!

Soprendentemente (al menos para mi), este ejecutable en Rust es casi 2 veces el tamaño del ejecutable de GO (incluso antes de optimizar Go). Si bien es cierto no estoy muy versado en Rust, pensé que al haber optado por tener un "Compilador lento" (Slow compiler), Rust tendria un binario más reducido.

1

rustc rust.rs  -C strip=symbols

1

strip rust

1
2

ls -lah ./rust #> 307K
./rust #> Hola, Mundo!

1

rustc rust.rs  -C strip=symbols -C opt-level="z" -C lto=no -C panic="abort" -C codegen-units=1

1
2

ls -lah ./rust #> 303K
./rust #> Hola, Mundo!

Para C, crearemos un archivo llamado hello.c y escribiremos el siguiente código:

1
2
3
4
5

#include<stdio.h>
int main(){
  printf("Hola, Mundo!")
  return 0;
}

Nota para los amantes de C: yo sé que, en teoría, podemos usar tan solo "puts", pero hoy en dia los compiladores convierten nuestro código en "puts" automáticamente, asi que realmente no tiene sentido complicarnos de esa manera como desarolladores.

Para compilarlo usaremos g++:

1

g++ hello.c -o hello

Veamos el tamaño del ejecutable:

1
2

ls -lah ./hello #> 16K
./hello #> Hola, Mundo!

16KB. ¿Cómo es posible que sea tan pequeño? ¿Tendrá que ver que C es un lenguaje "antiguo" y por eso es más eficiente? La respuesta es que no (en este caso). El tema principal es que g++ usa el linkeado dinámico de las bibliotecas que C necesita (a diferencia de Go y Rust), es decir asume que tenemos instalado en nuestra computadora C (la gran mayoría de sistemas operativos lo tienen). Ya que realmente no es una pelea justa, tratemos de compilarlo con bibliotecas "estáticas":

1

g++ hello.c -o hello -static

Veamos el tamaño:

1
2

ls -lah ./hello #> 840K
./hello #> Hola, Mundo!

Como podemos ver, si creamos el ejecutable con bibliotecas estáticas tenemos un archivo de 840KB. ¡Significativamente más grande que el de Rust! Incluso luego de correrlo por strip, ¡el binario sigue pesando 768KB!

Pasemos a Zig. Zig es un lenguaje que intenta ser el sucesor de C, pero más que reemplazarlo por completo intenta tener una relacion simbiotica con C. La sintaxis es bastante simple e incluso Zig tiene un compilador para C por lo que incluso podemos usar el mismo codigo fuente de C.

Para compilarlo con Zig usaremos el siguiente comando:

1

zig cc -target x86_64-linux-musl -static -o hello-zig

Nota: El comando compila el programa para la arquitectura que estoy usando para escribir este post.

Veamos el tamanno:

1
2

ls -lah ./hello-zig #> 17K
./hello-zig #> Hola, Mundo!

Obtenemos un binario bastante pequeño, pero cabe destacar que esto es porque Zig por defecto corre "strip" en el binario.

1
2

file hello-zig
hello-zig: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, stripped

Por ultimo veremos Nim. Nim, es un otro lenguaje relativamente joven, este se "compila" a C lo cual es bastante parecido a Zig. Sin lugar a dudas el lenguaje mas simple para el Hola Mundo:

1

echo "Hola, mundo!"

Para compilarlo de manera estática (ya que por defecto es dinámico, como C), tendremos que instalar musl, y luego correr:

1

nim c --gcc.exe:musl-gcc --gcc.linkerexe:musl-gcc --passL:-static -o=hello-nim hello.nim

Veamos el tamaño:

1
2

ls -lh ./hello-nim #=> 115 KB
./hello-nim #=> Hola, mundo!

Tán solo 115KB, sorprendentemente pequeño en realidad, siendo hasta ahora el binario más pequeño que hemos generado (con bibliotecas estáticas), ganandole a su hermano mayor, C.

Incluso podemos sacarle un poco más de jugo al compilador con el Flag "-d:release":

1

nim c --gcc.exe:musl-gcc --gcc.linkerexe:musl-gcc --passL:-static -o=hello-nim -d:release hello.nim

Analizando el tamaño, esta vez usaremos "du -sh", qué es similar a "ls -lah", (es idéntico si le agregamos –aparent-size).

1
2
3
4

du -sh ./hello-nim #=> 96KB
ls -lh ./hello-nim #=> 94 KB
du -sh --apparent-size ./hello-nim #=> 94KB
./hello-nim #=> Hola, mundo!

Se reduce un poco más, llegando a un ejecutable estático con menos de 100KB.