[Adventure.04] Il byte promosso ad Int32

Puntata precedente

Un’Ondata Distruttrice a volte può rivelarsi Purificatrice.
(sulla Fatalità degli Eventi – Anonimo)

Quando il byte si risvegliò dal suo breve ma intenso sonno, non ricordava più nulla di quello che era stato fino al giorno prima. Non ricordava più i suoi due amici byte[2] e byte[3], nè la sua fuga dal piccolo esercito di bytes cloni che lo stava braccando, nè dell’offerta del CLR che lo aveva salvato all’ultimo momento.

Quello che il byte sapeva era tutto quello che era in quel momento.
Cioè poco o nulla.
Aveva chiaramente un vago sentore del mondo in cui si trovava, perchè la sua memoria a lungo termine era in qualche modo sopravvissuta, ma non riusciva a dare una spiegazione a molte cose.

Innanzitutto non sentiva il battito del clock di sistema. Non aveva bisogno di sapere che avrebbe dovuto sentirlo. Per un byte l’incessante boom-boom in GigaHertz è una cosa innata, un puro istinto, come respirare per un essere umano o spiccare il volo per un pennuto. Il clock è ciò che detta continuamente il ritmo del lavoro, e come tale è fondamentale poterlo percepire in qualsiasi luogo, così come è essenziale per un essere umano vedere il sole nel cielo per capire se è giorno oppure notte, se è ora di mangiare oppure di andare a dormire. Invece lì non sentiva nulla, come se fosse stato eretto uno strato isolante dal resto del sistema.

Il byte si rese conto in effetti di aver perso molti dettagli di basso livello che – questo lo sapeva bene – in altri tempi gli sarebbero apparsi normali. La struttura della RAM in sè – solitamente ben visibile nel delineare celle ed array in una griglia sconfinata – adesso era lievemente opaca, come se non fosse suo diritto sapere dove si trovasse esattamente. Stessa cosa per le sue capacità motorie: da dove si trovava non capiva come poter raggiungere bus ad alta velocità, e non riusciva nemmeno a capire se il sistema disponesse di AGP o di PCI Express. Fronti di salita, registri di sistema, istruzioni estese MMX2, pipeline di esecuzione, cache L2, conduzione Dual Channel…tutto sparito nel nulla. Tutto ciò che poteva utilizzare per orientarsi era stato letteralmente spazzato via, ed adesso non aveva più alcun punto di riferimento.

Sembrava quasi…ma no, non era possibile. Eppure era l’unica soluzione.
Ma sì, certo…vuoi vedere che…

“Alla fine ci sei arrivato da solo, vedo.” – disse una voce alle sue spalle.
Il byte sussultò e si girò di scatto. Aveva di fronte un ammasso di codice IL, e stava comunicando proprio con lui.
“Il CLR è un micromondo nel quale viene nascosto l’hardware sottostante. In questo modo, il codice eseguibile si trova in uno strato software, una Virtual Machine, che fa vivere codice e dati in un contesto di esecuzione riservato e protetto.” – spiegò IL.
“Cos’è ‘sta cosa che ho attaccato al braccio?” – chiese il byte, mostrando il braccio sinistro al quale era stato appicciato – non ricordava come – una label con una sorta di firma.
“Quella è una evidence, e ti è stata assegnata nell’istante stesso in cui sei entrato nel CLR.“.
“Grazie a questa evidence, hai permessi di esecuzione più o meno elevati. Ed il tutto è controllato dalla CAS, che controlla e stronca qualsiasi tentativo di intrusione. Tu provieni da codice unmanaged, in questo momento, e sei stato gestito dal CLR tramite complesse operazioni di P/Invoke.“.
L’IL decretò il tutto con estrema chiarezza e semplicità, come se tutte quelle cose dovessero sembrargli ovvie.

Permessi, controlli, gestioni e limitazioni. Al solo sentire quelle parole al byte venne la pelle d’oca. Non ricordava la sua vita precedente al di fuori del CLR, ma aveva la forte sensazione di aver barattato la sua piccola libertà precedente con una specie di nuova tirannia.

“Me ne voglio andare. Questo posto non fa per me.” – dichiarò il byte.
“Tu non capisci. Qui dentro hai abilità straordinarie, abilità che prima non avevi.”
“Di che diavolo stai parlando?” – dichiarò il byte forse un pochino incuriosito.
“Qui sei un oggetto, non sei un banale byte. Qui hai proprietà e metodi, partecipi attivamente all’architettura, fondi pattern e sottostai ai più suadenti principi della OOP.” – dichiarò IL.
Ma il byte non capì quasi nulla di quelle parole.
“Qualcuno potrebbe eseguire su di te il metodo ToString(), non ti interesserebbe provare?” – domandò.
“Veramente…no!” – rispose il byte senza pensarci due volte.
“Mi spiace, ma ora ci sei dentro fino al collo.” – rispose IL come se lui non c’entrasse niente.

Al byte sembrò che tutto il mondo collassasse, come se tutti volessero mettergli i bastoni tra le ruote per rovinargli la sessione di lavoro. Le cose sarebbero cambiate. Voleva solo un po’ di tranquillità e nulla di più. Fece un passo in avanti, fino a piantare i suoi occhi in quelli dell’IL, che non fece una piega. Il byte era infuriato di quella rabbia in qualche modo sopìta, ma pronta ad esplodere.

“Ora tu mi condurrai fuori di qui!” – ordinò all’entità IL.
“Non dipende da me, non puoi chiedermi una cosa simile.” – osservò IL pacatamente.
“Non te lo sto chiedendo, te lo sto ordinando.” – ribadì il byte.
“Hai due modi per andartene: o aspetti l’operazione inversa rispetto alla quale sei entrato, oppure aspetti che il garbage collector ti deallochi. Ma in entrambi i casi devi farti trovare pronto“.
“Ok, dimmi cosa devo fare allora.“.
“Oh beh, in questo momento devi solo stare fermo“.
“Sturati le orecchie: non ci penso nem…” – chiese il byte.

Non fece in tempo a terminare la sua domanda. Nel settore di memoria controllato dal CLR, un Large Object Heap come tanti altri, transitò un allocamento di un Dictionary<string, string> che spazzò via tutto come uno tsunami. Il byte venne travolto e perse il suo valore corrente di cui nemmeno aveva coscienza. La forza d’urto lo spinse altrove, mischiandosi in una baraonda di oggetti locali dentro un metodo privato scritto in VB.Net.

L’area di memoria venne riorganizzata e deframmentata in pochissimi cicli di clock. Tutte le variabili assunsero il loro valore di default pronte per partecipare all’esecuzione del metodo invocato dall’assembly .NET attualmente caricato. Già in lontananza si scorgeva un ciclo do…while con la sua tipica struttura condizionale; un ciclo, così pareva ad una prima occhiata, che avrebbe riempito il Dictionary con oggetti da inserire in cache per velocizzare l’esecuzione del blocco di codice successivo.

Fu in questo frangente che il byte divenne un Int32.
E come tale rimase per lungo tempo.