Perché le dichiarazioni in molti linguaggi di programmazione terminano con un punto e virgola?

C'è una ragione per cui un punto e virgola è stato scelto come terminatore di riga anziché come simbolo diverso?

Voglio conoscere la storia dietro questa decisione e spero che le risposte possano portare a intuizioni che possono influenzare le decisioni future.

In inglese il punto e virgola viene utilizzato per separare gli elementi in un elenco di istruzioni, ad esempio

Vide tre uomini: Jamie, che veniva dalla Nuova Zelanda; John, il figlio del lattaio; e George, un tipo scarno di uomo.

Durante la programmazione si stanno separando un certo numero di istruzioni e l'utilizzo di un punto completo potrebbe essere facilmente confuso per un punto decimale. L'uso del punto e virgola fornisce un metodo facile da analizzare per separare le singole istruzioni del programma rimanendo vicino alla normale punteggiatura inglese.

Modifica da aggiungere
All'inizio, quando la memoria era costosa, l'elaborazione era lenta e venivano elaborati i primi linguaggi di programmazione, era necessario suddividere il programma in istruzioni separate per l'elaborazione. Alcune lingue richiedevano che ogni istruzione fosse posizionata su una riga in modo che il ritorno a capo potesse fungere da delimitatore di istruzione. Altre lingue consentivano un formato più libero per il layout del testo e quindi richiedevano un carattere delimitatore specifico. Questo personaggio è stato scelto per essere il punto e virgola, molto probabilmente a causa della somiglianza con il suo uso in lingua inglese (questa deve essere una supposizione; non ero lì al momento) e poiché non ha prodotto un conflitto con l'altra punteggiatura segni e simboli richiesti per scopi matematici o sintattici.

Modifica di nuovo
La necessità di alcuni caratteri di terminazione risale ai requisiti per l'analisi del testo della lingua. I primi compilatori furono scritti in linguaggio assembly o, in alcuni casi, direttamente in istruzioni binarie create a mano. Avere un carattere speciale che ha identificato la fine dell'istruzione e delimitato il pezzo di testo che viene elaborato rende l'elaborazione molto più semplice. Come ho detto sopra, altre lingue hanno usato il ritorno a capo o le parentesi. Algol, Pascal, Ada, BCPL, B, C, PL / M e altre famiglie di lingue usano il punto e virgola. Per quanto riguarda quale fu il primo ad usare questo personaggio particolare, non torno abbastanza indietro nella storia da ricordare. La sua scelta e adozione ha perfettamente senso

• Il suo uso rispecchia l'uso nella normale punteggiatura inglese.
• Altri caratteri (ad es. Il punto pieno) potrebbero essere fonte di confusione in quanto hanno già un uso comune (un punto pieno viene anche usato come punto decimale).
• Un carattere di punteggiatura visibile consente il layout del codice in formato libero.
• L'uso di un carattere delimitatore simile nelle lingue derivate o successive si basa sulla familiarità acquisita da tutti i programmatori che hanno utilizzato la lingua precedente.

Come osservazione finale, penso che ci sia stato più tempo speso in queste risposte e commenti di quanto non sia stato speso nel decidere di usare il punto e virgola per terminare un'affermazione durante la progettazione della prima lingua che l'ha usata in questo modo.

Molte lingue usano una sintassi modellata su C (modellata su B - grazie a @Crollster). Come si può vedere nei commenti, esiste una lunga catena di tali linguaggi ... B è stato ispirato da PL / I, che è stato preceduto da ALGOL nell'uso di ;come separatore.

Poiché in C la terminazione dell'istruzione è ;, queste lingue seguono l'esempio.

Per quanto riguarda il motivo per cui è stato selezionato come terminatore di istruzioni in C - probabilmente a causa del suo uso in inglese "per indicare dichiarazioni interdipendenti" .

C è stato anche inventato sul PDP-11 in un momento in cui era disponibile una quantità limitata di memoria per i set di caratteri, quindi gli inventori delle lingue dovevano lavorare all'interno di questi vincoli.

