"Non tipizzato" significa anche "tipizzato dinamicamente" nel mondo accademico della CS?

Sto leggendo un mazzo di diapositive che afferma "JavaScript non è tipizzato". Ciò contraddiceva ciò che pensavo fosse vero, quindi ho iniziato a scavare per cercare di saperne di più.

Ogni risposta a JavaScript è una lingua non tipizzata? afferma che JavaScript non è tipizzato e offre esempi di varie forme di tipizzazione statica, dinamica, forte e debole che conosco e che sono contenti ... quindi non era la strada da percorrere.

Così ho chiesto a Brendan Eich, il creatore di JavaScript, e ha detto:

i tipi accademici usano "non tipizzato" per indicare "nessun tipo statico". sono abbastanza intelligenti da vedere che i valori hanno tipi (duh!). il contesto è importante.

Le persone di informatica focalizzate sul mondo accademico usano "non tipizzato" come sinonimo di "tipizzato in modo dinamico" (ed è valido?) O c'è qualcosa di più profondo in questo che mi manca? Concordo con Brendan sul fatto che il contesto è importante, ma qualsiasi citazione di spiegazioni sarebbe eccezionale, poiché i miei libri "vai a" attuali non giocano a palla su questo argomento.

Voglio inchiodarlo in modo da poter migliorare la mia comprensione e perché anche Wikipedia non si riferisce a questo uso alternativo (che posso trovare, comunque). Non voglio sbagliare con l'uso del termine o mettendo in discussione l'uso del termine in futuro se sbaglio :-)

(Ho anche visto un piccolo Smalltalker dire che Smalltalk è anche "non tipizzato", quindi non è una cosa una tantum che è ciò che mi ha fatto partire in questa ricerca! :-))

Sì, questa è una pratica standard nella letteratura accademica. Per capirlo, aiuta a sapere che la nozione di "tipo" è stata inventata negli anni '30, nel contesto del calcolo lambda (in effetti, anche prima, nel contesto della teoria degli insiemi). Da allora è emerso un intero ramo della logica computazionale che è noto come "teoria dei tipi". La teoria del linguaggio di programmazione si basa su queste basi. E in tutti questi contesti matematici, "tipo" ha un significato particolare e ben consolidato.

La terminologia "tipizzazione dinamica" è stata inventata molto più tardi - ed è una contraddizione in termini di fronte al comune uso matematico della parola "tipo".

Ad esempio, ecco la definizione di "sistema di tipi" che Benjamin Pierce utilizza nel suo libro di testo standard Tipi e linguaggi di programmazione :

Un sistema di tipi è un metodo sintattico trattabile per dimostrare l'assenza di determinati comportamenti del programma classificando le frasi in base al tipo di valori che calcolano.

Inoltre osserva:

La parola "statico" viene talvolta aggiunta esplicitamente, ad esempio parliamo di un "linguaggio di programmazione tipicamente statico", per distinguere i tipi di analisi in fase di compilazione che stiamo prendendo in considerazione qui dalla tipizzazione dinamica o latente presente in linguaggi come Schema (Sussman e Steele, 1975; Kelsey, Clinger e Rees, 1998; Dybvig, 1996), in cui i tag di tipo runtime vengono utilizzati per distinguere diversi tipi di strutture nell'heap. Termini come "tipizzato in modo dinamico" sono probabilmente dei termini sbagliati e probabilmente dovrebbero essere sostituiti da "controllati dinamicamente", ma l'uso è standard.

La maggior parte delle persone che lavorano sul campo sembrano condividere questo punto di vista.

Si noti che ciò non significa che "non tipizzato" e "tipizzato dinamicamente" sono sinonimi. Piuttosto, il secondo è un nome (tecnicamente fuorviante) per un caso particolare del primo.

PS: E FWIW, mi capita di essere sia un ricercatore accademico nei sistemi di tipo, sia un implementatore non accademico di JavaScript, quindi devo convivere con lo scisma. :)

Sono un informatico accademico specializzato in linguaggi di programmazione e sì, la parola "non tipizzato" viene spesso (mis) utilizzata in questo modo. Sarebbe bello riservare la parola per l'uso con lingue che non portano tag di tipo dinamici, come Forth e codice assembly, ma queste lingue sono usate raramente e ancora più raramente studiate, ed è molto più facile dire "non tipizzato" di "digitato dinamicamente".

A Bob Harper piace dire che lingue come Scheme, Javascript e così via dovrebbero essere considerate lingue tipizzate con un solo tipo: valore. Mi appoggio a questa visione, in quanto consente di costruire una visione del mondo coerente usando solo un tipo di formalismo.

PS Nel calcolo lambda puro, gli unici "valori" sono termini in forma normale e gli unici termini chiusi in forma normale sono funzioni. Ma la maggior parte degli scienziati che usano il calcolo lambda aggiungono tipi di base e costanti e quindi si include un sistema di tipo statico per lambda o si torna ai tag di tipo dinamico.

