I primi assemblatori erano scritti in codice macchina?

Sto leggendo il libro The Elements of Computing Systems: Building a Modern Computer from First Principles , che contiene progetti che comprendono la costruzione di un computer da porte booleane fino ad applicazioni di alto livello (in questo ordine). Il progetto attuale a cui sto lavorando è scrivere un assemblatore usando un linguaggio di alto livello di mia scelta, per tradurre dal codice assembly Hack al codice macchina Hack (Hack è il nome della piattaforma hardware creata nei capitoli precedenti). Sebbene l'hardware sia stato tutto costruito in un simulatore, ho cercato di fingere che sto davvero costruendo ogni livello usando solo gli strumenti disponibili a quel punto nel processo reale.

Detto questo, mi ha fatto pensare. Usare un linguaggio di alto livello per scrivere il mio assemblatore è certamente conveniente, ma per il primissimo assemblatore mai scritto (cioè nella storia), non avrebbe bisogno di essere scritto in codice macchina, dato che era tutto ciò che esisteva al momento?

E una domanda correlata ... che ne dici di oggi? Se emergesse una nuovissima architettura CPU, con un nuovo set di istruzioni e una nuovissima sintassi dell'assemblaggio, come sarebbe costruito l'assemblatore? Suppongo che potresti ancora usare un linguaggio di alto livello esistente per generare file binari per il programma assembler, poiché se conosci la sintassi sia dell'assembly che dei linguaggi macchina per la tua nuova piattaforma, il compito di scrivere l'assemblatore è davvero solo un attività di analisi del testo e non è intrinsecamente correlata a quella piattaforma (cioè deve essere scritta nel linguaggio macchina di quella piattaforma) ... che è la vera ragione per cui sono in grado di "imbrogliare" mentre scrivo il mio assemblatore Hack nel 2012 e usare un po 'di preesistente linguaggio di alto livello per aiutarmi.

per il primo assemblatore mai scritto (cioè nella storia), non dovrebbe essere scritto nel codice macchina

Non necessariamente. Naturalmente la prima versione v0.00 dell'assemblatore deve essere stata scritta in codice macchina, ma non sarebbe sufficientemente potente per essere chiamata assemblatore. Non supporterebbe nemmeno la metà delle caratteristiche di un assemblatore "reale", ma sarebbe sufficiente scrivere la versione successiva di se stesso. Quindi è possibile riscrivere v0.00 nel sottoinsieme del linguaggio assembly, chiamarlo v0.01, utilizzarlo per creare il successivo set di funzioni dell'assemblatore v0.02, quindi utilizzare v0.02 per compilare v0.03 e così via, fino ad arrivare alla v1.00. Di conseguenza, solo la prima versione sarà nel codice macchina; la prima versione rilasciata sarà in linguaggio assembly.

Ho sviluppato il bootstrap di un compilatore di linguaggio template usando questo trucco. La mia versione iniziale utilizzava le printfistruzioni, ma la prima versione che utilizzavo nella mia azienda utilizzava proprio il modello di processore che stava elaborando. La fase di bootstrap è durata meno di quattro ore: non appena il mio processore è riuscito a produrre output a malapena utile, l'ho riscritto nella sua lingua, compilato e gettato via la versione non basata su modelli.

Secondo Wikipedia, il primo linguaggio mai assemblatore / assemblaggio è stato implementato per l'IBM 701 da Nathaniel Rochester . (Le date sono un po 'incerte dall'articolo di Wikipedia. Si afferma che Rochester si unì all'IBM nel 1948, ma un'altra pagina di Wikipedia afferma che il 701 fu annunciato pubblicamente nel 1952. E questa pagina dell'IBM afferma che "[un] progetto attuale è iniziato a febbraio 1, 1951 ed è stato completato un anno dopo " .)

Tuttavia "Assemblers and Loaders" di David Salomon afferma (a pagina 7) che EDSAC aveva anche un assemblatore:

"Uno dei primi computer con programmi memorizzati fu l'EDSAC (Electronic Delay Storage Automatic Calculator) sviluppato all'Università di Cambridge nel 1949 da Maurice Wilkes e W. Renwick. Fin dai primi giorni l'EDSAC aveva un assemblatore, chiamato Initial Orders. Fu implementato in una memoria di sola lettura formata da una serie di selettori telefonici rotanti, e accettava istruzioni simboliche. Ogni istruzione consisteva in una lettera mnemonica, un indirizzo decimale e un terzo campo che era una lettera. Il terzo campo causava uno di 12 costanti preimpostate dal programmatore da aggiungere all'indirizzo al momento dell'assemblaggio. " (Riferimenti omessi ... vedi l'originale.)

Supponendo che accettiamo che "gli ordini iniziali" abbiano la precedenza, abbiamo prove evidenti che il primo assemblatore è stato implementato nel codice macchina.

Questo modello (scrivendo gli assemblatori iniziali in codice macchina) sarebbe stato la norma negli anni '50. Tuttavia, secondo Wikipedia , "[a] ssemblers sono stati i primi strumenti linguistici a caricarsi da soli". Vedi anche questa sezione che spiega come un assemblatore primordiale ha scritto il codice macchina per usare un bootstrap di un assemblatore più avanzato che è stato codificato nel linguaggio assembly.

Al giorno d'oggi assemblatori e compilatori sono scritti in linguaggi di livello superiore e un assemblatore o compilatore per una nuova architettura di macchina viene in genere sviluppato su un'architettura diversa e compilato in modo incrociato.

(FWIW - scrivere e eseguire il debug di programmi non banali nel codice macchina è un processo estremamente laborioso. Qualcuno che sviluppa un assemblatore in codice macchina molto probabilmente avvia il bootstrap a un assemblatore scritto in assembler il più presto possibile.)

Questa pagina di Wikipedia sui compilatori e gli assemblatori di bootstrap merita una lettura ... se tutto ciò ti confonde.

Presumo che i primi assemblatori fossero scritti in codice macchina, perché come dici tu, nient'altro era disponibile allora.

Oggi, tuttavia, quando esce una nuovissima architettura CPU, usiamo quello che è noto come Cross-Compiler , che è un compilatore che produce codice macchina non per l'architettura su cui è in esecuzione, ma per un'architettura diversa.

(È un dato di fatto, come sono sicuro che scoprirai più avanti nel libro che stai leggendo, non c'è assolutamente nulla che rende un compilatore intrinsecamente più adatto a produrre codice macchina per l'architettura su cui è in esecuzione rispetto a qualsiasi altro altra architettura. È solo una questione di quale architettura tu, come creatore del compilatore, mirerai.)

Quindi, oggi è persino possibile (almeno in teoria) creare un'architettura nuova di zecca e avere compilatori di linguaggio di alto livello in esecuzione nativamente su di essa (compilati su altre architetture che usano cross-compilatori) prima ancora di avere un assemblatore per quell'architettura.

Inizialmente "assembly" è stato scritto su carta e poi "compilato" manualmente su schede perforate.

Mio nonno stava lavorando con una ZRA1 (scusate, la pagina esiste solo in tedesco, ma la traduzione di Google è ok al punto in cui potete effettivamente raccogliere i fatti più importanti: D).
Il modus operandi doveva scrivere il tuo codice su carta in una sorta di linguaggio di assemblaggio e il segretario avrebbe effettivamente fatto la trascrizione per perforare le carte, quindi le avrebbe passate all'operatore e il risultato sarebbe stato restituito la mattina dopo.

Tutto questo essenzialmente prima che i programmatori avessero il lusso di inserire dati attraverso una tastiera e visualizzarli su uno schermo.

E 'difficile essere certi circa la molto prima assembler (difficile definire anche quello che era). Anni fa, quando scrivevo alcuni assemblatori per macchine prive di assemblatori, scrivevo ancora il codice nel linguaggio assembly. Quindi, dopo aver completato una sezione di codice ragionevolmente completa, l'ho tradotta manualmente in codice macchina. Erano comunque due fasi completamente separate - quando stavo scrivendo il codice, non stavo lavorando o pensando a livello di codice macchina.

Dovrei aggiungere che in alcuni casi ho fatto un ulteriore passo avanti: ho scritto la maggior parte del codice in un linguaggio assembly che ho trovato più semplice da usare, quindi ho scritto un piccolo kernel (più o meno quello che ora chiameremmo una macchina virtuale) interpretarlo sul processore target. Era mortalmente lento (specialmente su un processore da 1 MHz, 8 bit), ma non importava molto, dato che normalmente funzionava solo una volta (o al massimo, poche volte).

Non è necessario un assemblatore per assemblare manualmente il codice della lingua dell'assembly nel codice macchina. Proprio come non è necessario un editor per scrivere il codice del linguaggio assembly.

Una prospettiva storica

I primi assemblatori furono probabilmente scritti in linguaggio assembly e poi assemblati a mano in codice macchina. Anche se il processore non aveva un "linguaggio assembly" ufficiale, probabilmente i programmatori hanno svolto la maggior parte del lavoro di programmazione usando una specie di pseudo codice prima di tradurlo in istruzioni macchina.

Anche nei primi giorni dell'informatica , i programmatori hanno scritto i programmi in una sorta di notazione simbolica e li hanno tradotti in codice macchina prima di inserirlo nel loro computer. Nel caso di Augusta Ada King, avrebbe dovuto tradurle in schede perforate per il motore analitico di Babbage , ma purtroppo non è mai stato costruito.

Esperienza personale

Il primo computer che possedevo era un Sinclair ZX81 (Timex 1000 negli Stati Uniti). La parte posteriore del manuale aveva tutte le informazioni necessari per tradurre Z80 linguaggio assembly in codice macchina (anche inclusing tutti i modo dell'indice strani codici operativi Z80 aveva).

Vorrei scrivere un programma (su carta) in linguaggio assembly e scorrere a secco il codice. Quando ero felice che il mio programma fosse privo di bug, avrei cercato tutte le istruzioni sul retro del manuale, tradotto in codice macchina e scritto anche il codice macchina sul foglio. Infine, digitarei tutte le istruzioni del codice macchina nel mio ZX81 prima di salvarlo su nastro e provare a eseguirlo.

Se non avesse funzionato, avrei ricontrollato il mio assemblaggio manuale e se qualche traduzione fosse errata avrei patchato i byte caricati dal nastro prima di salvarlo di nuovo e riprovare ad eseguire il programma.

Per esperienza, posso dirti che è molto più facile eseguire il debug del codice se è scritto nel linguaggio assembly piuttosto che nel codice macchina, da cui la popolarità dei disassemblatori. Anche se non hai un assemblatore, il montaggio manuale è meno soggetto a errori rispetto al tentativo di scrivere direttamente il codice macchina, anche se immagino che un vero programmatore come Mel potrebbe non essere d'accordo. * 8' )

Non c'è differenza allora o ora. Volete inventare un nuovo linguaggio di programmazione, scegliete uno dei linguaggi disponibili oggi per creare il primo compilatore. per un certo periodo di tempo, se è un obiettivo del progetto, si crea un compilatore in quella lingua e può quindi ospitare autonomamente.

Se tutto ciò che avevi era carta e matita e alcuni interruttori o schede perforate come interfaccia utente per il primo o il successivo nuovo set di istruzioni, hai usato uno o tutti gli elementi disponibili. Avresti potuto benissimo scrivere un linguaggio assembly, su carta, e quindi utilizzare un assemblatore, tu, per convertirlo in codice macchina, magari in ottale, poi ad un certo punto è andato nell'interfaccia alla macchina.

Quando oggi viene inventato un nuovo set di istruzioni, non diverso, a seconda dell'azienda / degli individui, delle pratiche, ecc. È molto probabile che l'ingegnere hardware che probabilmente sta programmando in verilog o vhdl, scriva i primi programmi di test manualmente nel codice macchina (probabilmente in esadecimale o binario). a seconda dei progressi dei team di software, possono molto rapidamente o non molto tempo passare al linguaggio assembly e quindi a un compilatore.

Le prime macchine informatiche non erano macchine di uso generale che potevi usare per creare assemblatori e compilatori. Li hai programmati spostando alcuni fili tra l'uscita dell'alu precedente all'ingresso del successivo. Alla fine avevi un processore per uso generale in modo da poter scrivere un assemblatore in assembly, assemblarlo a mano, inserirlo come codice macchina, quindi usarlo per analizzare ebcdic, ascii, ecc. E quindi self-host. memorizzare il file binario su alcuni supporti che è possibile leggere / caricare in seguito senza dover continuare a spostare gli interruttori sul codice della macchina di alimentazione manuale.

Pensa alle schede perforate e al nastro di carta. Invece di premere gli interruttori potresti sicuramente creare una macchina completamente meccanica, un dispositivo che risparmia manodopera, che ha creato il supporto che il computer leggerà. Invece di dover inserire i bit del codice macchina con interruttori come un altair, potresti invece alimentare nastro di carta o schede perforate (usando qualcosa di meccanico, non guidato dal processore, che alimenta la memoria o il processore, O usando un piccolo caricatore di avvio scritto con codice macchina). Questa non è stata una cattiva idea perché potresti creare qualcosa, guidato dal computer che potrebbe anche produrre meccanicamente i nastri di carta o le schede perforate, e poi reinserirle. Due fonti di schede perforate, il dispositivo di risparmio di lavoro meccanico non basato su computer e la macchina guidata da computer. entrambi producono i "binari" per il computer.

Ci sono uno o due casi nello zoo dei computer di Brook in cui ha detto qualcosa come "i mnemonici sono la nostra invenzione, il designer ha semplicemente usato un codice numerico o il carattere il cui codice era il codice operativo", quindi lì dove macchine per le quali non c'era nemmeno un linguaggio assembly.

L'inserimento dei programmi termina il debug sul pannello frontale (per coloro che non l'hanno fatto, è stato un modo per impostare la memoria, impostare alcuni interruttori sull'indirizzo, altri sul valore e premere un pulsante o un altro pulsante su leggere il valore) era comune molto più tardi. Alcuni vecchi timer si vantano che sarebbero ancora in grado di inserire il codice di avvio per le macchine che hanno usato ampiamente.

La difficoltà di scrivere direttamente il codice macchina e leggere i programmi dal dump della memoria dipende molto dal linguaggio macchina, alcuni sono relativamente facili (la parte più difficile è il tracciamento degli indirizzi), x86 è uno dei peggiori.

Ho costruito un computer nel 1975. Era molto avanzato rispetto al suo contemporaneo l'Altair, perché aveva una "monitor rom" che mi permetteva di inserire programmi digitando il codice macchina in esadecimale e visualizzando questo codice su un monitor video, dove come con il Ad Altair ogni istruzione della macchina doveva essere inserita un po 'alla volta usando una fila di interruttori.

Quindi sì, nei primi tempi dei computer e poi ancora nei primi tempi dei personal computer le persone scrivevano applicazioni in codice macchina.

Un aneddoto:

Quando ho imparato il linguaggio assembly, su Apple] [, c'era un programma incluso nella ROM chiamato micro-assemblatore. Ha eseguito la traduzione immediata delle istruzioni di assemblaggio in byte, non appena le hai inserite. Ciò significa che non c'erano etichette: se si desidera saltare o caricare, è necessario calcolare autonomamente gli offset. È stato molto più semplice che cercare i layout delle istruzioni e inserire valori esadecimali.

Senza dubbio, i veri assemblatori sono stati scritti per la prima volta utilizzando il microassemblatore o un altro ambiente non del tutto completo.