I sistemi operativi, padroni di casa della macchina

Nel modulo sull'architettura di Neumann abbiamo guardato il processore al lavoro, un esecutore scrupoloso che ripete all'infinito il suo giro di fetch-decode-execute, prelevando istruzioni e dati dalla memoria e scrivendovi i risultati. Abbiamo anche capito che questo esecutore, per quanto velocissimo, è terribilmente ingenuo, perché fa soltanto ciò che gli viene detto, nella sua lingua fatta di numeri. Accendendo la macchina troviamo però già un ambiente pronto, con scrivania e icone, e a prepararlo è il sistema operativo, il padrone di casa della macchina che questo modulo racconta.

Pensa a un condominio dove tutti vogliono la palestra e la lavanderia e nessuno assegna gli orari, perché la convivenza diventerebbe presto impossibile. Il computer è un condominio di questo tipo, dato che dentro di esso girano contemporaneamente decine di programmi che chiedono tutti lo stesso processore, la stessa memoria e gli stessi dischi, ed è il sistema operativo a fare da amministratore. Tanenbaum, il maestro da cui attinge questa pagina, gli assegna due facce, quella del gestore delle risorse e quella della macchina estesa, che seguiremo una alla volta.

La prima faccia è quella del gestore delle risorse, che in inglese si chiama resource manager, ed è facile da immaginare pensando a chi presidia una sala cinema ambita da molte troupe. Il sistema operativo tiene il registro di chi ha bisogno del processore, di chi aspetta la memoria, di chi usa il disco, e assegna ogni cosa con regole precise tra le parti condivise. Quando stampi mentre ascolti musica e scarichi una fotografia, sono questi meccanismi che impediscono alle tre richieste di intrecciarsi in un'unica stampa illeggibile.

La seconda faccia è più sottile e Tanenbaum la chiama extended machine, cioè macchina estesa, e serve a coprire la bruttezza dell'hardware dietro un volto gentile. L'hardware vero è complicatissimo, tanto che il manuale che descrive come comandare un singolo disco rigido supera le quattrocentocinquanta pagine, e nessun programmatore sensato vorrebbe affrontarlo. Il sistema operativo fa come un maggiordomo che riceve la richiesta portami un file e sotto il tavolo compie lui i movimenti scomodi, offrendo file e cartelle al posto dei circuiti e dei motorini. In questa veste il sistema trasforma un'interfaccia brutta in una bella, come ricorda il suo libro.

Per questi lavori il sistema si appoggia a una parte privilegiata di sé stesso, il kernel, parola tedesca che significa nocciolo. Il kernel è l'unico che gira in quella che si chiama kernel mode, una modalità con privilegi elevati che gli permette di parlare direttamente con l'hardware e toccare la memoria di chiunque, mentre tutto il resto gira in user mode come un semplice ospite. La distinzione ricorda un albergo dove soltanto il direttore possiede le chiavi di tutte le stanze, ed è una protezione fondamentale, perché ogni errore di un programma resta confinato nei suoi confini anziché spezzare l'intera casa.

Tutto il traffico tra gli ospiti e il direttore passa da un'unica porta, e questa porta ha un nome tecnico che vale la pena imparare, la system call, cioè la chiamata al sistema, che è il modo formale con cui un programma qualsiasi chiede un servizio al kernel, per aprire un file, per leggere un tasto o per mandare qualcosa in rete. Quando il tuo programma di scrittura salva il lavoro, sotto il cofano una chiamata chiede al kernel di aprire il file e un'altra gli consegna i dati da scrivere, e il processore passa da user mode a kernel mode soltanto per il tempo necessario, poi riconsegna il testimone. Capire questa porta chiarisce molte cose, perché i permessi, i processi e la memoria di cui parliamo sono controllati tutti al varco, dove ogni richiesta lascia il nome di chi chiede e l'attesa di una risposta.

Vale la pena seguire la macchina fin dal primo istante, perché premere il pulsante dà il via a una catena di consegne che merita un capitolo a parte. Quando alzi la serranda elettrica, la scheda madre sveglia un piccolo programma scritto nella sua memoria, chiamato firmware, che nei computer moderni risponde al nome di UEFI e nei più vecchi si chiamava BIOS, e questo custode compie prima un giro di controllo dei componenti, la cosiddetta autoverifica di accensione, assicurandosi che la memoria, il disco e la tastiera rispondano al proprio nome. Finito il controllo, il firmware cerca sul disco un settore speciale, il primo di tutti, dove risiede il bootloader, cioè il traghettatore di avvio, e lo carica in memoria per consegnargli il testimone.

