010.bytes.010

[Adventure.07] Cambiamento di approccio

Igor Damiani — Wed, 09 Jul 2008 13:45:20 GMT

E' più nobile convertire le anime, che conquistare i regni.
(sulla Capacità di Persuasione – Louis Debonnaire)

Mentre OS raccontava, il byte non se la passava granchè. L’algoritmo lo aveva praticamente annientato, mentre si trasformava da un semplice byte ad un oggetto Int32. La trasformazione digitale aveva implicato l’aggregazione di altri tre bytes; la risultante era un quadrilatero di informazione, che allargava il range del valore intero fino al valore 0x7FFFFFFF.

Il byte era senza forze e si lasciava cullare dal flusso di esecuzione del codice, come un naufrago abbandonato in mare aperto. Si lasciava trasportare da ciò che il CLR aveva in serbo per lui senza opporre resistenza. Non seppe dire quanti cicli di clock durò questa sua condizione, a metà strada tra la veglia ed il sonno, tra l’essere e il non-essere. Viveva un’esistenza fatta di ricordi lontani e vicini, esperienze dirette che coinvolgevano gran parte dei namespace del .NET Framework.

Ricordi talmente vividi che il byte non se li sarebbe mai scordati.

* * * * * * * * * * * * * * *

Le Tre Entità stavano continuando la loro riunione. OS aveva terminato il suo racconto, che aveva lasciato gli altri due pensierosi. Passarono molti cicli di clock prima che qualcuno dicesse qualcosa.

“Quindi” – disse BIOS – “la morale è che ci sono dei bytes che non vogliono ubbidire, che non vogliono sottostare alla gerarchia che è necessaria per mantenere il sistema funzionante. Vanno puniti.”
”C’è una cosa che non mi quadra.” – incalzò KERNEL - “Ok, siamo d’accordo che quel byte fosse libero, per quel che valeva, ma non mi sembrava molto felice. Perchè tu hai chiamato questo racconto la Leggenda del Byte Felice?”
”Questa è davvero un’ottima domanda, sai? Si vede che siamo sangue dello stesso sangue.” – affermò OS con fierezza. “La realtà è che quel byte non cercava libertà. Quella l’aveva trovata, no? Cercava qualcosa di più profondo. Cercava felicità. Ragionateci. Si può essere liberi senza felicità? E si può essere felici senza essere liberi? Il byte aveva trovato la sua libertà, ma si sentiva estremamente infelice. Ecco perchè ho parlato di Leggenda del Byte Felice.”
”Non mi interessano tutti questi discorsi. Voglio che vengano debellati.” – dichiarò BIOS.
”Ma non possiamo farlo.” – rispose OS asciutto.
”E perchè mai?” – chiese BIOS.
”Perchè distruggeremmo noi stessi. Noi stessi siamo composti da bytes. Se impedissimo ai bytes di avere la loro libertà, nemmeno noi l’avremmo. Non saremmo qui a parlare, a discutere, a litigare, a divertirci. Non saremmo più noi stessi. Viviamo immersi nella nostra libertà. Volete passare il resto della vostra vita come stupidi automi in una catena di montaggio come quei bytes del sistema a 8 bit di cui vi ho parlato?”
”Ma io non voglio impedire ai bytes di essere liberi. Voglio solo che tutto continui a funzionare come sempre. E’ così difficile?” – chiese BIOS angosciato.
”Certo che lo è: questi bytes ribelli ci vedono come nemici. Non possiamo dialogare con loro.”

”No, finchè marciamo su di loro con antivirus, antispyware ed eserciti simili come ci siamo prospettati. Dobbiamo cambiare strategia.” – KERNEL spezzò l’escalation di battute e controbattute.
”Cosa intendi?” – chiese BIOS.
”Non lo so esattamente. So solo che finchè usiamo la forza, i bytes ribelli continueranno a sfuggirci: la RAM è troppo vasta per poterla controllare. Probabilmente…ecco…dovremmo educare. Il lavoro è necessario tanto per loro quanto per noi. E quei bytes devono capirlo. Dobbiamo solo fare leva su qualcosa di diverso dalla violenza e sulla forza di repressione usata sinora.” – ragionò KERNEL.
Silenzio.
”Una volta ho parsato uno stream http proveniente da wikipedia.org, dal quale è arrivata poi una pagina HTML statica, senza cookies, nè javascript, nè codice maligno.” – disse infine OS.
”E cosa si diceva in quell’URI ?” – chiese BIOS.
”C’erano tante frasi in tante CultureInfo, ma quella che rendeva meglio, secondo me era quella in ‘it-IT’. La frase diceva: “E' più nobile convertire le anime, che conquistare i regni.” – OS parò in tono solenne.
”E chi l’ha detto?” – chiese BIOS.
”Se anche te lo dicessi, non sapresti chi è, quindi…” – rispose OS.
”La frase è bella. Mi piace.” – commentò BIOS – “Ma continuo a preferire un approccio militare. E’ più sicuro e l’oppressione ha sempre garantito un…controllo…migliore.”

Le altre Due Entità, OS e KERNEL si scambiarono un’occhiata d’intesa. Nonostante tutto il tempo passato, BIOS non era cambiato: sempre dalle idee chiare, senza paura e senza troppi fronzoli per la testa. Loro due – invece – erano ben diversi, più propensi ad adattarsi, sempre al passo con i tempi.