PPS Al poster originale: quando si tratta di linguaggi di programmazione, e in particolare di sistemi di tipi, le informazioni su Wikipedia sono di scarsa qualità. Non fidarti.

Ci ho pensato e ho scoperto che la risposta alla tua domanda è semplicemente e sorprendentemente "sì": i tipi di CS accademici, o almeno alcuni di essi, usano "non tipizzato" per significare "tipizzato dinamicamente". Ad esempio, Programming Languages: Principles and Practices , Third Edition (di Kenneth C. Louden e Kenneth A. Lambert, pubblicato nel 2012) dice questo:

Le lingue senza sistemi di tipo statico sono generalmente chiamate lingue non tipizzate (o lingue tipizzate dinamicamente ). Tali lingue includono Scheme e altri dialetti di Lisp, Smalltalk e la maggior parte dei linguaggi di scripting come Perl, Python e Ruby. Si noti, tuttavia, che un linguaggio non tipizzato non consente necessariamente ai programmi di danneggiare i dati, ciò significa solo che tutti i controlli di sicurezza vengono eseguiti al momento dell'esecuzione. [...]

[ link ] (nota: grassetto in originale) e continua a usare "non tipizzato" proprio in questo modo.

Lo trovo sorprendente (per le stesse ragioni che danno Afrischke e Adam Mihalcin), ma eccoti qui. :-)

Modificato per aggiungere: puoi trovare altri esempi collegandoti "untyped languages"a Google Ricerca Libri. Per esempio:

[…] Questo è il principale meccanismo di occultamento delle informazioni in molte lingue non tipizzate. Ad esempio lo schema PLT [4] utilizza generativi structs, […]

- Jacob Matthews e Amal Ahmed, 2008 [ link ]

[...], presentiamo un'analisi del tempo di legame per un linguaggio funzionale non tipizzato [...]. […] È stato implementato ed è utilizzato in un valutatore parziale per un dialetto libero di effetti collaterali dello Schema. L'analisi è abbastanza generale, tuttavia, per essere valida per linguaggi funzionali tipizzati non severi come Haskell. [...]

- Charles Consel, 1990 [ link ]

A proposito, la mia impressione, dopo aver esaminato questi risultati di ricerca, è che se un ricercatore scrive di un linguaggio funzionale "non tipizzato", molto probabilmente lo considera "non tipizzato" nello stesso senso del lambda non tipizzato calcolo che menziona Adam Mihalcin. Almeno, diversi ricercatori menzionano Scheme e il calcolo lambda nello stesso respiro.

Ciò che la ricerca non dice, ovviamente, è se ci sono ricercatori che rifiutano questa identificazione e non considerano queste lingue "non tipizzate". Bene, ho trovato questo:

Mi sono poi reso conto che non c'è davvero alcuna circolarità, perché le lingue tipizzate dinamicamente non sono lingue non tipizzate - è solo che i tipi non sono di solito immediatamente evidenti dal testo del programma.

- qualcuno (non so dire chi), 1998 [ link ]

ma ovviamente molte persone che rifiutano questa identificazione non sentono il bisogno di dirlo esplicitamente.

Non tipizzati e tipizzati dinamicamente non sono assolutamente sinonimi. Il linguaggio che viene spesso chiamato "non tipizzato" è il Lambda Calculus, che in realtà è un linguaggio unitped - tutto è una funzione, quindi possiamo dimostrare staticamente che il tipo di tutto è la funzione. Un linguaggio tipizzato dinamicamente ha più tipi, ma non aggiunge un modo per il compilatore di controllarli staticamente, costringendo il compilatore ad inserire controlli di runtime su tipi variabili.

Quindi, JavaScript è un linguaggio tipizzato in modo dinamico: è possibile scrivere programmi in JavaScript in modo tale che una variabile xpossa essere un numero, una funzione, una stringa o qualcos'altro (e determinare quale si richiederebbe per risolvere il problema di Halting o alcuni difficile problema matematico), quindi puoi applicare xun argomento e il browser deve verificare in fase di esecuzione che xsia una funzione.

Entrambe le affermazioni sono corrette, a seconda che tu stia parlando di valori o variabili. Le variabili JavaScript non sono tipizzate, i valori JavaScript hanno tipi e le variabili possono variare su qualsiasi tipo di valore in fase di esecuzione (cioè "dinamicamente").