FORTRAN ha usato il ritorno a capo per delineare le dichiarazioni. Periodo usato COBOL. LISP non ha usato nulla, basandosi sulle parentesi per tutto. ALGOL è stata la prima lingua a utilizzare il punto e virgola per separare le istruzioni. PASCAL ha seguito l'esempio di ALGOL, usando il punto e virgola per separare le dichiarazioni.

PL / I ha usato il punto e virgola per terminare le dichiarazioni. C'è una differenza, ed è facilmente visibile in PASCAL. Ada ha seguito l'esempio di PL / I su questo articolo, piuttosto che su ALGOL.

Il punto e virgola come separatore o terminatore di istruzioni è stato rapidamente accettato dalla comunità informatica come notazione utile e, per quanto ne so, ogni linguaggio strutturato a blocchi successivo ha seguito l'esempio di ALGOL e ha utilizzato il punto e virgola per separare o terminare le dichiarazioni.

Mi è stato detto molti anni fa che BCPL usava sia il punto e virgola AND il ritorno a capo come separatori / terminatori di istruzioni, ma non ho mai usato il linguaggio da solo e non sono in grado di verificarlo. Ad un certo punto, l'uso del ritorno a capo per separare o terminare le dichiarazioni è stato abbandonato dai discendenti BCPL. BCPL generò B, B generò C, C generò C ++, Java, D e tutta una serie di cose considerevolmente meno ben congegnate di PASCAL e Ada.

Perché non qualsiasi altro simbolo?

Alcune lingue hanno usato altri simboli - invece le vecchie versioni di BASIC utilizzavano due punti, per esempio.

Ignorando le poche eccezioni, tuttavia, penso che ci siano due ragioni principali. Il primo è che stai semplicemente cercando qualcosa di non ambiguo. In un tipico parser, se si verifica un errore abbastanza grave da non poter continuare ad analizzare l'istruzione corrente, in genere si tenta di ripristinare il parser semplicemente saltando al terminatore dell'istruzione e riavviando il parser dal inizio della prossima affermazione. Per questo, vuoi qualcosa che normalmente non accadrà in nessun'altra parte del codice e un punto e virgola sembra essere un simbolo con poco altro significato allegato, quindi è abbastanza facile dedicarlo a questo scopo.

Il secondo motivo è in qualche modo simile, ma mirava maggiormente alle persone che leggevano / usavano il codice. Ancora una volta, ritorna al fatto che il vero simbolo che usi non ha molta importanza. C'è un vantaggio sostanziale nella leggibilità da ottenere usando il simbolo che il tuo lettore è abituato a vedere per uno scopo particolare, quando e se possibile. Ciò non significa che la C sia l'unica sintassi perfetta e tutto il resto dovrebbe seguirla in modo sleale, ma significa che abbastanza persone hanno familiarità con quello stile di sintassi che un linguaggio vagamente simile guadagna molto (e perde molto poco) seguendo all'incirca la stessa sintassi dove può.

Noterei che questo è molto simile alla progettazione di quasi tutti gli altri programmi. Se scrivo un programma che utilizza finestre di qualche tipo, proverò a utilizzare solo le funzionalità native delle piattaforme di destinazione. Molte delle decisioni che incarna saranno in gran parte arbitrarie e potrebbero essere prese in modo diverso senza alcuna perdita significativa di funzionalità - ma allo stesso modo, cambiarle senza un sostanziale guadagno in termini di funzionalità confonde semplicemente gli utenti senza realizzare nulla di utile. Gli stessi principi di base si applicano a "cosa dovrebbe terminare (o separare) le dichiarazioni in una lingua?" come "come dovrebbe apparire una barra di scorrimento" o "come dovrebbe funzionare un controllo ad albero?" In tutti questi casi, la decisione è per lo più arbitraria e l'uniformità offre un vantaggio sostanziale in sé e per sé.

Aggiungo che lo stesso accade in molte lingue, proprio come molti di noi sono così abituati prima di programmare che poche persone ci pensano. Perché tutti usano "+" per indicare l'addizione o "-" per indicare la sottrazione? Perché la forma del simbolo non ha molta importanza, ma tutti coloro che accettano di applicare lo stesso significato a ciascun simbolo contano molto.