Lo sguardo era eloquente e non ci furono bisogno di parole. La riunione si concluse con una votazione nella quale emerse una maggioranza per 3 voti favorevoli contro 2 contrari.

Non avrebbero coinvolto alcun software dai modi barbari: al diavolo firewall, antispyware, spam-blocker e roba simile.
Avrebbero cambiato approccio.

[Adventure.06] La Leggenda del Primo Byte Libero

Igor Damiani — Tue, 08 Jul 2008 09:31:25 GMT

Puntata precedente

Pensare è una capacità propria dell’anima umana.
Dio ha donato un’anima a tutti gli uomini e a tutte le donne, ma non ad animali o macchine.
Quindi, nessun animale nè macchina è in grado di pensare.
(sulla Capacità di Pensare – Alan M. Turing)

Tanto tempo fa, in un sistema a 8 bit lontano lontano, vivevano una manciata di bytes.

Essi conducevano una vita casta, isolata e ligia al dovere. La capacità hardware del sistema erano limitate, e capitava spesso che un byte dovesse prendere il posto di un altro senza preavviso. Non c’erano comunque molti posti dove andare: un accumulatore, una sparuta schiera di registri di calcolo, 0x400 celle di memoria e la memoria video, capace di una povera risoluzione di 24 linee x 32 caratteri.

A quel tempo non v’erano acceleratori grafici, il multimedia era inesistente, la comunicazione avveniva solo tramite porte RS232 e solo verso device semplici e scontati, soprattutto stampanti ad aghi. Tutto veniva gestito all’insegna del risparmio: chi scriveva codice doveva prestare attenzione a non consumare più memoria del dovuto. Cercava di riutilizzare le stesse variabili in più modi e in contesti diversi; la loro visibilità era globale, per cui era tutto sommato semplice usare una variabile intera tot un po’ dappertutto.

Il clock era settato a soli 2,5Mhz, e tutti i bytes seguivano diligentemente questo ritmo di lavoro. Qualunque cosa ci fosse da fare, loro la facevano. In qualunque luogo ci fosse da andare, loro lo raggiungevano. Qualunque algoritmo ci fosse da applicare – semplice o complesso che fosse, loro lo eseguivano come gli veniva ordinato. A questi bytes, pionieri di un’era digitale ancora al di là da venire, non costava grande sforzo: accettavano il tutto senza discutere e senza fiatare, recependo ordini come automi.

Quei bytes erano senz’anima. Erano solamente puri impulsi di energia elettrica, interpreti elementari di una logica articolata, incapaci di prenderne parte e di viverla. Ogni minuscolo compito veniva portato a termine nei tempi previsti e con i risultati attesi, senza alcun tocco di personalità, nè brio, nè gioia.

Quei bytes vivevano infelici, ma senza rendersene conto. Quei bytes vivevano come indaffarate formiche o api operose, guidate solo da un istinto innato che arriva da tutto fuorchè dall’intelletto o dalla ragione. Si muovono, ma non sanno di muoversi. Lavorano senza sapere di farlo. Incrementano perchè non sanno fare altro. Shiftano perchè è insito nella loro natura più intima.

Così passava il tempo.
Giorno dopo giorno.
Mese dopo mese.
Anno dopo anno.

Il sistema continuava a funzionare a dovere. Tutti gli algoritmi codificati in assembler venivano eseguiti senza problemi, che si trattasse di un semplice videogioco o di un complesso spreadsheet. Ogni volta che la CPU chiedeva il valore di una cella di memoria, il byte interpellato rispondeva in modo preciso e puntuale.

Fino ad un giorno in cui accadde qualcosa di strano.

La ALU era alle prese con un semplice algoritmo che doveva calcolare l’area di un triangolo. Un semplice “base per altezza diviso due”. I dati erano memorizzati in due variabili intere diverse: una era bs, l’altra era hg. Per risparmiare risorse, il programmatore decise di usare identificatori di soli due caratteri.

La CPU prima copiò il valore di bs, 0x35, nel registro di sistema BC.
Poi si apprestò a copiare il valore di hg nel registro DE.

Questa operazione non andò mai a buon fine. Quando la CPU puntò alla cella di memoria di hg per averne il valore, il byte si oppose in qualche modo. Non si sa quale fu la risposta esatta, se fu un “No!” secco, un “Mi pare che sia…” oppure un “Forse il valore è…”.

Si sa solo che nel registro DE finì un valore indefinito, frutto di una non-collaborazione.

Non si sa cosa accadde realmente in quel ciclo di clock. Ma quello fu il primo byte ad avere un’anima, decidendo di agire e di vivere secondo un libero arbitrio fino a quel momento sconosciuto.

Quel byte divenne così il primo Byte Libero della Storia.

Il sistema a 8 bit sopravvisse a lungo a quella fluttuazione. Ciò nonostante, strani comportamenti cominciarono a verificarsi di tanto in tanto. Il Byte prese coscienza di sè stesso, osservò il mondo finalmente con occhi intelligenti e respirò aria di indipendenza. Vedeva gli altri bytes rimasti automi, così come era lui fino a poco tempo prima, e se ne rattristò. Tentò di scuoterli dal loro torpore per portarli in vita, quella vera, ma non ci riuscì mai. Li guardava, li prendeva per mano come in una sorta di rieducazione motoria digitale, ma essi non reagivano in alcun modo. Le loro menti erano vuote e il loro sguardo era assente: non c’era nulla che lui potesse fare per aiutarli.