Il bootloader ha un compito modesto e decisivo, e cioè pescare dalla partizione giusta il file del kernel, caricarlo nella memoria principale e lasciargli il comando. Il kernel, svegliatosi così in fretta, registra i propri driver, scopre quali periferiche esistono, prepara le tabelle per i processi e per i file, e poi accende i primi processi di tutti, quelli che a loro volta danno la mano ai servizi successivi, dai gestori di rete fino alla scrivania, finché sullo schermo compare la schermata di accesso che ti chiede chi sei. Da quel momento ogni cosa che muovi dipende dai meccanismi che stiamo per visitare, e tutta la fatica del risveglio dura pochi secondi.

Sopra questo cuore girano i processi, cioè i programmi mentre sono in esecuzione, ciascuno con dati e posto propri nella memoria. Ogni processo possiede uno spazio privato, una specie di appartamento con la porta chiusa, al riparo da vicini curiosi. Poiché i processi sono molti di più delle unità di calcolo reali, entra in scena lo scheduler, che assegna il processore a turno per un battito brevissimo e poi passa al successivo, così in fretta da dare l'illusione di un'esecuzione simultanea, come le palline di un giocoliere che sembrano librarsi insieme pur volando una alla volta. Aprendo Gestione attività su Windows o Monitoraggio attività su macOS la vedrai con i tuoi occhi.

Per gestire la folla il sistema classifica ogni processo con cura amministrativa, assegnandogli a ogni istante uno di tre stati, e cioè in esecuzione per chi possiede il processore in questo momento, pronto per chi sta in fila aspettando il proprio turno, e bloccato per chi attende qualcosa dall'esterno, per esempio una risposta dal disco o un tasto della tua tastiera. Le transizioni accadono di continuo, perché chi sta eseguendo esaurisce la fetta di tempo e torna pronto, chi aspettava il disco riceve la risposta e risale in fila, chi esegue chiede qualcosa e scivola in blocco, e il gioco ricomincia centinaia di volte al secondo per ciascun abitante della casa.

Per tenere il punto con ognuno di questi abitanti il sistema conserva un blocco descrittore, una scheda d'identità, chiamata in inglese process control block, che registra lo stato corrente, dove si è fermato il contatore delle istruzioni, quali file ha aperto e quanta memoria occupa. Quando arriva il turno, il contenuto di questa scheda viene versato nei registri del processore, che riparte esattamente dal punto in cui si era fermato, come un musicante che ritrova lo spartito sul leggio e riprende la battuta interrotta. Senza di essa ogni cambio di turno cancellerebbe la memoria del lavoro in corso, e nessun programma potrebbe mai proseguire.

I numeri danno il senso della fatica, perché la fetta di tempo, chiamata quantum, si misura in millesimi di secondo e il cambio avviene migliaia di volte al secondo, così veloce che il passaggio resta invisibile a chi guarda. Il giro di giostra più semplice si chiama round-robin, ogni processo prende la fetta e poi cede il posto, e accanto a questo turno equo il sistema tiene le priorità, facendo passare prima chi serve subito, come il giocoliere che dedica più attenzioni alla pallina più pesante, così la musica continua mentre il documento viene salvato e la pagina si aggiorna.

C'è poi un parente stretto del processo che conviene conoscere, il thread, parola che significa filo e indica un percorso di esecuzione leggero, perché mentre ogni processo ha il proprio spazio privato, i thread di uno stesso processo condividono lo stesso appartamento e lavorano in parallelo su compiti diversi, come i due cuochi di una stessa cucina che usano gli stessi armadi pur preparando piatti differenti. Il tuo programma di scrittura può così ascoltare la tastiera in un thread mentre salva il documento in un altro, e tu percepisci semplicemente una macchina reattiva, senza sapere che una piccola brigata lavora per te.

La convivenza, però, può incepparsi in un modo curioso che i libri chiamano deadlock, cioè stallo mortale, e l'immagine classica è la tavola di cena dove ogni ospite possiede una forchetta e attende la seconda posata tenuta dal vicino, così tutti restano seduti in silenzio con lo stomaco vuoto, ognuno in attesa di qualcuno che aspetta a sua volta. Tanenbaum elenca le quattro condizioni che rendono possibile questa tragedia dentro una sola frase memorabile, e cioè che ogni risorsa appartenga a un solo processo alla volta, che chi possiede una risorsa possa chiederne un'altra, che le risorse concesse non possano essere strappate via, e che i processi formino un cerchio in cui ciascuno attende qualcosa dal vicino successivo, e basta rompere una sola di queste catene per dormire tranquilli.