In JavaScript e in molte altre lingue, i valori e non le variabili portano tipi. Tutte le variabili possono variare su tutti i tipi di valori e possono essere considerate "tipizzate dinamicamente" o "non tipizzate" - dal punto di vista del controllo del tipo una variabile che non ha un tipo / inconoscibile e una variabile che può assumere qualsiasi tipo sono logicamente e praticamente equivalenti . Quando i teorici dei tipi parlano di lingue e tipi, di solito parlano di questo - variabili che trasportano tipi - perché sono interessati a scrivere controllori di tipi e compilatori e così via, che operano sul testo del programma (cioè variabili) e non su un programma in esecuzione in memoria (ovvero valori).

Al contrario in altre lingue, come C, le variabili portano tipi ma i valori no. In linguaggi come Java, variabili e valori portano entrambi i tipi. In C ++, alcuni valori (quelli con funzioni virtuali) portano tipi e altri no. In alcune lingue è anche possibile che i valori cambino tipo, sebbene questo sia generalmente considerato un cattivo design.

Questa domanda è tutta sulla semantica

Se ti do questi dati: di 12che tipo è? Non hai modo di saperlo con certezza. Potrebbe essere un numero intero - potrebbe essere un float - potrebbe essere una stringa. In questo senso sono molti dati "non tipizzati".

Se ti do un linguaggio immaginario che ti consente di usare operatori come "aggiungi", "sottrai" e "concatena" su questi dati e su alcuni altri dati arbitrari, il "tipo" è in qualche modo irrilevante (per il mio linguaggio immaginario) (esempio : forse add(12, a)rese 109che è 12più il valore ASCII di a).

Parliamo C per un secondo. C praticamente ti permette di fare quello che vuoi con qualsiasi dato arbitrario. Se stai usando una funzione che richiede due uints, puoi lanciare e passare tutto quello che vuoi, e i valori saranno semplicemente interpretati come uints. In questo senso C è "non tipizzato" (se lo trattate in questo modo).

Tuttavia - e arrivando al punto di Brendan - se ti dicessi che "La mia età è 12" - allora 12ha un tipo - almeno sappiamo che è numerico. Con il contesto tutto ha un tipo, indipendentemente dalla lingua.

Questo è il motivo per cui ho detto all'inizio: la tua domanda è di semantica. Qual è il significato di "non tipizzato"? Penso che Brendan abbia colpito l'unghia sulla testa quando ha detto "nessun tipo statico" - perché è tutto ciò che può significare. Gli umani classificano naturalmente le cose in tipi. Sappiamo intuitivamente che c'è qualcosa di fondamentalmente diverso tra un'auto e una scimmia - senza che ci venga mai insegnato a fare queste distinzioni.

Tornando al mio esempio all'inizio - un linguaggio che "non si preoccupa dei tipi" (di per sé) può consentire di "aggiungere" un "età" e un "nome" senza produrre un errore di sintassi ... ma che non significa che sia un'operazione logicamente sana.

Javascript può farti fare ogni sorta di cose folli senza considerarle "errori". Ciò non significa che ciò che stai facendo sia logicamente corretto. Questo è per lo sviluppatore di lavorare.

Un sistema / linguaggio che non impone la sicurezza dei tipi in fase di compilazione / costruzione / interpretazione è "non tipizzato" o "tipizzato dinamicamente"?

Semantica.

MODIFICARE

Volevo aggiungere qualcosa qui perché alcune persone sembrano essere coinvolte in "sì, ma Javascript ha alcuni" tipi "".

Nel mio commento sulla risposta di qualcun altro ho detto:

In Javascript potrei avere oggetti che ho costruito per essere "Scimmie" e oggetti che ho costruito per essere "Umani" e alcune funzioni potrebbero essere progettate per operare solo su "Umani", altre solo su "Scimmie", e altri ancora su "Things With Arms". Che il linguaggio sia mai stato detto o meno esiste una categoria di oggetti come "cose ​​con le braccia" è irrilevante per l'assemblaggio ("non tipizzato") come lo è per Javascript ("dinamico"). È tutta una questione di integrità logica - e l'unico errore sarebbe usare qualcosa che non aveva armi con quel metodo.

Quindi, se si considera che JavaScript abbia internamente una "nozione di tipi" - e, quindi, "tipi dinamici" - e si pensa che questo sia in qualche modo "nettamente diverso da un sistema non tipizzato" - si dovrebbe vedere dall'esempio precedente che qualsiasi "nozione di tipi "che ha internamente è davvero irrilevante.

Per eseguire la stessa operazione con C #, ad esempio, HO BISOGNO di un'interfaccia chiamata ICreatureWithArmso qualcosa di simile. Non così in Javascript - non così in C o ASM.

Chiaramente, indipendentemente dal fatto che Javascript abbia o meno una comprensione dei "tipi" è irrilevante.

Sebbene sia vero che la maggior parte dei ricercatori CS che scrivono sui tipi essenzialmente considerano solo le lingue con tipi derivabili sintatticamente come linguaggi tipizzati, ci sono molti più di noi che usano linguaggi tipizzati in modo dinamico / latente che si rammaricano per quell'uso.

