01
Uma revolução acidental
Em maio de 1995, Brendan Eich escreveu em dez dias o protótipo de uma linguagem que dentro da Netscape chamavam de Mocha. A história é contada tantas vezes que dela sobrou uma única moral: a linguagem foi feita às pressas, e é por isso que typeof null até hoje responde "object" e um array vazio somado a um objeto vazio vira string. A moral está certa, só explica pouco. Dezenas de linguagens foram montadas às pressas nos anos noventa, e quase todas morreram junto com os produtos para os quais foram montadas. O protótipo de Eich teve mais sorte: treze anos depois, equipes inteiras do Google, da Mozilla e da Apple passariam anos construindo compiladores em volta dele. Então, naqueles dez dias de maio, entrou na linguagem algo que não se vê à primeira vista.
Eich foi contratado pela Netscape no começo de 1995 com a promessa de que embutiria Scheme no navegador, e começou a trabalhar no dia três de abril. Scheme nunca chegou ao navegador. Naquelas mesmas semanas a Netscape negociava com a Sun sobre Java, e Marc Andreessen e Bill Joy concluíram que uma segunda linguagem na página só tinha direito de existir no papel de irmão caçula. O caçula devia lembrar o irmão mais velho nas chaves e nos pontos e vírgulas. Parecer com BASIC foi proibido num item à parte, porque BASIC pertencia à Microsoft, e naquele ano a Netscape disputava com a Microsoft a internet inteira. Classes ele também não ganhou: demoram para fazer, e com classes o caçula começaria a competir com o mais velho. Eich fez a sintaxe do jeito que foi encomendada e pôs dentro o que ele mesmo gostava. Funções podiam ser guardadas em variáveis e passadas como qualquer outro valor, ideia tirada de Scheme. Objetos dispensavam classes, ideia tirada de uma linguagem chamada Self.
Em setembro de 1995 a linguagem saiu numa versão de teste do Navigator 2.0 com o nome LiveScript, e em dezembro a Netscape e a Sun a anunciaram num comunicado conjunto já como JavaScript. Segundo Eich, Andreessen vinha conduzindo para esse nome desde o dia em que inventou o provisório «Mocha». O nome garantiu confusão em entrevistas de emprego por uns vinte anos, embora àquela altura as duas linguagens tivessem pouco em comum: chaves, ponto e vírgula e um comunicado à imprensa.
Self foi criada por David Ungar e Randall Smith em 1986 no Xerox PARC e depois desenvolvida em Stanford e na Sun. Ela não tem classes. Um objeto novo se obtém copiando um antigo, e tudo o que o objeto não sabe fazer sozinho ele delega a um pai, para o qual guarda uma referência. Ungar e Smith achavam as classes uma burocracia desnecessária: para que descrever de antemão como será um objeto, se dá para pegar um pronto e ajustar. O programador adora esse tipo de liberdade. Quem precisa executar o programa rápido detesta. Um compilador de C++ conhece a classe do objeto, portanto sabe que o campo x está, digamos, a oito bytes do início, e o lê com uma única instrução de máquina. Um compilador de Self não sabe nada disso, porque cada objeto é organizado como bem entender, e o campo precisa ser procurado pelo nome num dicionário a cada acesso, e, se não estiver lá, no dicionário do pai.
A equipe do Self passou o fim dos anos oitenta vencendo esse problema, e venceu com duas técnicas às quais esta história ainda vai voltar. A primeira foi descrita em 1989 por Craig Chambers, Ungar e Elgin Lee. A própria máquina percebe que muitos objetos têm o mesmo conjunto de campos na mesma ordem e cria em silêncio um mapa comum para eles, onde está anotado em que deslocamento fica cada campo. O programador não sabe nada sobre mapas e não pode se referir a eles. A linguagem aboliu as classes, e sua implementação as reconstrói aos poucos, observando como o programa de fato trata seus objetos. A segunda técnica se chama inline cache, cache embutido. A linha de código onde está escrito, digamos, o.x lembra o mapa do último objeto que passou por ela e o deslocamento onde o campo foi encontrado. Se o próximo objeto chega com o mesmo mapa, não é preciso procurar no dicionário. Em 1991, Urs Hölzle, junto com Chambers e Ungar, ensinou esse cache a lembrar vários mapas de uma vez e percebeu que ele tinha um efeito colateral mais valioso que a função principal. O cache também mantém um diário de quais objetos realmente passam por cada linha do programa, e tudo de que um compilador otimizador precisa é ler esse diário.
Em 1994, Hölzle e Lars Bak, ambos da equipe do Self, fundaram com alguns colegas uma empresa conhecida como Animorphic e construíram sobre essas ideias uma máquina virtual rápida para Strongtalk, um dialeto de Smalltalk. Em 1997 a Sun comprou a Animorphic, e a máquina deles virou a base do HotSpot, sobre o qual o Java roda até hoje.
Do Self, o JavaScript de 1995 tirou as regras do jogo: protótipos, delegação, objetos que mudam de forma em movimento. A técnica que tornava tudo isso rápido ele não tirou. Em dez dias não cabia, e as tarefas do Mocha eram modestas: validar um formulário antes do envio, trocar uma imagem quando o mouse passa por cima. O protótipo de Eich traduzia o programa para bytecode, e o interpretador de bytecode, nas palavras do próprio autor, saiu simples e lento e procurava as propriedades dos objetos pelo nome, como o Self antes da invenção dos mapas. Por treze anos isso bastou.
O Self chegou ao JavaScript uma segunda vez em setembro de 2008, junto com o navegador Chrome. O motor dele, o V8, foi escrito por uma pequena equipe em Aarhus, na Dinamarca, chefiada pelo mesmo Lars Bak, que até então tinha trabalhado nas máquinas virtuais de Self, Smalltalk e Java. Já na primeira documentação, o V8 explicava sua velocidade pelo acesso rápido a propriedades por meio de classes ocultas, pelo código de máquina com caches embutidos e pela coleta de lixo precisa. As classes ocultas do V8 são os mapas do Self com outro nome. A documentação do motor cita o Self explicitamente, e no código-fonte do V8 elas ainda se chamam Map.
A liberdade que a linguagem deu aos programadores em 1995 foi bancada em 2008 com técnica do mesmo laboratório, e quem fez isso foi um dos seus autores. Durante os treze anos entre essas datas, a web considerou o JavaScript uma linguagem para acender botões e, à sua maneira, tinha razão. Enquanto não havia motor rápido no navegador, ninguém em sã consciência escreveria nela um programa com mais de duzentas linhas.
O que essa liberdade significa para o motor se vê em dois trechos curtos. O primeiro poderia ter sido escrito em 1997, quando o JavaScript 1.2 permitiu declarar funções dentro de funções. Antes disso, todas as funções viviam no nível superior do script, e uma linguagem concebida à imagem de Scheme passou dois anos sem closures. No trecho não há let, arrow functions nem classes, porque ainda não tinham sido inventados:
function makeCounter() {
var n = 0;
return {
inc: function () { return ++n; },
get: function () { return n; }
};
}
var c = makeCounter();
c.inc(); c.inc();
c.get(); // 2
c.n; // undefined: n não é acessível de fora
Aqui não há classe, construtor nem a palavra private, mas o objeto tem estado privado, e só se chega a ele pelas duas funções entregues. As duas capturaram a mesma variável n, e o coletor de lixo não vai tocá-la enquanto pelo menos uma das funções estiver viva, embora makeCounter tenha terminado há muito tempo. Campos privados com # só entraram no padrão em 2022, e durante um quarto de século antes disso os dados em JavaScript eram escondidos justamente assim, com closures. Do mesmo mecanismo cresceriam depois os módulos, os tratadores de eventos e toda a assincronia de que trata a terceira parte deste livro.
No segundo trecho o programador nem tem o que olhar:
const a = { x: 1, y: 2 };
const b = { y: 2, x: 1 };
Para uma pessoa, a e b são iguais: os mesmos campos, os mesmos valores. Para o V8 são objetos de classes ocultas diferentes, porque os campos apareceram em ordem diferente, e uma função acostumada ao primeiro vai tropeçar no segundo. Quanto isso dói dá para medir. No diretório experiments/01-hidden-classes há um script que lê o campo x um milhão de vezes no mesmo laço e muda só o número de objetos de formas diferentes que passam por essa linha. Todos os objetos são pequenos, dois campos cada, para que o tamanho não confunda o resultado. No Node 24 e num notebook com Apple M4 Max, uma passada leva cerca de 1,1 ms quando a forma é uma só. Com quatro formas, cerca de 1,4 ms, e o cache ainda dá conta. Com trinta e duas, cerca de 3,3 ms: o V8 para de lembrar as formas uma a uma e procura o campo por um caminho mais geral e mais lento. Três vezes mais lento do nada, embora o programador só tenha mudado a ordem em que os objetos ganharam seus campos.
A primeira versão desse experimento me mostrou uma diferença de vinte vezes, e por pouco não escrevi que a culpa era do cache. A culpa era de outra coisa. Quando um objeto ganha o vigésimo campo por nomes calculados como o[’p’ + j], o V8 desiste da classe oculta para ele e guarda os campos num dicionário comum, como o Self antes dos mapas. O mesmo laço sobre esses objetos leva 35–42 ms, mais de trinta vezes mais que sobre os pequenos. Já o JavaScriptCore, o motor da Apple embutido no macOS, executa o mesmo código em 1,3 ms, porque não faz isso. O quanto os motores resolvem os mesmos problemas de formas diferentes é assunto do sexto capítulo.
Se você rodar o mesmo script com a flag –trace-deopt, o próprio motor conta o que aconteceu quando uma função compilada para uma forma recebeu outra:
[bailout (kind: deopt-eager, reason: wrong map): begin.
deoptimizing ... <JSFunction getX ...>, <Code MAGLEV> ...]
wrong map, ou seja, «mapa errado», em língua de gente quer dizer que a aposta não deu certo. O motor olhou para o programa e decidiu que por esta linha sempre passam objetos de uma única forma. Compilou para essa decisão um código de máquina com uma verificação na entrada. A verificação falhou, e o código foi jogado fora na hora. Isso se chama desotimização. O programa não percebeu nada e devolveu a resposta certa, só um pouco mais tarde. A segunda parte do livro é inteira sobre esse ciclo: observar, apostar, verificar, voltar atrás. É uma das técnicas mais produtivas da história das linguagens dinâmicas, e na última parte vou tentar mostrar que, pelo mesmo esquema, hoje se constroem sistemas aos quais se confiam coisas bem mais sérias do que a escolha de instruções de máquina.
A primeira edição da especificação ECMA-262 saiu em junho de 1997, quando a Netscape e a Microsoft já tinham divergido tanto nas implementações que foi preciso um árbitro. A especificação não diz uma palavra sobre o DOM, sobre setTimeout ou sobre a rede. Ela descreve valores, objetos, funções, a ordem de busca de propriedades pela cadeia de protótipos e a ordem de avaliação das expressões, e todo o resto é trazido à linguagem pela casa onde ela mora. O navegador traz o documento, os timers e o event loop descrito no padrão HTML. O Node, em 2009, traria arquivos, sockets e seu próprio event loop sobre a libuv. Uma linguagem sem entrada e saída próprias acabou sendo um inquilino conveniente, que se podia instalar em qualquer lugar. Ryan Dahl, que a instalou no servidor, explicou mais tarde a escolha assim. JavaScript é single-thread, os programadores de navegador estavam havia muito acostumados a requisições não bloqueantes via AJAX, e os projetos de JavaScript no servidor daquela época bloqueavam a thread a cada acesso ao disco ou à rede, e numa linguagem sem threads um servidor assim simplesmente parava de responder a todos os outros enquanto durasse cada acesso. Quando a terceira parte chegar ao Meteor e às suas fibers, vai ficar claro que a maior parte dos problemas dali nasceu nessa fronteira entre a linguagem e a casa.
Pegue a expressão mais sem graça da linguagem, o.x. Se o objeto tem um campo x, quem decide é o autor do programa, e se ele esqueceu de criá-lo, recebe undefined sem nenhum aviso. Onde procurar o campo, primeiro no próprio objeto e depois pela cadeia de protótipos até a cadeia acabar, está escrito na especificação. Todo o resto o motor decide sozinho e sem perguntar a ninguém: onde o campo fica na memória, que código de máquina vai lê-lo, quantas vezes verificar a forma do objeto. E ainda revê essas decisões em movimento. Já quando o objeto morre o autor não decide de jeito nenhum; desde o primeiro dia isso é tarefa do coletor de lixo.
Uma análise assim vai fechar cada capítulo. Eu a chamo de fronteira de responsabilidade: de um lado fica o que o programador precisa dizer ele mesmo, do outro, o que a máquina vai deduzir por ele sem quebrar o que foi prometido. Ainda é cedo para chamar isso de teoria; é uma ferramenta de trabalho, e no último capítulo vou examinar à parte onde ela ajuda e onde começa a forçar os fatos para caberem. Uma coisa já dá para ver. Quando a fronteira se desloca para o lado do motor, a responsabilidade passa para quem a verifica. Uma aposta perdida do compilador otimizador custa tempo e nunca custa correção, porque a desotimização devolve o programa ao comportamento que a especificação prescreve, e é por isso que se pode deixar o motor apostar o quanto quiser. Mais adiante no livro vão aparecer executores para os quais uma aposta perdida custa correção. Eles não têm essa rede de segurança, e ela precisa ser construída em volta deles à mão.