Perché l'operatore incaricato assegna a sinistra?

Idem @paxdiablo. I primi linguaggi di programmazione furono scritti da matematici - in realtà erano tutti. In matematica, secondo il suo principio - leggere da sinistra a destra - ha senso nel modo in cui funziona.

x = 2y - 4.

In matematica, dovresti dire questo: Sia x uguale a 2y -4.

Inoltre, anche in algebra lo fai. Quando risolvi un'equazione per una variabile, isolerai la variabile che stai risolvendo sul lato sinistro. cioè y = mx + b;

Inoltre, una volta che un'intera famiglia di lingue, come la famiglia C, ha una certa sintassi, è più costoso cambiarla.

BASIC , uno dei primi linguaggi del computer aveva la forma "corretta" di:

10 LET AREA = HEIGHT * WIDTH

che corrisponde alla mentalità matematica di specificare una variabile, come "Sia H l'altezza dell'oggetto".

COBOL era simile con la sua dichiarazione COMPUTE . Come con molti modi di fare le cose, potrebbe essere stata semplicemente una decisione arbitraria che è stata portata avanti attraverso molte lingue.

In realtà, esiste un linguaggio di programmazione che assegna alla parte destra: TI-BASIC ! Non solo, ma non usa "=" come operatore di assegnazione, ma utilizza una freccia conosciuta come operatore "STO".

Esempi:

5→A
(A + 3)→B
(A - B)→C

Nell'esempio precedente, vengono dichiarate tre variabili e dati valori. A sarebbe 5, B sarebbe 8 e C sarebbe -3. La prima dichiarazione / assegnazione può essere letta "Memorizza 5 come A".

Riguardo al motivo per cui TI-BASIC usa un tale sistema per l'assegnazione, lo attribuisco perché è un linguaggio di programmazione per un calcolatore. L'operatore "STO" sui calcolatori TI è stato spesso utilizzato nelle normali operazioni della calcolatrice dopo è stato calcolato un numero. Se si trattava di un numero che l'utente desiderava ricordare, avrebbe premuto il pulsante "STO" e il caclulator chiedeva loro un nome (inserendo automaticamente il blocco alfabetico in modo che le sequenze di tasti producessero lettere anziché numeri):

Sin(7 + Cos(3))
                    -.26979276
Ans→{variable name}
                    -.26979276

e l'utente può nominare la variabile qualunque cosa scelga. Dovendo attivare il blocco alfabetico, digitare il nome, quindi premere "STO", e premere il tasto "Ans" sarebbe stato troppo ingombrante per le normali operazioni. Poiché tutte le funzioni della calcolatrice sono disponibili in TI-BASIC, non sono stati aggiunti altri operatori di assegnazione poiché "STO" ha eseguito lo stesso compito, anche se a ritroso rispetto alla maggior parte delle altre lingue.