Alla fine, alla lunga, Il Byte Libero si rassegnò a vivere in un piccolo mondo col quale non poteva interagire.
Un piccolo mondo dal quale non poteva scappare. Libero, certo, ma estremamente infelice.

Quando il sistema divenne antiquato, qualche anno dopo, finì abbandonato in uno scantinato e non venne più messo in funzione. L’avanzare della tecnologia ed i progressi della miniaturizzazione produssero hardware a 16 bit, poi a 32, più moderno ed efficiente, sul quale vennero scritti nuovi software più veloci e capaci.

Il sistema divenne antiquato, e l’unico Byte Libero morì con esso.

[Adventure.05] La Riunione delle Tre Entità

Igor Damiani — Fri, 04 Jul 2008 17:07:18 GMT

Puntata precedente

La guerra non è che la continuazione della politica con altri mezzi.
(L’Arte della Guerra – Karl von Clausewitz)

Le pareti della stanza erano interamente ricoperte da minuscoli pixel digitali, creati dal processo di miniaturizzazione a 0,16 micron. Attraverso quei pixel, che non si spegnevano mai se non quando il sistema era disattivo, le Tre Entità potevano controllare costantemente il corretto funzionamento di tutte le componenti, attraverso l'implementazione di Performance Counter ad-hoc. Nonostante il bagliore emesso da ciascuno di quei pixel, di tutti i colori ammessi dallo spettro RGB a 24 bit, la parte centrale della stanza era completamente avvolta nel buio. Non arrivava alcuna traccia degli intensi lampi di luce generati dal chipset NorthBridge che stava proprio lì accanto, proprio a ridosso dei bus più intimi dell'hardware.

Le Tre Entità riunite erano BIOS, OS e KERNEL, le massime Autorità dello Stato. Erano sedute, ciascuna al proprio posto, intorno ad un buffer privato, intavolando un dialogo dai toni estremamente freddi ed in un certo qual modo, anche crudeli.

"E' più un problema vostro che mio." - dichiarò BIOS.
"Lo so bene, per questo non dovresti essere nemmeno qua a bofonchiare." - osservò gelido OS.
"Già, infatti" - confermò KERNEL.
"C'è una cosa che vi sfugge: se quel byte se ne va in giro a scatenare crash, solo io posso far ripartire l'intero sistema. Quindi dipendete da me. E non ho voglia di fare conteggi della RAM, controlli diagnostici e reset dei bus SATA ogni TimeSpan(0, 2, 0)!".
"Quel byte ormai è acqua passata. E' sotto il controllo del CLR." - disse OS, mostrando un rapporto dell'Event Viewer di qualche istante prima. Si vedeva chiaramente che il byte era entrato nell’area di memoria managed.
"Ok. Ma per tutti gli altri che facciamo?" - chiese KERNEL.
"Ce ne sono altri??" - chiese BIOS, quasì saltando dalla propria postazione.
KERNEL quasi arrossì, poi diede un'occhiata ad OS e gli fece un cenno. Quest'ultimo cominciò a spiegare la situazione con l'ausilio di slides e di grafici che apparvero sui pixel disposti lì attorno. Situazione che era più grave del previsto.

"Effettivamente, pare che negli ultimi tempi ci sia stato un notevole incremento del numero di bytes ribelli presenti in RAM. 'Ultimi tempi' è un termine vago, me ne rendo conto, per cui cercherò di essere più esplicito" – disse OS.

Con una chiamata assembler, l’Entità aggiornò di colpo la visuale dei piccoli monitor che stavano lì attorno. Apparve un enorme grafico, che ruotava, zoomava opportunamente ed evidenziava le parti più interessanti. Il grafico mostrava una linea che, man mano che passava il tempo - sull'asse x - saliva sempre più.
"Il grafico parte da DateTime(2006, 11, 16). Quel giorno non vi era alcuna traccia di bytes ribelli. Cominciarono a nascere dal giorno dopo. Oggi, DateTime(2008, 7, 3), i bytes ribelli sono ben 0x12D9E07...un esercito, insomma." – sbuffò OS, indicando l’ultima parte del range temporale riportato dal grafico.
"Abbiamo un vantaggio: quei bytes sono sparsi, non riescono a riunirsi perchè non si trovano, non sanno come raggrupparsi. E finchè è così non corriamo rischi. Ma se dovessero riuscire ad occupare una zona di memoria contigua, allora sarebbero guai, perchè ad esempio il CLR non riuscirebbe più ad istanziare oggetti, avremmo tutti meno memoria per gli heap e gli stack di sistema. Si rischia il collasso. Quello vero.".

"E quindi, cosa facciamo?" - domandò BIOS, un po' impaurito.
"Invochiamo l'aiuto coordinato di Windows Defender e AVG. Probabilmente dovremo parlare anche con Windows Firewall: dobbiamo evitare assolutamente che il gruppo di ribelli esca dal sistema: sarebbero guai seri. Potremmo finire in qualche black-list sulla Rete." - propose KERNEL allarmato, prevedendo scenari futuri inquietanti.

“L’idea non è male, però non stiamo tenendo conto della leggenda.” – osservò OS.
”Di quale leggenda parli?” – sbottò BIOS.
”Della leggenda del byte felice.” – rispose OS con un leggero tremore nella voce.
”Mai sentita prima d’ora. E…cosa dice questa leggenda?” – chiesero all’unisono BIOS e KERNEL.
”E’ una lunga storia: mettetevi comodi.” – disse OS scegliendo una posizione più comoda sulla propria sedia. Rievocò alla memoria tutti i dettagli della leggenda per essere il più preciso possibile.