Ritengo che ci siano 3 tipi [SIC] di lingue:

Non tipizzato - solo l'operatore determina l'interpretazione del valore - e generalmente funziona su qualsiasi cosa. Esempi: assemblatore, BCPL

Digitato staticamente: espressioni / variabili sono associate a tipi e quel tipo determina l'interpretazione / validità dell'operatore in fase di compilazione. Esempi: C, Java, C ++, ML, Haskell

Digitato in modo dinamico: ai valori sono associati tipi e questo tipo determina l'interpretazione / validità dell'operatore in fase di esecuzione. Esempi: LISP, Scheme, Smalltalk, Ruby, Python, Javascript

Per quanto ne sappia, tutte le lingue tipizzate dinamicamente sono sicure per i tipi, vale a dire che solo operatori validi possono operare su valori. Ma lo stesso non è vero per il linguaggio tipizzato staticamente. A seconda della potenza del sistema di tipo utilizzato, alcuni operatori possono essere controllati solo in fase di esecuzione o per niente. Ad esempio, la maggior parte dei linguaggi digitati staticamente non gestiscono correttamente l'overflow di numeri interi (l'aggiunta di 2 numeri interi positivi può produrre un numero intero negativo) e i riferimenti di array fuori limite non sono controllati affatto (C, C ++) o sono controllati solo su run-time. Inoltre, alcuni sistemi di tipi sono così deboli che una programmazione utile richiede tratteggi di escape (cast in C e famiglia) per modificare il tipo di espressioni in fase di compilazione.

Tutto ciò porta a affermazioni assurde, come ad esempio che il C ++ è più sicuro di Python perché è (tipicamente statico), mentre la verità è che Python è intrinsecamente sicuro mentre puoi sparare una gamba con C ++.

Non sono uno scienziato informatico, ma sarei piuttosto sorpreso se "non tipizzato" venisse davvero usato come sinonimo di "tipizzato dinamicamente" nella comunità CS (almeno nelle pubblicazioni scientifiche), poiché questi due termini descrivono concetti diversi. Un linguaggio tipizzato in modo dinamico ha una nozione di tipi e applica i vincoli di tipo in fase di esecuzione (ad esempio non è possibile dividere un numero intero per una stringa in Lisp senza ottenere un errore) mentre un linguaggio non tipizzato non ha alcuna nozione di tipi in tutto (ad es. assemblatore). Anche l'articolo di Wikipedia sui linguaggi di programmazione (http://en.m.wikipedia.org/wiki/Programming_language#Typed_versus_untyped_languages) fa questa distinzione.

Aggiornamento: forse la confusione deriva dal fatto che alcuni testi dicono qualcosa nella misura in cui "le variabili non vengono digitate" in Javascript (il che è vero). Ma ciò non significa automaticamente che la lingua non sia tipizzata (il che sarebbe falso).

Concordo con Brendan: il contesto è tutto.

La mia opinione:

Ricordo di essere stato confuso, intorno al 2004, perché c'erano delle discussioni sul fatto che Ruby fosse tipizzato o tipizzato dinamicamente. Le persone C / C ++ della vecchia scuola (di cui ero uno) pensavano al compilatore e dicevano che Ruby non era tipizzato.

Ricorda, in C, non ci sono tipi di runtime, ci sono solo indirizzi e se il codice che sta eseguendo decide di trattare qualunque cosa sia a quell'indirizzo come qualcosa che non è, whoops. È decisamente non tipizzato e molto diverso da quello digitato dinamicamente.

In quel mondo, "digitare" riguarda tutto il compilatore. Il C ++ aveva una "tipizzazione forte" perché i controlli del compilatore erano più severi. Java e C erano più "tipizzati debolmente" (c'erano persino argomenti sul fatto che Java fosse tipizzato fortemente o debolmente). I linguaggi dinamici erano, in quel continuum, "non tipizzati" perché non avevano alcun controllo del tipo di compilatore.

Oggi, per i programmatori esperti, siamo così abituati ai linguaggi dinamici, ovviamente pensiamo che non tipizzato significhi nessun compilatore né controllo del tipo di interprete, il che sarebbe follemente difficile da eseguire il debug. Ma c'è stato un periodo in cui ciò non era ovvio e nel mondo più teorico di CS potrebbe non essere nemmeno significativo.

In un certo senso, nulla può essere non tipizzato (o quasi nulla, comunque) perché devi avere un certo intento nel manipolare un valore per scrivere un algoritmo significativo. Questo è il mondo del CS teorico, che non tratta i dettagli di come un compilatore o un interprete viene implementato per un determinato linguaggio. Quindi "non tipizzato" è (probabilmente, non lo so) completamente privo di significato in quel contesto.