di  -  mercoledì 1 ottobre 2008

Era questo il nome di una rubrica che apparve sulle pagine di una rivista che rimane nella storia dell’informatica: Byte. Questa rubrica ospitava degli articoli estremamente interessanti che riguardavano, appunto, la programmazione in linguaggio assembly.

Già, perché con l’introduzione dei monitor (vedi questo articolo) e la maggior facilità di utilizzare l’assembly (al posto del ben più macchinoso linguaggio macchina), questo linguaggio si diffuse molto rapidamente fra gli smanettoni.

Rimanevano, però, non pochi problemi coi monitor… Ad esempio aggiungere pezzi di codice all’interno del programma già scritto era particolarmente contorto perché richiedeva lo spostamento di blocchi di memoria per fare spazio per la nuova parte, e ciò costringeva anche a ricalcolare i richiami alle routine che, a causa del movimento effettuato, erano state spostate. Ovviamente non era solo questo il problema.

A dare una svolta contribuì, nella seconda metà degli anni ’80, la proliferazione di quelli che in gergo vengono chiamati assemblatori. Si trattava di compilatori che processavano file di testo scritti in linguaggio assembly e producevano come risultato finale dei file denominati oggetto o, molto più raramente, l’eseguibile finale.

I file oggetto non erano ancora direttamente eseguibili in quanto necessitavano di un ulteriore programma chiamato linker che provvedeva a “metterli assieme” e generare l’eseguibile. All’apparenza sembra tutto molto più complicato (d’altra parte coi monitor si poteva scrivere fin da subito codice assembly che veniva immediatamente convertito in linguaggio macchina; quindi pronto per l’esecuzione), ma i vantaggi erano (e rimangono) notevoli.

In primo luogo generando diversi file oggetto che contenevano particolari porzioni di codice, veniva introdotto il concetto di modularizzazione. Era, cioé, possibile organizzare il codice in blocchi di routine che si occupavano di specifiche funzionalità. Ad esempio la gestione della grafica si trovava in un file oggetto, quello della musica in un altro, quello per l’accesso ai dati in un altro ancora, ecc.

In questo modo diveniva molto semplice riutilizzare il codice già scritto senza andare a reinventare la ruota ogni volta, oppure ricorrere al famigerato copia & incolla. L’applicazione, quindi, era composta da una parte principale che richiamava poi diverse altre parti sparse nei file oggetto.

Altri vantaggi degli assembler erano quelli di utilizzare dei simboli per marcare l’inizio di routine o dati, e questo evitava di dover specificare direttamente gli indirizzi di memoria dei medesimi, in quanto era lui (o il linker) a farsi carico di “sbrogliare la matassa” alla fine (cioé attribuendo l’indirizzo giusto a ogni cosa).

Inoltre era possibile utilizzare delle espressioni matematiche per eseguire dei calcoli, e si potevano anche creare delle macro che permettevano di creare dei template per blocchi di istruzioni la cui struttura era ripetuta (oppure si potevano anche creare nuove istruzioni).

Gli strumenti che mettevano a disposizione gli assemblatori erano, dunque, molto comodi e cambiavano radicalmente l’approccio alla stesura di codice assembly. Era divenuto talmente semplice usare l’assembly che, ad esempio, buona parte delle applicazioni per l’Amiga erano scritte con questo linguaggio.

Oggi un approccio del genere sarebbe improponibile, visti i tempi necessari per lo sviluppo (infatti si predilige la produttività all’efficienza), ma all’epoca era cosa comune. Penso che molti ricorderanno le famose demo che giravano; beh, erano scritte tutte in assembly! Idem per i giochi, ma anche applicazioni complesse. L’assembly era veramente a portata di mano…

7 Commenti »

I commenti inseriti dai lettori di AppuntiDigitali non sono oggetto di moderazione preventiva, ma solo di eventuale filtro antispam. Qualora si ravvisi un contenuto non consono (offensivo o diffamatorio) si prega di contattare l'amministrazione di Appunti Digitali all'indirizzo info@appuntidigitali.it, specificando quale sia il commento in oggetto.

  • # 1
    Jacopo Cocchi
     scrive: 

    un incubo! :D

    Non ho fatto in tempo a vivere quei tempi, smanettando in Basic alle medie con il C64 :P

  • # 2
    ekerazha
     scrive: 

    Da quello screenshot si intravede assembly che potrebbe essere assembly per Motorola M68K (da notare i caratteristici “move.lunghezza”), CPU di alcuni Amiga (dell’Amiga 500 di sicuro). Ci ho preso? :-D

  • # 3
    Crono
     scrive: 

    come vorrei aver vissuto tutto ciò

  • # 4
    LGraz
     scrive: 

    Ah, le demo…ricordo i dischetti con sopra i vincitori
    dell’Assembly!

    …che, tra l’altro, ancora si tiene, tra fine luglio ed
    inizio agosto, anche se “un pò” ampliato (ma con ancora
    i demo-contest) [www.assembly.org]

  • # 5
    Cesare
     scrive: 

    @crono: da un certo punto di vista son contento, ma ripensandoci adesso non posso che concordare con Jacopo. :D

    @ekerazha: esattamente. Comunque l’architettura Motorola 680×0 è stata usata da tutti gli Amiga fino al fallimento di Commodore.

  • # 6
    Bopalo
     scrive: 

    Ho vissuto quei tempi, il che mi fa pensare purtroppo solo ad una triste cosa:
    Sto invecchiando!

    Comunque complimenti a Cesare per l’articolo. Vecchiaia a parte fa piacere anche rivivere quei tempi magici in cui l’informatica di massa era solo agli albori.

  • # 7
    SWEET 16: la virtual machine a 16 bit di Steve Wozniak - Appunti Digitali
     scrive: 

    […] veniva richiamata all’occorrenza da una normale applicazione scritta in linguaggio macchina o assembly […]

Scrivi un commento!

Aggiungi il commento, oppure trackback dal tuo sito.

I commenti inseriti dai lettori di AppuntiDigitali non sono oggetto di moderazione preventiva, ma solo di eventuale filtro antispam. Qualora si ravvisi un contenuto non consono (offensivo o diffamatorio) si prega di contattare l'amministrazione di Appunti Digitali all'indirizzo info@appuntidigitali.it, specificando quale sia il commento in oggetto.