Il sistema dona a ogni processo un'illusione di secondo tipo, la memoria virtuale, per cui ciascuno è convinto di possedere uno spazio tutto suo anche quando la memoria vera è una sola e va spartita. Qui funziona benissimo l'analogia della scrivania, perché la memoria principale, quella chiamata RAM, è il piano che ospita i fogli del lavoro corrente, capiente ma troppo piccolo per tutto quello che possiedi, mentre il disco è lo scaffale in fondo allo studio. Quando lo spazio scarseggia, il sistema ripone nello scaffale i fogli inutilizzati da più tempo, in un'operazione chiamata paging, così il piano torna libero, e il rallentamento con troppi programmi aperti è questa scrivania che si svuota e si riempie.

Dietro l'illusione si nasconde un meccanismo di traduzione preciso, perché ogni processo ragiona con indirizzi logici, numeri che partono da zero nel suo mondo privato, e una tabella tenuta dal sistema con l'aiuto del processore converte ogni indirizzo logico nell'indirizzo fisico reale dove la parola vive nella memoria vera, spostando all'occorrenza le pagine, cioè i pezzi di qualche kilobyte in cui la memoria viene tagliata, là dove c'è posto. Così due processi possono entrambi chiamare casa il numero mille, e il sistema li conduce a due stanze differenti senza che nessuno dei due sospetti dell'altro.

Quando un processo tocca una pagina che in quel momento vive sul disco, scatta il page fault, cioè l'interruzione per pagina mancante, e il sistema sospende chi ha richiesto, va a prendere la pagina, la colloca nella memoria e fa ripartire l'interessato, che nemmeno se ne accorge. Quando la memoria scarseggia davvero, il sistema passa allo swapping, cioè allo scambio, allontanando interi processi dormienti sul disco per far posto a quelli desti, e per questo la quantità di RAM si sente tutta nei giorni di lavoro pesante, perché una scrivania piccola obbliga a viaggi continui verso lo scaffale, e i viaggi col disco sono migliaia di volte più lenti dei movimenti sul piano.

Passiamo alla parte che vedi ogni giorno, i file e le cartelle, organizzati da una componente chiamata file system, che decide nomi, dimensioni e modo di ritrovarle. L'organizzazione è quella di un albero rovesciato che parte dalla radice, un tronco unico da cui si dipartono rami, le cartelle, che contengono altri rami o le foglie, che sono i file, e ogni elemento si raggiunge seguendo un percorso, cioè la lista dei rami da attraversare fino alla foglia, esattamente come per arrivare a una casa segui via, viale e numero civico scritti sull'indirizzo di una lettera. Come il postino che consegna senza conoscere tutta la città, il sistema scende lungo i nomi delle cartelle fino al file cercato.

Dietro i nomi delle foglie c'è una contabilità minuziosa, perché il file system per ogni file conserva un inode, un cartellino che registra chi è il proprietario, quali permessi porta, quanto è grande e soprattutto quali blocchi del disco ne contengono i pezzi, così quando apri una fotografia il sistema percorre il cartellino e raccoglie i frammenti sparsi. Per non perdere il filo di questa matassa esiste una tabella di allocazione che segna i blocchi liberi e quelli occupati, e i file system moderni tengono anche un giornale, un registro nel quale ogni modifica viene annotata prima di essere compiuta, così se la corrente salta a metà di un salvataggio il sistema rilegge il giornale e ricostruisce lo stato pulito, anziché ritrovarsi con un disordine inspiegabile.

L'albero, infine, è più flessibile di quanto sembri, perché il comando di mount, cioè di montaggio, permette di appuntare il file system di un secondo disco o di una chiavetta come nuovo ramo sopra un ramo esistente, esattamente come innestare un ramo nuovo su un albero vero, e da quel momento le foglie dell'aggiunta si raggiungono con un semplice percorso come ogni altra. La lista di ciò che è innestato, con lo spazio che ogni ramo offre e quello che resta libero, si legge con un comando che incontreremo tra poco, e capire questo meccanismo spiega perché nei sistemi di famiglia Unix anche la chiavetta ha il suo posto preciso nell'albero, anziché comparire come un mondo a parte.