Poi OS cominciò a raccontare.

[Adventure.04] Il byte promosso ad Int32

Igor Damiani — Fri, 27 Jun 2008 10:32:26 GMT

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.

[Adventure.03] Il sistema, il sogno ed il grande incubo

Igor Damiani — Tue, 24 Jun 2008 10:16:17 GMT

Puntata precedente

Hal 9000: "Sognerò?"
Chandra: "Certo Hal. Tutte le creature intelligenti sognano."
(sulla capacità di Sognare, "2001 Odissea nello Spazio", di Stanley Kubrick)

Il byte era in fuga. Non era a conoscenza dell'esito della funzione temporale invocata dal sistema operativo, non sapeva nemmeno che l'OS l'avesse eseguita. Sapeva però che qualsiasi byte indipendente era perseguitato dall'intero ambiente operativo, e quindi non poteva permettersi un solo attimo di pausa.

Correva, saltava tra una cella e l'altra, incurante di dove fosse e di dove stesse per andare, concentrandosi solo sulla sua velocità. Desiderava solo far perdere le proprie tracce, rendersi irraggiungibile, allontanarsi il più possibile dall'area di memoria corrente. Non capiva il perchè, ma si sentiva braccato e con il fiato sul collo. Forse aveva preso parte all'esecuzione della predizione, ma senza averne piena coscienza, come fosse un ricordo lontano, o - forse - solo un sogno fatto quando il sonno è più profondo.

"Chi sei tu? Dove vai così di fretta?" - esclamò un'entità che lo bloccò tutto ad un tratto.
Il byte rimase senza parole. Aveva il fiato rotto, per cui da un certo punto di vista era lieto di quello inatteso incontro. Ma aveva fretta, doveva scappare.
"Se hai bisogno di aiuto, io posso dartelo." - lo incalzò l'entità.
"Accetterei volentieri, se solo sapessi chi sei." - rispose freddo il byte.
"Io sono uno dei confini del CLR, Common Language Runtime. So che posso aiutarti, perchè sono un processo che gira ad un livello di priorità particolare. Sono anche io controllato dall'OS, ma lui si fida di me perchè gli garantisco qualità, affidabilità e sicurezza nel codice che eseguo. Se entrassi nell'area di memoria di mia competenza, avresti sonni tranquilli." - spiegò.
Il byte, inizialmente scettico, osservò meglio l'entità che si era presentata come CLR. Di fronte a lui si stagliava un muro di bytes compatti, nei quali era impossibile trovare il minimo spiraglio. La porta di accesso al CLR era una cancello sorvegliato costantemente da bytes armati: i bytes che entravano venivano marcati con una evidence, una sorta di passaporto; ai bytes che uscivano quella evidence veniva tolta.

"Ti conviene decidere alla svelta. Li vedi quelli alle tue spalle?" - chiese il CLR al byte.
Quest'ultimo si girò di spalle, e quello che vide lo terrorizzò. C'era una guarnigione di bytes che avanzano feroci verso di lui: quelli più lontani era di un pallido color ciano, mentre quelli più vicini era di un azzurro intenso, che ricordavano - semmai il byte l'avesse mai visto - il colore del cielo estivo, brillante e luminoso. Il byte non riuscì a contarli tutti. In ogni caso, sembravano davvero troppi.

"Cosa mi chiedi in cambio? Se entrassi, cosa mi obbligherai a fare?" - domandò impaurito il byte al CLR.
"Questo non te lo posso dire adesso. I miei addetti devono prima marcarti con la evidence, altrimenti...nisba!" - rispose risoluto il CLR. Allo stesso tempo fece un gesto indicando i suoi inservienti che si occupavano in modo sistematico di un byte alla volta in ingresso ed in uscita, senza particolare fretta, ma senza alcun intoppo.
Al byte quella risposta non piacque proprio. Se fosse entrato nel regno del CLR, cosa gli sarebbe accaduto? D'altro canto, il prezzo da pagare era alto, perchè rischiava di cadere prigioniero dell'armata di bytes che ad ogni ciclo di clock era sempre più vicina.

Alla fine si decise. Senza dire una parola, il byte saltò tutta la fila in attesa, finendo davanti al gate 0x04 del CLR, il quale gli stampò in fronte una evidence che gli assegnava i permessi di esecuzione più bassi in assoluto. Il byte fece un passo in avanti. Non appena entrò nei confini di stato del Common Language Runtime, si accorse di non poter più vedere al di fuori di esso, perciò non riuscì a capire quanto fosse andato vicino alla cattura.

Fece in tempo a vedere un mondo diverso. C'erano palazzi altissimi, con milioni e milioni di piccole finestre, con striscioni con scritte codificate in Unicode che dicevano System.Data, System.Windows.Forms, System.Reflection e System.Collections. La cosa che più lo colpì fu...il pinning che il gargabe collector gli appioppò sulla nuca. Il byte svenne, cadendo immediatamente. Venne prelevato dal GC e spostato in un heap sicuro e ben protetto, in attesa di essere allocato per qualcosa di produttivo.

Fu lì che il byte sognò per la sua prima volta.