Il punto e virgola è stato originariamente proposto in Algol 60 come separatore di istruzioni , non come terminatore.

Prima di Algol 60, l'unico linguaggio di programmazione di alto livello esistente era Fortran, che richiedeva che ogni istruzione fosse su una riga separata. Le dichiarazioni che si estendono su più righe, come i do-loop, sono state considerate una stranezza e sono state considerate come "blocchi di istruzioni".

I progettisti di Algol 60 hanno capito che le dichiarazioni necessitavano di una struttura gerarchica (if-then-else, do-loop, case case ecc.) E potevano essere annidate l'una all'interno dell'altra. Quindi, l'idea di ogni affermazione seduta su una linea separata non aveva più senso. Composizione sequenziale di dichiarazioni del modulo S1; S2; ...; Sn facoltativamente racchiuso tra parentesi di inizio - fine sono stati chiamati istruzioni composte e si adattano alla struttura gerarchica delle istruzioni previste da Algol 60. Quindi, qui, il punto e virgola è chiaramente un separatore di istruzioni , non un terminatore.

Ciò ha causato problemi nella pratica. Algol 60 aveva anche una "dichiarazione vuota" che non veniva indicata scrivendo nulla. Quindi, si potrebbe scrivere " inizio S1; fine " dove appare il punto e virgola come se stesse terminando S1. Ma il compilatore Algol 60 lo ha davvero trattato come un separatore tra S1 e una dichiarazione vuota invisibile che lo seguiva. Queste sottigliezze erano un po 'troppo per i programmatori pratici. Essendo stati usati per linguaggi orientati alla linea come Assembly e Fortran, pensavano davvero al punto e virgola come terminatore per le dichiarazioni. Quando i programmi venivano scritti, di solito il punto e virgola veniva inserito alla fine delle istruzioni, in questo modo:

    a [i]: = 0;
    i: = i + 1

e il punto e virgola sembrava davvero un terminatore per la prima affermazione. Se i programmatori trattassero il punto e virgola come un terminatore, un'istruzione come questa darebbe un errore di sintassi:

    se i> 0 allora
      a [i]: = 0;
    altro
      a [i]: = 1;

perché il punto e virgola termina il "if" e, quindi, "else" diventa penzolante. I programmatori erano completamente confusi.

Quindi, PL / I, che è stato il successore di IBM a Fortran orientato alla linea, ha deciso di rendere il punto e virgola un terminatore di istruzione anziché un separatore. I programmatori erano contenti di quella scelta. La maggior parte dei linguaggi di programmazione ha seguito l'esempio. (Pascal ha resistito alla tendenza, ma il suo successore Ada ha rinunciato.)