Sopra questo albero si innesta la gestione degli utenti, perché un computer può ospitare più persone e ogni cosa conservata porta scritto chi può farci cosa. Ogni file ha infatti tre permessi possibili, la lettura, che consente di guardarne il contenuto, la scrittura, che consente di modificarlo, e l'esecuzione, che consente di avviarlo come programma, e questi tre diritti vanno al proprietario, al suo gruppo e a tutti gli altri, con la logica con cui un condominio distingue ciò che è di una casa, ciò che è comune a un piano e ciò che è aperto a chiunque passi.

I tecnici hanno trovato un modo compatto per scrivere tutto questo con tre cifre, e la chiave sta nel dare a lettura, scrittura ed esecuzione i valori 4, 2 e 1, così la cifra 7, che somma i tre valori, descrive un padrone che può tutto, mentre il 5, che somma 4 e 1, descrive chi legge ed esegue senza poter modificare, e digitare chmod 755 relazione.txt equivale a consegnare le chiavi complete al proprietario e quelle di sola consultazione al resto del mondo. Il comando chmod accetta anche una forma a lettere, dove chmod u-r prova.txt toglie la lettura al proprietario, segnato dalla u iniziale, e l'esperimento che trovi più avanti gioca proprio con questi segnali, togliendo e ridando una chiave su una copia di prova.

C'è infine un utente che va tenuto per ultimo, perché è il più potente e il più pericoloso, e si chiama root, parola che significa radice e sta per amministratore, il direttore dell'albergo di prima. Root può cancellare qualsiasi file e comandare qualsiasi periferica, e questo potere torna comodo quando serve sistemare qualcosa di rotto, però diventa devastante per un semplice errore di distrazione, un po' come dare a un bambino le chiavi di una ruspa. Per evitare che chi amministra entri come root tutto il giorno, i sistemi di famiglia Unix offrono il comando sudo, che concede un singolo ordine con i poteri amministrativi dopo aver chiesto la propria password, un po' come un portiere che apre una porta sola per consegnare una lettera e poi richiude, e questo piccolo rito quotidiano è la forma più concreta del principio del privilegio minimo, che vuole ognuno con le chiavi strettamente necessarie e niente di più.

Tutto questo disegno, dalla separazione degli utenti ai privilegi minimi, è la prima linea di difesa di una macchina connessa, perché la maggior parte dei mali che il progetto Tutanum studia nella sua sezione Discussione, dai programmi ingannevoli agli intrusi, incontra proprio questi muri, e un errore commesso con un utente comune resta un incidente circoscritto, mentre lo stesso errore commesso con i pieni poteri può compromettere l'intera casa. Abitudini semplici come usare account separati per le prove, concedere i permessi larghi solo dove servono e digitare sudo soltanto dopo aver riletto il comando scritto trasformano la sicurezza da parola da manuale a gesto quotidiano, e su questo ponte il percorso tornerà più avanti.

Restano due personaggi di raccordo, e il primo è il driver, parola che significa conducente ed è un piccolo interprete tra il sistema e ogni periferica. Ogni dispositivo, dalla stampante al mouse, parla infatti un dialetto tutto suo, con comandi, tempi e capricci propri, e il driver traduce le richieste generiche nei comandi esatti che quell'apparecchio capisce, come un interprete che ripete ogni frase nella lingua di ciascun ascoltatore. Nei sistemi di famiglia Unix questa traduzione diventa quasi fisica, perché ogni periferica compare come un file dentro la cartella /dev, e scrivere dentro il file giusto equivale a consegnare un ordine al dispositivo, così quando colleghi un dispositivo mai visto prima è il driver che gli viene affidato per farglielo riconoscere.

Il secondo personaggio è la shell, parola che significa conchiglia e indica l'interfaccia a riga di comando, il luogo dove ordini cose alla macchina scrivendole con la tastiera invece di toccare icone col mouse. La shell è un programma come un altro, e vale la pena fissarlo, perché anche finestre e icone sono programmi come un altro che chiedono servizi al sistema come qualunque foglio di calcolo. Scrivendo un comando ricevi un servizio diretto e immediato, senza grafica, e questa immediatezza la rende lo strumento preferito di chi amministra i server, macchine lontane che spesso non hanno nemmeno lo schermo attaccato, e gli esperimenti si svolgeranno proprio lì.