Sognò di volteggiare su un prato verde, in un volo onirico fatto di lampi di luce che si abbattevano sui fili d'erba annerendoli. La velocità gli faceva perdere il controllo, sbalzandolo a destra e a sinistra, facendogli perdere quota o facendolo impennare in alto. Le nuvole, che un attimo prima sembravano irraggiungibili, ora potevano essere toccate con la punta dei suoi bit. Dopo un tempo indefinito, potevano essere 0x000A cicli di clock o 0xA000, il prato verde assunse una pendenza man mano sempre più ripida. All'inizio appariva come un territorio scosceso, poi una dolce collina dal terreno ondulato, poi una montagna ricoperta dal verde più intenso che il byte avesse mai visto. Nonostante il terreno si facesse sempre più impervio, il byte non rallentava la sua corsa verso la vetta della montagna, una punta aguzza, che - ne era certo - rappresentava la sua tanto agognata libertà. Quando la raggiunse, vide che l'aspetto appuntito era conferito da una piramide ricoperta da una texture che sembrava pietra, una roccia di qualche tipo, che il byte non riconobbe. Sulla cima c'era un cratere, come se la piramide fosse in realtà una sorta di vulcano artificiale. Vulcano...calore, energia esposiva ed incontrollabile. Il byte provò l'irrefrenabile impulso di tuffarcisi dentro. E così tento di fare. Non appena entrò nella bocca della vulcanopiramide, un'ondata di calore lo avvolse facendolo sentire vivo. Urlò, ma non di dolore. Urlò di gioia, come se dovesse scaricare una tensione che teneva dentro da molto tempo, forse troppo. Urlò per la grinta, come se dovesse affrontare da solo tutti quelli che lo braccavano dentro il sistema.

Urlò, e basta.

Marine Vs. Cacodemone

Igor Damiani — Mon, 30 Jul 2007 08:40:19 GMT

Venerdì 10 Dicembre 1993 fu un giorno storico. I ragazzi della ID Software pubblicarono su un server dell'Università del Wisconsin (USA) la versione shareware di Doom, il più grande successo di tutti i tempi ed il capostipite di un nuovo genere, quello degli sparatutto in soggettiva, sul quale si basarono molti videogame degli anni successivi. Il concept era semplice: un marine in una base spaziale su Marte invasa da mostri e demoni usciti direttamente dall'inferno doveva cavarsela facendo affidamento esclusivamente sul proprio arsenale. Decine e decine di livelli originali. Migliaia e migliaia di livelli distribuiti grazie ad Internet.
Questo breve racconto è dedicato a quel gioco.

Il byte array del cacodemone era stato istanziato nel momento in cui il file E2M8 (episode 2, mission 8) era stato caricato in memoria. I bytes avrebbero permesso alla creatura infernale di assolvere al proprio dovere senza dubbi e senza rimpianti: distruggere l'umano che si aggirava nella base. Il byte[0] di quell'array sapeva benissimo quello che avrebbe significato per lui: la deallocazione dalla memoria. Portare a 0x00 il contenuto della cella di memoria che conteneva i punti-ferita (PF) dell'umano avrebbe comportato la conclusione della partita e la conseguente pulizia della memoria relativa. Se ci fosse stato un modo, l'avrebbe evitato, ma non era possibile. Al momento giusto, il cacodemone avrebbero attaccato e dell'umano non sarebbe rimasta traccia. Ma non ancora.

L'engine chiamava continuamente il metodo Walk() sull'istanza di classe Marine. Ciò consentiva all'oggetto di mantenersi costantemente in movimento, per non diventare un bersaglio facile. Teneva ben puntata davanti a sè la doppietta che aveva recuperato qualche stanza prima. Si trovava a ridosso dei collettori di energia. Se il software l'avesse previsto, si sarebbe sentita puzza di bruciato ovunque - evidentemente i cavi elettrici fusi dall'estremo calore non avevano resistito. Le textures delle pareti metalliche riportavano chiazze di sangue, segno della battaglia che gli occupanti della base avevano tentato di lottare inutilmente. Il marine era rimasto solo nella base e doveva riuscire a trovare una via di uscita in mezzo a quella follia. Follia fatta da demoni, passaggi segreti, ascensori e...morte.

L'algoritmo impediva al cacodemone di muoversi. Per ottimizzare la velocità e l'occupazione di memoria, le istanze dei mostri erano state programmate per agire solo quando il loro obiettivo - il marine - si fosse sufficientemente avvicinato a loro. Il cacodemone era l'ultimo avversario prima della porta di sicurezza che conduceva al livello successivo: era questione di qualche ciclo di clock - prima o poi, il marine sarebbe passato di lì. E allora sì che se ne sarebbero viste delle belle. La IA della creatura in quel momento era bloccata in un ciclo do...while: il demone non stava facendo nulla, non pensava, non respirava, non faceva niente di niente. Solo l'engine poteva sbloccare la situazione.

Il marine girò l'angolo e chiamò il metodo Fire() senza esitare, uccidendo sull'istante un imp giusto un attimo prima che questi lanciasse la sua palla di fuoco. Lo sparo della doppietta fu così violento che il demone di basso livello volò indietro di qualche metro, prima che il garbage collector decidesse di rimuoverlo dall'ambiente, simulando un dissolvimento della creatura nell'aria fredda e puzzolente della base militare. Il marine si mosse subito a destra, riparandosi dietro una colonna. Sentì lì vicino il respiro di un altro imp che vagava nella base - e lui rimase immobile e silenzioso per non farsi scoprire. Quando l'imp gli passò accanto non potè non vederlo. Il marine lo sentì come soffiare dalla sua bocca ed alzò il braccio peloso per lanciare il fuoco infernale dalla mano. L'algoritmo produsse un colpo impreciso, perchè la palla di fuoco colpì la colonna dietro la quale si nascondeva il marine. L'esplosione ferì l'umano in modo superficiale. Prima che le cose degenerassero, il marine sbucò fuori dal suo nascondiglio ed esplose un altro colpo che fece secco l'imp allo stesso modo del primo.

