Hello, World!

A meta' viaggio verso la Luna, l'equipaggio di Artemis 2 si volta e scatta una foto intera della terra, Hello, World.

Gli Stati Uniti sono quel paese che elegge per due volte Donald Trump come suo presidente e contemporaneamente manda gente in orbita sulla luna.

Il ritorno dell'homo sapiens sulla roccia grigia avviene dopo piu' di 50 anni, lo stesso progetto Artemis arriva con 20 anni di ritardo sulla tabella di marcia.

Voto procrastinazione: 8.5. Hello, World! e' anche il programma che per tradizione viene utilizzato come introduzione al lessico e alla grammatica di un linguaggio di programmazione. Qui ne elenco un po', in ordine sparso e mischiando linguaggi interpretati e compilati.

"hello, world" (senza maiuscole e punto esclamativo) compare per la prima volta come esempio nel linaguaggio C. Suona come un Haiku dal sapore nostalgico e rassicurante (soprattutto quel return 0), ma anche contemporaneo:

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}   

Fortran 77 ha delle regole molto stringenti sulla composizione della riga. Il codice viene scritto dalla colonna 7 alla 72 e tutto in CAPS LOCK!!!:

C      THIS IS A COMMENT
       PROGRAM HELLO
       PRINT *, 'HELLO, WORLD!'
       STOP
       END

Se Shakespeare fosse stato un programmatore avrebbe scritto in Cobol, il linguaggio piu' prosaico della lista:

IDENTIFICATION DIVISION.
       PROGRAM-ID. HELLO-WORLD.
       
       PROCEDURE DIVISION.
           DISPLAY 'Hello, World!'.
           STOP RUN.

Il common-lisp e' solo uno dei dialetti di una famiglia molto larga. In Lisp (abbreviazione di "list processing") tutto e' una lista e quindi chiuso tra parentesi. format indica una funzione, t e' il corrispettivo di printf in C, i caratteri ~% indicano una nuova linea ("\n" in C). Hello World! entra in una riga di codice:

(format t "Hello, World!~%")

Il mio primo videogioco lo sviluppai a 10 anni, circa. In realta' era un guess the number in cli, non proprio videogioco, e copiai il codice da una rivista de l'epoca (TGM?). Comunque lo digitai in BASIC. In BASIC per Commodore64 i numeri sono obbligatori perche' all'epoca gli editor non avevano la possibilita' di muoversi su tutto lo schermo e per modificare il codice era necessario specificare la riga:

10 PRINT "Hello, World!"
20 END

Nel 1980 arriva il qbasic, i numeri di riga diventano opzionali:

PRINT "Hello, World!"

Dieci anni dopo Microsoft rende la programmazione piu' accessibile inventando il Visual Basic. Hello, World! pero' diventa piu' prolisso:

Module HelloWorld
    Sub Main()
        Console.WriteLine("Hello, World!")
    End Sub
End Module

Pascal, torniamo agli anni 70. Notevole il punto dopo end, indica la fine del codice sorgente:

program HelloWorld;
begin
  writeln('Hello, World!');
end.

Ada e' nipote di Pascal e utilizzato nella ISS, per rimanere in tema di esplorazione spaziale:

with Ada.Text_IO; use Ada.Text_IO;
procedure Hello is
begin
Put_Line ("Hello, world!");
end;

Larry Wall, personaggio molto cinematografico, e' linguista prima di essere pogrammatore. Non stupisce che la sua creazione, Perl, abbia come motto: "There's more than one way to do it" (TMTOWTDI):

use IO::Handle;
STDOUT->print("Hello, World!\n");

o:

use v5.10;
say "Hello, World!";

o:

system("echo Hello, World!");

o:

print pack("H*", "48656c6c6f2c20576f726c64210a");

In opposizione al TMTOWTDI c'e' il tredicesimo aforisma de The Zen of Python, che dice "There should be one—and preferably only one—obvious way to do it."

print("Hello, World!")

Tornando alla procrastinazione, tema centrale di questo blog, Non oggi dedichero' del serio tempo allo studio di Haskell, linguaggio puramente funzionale che negli anni '90 ha tamponato l'ascesa straripante della programmazione a oggetti. Questo codice, apparentemente semplice, nasconde un importante cambio di paradigma:

main :: IO ()
main = putStrLn "Hello, World!"

A proposito di programmazione a oggetti, non posso non citare l'ubiquo C++, qui molto simile a suo nonno C:

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

E quell'abominio boilerplate di Java:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Secondo il sondaggio 2025 di StackOverflow, i linguaggi piu' utilizzati e quelli che si vorrebbero imparare:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

fun main() {
    println("Hello, World!")
}

const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, World!\n", .{});
}

fn main() {
    println!("Hello, World!");
}

Oltre ad astrarre problemi piu' complessi di Hello, World!, la spinta a creare nuovi linguaggi viene dala necessita' di rendere leggibile il codice che in ultima iterazione viene trasformato in codice binario. Leggibile sia da chi il codice non l'ha scritto, sia da chi l'ha scritto ma deve tornarci molto dopo, ovvero discostarsi il piu' possibile da Assembly, qui nella version x86 in tutto il suo ermetico splendore:

.section  .data
msg:
    .asciz "Hello, World!\n"
msg_len = . - msg

.section .text
.globl _start
_start:
    movl $4, %eax
    movl $1, %ebx
    movl $msg, %ecx
    movl $msg_len, %edx
    int $0x80

    movl $1, %eax
    xorl %ebx, %ebx
    int $0x80