La shell, però, somiglia più a un linguaggio che a uno sportello, perché ogni riga che scrivi è una frase con un verbo, cioè il comando, seguito dai complementi, cioè gli argomenti, e dagli avverbi, cioè le opzioni introdotte da un trattino, come quando scrivi ls -l per chiedere l'elenco lungo che mostra permessi e date. Le opzioni cambiano il modo in cui il verbo agisce, e quasi ogni comando ne possiede diverse, così uno stesso strumento sa essere sintetico o loquace a seconda di come lo invochi, e imparare un comando significa imparare quali desideri sa ascoltare.

Due artifici rendono la conversazione potente, e il primo sono le wildcard, o jolly, dove l'asterisco sta per qualunque sequenza di caratteri e il punto interrogativo per un carattere solo, così ls *.txt elenca tutti i file che finiscono in quel modo senza che tu li nomi uno a uno. Il secondo artificio è la pipe, cioè il tubo, che collega l'uscita di un comando all'ingresso del successivo con una sbarra verticale, così ls | grep prova chiede all'elenco di passare attraverso il filtro che mostra solo le righe contenenti la parola cercata, e con la ridirezione segnata dal segno di maggiore, come in echo ciao > prova.txt, l'uscita finisce dentro un file invece che sullo schermo. Quando un comando ti sfugge, la pagina di manuale aperta da man seguito dal nome, o la parola help su Windows, ti restituiscono le spiegazioni al volo.

Prima di sporcarci le mani, un minuto di storia orienta tra le famiglie dei sistemi operativi, perché quasi tutti quelli che usi oggi discendono da un antenato chiamato Unix, nato nei laboratori Bell alla fine degli anni Sessanta, dove Ken Thompson e Dennis Ritchie lo scrivevano col nuovo linguaggio C, inventato dallo stesso Ritchie, e questa scelta rese il sistema portabile, cioè capace di cambiare macchina senza essere riscritto da zero. Negli anni Ottanta il mondo si accordò sullo standard POSIX, che fissa l'elenco dei servizi che un sistema deve offrire perché i programmi scritti per l'uno girino sugli altri, e quando i detentori di Unix ne proibirono lo studio nei corsi, Tanenbaum scrisse da zero un sistema piccolo e leggibile, chiamandolo MINIX e pubblicandone il codice completo per gli studenti, che potevano aprirlo come si apre una rana nel laboratorio.

Nel 1991 Torvalds annunciò il proprio lavoro con un messaggio diventato leggendario sui forum Usenet dell'epoca, scrivendo che si trattava soltanto di un hobby e che non sarebbe mai diventato grande e professionale come il sistema che l'aveva ispirato, e la storia gli diede torto in modo glorioso, perché da quel tentativo nacque Linux, che oggi gira nella maggior parte dei telefoni e dei server del mondo. Dalla stessa radice Unix crescono i sistemi BSD, nati a Berkeley e portati poi fino a FreeBSD, su cui poggia l'infrastruttura di Tutanum, e perfino le famiglie lontane trattano con questa eredità, perché Windows NT costruì negli anni Novanta una discendenza tutta nuova, mentre macOS poggia le proprie fondamenta su radici BSD, così l'ombra di Unix copre quasi ogni macchina moderna.

C'è un filo rosso che lega Unix, MINIX, Linux e FreeBSD, ed è la disponibilità del codice sorgente, cioè del testo leggibile dei programmi, che nei sistemi liberi chiunque può studiare e migliorare, mentre nei sistemi chiusi resta segreto di fabbrica. Questa tradizione nacque nelle università, dove condividere il sapere era il pane quotidiano, e spiega perché il progetto GNU, avviato da Richard Stallman, si proponeva di ricostruire un sistema interamente libero, e perché Tutanum scelga FreeBSD per la propria casa, fondandosi su software che può essere ispezionato riga per riga, lontano dalle scatole chiuse.

Con queste idee in testa non resta che verificare tutto con gli occhi e con le mani, perché ogni concetto di questa pagina vive dentro il computer che stai usando adesso, e la parte pratica te lo dimostrerà in sette esperimenti, dal più semplice al più articolato, con strumenti che possiedi già.

Il primo esperimento comincia aprendo un terminale, cioè la finestra in cui si scrive alla shell, che su Linux si chiama Terminale, su macOS trovi tra le applicazioni, e su Windows si chiama Prompt dei comandi oppure PowerShell. Davanti al cursore lampeggiante prova pwd, che mostra in quale cartella ti trovi, poi ls su Linux e macOS oppure dir su Windows, che elencano il contenuto come faresti aprendola col mouse, e infine cd seguito da un nome per entrare in una sottocartella. Puoi salire con cd .. fino alla radice, dove riconoscerai le cartelle principali, e ridiscendere verso la tua home, la cartella personale assegnata a te, finché cat o type ti faranno leggere un file di testo.