(Aneddoto: TI-BASIC è stata una delle prime lingue che ho imparato, quindi quando ho iniziato a studiare Java all'università ho pensato che assegnare a sinistra fosse inusuale e "indietro"!)

Euristico 1: Di fronte a più di un modo possibile di fare qualcosa durante la progettazione di una lingua, scegli la più comune, la più intuitiva, altrimenti finirai con Perl +.

Ora, come è più naturale (almeno per un oratore inglese)? Diamo un'occhiata a come scriviamo / diciamo le cose in inglese:

Steven ora ha 10 anni (al contrario di 10 anni che Steven ora è). Pesa più di 190 libbre (rispetto a più di 190 libbre che peso).

Nel codice:

steven = 10
i > 190

Quanto segue suona anche più naturale:

"Se Mary ha 18 anni, allora può avere una caramella". "Se ho meno di 21 anni, poi chiederò a mio fratello di farmi da tequila".

if (mary == 18) { ... }
if (i < 21) { ... }

a:

"Se 18 anni Mary è ..." "Se 21 è maggiore della mia età ..."

Ora il codice:

if (18 == mary) { ... }
if (21 > i) { ... }

Nota che non è naturale né ai programmatori né agli anglofoni. Le frasi suonano come quelle di yoda e il codice è soprannominato condizioni yoda. Questi potrebbero essere utili in C ++, ma sono sicuro che la maggior parte della gente sarebbe d'accordo: se un compilatore potesse fare il sollevamento pesante e alleviare il bisogno di condizioni di yoda, la vita sarebbe un po 'più facile.

Naturalmente, ci si può abituare a qualsiasi cosa. Ad esempio, il numero 81 è scritto come:

Eighty One (inglese) Ottanta e uno (spagnolo) Uno e ottanta (tedesco).

Infine, ce ne sono 4! = 24 modi validi per dire "mela verde giace sul tavolo" in russo - l'ordine (quasi) non ha importanza, tranne che "on" deve venire insieme a "table". Quindi, se sei un madrelingua russo (per esempio), allora non ti importa se uno scrive a = 10 o 10 = a perché entrambi sembrano ugualmente naturali.

Mentre la linguistica è un argomento affascinante, non l'ho mai studiato formalmente e non conosco molte lingue. Spero di aver fornito sufficienti contro-esempi però.

È iniziato con FORTRAN negli anni '50. Dove FORTRAN era l'abbreviazione di FORmula TRANslation - le formule in questione erano semplici equazioni algebriche che per convenzione si assegnano sempre a sinistra.

Il suo COBOL quasi contemporaneo, d'altra parte, doveva essere simile all'inglese e assegnato a destra (soprattutto!).

MOVE 1 TO COUNTER.
ADD +1 TO LINE-CNT.
MULTIPLY QTY BY PRICE GIVING ITEM-PRICE.

Bene, come ha sottolineato @ diceguyd30, ci sono entrambe le notazioni.

• <Identifier> = <Value> significa "lascia identificatore essere valore ". O per espandere quello: Definisci (o ridefinisci) la variabile Identificatore a Valore .
• <Value> -> <Identifier> significa "store Valore a Identificatore ". O per espandere quello: Inserisci Valore nella posizione designata da Identificatore .

Ovviamente, in generale l' Identificatore potrebbe essere in effetti un qualsiasi valore L.

Il primo approccio onora il concetto astratto di variabili, il secondo approccio riguarda più lo storage effettivo.

Si noti che il primo approccio è comune anche nelle lingue, che non hanno assegnazioni. Inoltre, la definizione e l'assegnazione delle variabili sono relativamente vicini <Type> <Identifier> = <Value> rispetto a <Identifier> = <Value> .

Come è già stato detto, molto bene tutti i primi linguaggi del computer funzionavano in questo modo. Per esempio. FORTRAN, che è arrivato molti anni prima di BASIC.

In realtà è molto sensato avere la variabile assegnata sulla sinistra dell'espressione di assegnazione. In alcune lingue, potresti avere diverse routine sovraccaricate con lo STESSO NOME, restituendo diversi tipi di risultato. Consentendo al compilatore di vedere prima il tipo della variabile assegnata, conosce quale routine sovraccaricata chiamare, o quale cast implicito generare quando converte (ad es.) Un intero in un float. Questa è una spiegazione semplicistica, ma spero che tu abbia l'idea.

Potrebbe essere un residuo dei primi algoritmi di analisi. Ricorda che il parsing di LR fu inventato solo nel 1965, e poteva ben essere che i parser di LL avessero problemi (entro i limiti di tempo e di spazio delle macchine in quel momento) che andavano al contrario. Prendere in considerazione:

identifier = function();
function();

I due sono chiaramente disambiguati dal secondo token. D'altra parte,

function() = identifier;
function();

Non divertente. Questo peggiora quando inizi a nidificare le espressioni di assegnazione.

function(prev_identifier = expression) = identifier;
function(prev_identifier = expression);

Ovviamente, è più facile disambiguare le macchine significa anche più facile disambiguare per gli umani. Un altro semplice esempio potrebbe essere la ricerca dell'inizializzazione di un determinato identificatore.

identifier1 = expressionOfAnArbitraryLength;
identifier2 = expressionOfAReallyReallyReallyArbitraryLength;
identifier3 = expression;
identifier4 = AlongLineExpressionWithAFunctionCallWithAssignment(
    identifier = expr);

Facile, basta guardare il lato sinistro. Lato destro, d'altra parte

expressionOfAnArbitraryLength = identifier1;
expressionOfAReallyReallyReallyArbitraryLength = identifier2;
expression = identifier3;
AlongLineExpressionWithAFunctionCallWithAssignment(expr = identifier
    ) = identifier4;

Specialmente quando non puoi grep di schede perforate, è molto più difficile trovare l'identificatore che desideri.

Le lingue dell'Assembly hanno la destinazione come parte dell'opcode di sinistra. I linguaggi di livello superiore tendevano a seguire le convenzioni delle lingue precedenti.

Quando vedi = (o := per i dialetti Pascalish), potresti pronunciare quelli come is assigned the value , quindi la natura da sinistra a destra avrà senso (perché leggiamo anche da sinistra a destra la maggior parte delle lingue). Dal momento che i linguaggi di programmazione sono stati sviluppati prevalentemente da persone che leggono da sinistra a destra, le convenzioni sono rimaste bloccate.

È un tipo di dipendenza del percorso . Suppongo che se la programmazione per computer sia stata inventata da persone che parlavano ebraico o arabo (o qualche altra lingua da destra a sinistra), allora sospetto che metteremo la destinazione sulla destra.

Per quel che vale, la maggior parte delle istruzioni in COBOL legge da sinistra a destra, quindi i due operandi sono stati nominati per primi e la destinazione per ultimi, ad esempio: multiply salary by rate giving tax .

Tuttavia, non suggerirò che il tuo studente possa preferire COBOL, per timore che sarei (giustamente) segnalato per aver fatto un commento così basso, rozzo, insipido! : -)

