GNU e Linux, due realtà al centro della comunità di hacker di mezzo Pianeta, tendono ormai a prendere sempre più piede nel mondo moderno, sebbene non senza difficoltà iniziali, livellate in certa misura dagli sforzi di molti appassionati, come potente e valida alternativa libera e gratuita a sistemi operativi proprietari come Microsoft Windows e Mac OS X.
Circa il 90% delle macchine nella lista dei 500 supercomputer più potenti del mondo sono governati da versioni modificate di Linux: tra questi il System z9 dell'IBM, un mainframe in grado di gestire migliaia di istanze del kernel contemporaneamente. Dalla parte opposta possiamo trovare sistemi operativi basati su Linux anche negli iPod, che usiamo spesso per ascoltare i nostri MP3 o i nostri video mentre siamo su un autobus o in treno.
Ma quali sono le radici di un sistema così portabile, versatile, scalabile e modificabile? Da che cosa derivano le sue caratteristiche? Cercherò di rispondere a queste domande nel modo più completo e stringato possibile.
Un tuffo nel passato
Per comprendere in modo più dettagliato le origini di Linux, GNU e UNIX dobbiamo ritornare indietro nel tempo, all'inizio degli anni 60, quando gli elaboratori a transistor della seconda generazione, come la serie IBM 7090 del 1959, cominciarono ad essere realtà di tutti i giorni nelle più grandi aziende di gestione dati. La loro velocità di calcolo e di esecuzione delle istruzioni cominciava paradossalmente ad essere sempre più un ostacolo per l'industria, i cui amministratori vedevano una intera macchina dai costi che superavano facilmente i 60mila dollari di noleggio al mese monopolizzata da un solo utente. Infatti quello che oggi viene chiamato "multiutenza" allora non esisteva e le macchine dovevano per forza di cose dedicare tutte le proprie risorse ad un utente alla volta.
Nel 1961 al MIT (Massachussets Institute of Technology) di Cambridge venne per la prima volta dimostrato un metodo per condividere le risorse di una macchina (principalmente memoria secondaria e processore) tra più utenti. Il sistema operativo, pionieristico per l'epoca, fu chiamato CTSS (acronimo di Compatible Time-Sharing System) e "insegnò al mondo come fare il time-sharing". Il primo mainframe che lo ospitò fu un IBM 7094.
Il CTSS comprendeva dei concetti all'epoca ritenuti futuristici, come una forma arcaica di shell scripting (usato in UNIX e in GNU/Linux) e un sistema di messaggistica tra gli utenti, che può essere visto come l'antenato della posta elettronica quasi trent'anni prima dell'invenzione del WWW. Tra le altre cose, il CTSS introdusse per la prima volta il concetto di demone, ovvero di programma che viene avviato in background e che resta in ascolto di eventuali cambiamenti dello stato logico di un sistema. Un esempio di demone moderno è udevd, che si preoccupa di "ascoltare" i dati inviati dal kernel Linux, esportati attraverso sysfs, quando "si accorge" che una periferica è stata inserita o rimossa dal sistema.
Time-sharing, multitasking, multiutenza
Si sente tanto parlare in giro di multitasking e multiutenza, ma prima di andare avanti ritengo giusto spiegare per sommi capi che cosa significano queste parole a chi ancora non sa di che cosa si tratta.
Il multitasking è una tecnica per la quale due o più processi (ovvero le "forme" che i programmi assumono quando vengono caricati in memoria e "fatti partire") "condividono" le risorse di una macchina per la loro esecuzione, dando l'illusione che su un sistema girino più processi contemporaneamente. Ma nella realtà non è così.
Il multitasking si può dividere in due branche: il multitasking cooperativo e i multitasking preventivo.
Il multitasking cooperativo era una vecchia implementazione di "accesso multiplo" alle risorse di un computer, ma avveniva tra i processi, senza interventi rilevanti da parte del sistema operativo. I processi "collaboravano" per cedersi le risorse a vicenda, ma senza controllo dall'alto si potevano avere due scenari estremamente controproducenti: se un programma non veniva scritto in modo ottimale poteva prendersi tutte le risorse di una macchina per un periodo di tempo eccessivo, oppure causare un hang di sistema, poiché se il blocco del programma avveniva prima che cedesse le risorse questo si poteva tradurre in conseguenze anche catastrofiche, specialmente in sistemi cosiddetti life-critical, che dovevano richiedere calcoli in tempo reale e senza alcun ritardo tollerabile.
Questo modello di multitasking non è praticamente più usato, e le ultime implementazioni conosciute al pubblico risalgono ai primi sistemi operativi Windows (prima di Windows 95) e Mac OS (prima di Mac OS X).
Il multitasking preventivo è il modello più diffuso attualmente. Esso usa il controllo da parte del kernel che, generando dei particolari segnali chiamati interrupt, "istruisce" i processi dicendo loro quando intervenire e quando tornare in standby. Il frammento di kernel che si occupa del ciclo dei processi è chiamato scheduler e ne esistono di vari tipi, che possono implementare molti tipi di ciclo, detti algoritmi di scheduling (scheduling algorithms).
In poche parole, dato un numero di processi n, si prende una certa quantità di tempo (chiamata in gergo quanto) e si assegna al processo x (0) affinché possa "prendere il controllo" del processore e fargli eseguire una certa quantità di istruzioni. Allo scadere del quanto il processo x (0) viene messo in standby e il quanto successivo viene assegnato al processo x (1), che a sua volta usa il processore per fargli eseguire una quantità di istruzioni permessagli dal quanto di tempo. Il ciclo continua fino al processo x (n-1), dopodichè il kernel ritorna al processo x (0) e il ciclo ricomincia.
Questo è l'esempio di algoritmo più semplice, conosciuto con il nome di round-robin, e durata e frequenza dei quanti assegnati può dipendere dalla priorità data dal kernel al processo (o anche attraverso strumenti software controllati dall'utente come nel caso di renice per un sistema GNU/Linux).
La multiutenza consente a più persone di accedere alla stessa macchina nello stesso lasso di tempo, e di credere che essa sia interamente a loro disposizione.
Un esempio molto semplice e frequente è la connessione ad un sito Internet. Apriamo il nostro browser e digitiamo l'indirizzo: la pagina del sito ci compare davanti e ci possiamo fare tutto ciò che il server ci concede, come se fossimo sul posto e come se fosse tutto solo per noi. Ma non è vero: è solo un'illusione data dalla multiutenza, e si può pensare come una forma analoga di multitasking dove, al posto dei processi, ci sono le istanze utente.
Tutto questo sotto il profilo del time-sharing, ovvero la "condivisione temporale" gestita dai kernel moderni che prende diverse forme, come multiutenza (condivisione di risorse da parte degli utenti) o multitasking (condivisione di risorse da parte dei processi).
Sembra impensabile che fino ad un certo punto della storia dell'informatica soltanto un utente o un processo alla volta potesse utilizzare una macchina. Ma si sa, le tecnologie non saltano fuori dal nulla, e prima della comparsa di una nuova idea c'è sempre un qualche cosa di "più primitivo". Il time-sharing fu un punto di svolta, e il CTSS fu una pietra miliare. Ma non finì qui, ci furono molti "raffinamenti successivi" nella storia di GNU/Linux e per conoscerli dobbiamo tornare in carreggiata...
Multics, una fucina di nuove idee
Il Multics (Multiplexed Information and Computing System) fu uno sforzo congiunto di Bell Labs, MIT e General Electric per fornire un nuovo sistema operativo che utilizzasse il time-sharing. Lo sviluppo del software cominciò nel 1964 e, al pari del CTSS, portò una serie di innovazioni tecnologiche al mondo dell'informatica.
Fu il primo sistema operativo ad introdurre un filesystem gerarchico (il sistema cartelle-file-sottocartelle connesse insieme da una directory radice) e le access control lists (o ACL), ovvero un metodo per controllare quale utente avrebbe potuto compiere quale azione su quale file: è l'equivalente dei moderni "permessi" in un filesystem Linux. Introdusse inoltre i link simbolici, ovvero dei collegamenti "virtuali" a dei file "reali" posti in luoghi differenti del filesystem, e fu uno dei primi sistemi operativi a supportare più di un processore.
I progettisti del Multics implementarono inoltre una versione primitiva del dynamic linking (linking dinamico) tra processi in memoria: un processo che ne facesse richiesta poteva disporre successivamente di ulteriori segmenti di memoria da utilizzare nell'esecuzione. Questo permetteva ai processi di usare le routine o le funzioni più recenti programmate per essi. Il dynamic linking è estensivamente utilizzato dai compilatori odierni: le librerie condivise (dynamic linking libraries, o .dll in Windows e i shared objects o .so* in Linux) si basano su questo principio.
Un'altra grande idea fu un tipo primitivo di riconfigurazione hardware automatica "a caldo". Periferiche come banchi di memoria e unità disco potevano essere scambiati mentre la macchina era in funzione. Una specie di antenato del Plug'n'Play.
Bell Labs, Multics e Space Travel
I Bell Labs trovarono il Multics carente ed uscirono dal progetto nel 1969. Apprezzarono gli obiettivi di Multics ma non la sua architettura, a loro giudizio eccessivamente complessa. Ciononostante avevano bisogno di un sistema operativo per continuare le loro ricerche.
Cominciò tutto da un videogioco, scritto da Ken Thompson e chiamato Space Travel, per il sistema GE-645 della General Electric. Vide che era troppo lento e pesante e lo riscrisse su un PDP-7 della DEC (Digital Equipment Corporation), e fu così sorpreso dal risultato che chiese aiuto a Dennis Ritchie per scrivere un sistema operativo su quella nuova macchina. Il primo nome del sistema fu dato da Brian Kernighan, loro collega ricercatore ai Bell Labs: Unics, in contrapposizione a "Multics", che fu poi trasformato in UNIX e infine UNIX. Riprogettarono quello che poi divenne un sistema operativo più semplice e compatto, sebbene ugualmente versatile e robusto, e lo scrissero interamente in linguaggio assembly PDP-7.
Nel 1973 fu riscritto nel linguaggio C, creato dai Bell Labs appositamente per il nuovo UNIX, che portò il sistema operativo ad essere fregiato della definizione di "portabile". La caratteristica di "portabilità", infatti, consente ad un software scritto in un determinato linguaggio (definito per l'appunto "portabile") di essere compilato, assemblato e fatto girare su una macchina di qualsiasi architettura, a patto di avere il compilatore appositamente creato per quella macchina.
BSD, quattro anni dopo
Fino al 1982 il codice sorgente di UNIX poteva essere distribuito alle università, permettendo a ricercatori esterni di estenderne le funzionalità. Una di queste università fu l'Università di California, a Berkeley, che installò una delle prime versioni di UNIX sul loro PDP-11 nel 1974.
Grazie al lavoro estensivo di Bill Joy, un laureando di Berkeley, nel 1977 vide la luce per la prima volta una specie di "aggiunta" a UNIX, un compilatore del linguaggio Pascal e un editor di testo lineare, ex. Berkeley Software Distribution, o BSD, nacque, e con il passare del tempo Joy aggiunse ulteriori componenti. Alla prima versione, 1BSD, seguirono altre.
2BSD aggiunse una versione modificata del primo editor lineare ex, chiamata vi, e un tipo di shell UNIX (la C shell) la cui sintassi degli script ricorda molto la sintassi del C. Entrambi i software sono sopravvissuti al tempo e vengono utilizzati ancora oggi, sebbene in maniera meno frequente. Nel 1983 2.9BSD fu la prima versione di BSD ad essere una vera e propria "derivazione" di UNIX piuttosto che un "gruppo" di software modificati. Essa rimase sul PDP-11 quasi fino ai giorni nostri, nel 1995 con 2.11BSD.
Nel 1978 arrivò a Berkeley un VAX (Virtual Address eXtension), una macchina costruita da DEC che implementava un nuovo tipo di utilizzo della memoria, la memoria virtuale, che permette di "ingannare" un processo facendogli credere che la memoria a cui ha accesso sia contigua e relativamente vasta, mentre nella realtà può essere più o meno limitata e frammentata in RAM.
Al tempo UNIX non sapeva che cosa fosse la memoria virtuale, e così gli studenti di Berkeley riscrissero per la maggior parte il codice del kernel di UNIX e rilasciarono 3BSD, uno dei primi sistemi operativi che seppe utilizzare la memoria virtuale, nel 1979, come "biforcazione" di quel BSD che rimase sul PDP-11.
Una nuova branca dell'università di Berkeley, Computer Systems Research Group (CSRG) fu voluta dalla DARPA (Defense Advanced Research Project Agency, una "costola" del Dipartimento della Difesa statunitense) per continuare le ricerche su BSD. CSRG lavorò a tutte le versioni successive sviluppate su VAX, le 4*BSD, e sulla portabilità del sistema da quando divenne chiaro, nel 1986, che il VAX stava invecchiando troppo per poter produrre risultati apprezzabili. Nel 1995 la CSRG venne chiusa, lasciando in eredità la 4.4BSD-Lite Release 2.
Lynne Jolitz e William Jolitz, studenti dell'università di Berkeley, avevano sufficiente esperienza sul sistema BSD quando, nel 1992, rilasciarono 386BSD, una versione libera di BSD, derivata sia da versioni del PDP-11 (2.9BSD) che da versioni VAX (4.3BSD Net/2). In breve si formò una comunità di entusiasti che da 386BSD generarono NetBSD e FreeBSD nel 1993, e OpenBSD nel 1995. E fu così che anche BSD, "zio" di GNU/Linux, venne fatto conoscere al grande pubblico, con tre varianti principali che vengono usate ancora oggi.
Un salto in avanti
UNIX, in mezzo a tutta la tempesta di cambiamenti, subì evoluzioni e revisioni come qualsiasi altro software... fino a che la sua fama arrivò ad un'università di Amsterdam, facoltà di Scienze della Computazione, dove insegnava il professor Andrew S. Tanenbaum.
Linux side - Una rivoluzione ad Amsterdam
UNIX non fu liberamente distribuibile. La AT&T, proprietaria dei Bell Labs, lo protesse dal 1982 con delle licenze proprietarie, impedendo in seguito la distribuzione e lo studio del codice sorgente. Andrew S. Tanenbaum, un professore di Scienze della computazione dell'università di Vrije, Amsterdam, vedeva UNIX come un esempio di sistema da insegnare ai suoi studenti, ma la sua licenza impediva di capire come funzionava a utenti esterni al gruppo degli sviluppatori.
Decise così di creare, nel 1987, un clone di UNIX che potesse consegnare ai suoi allievi affinché lo studiassero e imparassero i meccanismi principali su cui un sistema operativo si fonda. Mise il nome di MINIX al suo clone e tutto fu in pace ad Amsterdam.
Ma ad Helsinki il terremoto doveva ancora cominciare. Uno studente dell'università della capitale finlandese raggranellò un po' di soldi per procurarsi un 386 e una copia di MINIX da utilizzare per le sue ricerche. Egli usò MINIX e lo apprezzò, ma aveva altre idee in mente, soprattutto quella di renderlo gratuito. Allora decise di usare MINIX come "trampolino di lancio" per sviluppare il suo sistema operativo personale.
Linus Torvalds, in circa metà anno, incorporò alcune delle funzionalità di MINIX nel suo progetto da zero, modellando quello che sarebbe poi diventato il kernel di uno dei sistemi operativi liberi più potenti del mondo. Il 25 agosto del 1991, su comp.os.minix, annunciò il suo lavoro e l'intenzione di ascoltare chiunque avesse utilizzato MINIX o UNIX e volesse implementare o correggere alcune delle loro caratteristiche, o aggiungerne di nuove.
Voleva chiamare il suo kernel Freax, una parola nata dalla fusione "hacker-style" di free, freak e la X di UNIX. Un suo amico, Ari Lemmke, che gestiva il server ftp dove Linus depositava i suoi file gli suggerì di chiamarlo Linux, l'insieme del nome del suo creatore, Linus, e di X, marcandolo come uno dei tanti "rami" della famiglia dei sistemi UNIX e dando finalmente un nome alla rivoluzione informatica moderna del software libero.
GNU Side - Stallman e la FSF
Nei tardi anni'60 un gruppo di sviluppatori del MIT AI Lab non fu d'accordo con le decisioni prese nella progettazione di Multics. Il nuovo progetto fu chiamato ITS, ovvero Incompatible Time-sharing System, il cui nome fu scelto di proposito per "contrasto" verso il CTSS. Era un sistema rivoluzionario per l'epoca.
Tra le innovazioni più rilevanti ci furono le basi dei filesystem di rete, chiamati inter-machine filesystem access, antenati di di filesystem moderni come nfs o cifs; supporto simultaneo di processi real-time e time-sharing; output per terminali indipendenti dall'hardware in uso (una specie di "nonno" dei moderni driver per le schede video), dove i programmi generavano comandi generici che il sistema provvedeva a tradurre nei segnali giusti che inviava alla periferica video.
Richard Matthew Stallman, classe 1953, aveva sempre creduto nella cultura hacker. Fu per questo motivo che il lavoro svolto sull'ITS lo lasciò insoddisfatto, prima di tutto perché ITS era scritto in assembly, e sentiva che c'era il bisogno di un sistema portabile. Per rincarare la dose, a cavallo tra gli anni 70 e 80 le aziende cominciarono a chiudere i sorgenti dei loro software e a proteggere i programmi con licenze proprietarie, impedendo la diffusione, lo studio, la modifica e la redistribuzione del codice.
Il 27 settembre del 1983 Stallman (per gli amici rms) annunciò la sua intenzione di creare un sistema operativo su net.unix-wizards e net.soft e di "regalarlo a chiunque fosse stato in grado di utilizzarlo". Diede il nome GNU al suo sistema, un acronimo ricorsivo che sta per GNU's Not UNIX. Decise di ispirarsi a UNIX poiché esso si dimostrò robusto e scalabile, e ciò che avrebbe costruito avrebbe dovuto essere compatibile con esso. L'obiettivo finale di Stallman era creare qualcosa che gli utenti fossero liberi di installare, usare, modificare e condividere, com'era stato prima degli anni 70.
Lo sviluppo del software cominciò nel 1984, subito dopo che Stallman lasciò il MIT affinché nessuno potesse accampar pretese su ciò che aveva intenzione di fare. Gli inizi furono incoraggianti: molti dei suoi ex-colleghi gli permisero di utilizzare delle attrezzature del MIT (tra cui un'intera stanza per dormire e lavorare), e diversi software erano già a disposizione di Stallman senza particolari vincoli: per esempio la licenza di X Window System, un'interfaccia grafica ideata dallo stesso MIT, era molto permissiva e lasciava la libertà di utilizzo e modifica dei sorgenti.
Nel 1985 fondò la Free Software Foundation, o FSF, che ancor oggi si preoccupa di mantenere i diritti di libertà della condivisione e della redistribuzione di software protetto dalla GNU General Public License (GPL).
Avanti con i lavori, ma... manca il kernel
Un sistema operativo è fatto di tante cose. Le principali sono il kernel, ovvero il "nucleo" del sistema, e le applicazioni, le più importanti delle quali permettono all'utente di interagire direttamente con il kernel, come ad esempio un interprete dei comandi (una shell UNIX o un command.com DOS), per manipolare il sistema.
In GNU lo sviluppo dei programmi procedeva bene, e nel 1990 l'unico componente importante che mancava era il kernel. Quindi i lavori su HURD cominciarono.
Qualche parola su HURD
Alzino la mano quanti di voi sanno che cos'è HURD. Sono pronto a scommettere che probabilmente dei sei utenti che mi hanno seguito fino qui si e no la metà sa di che cosa si tratta.
HURD: HIRD of UNIX-Replacing Daemons
HIRD: HURD of Interfaces Representing Depth
Dietro questo acronimo mutualmente ricorsivo sta uno sforzo da parte di Stallman e della FSF di dotare GNU di un kernel esclusivo. HURD ha un'infanzia infelice, un'adolescenza travagliata e una maturità incompleta.
Già nel 1986 furono intrapresi tentativi di fornire un kernel a quello che sarebbe diventato il futuro GNU. L'idea principale fu di adattare il kernel di 4.4BSD-Lite ad opera di Thomas Bushnell, il principale progettista di HURD. Tuttavia nel 1987 i tentativi di adattamento furono abbandonati a causa della mancanza di cooperazione dei programmatori di Berkeley, casa madre di BSD. Stallman suggerì in seguito di prendere a modello il kernel Mach in fase di sviluppo alla Carnegie-Mellon University della Pennsylvania, ma passarono tre anni senza che l'università decidesse di rendere liberi i sorgenti del loro software. Era ormai il 1990 e, rassegnatosi, il progetto GNU decise di creare da zero il proprio kernel.
L'inizio della fusione
Fato volle che l'anno successivo, il 1991, Linus rilasciasse la versione 0.01 del suo Linux. A quel punto scattarono le collaborazioni da entrambe le parti: sviluppatori di Linux trasportarono codice GNU e lo fecero funzionare tramite il nuovo kernel, e gli sviluppatori GNU, quando vennero a sapere dell'esistenza di Linux, adattarono alcune parti di GNU ad esso. Questo lavoro combinato permise di riempire il vuoto lasciato da HURD e dare alla luce un nuovo sistema operativo.
All'inizio non erano ben chiare le idee su come rendere accessibile al pubblico un sistema operativo così "embrionale", ma alcune persone ci provarono. Uno dei primi "abbozzi" di distribuzione fu la Softlanding Linux System, o SLS, creata da Peter MacDonald nel 1992; in breve fu soppiantata, perché ritenuta instabile, da una delle distribuzioni più longeve della storia di GNU/Linux, ovvero la Slackware (chiamata "Slack" dagli affezionati), ideata e mantenuta da Patrick Volkerding (e i suoi collaboratori) a partire dal 1993. Seguirono a ruota altre distribuzioni, come la Debian di Ian Murdock (1993), Red Hat Linux (Red Hat, 1994), SuSE (Novell, 1994), Mandrake Linux (Mandrakesoft, 1998, poi Mandriva di Conectiva), Gentoo Linux (1999, di Daniel Robbins), e tutta una serie di derivate come Fedora, Knoppix, Corel, OpenSUSE, la famiglia Ubuntu, senza contare le derivate delle derivate... e se si hanno conoscenze sufficienti ci si può anche fabbricare la propria distribuzione personale, si veda il progetto di LinuxFromScratch, solo per veterani smanettoni.
Linux oggi
Ciò che comunemente viene chiamata "distribuzione" non è altro che una collezione di software degli autori più svariati, messi insieme in un unico supporto. Ciascuno di quei software ha avuto una storia a volte condivisa, a volte separata e solitaria. Sono come molti piccoli torrenti che confluiscono in un solo grande fiume in cui ogni acqua mantiene magicamente il suo colore, sono ingredienti di una ricetta di base che può essere modificata a seconda dell'utente o del gruppo che ne fa uso, o delle necessità. Non esiste la distribuzione, esiste solo una distribuzione che ci può andare bene.
La libertà di utilizzo, idea in cui Stallman crede e in cui credeva quando pensò a GNU per la prima volta, è forse la molla che ha spinto e spinge molti utenti ad avvicinarsi al software libero, o almeno che li spinge a guardarsi intorno per vedere se esistono delle alternative rispetto a ciò che stanno usando, ed è la stessa identica molla che può spingere un veterano di Linux a cambiare distribuzione, perché sente il bisogno di una libertà che la distribuzione che sta usando ora non gli può dare. Ma in fin dei conti, quale che sia il software che l'utente decida di usare o come lo decida di usare, dietro c'è sempre una storia, semplice o complicata che sia, che duri un giorno o una generazione, che forse vale la pena raccontare a chi ha orecchie per ascoltare.
MegaLab.it rispetta la tua privacy. Per esercitare i tuoi diritti scrivi a: privacy@megalab.it .
Copyright 2008 MegaLab.it - Tutti i diritti sono riservati