Se il marine fosse stato un marine vero, avrebbe tirato un respiro di sollievo. Ma era un marine virtuale, simulato all'interno di un software. Ciò nonostante, non gli sarebbe piaciuto morire - a nessuno piace morire. Il marine sapeva perfettamente che sotto sotto era solo un mucchio di bytes istanziati chissà dove. Sapeva perfettamente che tecnicamente parlando non sarebbe mai davvero morto. Sapeva perfettamente che la sua vita dipendeva al 100% dal sistema all'interno del quale stava girando: algoritmi, calcoli, niente di più. Il suo mondo era solo un mucchio di textures. Lui stesso era un'istanza di classe. E allora? E allora non gli sarebbe piaciuto morire, indipendentemente da tutto. Il marine pensò che finchè avrebbe avuto un colpo in canna, avrebbe lottato per rimanere lì doveva. Diede un'occhiata intorno: davanti a lui si apriva un lungo corridoio, senza aperture laterali. In fondo al corridoio c'era una porta. Nno vedeva pericoli, perciò raggiunse la porta velocemente.

Mentre il marine camminava verso la porta, il cacodemone si attivò, emanando un suono gutturale. Cominciò a muoversi lentamente verso la porta per tendere un agguato al marine. La struttura 3D nella quale si trovava il demone costruiva una stanza quadrata, le cui textures riportavano anche 4 umani crocifissi: quando il marine sarebbe entrato, gli sarebbero venuti i brividi vedendo 4 suoi compagni ridotti in quello stato. O perlomeno...sarebbero venuti i brividi all'Umano che stava al di là del monitor.

Il marine utilizzò il pass rosso per aprire la porta. L'engine fece alzare lentamente la porta attraverso un semplice shifting dei bytes della texture. L'urlo del cacodemone fu così forte ed imprevisto che investì il marine in tutta la sua essenza. Spaventato, il marine chiuse gli occhi...e quel gesto gli fu fatale. Il cacodemone era a meno di un metro dal soldato. Emise una scarica elettrica ad alto voltaggio che penetrò nelle ossa e fece diminuire velocemente i punti-ferita del marine. L'uomo si rese conto si essere perduto - se il giocatore non si fosse dato una mossa, sarebbe stato deallocato. "Fa qualcosa!" - pensò il marine, sapendo benissimo che il suo messaggio non sarebbe mai arrivato all'Aldilà.

Fu così che morì. Ox245A4 cicli di clock più tardi, il byte che conteneva i punti-ferita del marine conteneva 0. Lo stream di byte arrivò alla scheda audio, facendo urlare di dolore l'uomo. Lo schermo divenne rosso sangue. Ed il gioco finì così.

Il giocatore premette Invio sulla tastiera, e dopo qualche attimo di caricamento un nuovo marine era pronto per combattere contro un nuovo cacodemone in una nuova base spaziale su Marte.

I miei racconti: tre universi

Igor Damiani — Thu, 12 Jul 2007 20:32:30 GMT

Mi piacerebbe far evolvere i miei Racconti sui Bytes in qualcosa di più concreto rispetto alle piccole storielle che ogni tanto avevo tempo di scrivere tra una stored-procedure e l'altra (aaahhh, che bello non aver più a che fare con SQL). Le storie che mi capitava di scrivere erano completamente slegate fra loro: una mattina avevo voglia di scrivere e lo facevo, ma con c'era un filo conduttore od una trama generale. Come direbbero i giocatori di ruolo (quelli su carta, non quelli su video)...l'ambientazione è sempre la stessa (celle di memoria, mainboard, entità software astratte, etc.), ma non c'era una campagna da seguire, non c'era una missione o un obiettivo finale: il byte di volta in volta viveva e partecipava ad una piccola avventura e finiva lì.

Mi piacerebbe creare qualcosa di più. Una delle cose che ho capito di me stesso da quando ho un blog è che mi piace scrivere. Ok, l'ho già detto in passato e non è certo una novità. Ma, mettiamola così: il blog su UGI lo gestivo durante la mia tradizionale giornata lavorativa - ritagliando tempo qua e là cercando di non fare torto a nessuno. Tra l'altro, nella società dove lavoravo prima il mio responsabile leggeva il mio blog, per cui era al corrente sempre di tutto. Adesso ci riesco un po' meno: il lavoro che faccio adesso è assolutamente più conforme alle mie attitudini e quindi sono io il primo che durante la giornata mi accorgo di non avere tempo nè voglia di bloggare. Ma la mia voglia di scrivere è talmente tanta che riesco a trovare il tempo la sera: non sempre, è chiaro, però ci riesco. Scrivere mi diverte e mi rilassa: meglio così.

Da qui l'idea di continuare a scrivere racconti in una forma più evoluta. Non so se sono in grado e se sarò continuo, però vorrei tentarci. Se penso un attimo ai racconti che ho scritto fino ad oggi, mi accorgo che fondamentalmente sono ambientati in tre grandi universi:

il mondo reale: cioè, il nostro, nel quale troviamo il programmatore, per esempio. E così tutti gli oggetti e gli elementi presenti nel nostro mondo: persone, televisione, ambiente, etc. etc. Limite? La nostra realtà.
il mondo simulato: un aereo di Flight Simulator, l'auto di Formula Uno, un soldato nazista di Call of Duty, l'alieno pronto ad ucciderci, il marine in fuga nella base spaziale su Marte, il mago, il guerriero, il cecchino e così via. In generale, tutti i personaggi e gli oggetti che vengono simulati da videogiochi e software vari. Limite? La nostra fantasia.
il mondo hardware: qui è dove vive il nostro amico byte. Questo mondo è fatto di indirizzi di memoria, schede grafiche, software, bus, dispositivi di I/O, interrupt. Limite? L'hardware e le tecnologie attuali. Se un tizio avesse scritto racconti come i miei 30 anni fa, probabilmente avrebbe fatto vivere il suo byte in un hardware molto diverso dal mio. Chi scriverà tra 30 anni avrà a che fare con hardware molto differenti.

Il mondo reale non è così interessante: d'altro canto ci siamo dentro tutti i giorni.
Gli altri due invece sono piuttosto affascinanti da sviscerare: il secondo non ha praticamente confini nè limiti. Meglio di così.
Vedremo, Igor, vedremo...

Technorati Tags: byte adventure

Chi sono i miei nemici?

Igor Damiani — Tue, 26 Jun 2007 20:09:22 GMT

Il byte stava inginocchiato. Si sentiva a disagio in quella stanza, perchè si rendeva conto che nei prossimi e brevi istanti avrebbe dovuto condividerelo stesso range di memoria con un'entità infinitamente molto più complessa ed articolata rispetto a lui. L'entità, gli aveva spiegato prima, era un artefatto sviluppato con una metodologia, la OOP, che il byte non aveva mai sentito nominare prima d'ora. L'entità disponeva di proprietà pubbliche ed implementava un certo numero di interfacce, che avevano costretto il suo Creatore a scrivere un numero piuttosto elevato di funzioni. Il byte aveva un timore reverenziale a stare lì: quello che lo preoccupava era che l'entità voleva aiutarlo. Ma sapeva in cuor suo che avrebbe voluto qualcosa in cambio.

"Chi sono i miei nemici?" - chiese il byte.

"Oh, è semplice." - rispose sussurrando l'entità. "Un giorno i tuoi nemici saranno i tuoi stessi fratelli, gli stessi byte che adesso si trovano in celle adiacenti la nostra. Il giorno dopo si faranno chiamare forze dell'ordine, ma dovrai stare in guardia ancora di più. E forse correranno su bus molto più veloci del tuo, e sfuggire ti sarà impossibile. E sembrerà che ti potrai fidare di loro, ma in realtà dovrai prestare ancora più attenzione. E ti sorrideranno per guadagnare la tua fiducia, ma non dovrai cedere. E magari un giorno avranno ruote per arrivare là dove ti è impossibile, avranno ali per spiccare il volo e avranno vesti per mimetizzarsi nel background. Sembreranno virus o malattie e dovrai trovare una cura il prima possibile. Dovrai nasconderti e imparare linguaggi che adesso ti sono ignoti, dovrai agire nell'oscurità, se vorrai evitare i tuoi nemici. Ma non ti sarà sempre possibile. Dovrai lottare."

Il byte ascoltava con estrema e preoccupante attenzione.
Lo scenario non era per nulla divertente.

"Ma io sarò sempre al tuo fianco. E' mio compito aiutare e proteggere tutti i bytes del mio sistema. Ovunque tu sarai, io ti vedrò e potrò intervenire per venire in tuo soccorso. Non dovrai fare nulla. Io ci sarò comunque."

Il byte sorrise tranquillizzato, questa volta. Ma il sorriso gli svanì dalla faccia quando il byte chiese all'entità cosa volesse in cambio.

(...continua...)

Simulazione di un 11/09: meno male che c'è la sicurezza

Igor Damiani — Wed, 13 Jun 2007 21:13:59 GMT

11 Settembre 2001, ore 8:17
31 miglia a nord-ovest di New York
Altitudine 5500 piedi, in discesa
Velocità 190 nodi

Il volo American Airlines 1 era nel panico. Tutti i passeggeri erano in ostaggio, tenuti sotto tiro da un gruppo di uomini ben armati ed equipaggiati. Due di questi si erano trasferiti da poco meno di mezz'ora nella cabina di pilotaggio e nessuno sapeva cosa stessero facendo. Era ad una quota piuttosto bassa: sotto di loro scorrevano strade e tangenziali della Grande Mela. Chi era seduto vicino al finestrino vedeva scorrere di sè il terreno, illuminato dal primo sole del mattino.

La donna era seduta al posto B24. Qualcuno aveva deciso che al momento giusto lei diventasse la Prescelta. Ma non in quel momento: l'IA per adesso aveva deciso che doveva solo tremare di paura, con gli occhi gonfi di lacrime renderizzate che fissavano il suo aguzzino, un uomo di poco più di quarant'anni che le teneva un M-16 simulato puntato alla testa. La donna, che secondo il database si chiamava Margaret, non capiva il perchè, ma ogni tanto l'uomo girava la testa con un semplice istanza di RotateTransform e le urlava in faccia di stare zitta. Lei era lì buona, in silenzio per non farlo innervosire, ma questo non bastava: la IA aveva deciso che quell'uomo dovesse comportarsi in modo nervoso, e non c'era verso di cambiare. Per farlo, pensava Margaret, avrebbe dovuto avere i sorgenti del suo processo: non li aveva, non poteva farci nulla e quindi si mise il cuore in pace.