she said that left-to-right seemed more natural to her, since that's how most of us read natural languages.

Penso che questo sia un errore. Da un lato, puoi dire "assegna 10 a x" o "sposta 10 a x". D'altra parte, puoi dire "imposta da x a 10" o "x diventa 10".

In altre parole, a seconda della scelta del verbo, la variabile assegnata a può essere o non essere il soggetto e potrebbe o meno essere sulla sinistra. Quindi "ciò che è naturale" dipende interamente dalla tua scelta abituale di formulazione per rappresentare l'incarico.

In pseudocodice, l'operatore di assegnazione è scritto molto comunemente a destra. Ad esempio

2*sqrt(x)/(3+y) -> z

Nelle calcolatrici Casio, anche le varianti non programmabili, la variabile di assegnazione viene visualizzata anche a destra

A+2B → C

In avanti anche la variabile è sulla destra

expression variable !

In x86, la sintassi Intel ha la destinazione sulla sinistra, ma la sintassi GAS inverte l'ordine, creando confusione a molte persone, in particolare sulle istruzioni relative all'ordine dei parametri come sottrazione o confronti. Queste istruzioni sono le stesse in 2 diversi dialetti

mov rax, rbx    ; Intel syntax
movq %rbx, %rax ; GAS syntax

Entrambi spostano il valore in rbx in rax. Nessun altro linguaggio di assemblaggio so scrivere la destinazione sulla destra come GAS.

Some platforms put the expression on the left and the variable on the right:

MOVE expression TO variable      COBOL
expression → variable            TI-BASIC, Casio BASIC
expression -> variable           BETA, R
put expression into variable     LiveCode

link

La maggior parte delle lingue assegna il valore a sinistra, una delle ragioni per cui è facile allineare gli operatori, più facile da leggere e riconoscere la variabile, poiché gli operatori di assegnazione e le posizioni delle variabili non variano molto nelle linee, ed è più facile per leggere come "lascia che la variabile abbia un valore".

Tuttavia alcune persone preferiscono dire "sposta il valore da x a y" e scrivi la variabile a destra.

Penso che segua un modo logico di pensare.
Prima deve esserci una scatola (variabile), quindi inserire un oggetto (valore) al suo interno.
Non metti l'oggetto in aria e poi metti una scatola attorno ad esso.