JavaScript è diventato il linguaggio nativo del Web. Anima le interfacce, reagisce alle azioni degli utenti, comunica con i server ed esegue applicazioni complete nel browser. Con Node.js è arrivato anche sui server e negli strumenti di sviluppo. Nel 1995 nulla di tutto questo era previsto su una scala simile.
La sua storia non è quindi quella di un progetto perfetto eseguito dall’inizio alla fine. È la storia di un linguaggio nato sotto pressione, diventato inevitabile grazie alla distribuzione universale e migliorato continuamente senza poter cancellare il proprio passato.
1995: rendere programmabile il browser
All’inizio degli anni Novanta il Web è soprattutto documentale. HTML descrive il contenuto, HTTP trasporta le risorse e il browser mostra la pagina. Per ottenere un nuovo risultato è generalmente necessario contattare di nuovo il server.
Netscape capisce che il browser può diventare una piattaforma applicativa. Vuole un linguaggio leggero che gli autori possano inserire direttamente nelle pagine, accanto a Java, allora fortemente promosso da Sun.
Brendan Eich entra in Netscape nell’aprile 1995 e a maggio realizza in circa dieci giorni il primo prototipo, Mocha. I celebri «dieci giorni» riguardano questo prototipo, non il JavaScript moderno. Mocha diventa LiveScript e poi JavaScript alla fine del 1995.
Il nome sfrutta la popolarità di Java ma crea una confusione duratura. JavaScript non è un Java ridotto. La superficie ricorda la famiglia C, mentre tra le influenze profonde ci sono Scheme, per le funzioni di prima classe, e Self, per gli oggetti basati su prototipi.
Un modello insolito sotto una sintassi familiare
In JavaScript le funzioni sono valori: possono essere memorizzate, passate e restituite. È un modello particolarmente adatto alle interfacce guidate dagli eventi.
Il modello storico degli oggetti si basa sui prototipi. Gli oggetti possono delegare la ricerca delle proprietà ad altri oggetti. La moderna sintassi class offre un’astrazione familiare, ma continua a poggiare su questo meccanismo.
Tipizzazione dinamica e conversioni implicite facilitarono la scrittura di piccoli script, producendo però anche note peculiarità. Molta dell’evoluzione successiva consiste nel migliorare il linguaggio senza rompere le pagine che dipendono da comportamenti precedenti.
JavaScript non è il browser
Linguaggio e ambiente Web vengono facilmente confusi. DOM, eventi, rete e archiviazione Web sono però API del browser, non parti del nucleo ECMAScript.
La distinzione diventa fondamentale quando JavaScript esce dal browser: lo stesso linguaggio può funzionare in ambienti differenti con API differenti.
Storicamente il DOM è comunque decisivo. Espone la pagina come struttura programmabile e consente di modificare testo, attributi, stili ed elementi dopo il caricamento. Il documento Web diventa un’interfaccia dinamica.
La guerra dei browser e la necessità di uno standard
Microsoft introduce JScript in Internet Explorer nel 1996. Netscape e Microsoft distribuiscono anche API incompatibili, costringendo gli sviluppatori a gestire le differenze tra browser.
Netscape sottopone quindi il linguaggio a Ecma International. Nel 1997 viene pubblicata la prima edizione di ECMA-262, che definisce ECMAScript.
JavaScript rimane il nome comune; ECMAScript diventa la specifica standardizzata. La normalizzazione non elimina subito le differenze tra browser, ma fornisce al nucleo del linguaggio un riferimento indipendente da un singolo produttore. ECMAScript 3, pubblicato nel 1999, resta per anni la base del JavaScript ampiamente diffuso.
La retrocompatibilità diventa una regola del Web
La prima guerra dei browser lascia API proprietarie, motori incoerenti e molto codice di adattamento. Stabilisce però anche un vincolo permanente: il Web cerca di non rompere i contenuti esistenti.
typeof null, uguaglianza debole, conversioni implicite e vecchie regole di scope hanno origini diverse, ma una volta che un comportamento viene utilizzato su vasta scala diventa difficile modificarlo in modo incompatibile. JavaScript moderno tende quindi ad aggiungere meccanismi migliori invece di riscrivere il passato.
ECMAScript 4: imparare a evolvere senza rotture
Negli anni Duemila ECMAScript 4 propone una trasformazione molto ambiziosa, con classi più formali, tipi opzionali e numerose nuove funzionalità. I partecipanti non trovano un accordo su complessità, compatibilità e direzione, e il progetto viene abbandonato.
L’esperienza influenza il futuro: JavaScript evolve sempre più attraverso cambiamenti graduali e compatibili. ECMAScript 5 arriva nel 2009 con strict mode e importanti miglioramenti per oggetti e array.
Ajax e jQuery: JavaScript alimenta le applicazioni Web
A metà degli anni Duemila, applicazioni come Gmail e Google Maps dimostrano che una pagina può comunicare con i server in background e aggiornare solo una parte dell’interfaccia. Nel 2005 il termine Ajax rende popolare questo modello.
I siti iniziano a comportarsi come applicazioni. JavaScript passa da validazioni ed effetti alla gestione dello stato e dell’interazione.
Le differenze tra browser restano problematiche. Dal 2006 jQuery offre un’API più uniforme per DOM, eventi e richieste. Il suo enorme successo riflette la frammentazione della piattaforma dell’epoca. Con la successiva convergenza dei browser sugli standard, parte di questo livello di compatibilità diventa meno necessario.
La corsa dei motori JavaScript
Applicazioni più complesse spingono i produttori a investire nelle prestazioni. Nel 2008 Google introduce V8 con Chrome. La competizione con SpiderMonkey, JavaScriptCore e altri motori accelera enormemente JavaScript. La compilazione just-in-time rende praticabili applicazioni browser molto più grandi.
Node.js: uscire dal browser
Nel 2009 Ryan Dahl crea Node.js intorno a V8. JavaScript può ora essere utilizzato comodamente per server e strumenti da riga di comando, con un modello di I/O asincrono adatto al software di rete.
Node.js trasforma l’ecosistema. JavaScript può essere usato su client e server, npm cresce fino a diventare un enorme registro di pacchetti e il linguaggio entra nei sistemi di build, nei test e nell’automazione.
ECMAScript 2015: modernizzare senza ricominciare
ECMAScript 2015 (ES6) introduce let, const, arrow function, moduli, promise, generatori, sintassi delle classi e molte altre funzionalità.
Le novità non sostituiscono il vecchio JavaScript: costruiscono uno strato moderno compatibile con il codice esistente. In seguito ECMAScript adotta un ciclo annuale, con proposte che maturano progressivamente nel processo TC39.
Framework e TypeScript
Con la crescita delle applicazioni, il problema si sposta verso l’organizzazione di grandi interfacce. Backbone, Angular, React, Vue, Svelte e altri strumenti propongono modelli diversi per componenti, stato e rendering. Appartengono all’ecosistema costruito sopra JavaScript, non al nucleo del linguaggio.
Nel 2012 Microsoft presenta TypeScript, che aggiunge soprattutto un sistema di tipi statici e viene trasformato in JavaScript per gli ambienti esistenti. TypeScript non sostituisce quindi JavaScript: dipende da esso.
Perché JavaScript ha vinto
Il vantaggio decisivo di JavaScript non è stato la perfezione, ma la distribuzione. Ogni browser importante includeva un motore JavaScript senza richiedere installazioni aggiuntive.
La disponibilità universale ha creato un circolo virtuoso: più utenti hanno attirato maggiori investimenti in motori, standard, strumenti e librerie. La capacità di evolvere senza abbandonare il vecchio Web ha protetto questo vantaggio.
Il JavaScript del 2026 è quindi una piattaforma collettiva. Brendan Eich ne ha creato il nucleo iniziale, ma il linguaggio moderno è il risultato del lavoro di TC39, team dei motori, produttori di browser, creatori di strumenti e milioni di sviluppatori.
Cronologia
- 1995: Mocha, LiveScript e JavaScript in Netscape.
- 1996: JScript in Internet Explorer; inizia la standardizzazione Ecma.
- 1997: prima edizione di ECMA-262.
- 1999: ECMAScript 3.
- 2005: Ajax rende popolari le applicazioni Web asincrone.
- 2006: appare jQuery.
- 2008: Chrome e V8 intensificano la competizione sulle prestazioni.
- 2009: ECMAScript 5 e Node.js.
- 2012: viene presentato TypeScript.
- 2015: ECMAScript 2015 modernizza profondamente il linguaggio.
- Dal 2016: ECMAScript evolve con cadenza annuale.
Domande frequenti
JavaScript è stato davvero creato in dieci giorni?
Brendan Eich realizzò il primo prototipo in circa dieci giorni nel maggio 1995. Il linguaggio pubblicato e standardizzato continuò poi a evolversi per tre decenni.
JavaScript e Java sono collegati?
Hanno nomi simili e alcuni elementi sintattici comuni, ma sono linguaggi distinti. L’associazione del nome JavaScript con Java fu soprattutto commerciale.
Qual è la differenza tra JavaScript ed ECMAScript?
ECMAScript è la specifica standard del nucleo del linguaggio. JavaScript è il nome storico e comune delle sue implementazioni.
Il DOM fa parte di JavaScript?
No. Il DOM è un’API fornita dall’ambiente Web. Altri ambienti JavaScript, come Node.js, forniscono API differenti.
Perché JavaScript conserva vecchi comportamenti?
Perché modificarli in modo incompatibile potrebbe rompere enormi quantità di pagine esistenti. La retrocompatibilità è un vincolo centrale della sua evoluzione.