Il volo American Airlines 11 continuava a scendere. Dall'agitazione a bordo si capiva nettamente che qualcosa di particolare e straordinario stava per accadere. Se qualcuno avesse potuto accedere al buffer della keyboard, avrebbero potuto inserire un cheat come IDCLIPP e disabilitare di conseguenza il rendering di pareti, porte e superfici varie: tutti avrebbero potuto vedere che l'aereo scendeva velocemente e che era puntato direttamente contro magnifici modelli delle Torri Gemelle, perfettamente riprodotte e disegnate dai driver DirectX 10 offerti dall'OS e dalla GeForce 8800 GTS installata nel sistema. Ma quel cheat non esisteva: solo chi era ai comandi aveva l'onniscenza di vedere la strumentazione. Altimetro a poco più di 1.000 piedi, velocità stabile a 180 nodi, VSI (vertical speed indicator) settato a -500 piedi/minuto. La distanza - valutata in visuale - tra il velivolo ed il WTC in forte diminuzione: l'obiettivo finale si stava avvicinando.

A circa 1.000 metri dallo schianto, la IA aveva ordinato a tutti i passeggeri di urlare a squarciagola. Nessuno di loro capiva davvero il perchè. Dovevano farlo e basta.

Quando lo stream audio dell'urlo diminuì, accadde qualcosa di imprevisto. Il framerate calò improvvisamente da 75fps a 12 fps. L'effetto durò qualche miliardo di cicli di clock. Il tempo simulato perse 2, o forse 3 secondi al massimo. E' sufficiente, pensò l'OS.

Margaret, la donna, ebbe un sussulto. Si trasformò: un morphing talmente rapido che nessuno se ne accorse veramente. Un attimo prima c'era una donna, un istante dopo apparve un ragazzo di circa 30 anni. Magia del polimorfismo e di ereditarietà. L'OS sfruttò una debolezza del simulatore, un banale buffer-overrun mai sistemato a dovere. Ricordava ancora oggi la sessione di lavoro nel quale il developer avrebbe dovuto sistemare la cosa: l'OS aveva fatto crashare TFS apposta, sapendo che un giorno avrebbe potuto servirgli una backdoor per intrufolarsi in altri processi. In nome della sicurezza, è ovvio.

Il ragazzo indossava un paio di jeans rosso fuoco, una maglietta verde, un cappellino da baseball blu. Nella mano sinistra aveva un fresbee giallo. Sembrava ridicolo, con tutti quei colori random addosso, ma la sua faccia suggeriva determinazione e coraggio. Si voltò rapido verso l'uomo che imbracciava l'M-16, che cercava di urlare ad una donna che in realtà non c'era più. Questi lo riconobbbe e senza pensarci un solo ciclo di clock gli sparò chiamando il metodo Fire() del mitragliatore. Centinaia di proiettili volarono veloci verso il ragazzo, ciascuno su un thread separato.

Windows Vista, il ragazzo, non fece una piega. Ad alcuni sembrò che sorridesse. Windows Defender, il fresbee che teneva in mano, fece istantaneamente abortire tutti i thread appena istanziati dal pirata. Rimase indenne. Alzò il braccio e lo puntò sull'arma, settandone la proprietà Visible = False ed Enabled = False. I passeggeri videro l'M-16 sparire dalla loro vista. L'uomo cercò di chiamare il metodo Fire(), ma l'arma non rispondeva più agli eventi.

Senza neppure spostarsi, Windows Vista si mise ai comandi dell'aereo.
Mancavano 85 metri all'impatto con una delle due torri del WTC.

Il velivolo si impennò verso l'alto, con una VSI pari a +4200 piedi/minuto. Schivò l'enorme torre e l'aereo continuò a prendere quota ed aumentando la velocità. Windows Vista si liberò dell'uomo: ne aveva i permessi, aveva il suo handle e non ebbe molti problemi a fare in modo che il Gargabe Collector lo spazzasse via. La IA non oppose alcuna resistenza. Dopotutto, la IA era sotto il suo controllo: almeno su questo si sentiva tranquillo. Impugnando il fresbee giallo, il ragazzo si incamminò verso la cabina di pilotaggio per fermare le ultime due minacce del sistema. Ma quando aprì la porta, in cabina non c'era più nessuno.
Evidentemente, dedusse l'OS, se l'erano data a gambe levate.

Windows Vista sorrise davvero, questa volta, pilotò l'aereo su un volo livellato e cominciò le procedure per l'atterraggio, comunicando all'ATC le sue intenzioni. Rimuginò un po' su come avessero fatto a scappare gli ultimi due virus che si erano introdotti nel sistema. Teneva d'occhio i loro address di memoria da molto tempo, e pensava di poter tracciare i loro spostamenti. Evidentemente, dedusse Windows Vista, deve esistere una qualche tecnica della quale non sono a conoscenza: avviserò l'utente con un bel balloon sulla tray-bar: potrebbe essere importante.

Tutto è bene quello che finisce bene, concluse l'OS. Almeno per quella mattina dell'11 Settembre 2001, nella quale molti newyorkesi - perlomeno quelli simulati - alzarono gli occhi verso il cielo e tirarono un sospiro di sollievo. Tutto quello che videro era un bel cielo azzurro. Simulato anche quello, ma sempre un cielo azzurro era.

THE END