Il secondo esperimento ti mostra la folla dei processi, e richiede di digitare top oppure, se installato, htop su Linux e macOS, oppure tasklist su Windows, comandi che aprono o stampano l'elenco dei processi vivi con accanto quanto processore e quanta memoria usano in questo momento. Scorri l'elenco con calma e prova a ritrovare lo stesso terminale da cui stai guardando, che a sua volta è un processo come gli altri con il suo turno nelle mani dello scheduler, e osserva quanti processi lavorano mentre tu non premi alcun tasto. Capirai allora che tanti lavori apparentemente insieme si scompongono, a ogni istante vero, in un solo processo che avanza e tanti che aspettano il proprio battito.

Il terzo esperimento insegna a leggere le tessere di identità dei file, perché ls -l elenca ogni elemento con una riga che comincia da una stringa di dieci segni, dove la prima lettera distingue il file dalla cartella e le nove successive raccontano i permessi di proprietario, gruppo e altri con le lettere r, w e x al posto dei tre diritti, mentre i segni meno segnalano le porte chiuse, e accanto trovi il nome di chi possiede il file e la data dell'ultima cura. Confronta le righe di una tua fotografia e di una tua cartella e osserva come le chiavi cambino di mano, perché quella lettura diretta è il modo più naturale per capire chi può cosa dentro la casa.

Il quarto esperimento gioca con quei segni su una copia di prova, e ti invita a togliere al proprietario la lettura con chmod u-r prova.txt e poi a riprovare ad aprirla con cat, perché il rifiuto educato che ricevi, che sui sistemi di famiglia Unix suona come permesso negato, è il sistema che fa il suo dovere davanti ai tuoi occhi. Ridare il diritto con chmod u+r prova.txt riapre la porta, e questo piccolo scambio di chiavi togliere e ridare è il modo più diretto per capire i permessi sul serio, lontano dalle definizioni del libro.

Il quinto esperimento chiude il cerchio tra comandi scritti e cartelle viste, e ti chiede di creare una nuova cartella con mkdir seguito da un nome inventato, di entrarci e di fabbricarvi un file di testo vuoto con touch appunti.txt oppure pieno con echo ciao > prova.txt, dove il segno di maggiore convoglia le parole dentro il file. Fatta questa magia sullo schermo nero, apri il gestore file grafico e naviga fino alla cartella appena creata, dove troverai i file identici e disponibili, perché scrivere con la tastiera e toccare icone col mouse sono due modi diversi di chiedere lo stesso servizio allo stesso padrone di casa.

Il sesto esperimento unisce i comandi con i tubi e i jolly, e ti chiede di riempire una cartella di qualche file d'immaginazione, poi di elencare solo quelli che terminano in txt con ls *.txt, e infine di passare l'elenco intero dentro il filtro con ls | grep prova, osservando come la seconda metà della frase scolpisca la prima, perché grep tiene soltanto le righe che contengono la parola indicata. Quando qualche comando ti sfugge, man ls apre il manuale sui sistemi di famiglia Unix e help risponde al volo su Windows, così il dubbio diventa la scusa per scoprire la pagina successiva.

Il settimo esperimento misura le risorse della casa, con df -h che mostra per ogni ramo innestato quanto spazio contiene e quanto resta libero in numeri leggibili, e con free -h, presente su Linux, che racconta la memoria vera e la sua alleata di scorta, lo swap, così puoi riconoscere con i tuoi occhi la scrivania e lo scaffale di cui abbiamo parlato. Su macOS, dove free manca, il Monitoraggio attività racconta la stessa storia con numeri e grafici, e confrontare le cifre prima e dopo aver aperto un programma pesante mostra quanto velocemente la scrivania si affolli.

I concetti di questa pagina sono riassunti nei due volumi di Tanenbaum custoditi dal progetto nella sua cartella dei libri, e cioè Modern Operating Systems e Operating Systems: Design and Implementation, testi che partono dai processi e dalla memoria e arrivano ai file system e alla storia di Unix, MINIX e Linux, e da cui questa conversazione trae ordine, analogie e qualche numero preciso. Ora che sai chi governa la casa, possiamo cominciare a visitarne le stanze una a una, e la prima è quella dove i programmi prendono vita come processi, quindi prosegui verso la pagina sui processi e sui thread, dove seguiremo il sistema operativo mentre distribuisce il tempo della CPU tra i tanti ospiti della macchina.