[Nota aggiunta: l' articolo di Wikipedia sui confronti dei linguaggi di programmazione ha una bella tabella che riassume il modo in cui il punto e virgola viene trattato in vari linguaggi di programmazione.]

Questo è praticamente un lavoro di ipotesi puro, ma guardando una tastiera QWERTY standard limitata ai valori ASCII i caratteri naturali per la terminazione / separazione sarebbero.!?,:; e ritorni a capo. di quelli!?: dovrebbe essere immediatamente squalificato per avere più chiavi e la terminazione delle dichiarazioni sarà una cosa molto comune. I periodi sarebbero squalificati perché facilmente confusi con i punti decimali che li renderebbero inutilmente complicati per essere un terminatore dato lo spazio limitato dei computer iniziali. i ritorni a capo sarebbero squalificati dopo che le righe di codice avevano il potenziale per essere più lunghe di quelle che possono essere mostrate su una singola riga sullo schermo, quindi sarebbe più difficile leggere un programma quando le linee dovevano essere fatte scorrere orizzontalmente, o richiedono caratteri aggiuntivi per creare una continuazione nella riga successiva che aggiunga ancora complessità. questo lascia, e; come opzioni, di quelle, è usata molto più spesso nella scrittura rispetto a; quindi il punto e virgola viene scelto perché è più facile da digitare, meno confuso perché aggiunge significato a un personaggio con significato limitato e meno complicato perché non esistono casi speciali con il suo uso.

Il punto e virgola è stato scelto perché era il miglior personaggio basato sulla pigrizia e sulla semplicità.

È in gran parte una scelta arbitraria. Alcune lingue hanno fatto altre scelte. COBOL termina le dichiarazioni con il .carattere. FORTRAN, BASIC e Python generalmente terminano le istruzioni con newline (con sintassi speciale per le istruzioni multilinea). E Lisp racchiude le sue dichiarazioni tra parentesi.

Il motivo principale ;è così popolare come separatore / terminatore di istruzioni è che la maggior parte delle lingue popolari di oggi si basano su ALGOL , che ha utilizzato tale convenzione.

invece di un simbolo diverso?

Quale altro simbolo potresti scegliere?

I caratteri ASCII # $ @ [] ^ _ `{|} ~ non erano sempre presenti nelle prime codifiche di caratteri come ISO 646 .

I caratteri ()*+-/<=>vengono generalmente utilizzati come operatori matematici e creerebbero ambiguità di analisi se utilizzati come terminatori di istruzioni.

product = a * b *  // If '*' were a statement terminator,
c * d *            // Are there two factors, or four?

Problemi simili si applicherebbero a 'e ", che sono generalmente usati come delimitatori di stringa; ,, che viene in genere utilizzato per separare gli argomenti delle funzioni e ., che viene in genere utilizzato come punto decimale (o come delimitatore in costrutti come some_struct.some_field).

Che lascia !%&:;?.

Scegliere !o ?probabilmente non causerebbe difficoltà tecniche, ma i loro significati inglesi darebbero lo stato d'animo sbagliato al programma.

print(x)?  # Yes, you should.
           # It's an IMPERATIVE language; stop questioning my commands.
print(x)!  # OK!  You don't have to shout!

La &sarebbe una scelta più sensata come separatore di dichiarazione (non terminatore), perché

do_thing_a() &
do_thing_b()

può essere letto come un comando per fare la cosa A e poi fare la cosa B. Ma la maggior parte delle lingue con un &operatore la usa come AND logico o bit a bit .

Il %segno potrebbe causare confusione in istruzioni come interest_rate = 2.99%(che imposterebbe la variabile 2.99invece del previsto 0.0299). Naturalmente, il noto significato matematico di %non ha impedito a C di utilizzarlo come operatore residuo.

In modo che lascia :e ;.

: è una scelta sensata, e in effetti viene usato come separatore di istruzioni all'interno della linea nella maggior parte dei dialetti di BASIC.

Ma ;ha la grammatica inglese dalla sua parte; può essere usato per separare le clausole all'interno di una frase.

Invece di provare a rispondere alla tua domanda principale, penso che sia meglio concentrarsi sulla tua domanda implicita:

Voglio conoscere la storia dietro questa decisione e spero che le risposte possano portare a intuizioni che potrebbero influenzare le decisioni future nella progettazione e implementazione dei linguaggi di programmazione.

Se vuoi conoscere la progettazione del linguaggio di programmazione e la storia dell'implementazione e ottenere maggiori informazioni sul processo, gli atti delle Conferenze sulla storia dei linguaggi di programmazione sono un ottimo punto di partenza. (Penso che avrai bisogno di un abbonamento ACM per poter accedere al procedimento.)

Perché le dichiarazioni in molti linguaggi di programmazione terminano con un punto e virgola? C'è una ragione per cui un punto e virgola è stato scelto come terminatore di riga anziché come simbolo diverso?

Prendendo la tua domanda principale come una domanda di esempio a cui potresti voler provare a leggere leggendo il procedimento HOPL, vorrei offrire il seguente punto: le persone che progettano un nuovo linguaggio di programmazione di solito lo fanno perché considerano quelli che sanno essere rotto / carente in qualche modo. Il loro nuovo linguaggio è, da un lato, progettato per correggere questa carenza. D'altra parte, i progettisti di lingue copieranno anche elementi di design da altre lingue che ritengono buoni, o semplicemente non cambiano quegli elementi con cui non hanno avuto problemi.

Soprattutto quell'ultima parte è importante: invece di cercare di scoprire quale linguaggio di programmazione è mai stato il primo a usare i punti e virgola come terminatori e perché molti altri linguaggi di programmazione lo hanno copiato, probabilmente imparerai di più guardando i linguaggi che non hanno copiato esso. Ad esempio, mentre Smalltalk ha preso molta ispirazione da Simula, non è stato cosìcopia la sua sintassi e in particolare l'uso dei punti e virgola come terminatori di istruzioni. Ha cambiato i terminatori (in realtà i separatori) in un punto e usa il punto e virgola per qualcos'altro. Al contrario, la prima lingua che abbia mai usato un punto e virgola come terminatore di istruzioni potrebbe aver avuto un motivo per cambiare questo da quello che era usato nelle lingue che lo precedevano. È anche possibile che sia stata la prima lingua a introdurre l'intero concetto di terminatore di istruzioni (o lo abbia fatto indipendentemente dalle altre lingue) e che il punto e virgola sia stato usato per qualche motivo che ora è perso nel tempo. (Sospetto che questo sia il caso qui, poiché nessuno degli altri risponditori è stato in grado di trovare una citazione dalla persona che ha introdotto il punto e virgola anziché offrire supposizioni retrofittate sul perché il punto e virgola fosse una buona scelta.) Ma per ribadire il mio punto, Penso che imparerai di più osservando perché i designer linguistici hanno cambiato le cose piuttosto che perché le hanno copiate / conservate. Quando le persone cambiano cose di solito vogliono o devono spiegare il cambiamento, mentre non lo fanno quando copiano o mantengono le stesse cose perché “perché dovremmo cambiarlo? è proprio così! ”

Riguarda la visibilità.

I primi separatori di dichiarazioni erano i "." come in COBOL e nuova linea, ritorno a capo in FORTRAN.

La CR si è dimostrata limitante in quanto rende difficile far scorrere un'istruzione su più righe.

L'arresto completo ha causato un problema più interessante. Quando leggi il testo in inglese, il tuo cervello elabora i punti di arresto a livello subliminale, sei consapevole che una frase è finita e puoi fermarti per respirare ma non ti accorgi davvero di. quello lo ha segnalato. Anche in molti caratteri il '.' è il carattere più piccolo possibile a volte reso come un singolo pixel. Periodi mancanti o extra sono diventati la causa più comune di errori nei programmi COBOL.

Quindi, imparando dai primi errori, ALGOL sceglie un terminatore specifico che consentirebbe a un'affermazione di fluire su più righe e, quindi, ne sceglie una che era visibile e facilmente notabile dai lettori umani. Il punto e virgola è sia abbastanza grande che insolito nell'inglese comune da non essere elaborato inconsciamente.

Comprendevo che era stato scelto perché era necessario un terminatore di dichiarazione esplicito diverso da un ritorno a capo / nuova riga. Ai tempi degli schermi a 80 colonne, in realtà avere una singola riga di wrapping di codice su più righe era abbastanza comune che l'uso di \ r o \ n per il terminatore di istruzioni non avrebbe funzionato.

I punti e virgola erano solo utili perché non sono usati nelle dichiarazioni logiche / matematiche. Pertanto, non sono in conflitto con il contenuto effettivo delle dichiarazioni in misura significativa.

Personalmente, penso che l'uso continuo del punto e virgola, insieme ai requisiti di stile per mantenere le righe sotto gli 80 caratteri, sia francamente stupido e anacronistico. Lingue come Python hanno ampiamente dimostrato che è possibile scrivere codice conciso e facile da capire più facilmente senza di loro. Inoltre, se si hanno problemi con linee più lunghe di 80 caratteri, è necessario un monitor più grande.

Ecco due domande: perché ALGOL ha ottenuto il punto e virgola e perché altre lingue lo hanno seguito.

La prima domanda ha già ricevuto risposta in molti modi qui.

Come il secondo, ALGOL è stato ampiamente utilizzato come linguaggio pseudocodico per la scrittura di algoritmi. Quindi, i punti e virgola diventano presto naturali per gli utenti di lingue diverse. E naturalmente sono stati presi per le lingue più giovani.

Potrei sbagliarmi, ma penso che ciò abbia a che fare con il fatto che in molti assemblatori è stato usato un punto e virgola per iniziare un commento, di solito dopo un'istruzione. Tutto dopo un ;era un commento e non faceva più parte dell'istruzione stessa.

Quindi è necessario terminare le istruzioni quando le si digita in un interprete. Brevi istruzioni (ad es. Espressioni matematiche) potrebbero essere terminate semplicemente premendo il tasto Invio, dicendo all'interprete che l'espressione è pronta per essere calcolata e ha prodotto un risultato. Ma a volte si voleva inserire più righe di codice per l'istruzione, quindi un modo per ottenerlo era usare un carattere speciale come terminatore dell'istruzione anziché dipendere solo dal tasto Invio. In questo modo, l'utente può inserire più righe di codice contemporaneamente, poiché Invio non lo ha ancora inviato all'interprete. Solo quando l'interprete trovava il carattere finale in una riga immessa con Invio, lo eseguiva e calcolava il suo risultato.

Ora combina queste due cose insieme e il punto e virgola sembra essere una scelta ovvia per il carattere finale: dice dove finisce la parte dell'istruzione e inizia la parte del commento, quindi quando l'interprete la incontra in una riga, sa che può svuotare tutte le righe dell'espressione che ha bufferizzato finora ed eseguirlo, perché l'istruzione è appena terminata, ora siamo in un commento (beh, almeno fino alla fine di questa riga, perché la riga successiva inizierà nel codice di nuovo la modalità, avviando una nuova espressione / istruzione).

Ciò presuppone, naturalmente, che fosse proprio il punto e virgola che è stato utilizzato per i commenti dalla persona che ha avuto l'idea di riutilizzarlo come terminatori di istruzioni. Avendo avuto qualsiasi altro personaggio, avremmo potuto finire con un terminatore di istruzioni diverso.

Inb4: No, questo non è un account storico. Non ho alcuna prova che questo sia il modo in cui i punti e virgola hanno preso vita. È proprio come immagino che potrebbe essere successo.

La maggior parte delle lingue ha preso il punto e virgola perché era già ampiamente utilizzato a tale scopo e il cambiamento non aveva senso.

E considerando le prime lingue che fanno questa scelta, dovrai considerare quali sono le alternative. Quando si progetta una lingua, si desidera che siano disponibili i caratteri necessari e i set di caratteri in questo momento sono stati codificati su 6 bit, spesso con alcuni modelli riservati, spesso con alcuni caratteri non definiti in modo preciso (per una ricorrenza successiva, si pensi al varianti nazionali di ISO-646 - la variante americana è ben nota sotto il nome ASCII - che riutilizza i codici per caratteri "comuni" come [, #o $, e vede l'effetto in un contesto in cui vi è solo la metà del numero di posizioni di codice disponibile e lettere e cifre riservando più della metà di quelle).

Probabilmente non c'era nessun altro personaggio che potesse essere usato come separatore di istruzioni in modo intuitivo ( .è probabilmente già l'unico serio contendente per quei criteri) e senza introdurre difficoltà di lex o analisi in un momento in cui la teoria di analisi e lexing era ancora in elaborazione ( .è ora fuori discussione a causa del suo utilizzo in numeri reali).

Un altro motivo per cui usare il punto e virgola è perché è uno dei caratteri che non richiediamo o che usiamo più spesso.

Supponiamo di usarlo più spesso come nome di variabile o qualcosa del genere e se il punto e virgola sarebbe stato usato come parola chiave o come operatore, sarebbe stato un conflitto di simboli per il compilatore, quindi era importante usare un simbolo che non è spesso usato nella codifica.

Credo che i linguaggi di programmazione in stile C lo abbiano reso popolare e quindi gli autori di nuovi linguaggi di programmazione non volevano reinventare la ruota e hanno continuato ad usarla, fino ad ora.