Oferecido por
Muitos projetos de software surgem porque – em algum lugar por aí – um programador tinha um problema pessoal para resolver.
Foi mais ou menos isso que aconteceu com Graydon Hoare. Em 2006, Hoare era um programador de computadores de 29 anos trabalhando para a Mozilla, a empresa de navegadores de código aberto. Ao voltar para casa, um apartamento em Vancouver, ele descobriu que o elevador não estava funcionando; seu software havia travado. E não era a primeira vez que isso acontecia.
Hoare morava no 21º andar e, enquanto subia as escadas, se irritou. “É ridículo”, pensou ele, “que nós, da computação, não tenhamos conseguido sequer fazer um elevador que funcione sem travar!” Muitas dessas panes, Hoare sabia, se devem a como o programa faz uso da memória. O software em dispositivos como elevadores é frequentemente escrito em linguagens como C++ ou C, que são famosas por permitir aos programadores escrever códigos que rodam muito rápido e são bastante compactos. O problema é que essas linguagens também tornam fácil a introdução acidental de bugs de memória, erros que causam panes. A Microsoft estima que 70% das vulnerabilidades em seu código se devem a erros de memória em códigos escritos nessas linguagens.
A maioria de nós, se tivéssemos que nos arrastar escada acima por 21 andares, ficaríamos irritados e depois deixaríamos para lá. Mas Hoare decidiu fazer algo a respeito. Ele abriu seu notebook e começou a projetar uma nova linguagem de computador, uma que, esperava ele, tornasse possível escrever códigos pequenos e rápidos sem bugs de memória. Ele a chamou de Rust, em homenagem a um grupo de fungos notavelmente resistentes que são, segundo ele, “superprojetados para sobrevivência”.
Dezessete anos depois, Rust se tornou uma das novas linguagens mais famosas do planeta, talvez a mais famosa. Existem 2.8 milhões de programadores escrevendo em Rust e companhias como Microsoft e Amazon a consideram fundamental para seu futuro. A plataforma de chat Discord usou Rust para acelerar seu sistema, o Dropbox usa para sincronizar arquivos e a Cloudfare usa para processar mais de 20% de todo o tráfego da internet.
Quando o Stack Overflow, fórum de discussão para programadores, conduz sua pesquisa anual com desenvolvedores de todo o mundo, Rust vem sendo eleita como a linguagem de programação mais “amada” por sete anos consecutivos. Até o governo dos Estados Unidos vem promovendo avidamente softwares em Rust como meio de tornar seus processos mais seguros. A linguagem se tornou, como muitos projetos de código aberto de sucesso, uma obra coletiva: existem hoje centenas de colaboradores fervorosos, muitos dos quais são voluntários. Hoare se afastou do projeto em 2013, feliz em deixá-lo nas mãos desses outros engenheiros, incluindo uma equipe principal da Mozilla.
Não é incomum que alguém crie uma nova linguagem de programação. Muitos programadores criam pequenas linguagens como projetos paralelos o tempo todo. Mas é extremamente raro que uma se consolide e se torne parte do panteão das linguagens mais conhecidas, ao lado, digamos, de JavaScript, Python ou Java. Como Rust conseguiu?
Para ter uma ideia do que torna Rust tão útil, vale a pena dar uma olhada embaixo do capô, em como linguagens de programação lidam com a memória do computador.
Poderíamos, muito grosseiramente, pensar na memória dinâmica do computador como um quadro de giz. Quando um software é executado, ele constantemente escreve pequenas quantidades de dados no quadro, monitorando suas posições e apagando o que não é mais necessário. Contudo, diferentes linguagens de programação fazem isso de maneiras diferentes. Uma linguagem mais antiga, como C ou C++, é projetada para dar ao programador muito poder sobre como e quando o software usa o quadro. Esse poder é útil: com tanto controle sobre a memória dinâmica, um programador pode fazer com que o software rode bem rápido. É por isso que C e C++ são usadas com tanta frequência para escrever códigos “bare metal”, o tipo que interage diretamente com o hardware. Máquinas que não tem sistemas operacionais como Windows ou Linux, incluindo desde máquinas de diálise a caixas registradoras, executam esse tipo de código. (que também é usado para computação mais avançada: em determinado ponto um sistema operacional precisa se comunicar com o hardware. Os kernels do Windows, do Linux e do MacOS são significativamente escritos em C.)
“É agradável escrever em Rust, o que talvez seja estranho de dizer, mas é só que a linguagem é fantástica. É divertida. Você se sente um mágico, e isso nunca acontece com outras linguagens.”
Parker Timmerman, engenheiro de software.
Mas, por mais rápidas que sejam, linguagens como C e C++ têm uma desvantagem. Elas exigem que o programador acompanhe cuidadosamente em que memória se está escrevendo e quando apagá-la. E se acidentalmente esquecemos de apagar algo? É possível que causemos uma pane: o software pode, mais tarde, tentar usar um espaço na memória que acha estar vazio quando, na verdade, há algo lá. Ou podemos estar deixando uma entrada discreta para um intruso digital. Um hacker pode descobrir que um programa não está limpando a sua memória corretamente – informações que deveriam ter sido apagadas (senhas, informações financeiras) continuam salvas – e se aproveitar desses dados. À medida que um código em C ou C++ vai crescendo, é possível que até o mais cuidadoso dos programadores cometa vários erros de memória, enchendo o software de bugs.
“Em C ou C++ você tem sempre esse medo de que o seu código vá explodir aleatoriamente”, diz Mara Bos, cofundadora da empresa de drones Fusion Engineering e chefe da equipe da biblioteca de Rust.
Nos anos 90, um novo conjunto de linguagens, como Java, JavaScript e Python, se tornou popular. Essas adotavam uma abordagem bem diferente. Para aliviar o estresse dos programadores, elas gerenciavam automaticamente a memória usando “coletores de lixo”, componentes que periodicamente limpavam a memória enquanto um software era executado. Pronto: era possível escrever códigos sem erros de memória. Mas o lado negativo era a parda do controle refinado. Os programas têm um desempenho mais lento (porque a coleta de lixo toma um tempo crucial de processamento). E softwares escritos nessas linguagens usavam muito mais memória. Assim, o mundo da programação se dividiu, grosso modo, em duas tribos. Se um software precisava rodar rapidamente ou no pequeno chip de um dispositivo integrado, era mais provável que fosse escrito em C ou C++. Se era um aplicativo web ou mobile, parcela cada vez maior do mundo dos códigos, então se usava uma linguagem mais nova, com coleta de lixo.
Com Rust, Hoare objetivava criar uma linguagem que fosse um meio-termo entre essas duas abordagens. Ela não exigiria que programadores determinassem manualmente onde na memória colocar os dados; Rust faria isso. No entanto, também imporia muitas regras estritas de como dados podem ser usados e copiados dentro de um programa. Seria necessário aprender essas regras, que são muito mais onerosas que as de Python ou JavaScript. O código seria mais difícil de escrever, porém seguro em termos de memória – não precisaríamos ter medo de acidentalmente inserir um bug fatal de memória. Fundamentalmente, Rust também ofereceria “segurança de concorrência”. Programas modernos fazem várias coisas simultaneamente – em outras palavras, concorrentemente – e, às vezes, threads de um código tentam modificar o mesmo pedaço da memória praticamente ao mesmo tempo. O sistema de memória da Rust evita que isso aconteça.
Quando abriu seu notebook para começar a projetar Rust, Hoare já contava com 10 anos como veterano em software, trabalhando em tempo integral na Mozilla. Rust era só um projeto paralelo, a princípio. Hoare insistiu nisso por alguns anos e, quando mostrou a outros programadores, as reações foram mistas. “Algum entusiasmo”, disse-me ele por e-mail. “muito revirar de olhos e ‘isso nunca vai funcionar’ ou ‘isso nunca vai ser utilizável’”.
Os executivos da Mozilla, contudo, ficaram intrigados. Rust, eles perceberam, poderia ajudar a criar um navegador melhor. Navegadores são softwares notoriamente complexos, com muitas oportunidades para erros de memória perigosos.
Um dos empregados envolvidos foi Patrick Walton, que entrou para a Mozilla após decidir deixar seu doutorado em linguagens de programação. Ele se lembra de Brendan Eich, o inventor do JavaScript, puxando-o para uma reunião na Mozilla: “Ele disse, ‘porque você não entra nessa sala onde vamos discutir decisões de design para Rust?’”. Walton achou que Rust parecia incrível; ele se juntou a Hoare e a um grupo crescente de engenheiros para desenvolver a linguagem. Muitos, como os engenheiros da Mozilla Niko Matsakis e Felix Klock, tinham experiência acadêmica em pesquisas com memória e linguagens de programação.
Em 2009, a Mozilla decidiu patrocinar oficialmente Rust. A linguagem seria de código aberto, de responsabilidade apenas das pessoas que a desenvolveram, mas a Mozilla estava disposta promovê-la pagando engenheiros. O grupo de Rust ocupou uma das salas de conferência da empresa; Dave Herman, cofundador da Mozilla Research, a apelidou de “a caverna dos nerds” e colocou uma placa do lado de fora da porta. Pelos 10 anos seguintes, a Mozilla empregou mais de uma dúzia de engenheiros para trabalhar com Rust em tempo integral, estima Hoare.
“Todo mundo realmente sentia que estava trabalhando em algo que podia ser muito grande” se recorda Walton. Essa animação se propagou para fora do prédio da Mozilla também. No início dos anos de 2010, Rust já atraía voluntários ao redor do mundo, de todos os nichos da área de tecnologia. Alguns trabalhavam para grandes empresas de tecnologia. Um dos principais colaboradores foi um estudante de ensino médio da Alemanha. Na conferência da Mozilla em British Columbia, em 2010, Eich se levantou e disse que haveria uma palestra sobre uma linguagem experimental e “não vá a não ser que seja um verdadeiro nerd das linguagens de programação” lembra Walton. “E claro que a sala encheu.”
Pelos primeiros anos daquela década, engenheiros da Mozilla e voluntários do mundo todo gradualmente aprimoraram o núcleo da Rust, a forma como ela é projetada para gerenciar memória. Eles criaram um sistema de “propriedade” para que cada dado possa ser referenciado por apenas uma variável; isso reduz muito as chances de problemas de memória. O compilador de Rust, que pega as linhas de código escritas e as transforma no software que é executado pelo computador, aplica rigorosamente as regras de propriedade. Se um programador viola as regras, o compilador se recusa a compilar o código e transformá-lo em um programa executável.
Muitos dos truques empregados pela Rust não são novidade: “Eles são, em sua maioria, pesquisas de décadas” diz Manish Goregaokar, que lidera o time de ferramentas de desenvolvedor de Rust e que trabalhou para a Mozilla nesses primeiros anos. Mas os engenheiros de Rust eram especialistas em encontrar esses conceitos mais aprimorados e transformá-los em recursos práticos utilizáveis.
À medida que a equipe aperfeiçoava esses sistemas de gerenciamento de memória, Rust tinha cada vez menos necessidade de seu próprio coletor de lixo e, em 2013, a equipe o removeu. Programas escritos em Rust passaram a rodar mais rápido, sem paradas periódicas para que o computador realize uma limpeza. Alguns engenheiros de software, ressalta Hoare, podem argumentar que Rust ainda possui elementos que se assemelham à coleta de lixo, como seu sistema de “contagem de referência”, parte do modo pelo qual sua mecânica de propriedade de memória funciona. Mas, de qualquer forma, a performance da Rust se tornou excepcionalmente eficiente. Ela se aproximou de C e C++, mantendo-se segura em termos de memória.
A remoção da coleta de lixo “levou a uma linguagem mais enxuta e melhor”, disse Steve Klabnik, programador que se envolveu com Rust em 2012 e escreveu sua documentação pelos 10 anos seguintes.
Ao longo do caminho, a comunidade de Rust foi também criando uma cultura que veio a ser conhecida por ser incomumente amigável e aberta à recém-chegados. “Ninguém nunca te chama de novato”, diz Nell Shamrell-Harrington, uma engenheira-chefe da Microsoft que, na época, trabalhou com Rust na Mozilla. “Nenhuma pergunta é considerada idiota”.
Parte disso, diz ela, é porque Hoare havia postado, logo no começo, um “código de conduta” proibindo assédio, ao qual todos que contribuíam com Rust tinham que aderir. A comunidade abraçou a ideia e isso, dizem seus membros de longa data, atraiu programadores queer e trans a se envolver com Rust em proporções maiores do que as encontradas em qualquer outra linguagem. Até as mensagens de erro que o compilador cria quando um programador se equivoca são especialmente atenciosas; elas descrevem o erro e educadamente sugerem como corrigi-lo.
“Os compiladores de C e C++, quando cometo erros, me fazem sentir uma pessoa horrível”, diz Shamrell-Harrington rindo. “O compilador de Rust é mais como se estivesse te orientando a escrever um código superseguro.”
Em 2015 a equipe estava obcecada por finalmente lançar uma versão “estável” de Rust, confiável o suficiente para que empresas a usassem na criação de softwares para clientes reais. Fazia seis anos desde que a Mozilla havia adotado Rust e, nesse longo período de desenvolvimento, os programadores se mostravam ansiosos para experimentar versões demo, ainda que instáveis. “O compilador quebrava o tempo todo”, conta Goregaokar. Era a hora de apresentar a “1.0” para o mundo.
Walton se lembra de passar horas na frente de seu notebook. Klabnik “escreveu umas 45 páginas de documentação nas últimas duas semanas”, ele recorda. Em 15 de Maio de 2015, o grupo finalmente lançou a primeira versão, e grupos de nerds de Rust se reuniram para celebrar ao redor do mundo.
O investimento da Mozilla começou a dar frutos. Em 2016, um grupo da Mozilla lançou o Servo, um novo navegador criado usando Rust. No ano seguinte, outro grupo usou Rust para reescrever a parte do Firefox que renderiza CSS, uma linguagem usada para especificar a aparência de websites. A mudança deu ao navegador uma melhora de desempenho perceptível. A companhia também usou Rust para reescrever o código que lidava com arquivos multimídia MP4 e corria risco de admitir códigos inseguros e maliciosos.
Os desenvolvedores de Rust – “Rustáceos”, como começaram a se chamar – logo ouviram falar de outras empresas que estavam experimentando sua nova linguagem.
Programadores da Samsung disseram a Klock, que estava trabalhando no escritório da Mozilla na França, que haviam começado a usar Rust. O Facebook (mais tarde conhecido como Meta) usou Rust para reprojetar o software que seus programadores usam para administrar seu código fonte interno. “É difícil exagerar o quão importante ela [Rust] é” diz Walton, que trabalha para a Meta atualmente.
Logo Rust começou a aparecer no núcleo de alguns softwares de notória importância. Em 2020, o Dropbox revelou uma nova versão da sua “sync engine”, software responsável por sincronizar arquivos entre computadores de usuários e o armazenamento em nuvem do Dropbox, que engenheiros haviam reescrito em Rust. Originalmente, o sistema havia sido criado em Python, mas agora estava lidando com bilhões de arquivos (e trilhões de arquivos sincronizados online). Rust tornou mais fácil, e até aprazível, lidar como toda essa complexidade, diz Parker Timmerman, engenheiro de software que deixou o Dropbox recentemente.
“É agradável escrever em Rust, o que talvez seja estranho de dizer, mas é só que a linguagem é fantástica. É divertida. Você se sente um mágico, e isso nunca acontece com outras linguagens”, diz ele. “Nós realmente fizemos uma grande aposta – é uma tecnologia nova.”
Algumas empresas estavam descobrindo que Rust diminuía seu pavor de erros de memória; Mara Bos usou Rust para reescrever completamente o software de controle de drones de sua companhia, originalmente escrito em C++.
Outras estavam descobrindo as alegrias de abandonar a coleta de lixo. No Discord, engenheiros vinham há muito insatisfeitos com o fato de que o coletor de lixo em Go, linguagem usada por eles para construir partes críticas do software, deixava as coisas mais lentas. Seu software em Go realizava o procedimento aproximadamente a cada dois minutos, embora os engenheiros do Discord tivessem escrito o código de forma tão cuidadosa que não havia lixo a ser coletado. Em 2020, eles reescreveram esse sistema em Rust e descobriram que agora ele roda 10 vezes mais rápido.
Até mesmo os executivos e engenheiros da Amazon Web Services, plataforma de computação em nuvem da gigante da tecnologia, vêm se convencendo de que Rust poderia ajudá-los a escrever códigos mais seguros e rápidos. “Rust está posicionada de forma única para proporcionar vantagens que não consigo obter de outras linguagens. Ela te dá múltiplos superpoderes em uma única linguagem” diz Shane Miller, que criou o time de Rust da AWS antes de deixar a empresa, no ano passado.
Talvez o mais importante para a gigante da computação em nuvem seja o estudo que descobriu que códigos baseados em Rust rodam de forma tão eficiente que consomem metade da eletricidade que sistemas semelhantes escritos em Java, linguagem normalmente usada pela AWS. “Eu poderia, então, criar um centro de processamento de dados que executa 2X a quantidade de trabalho que eu tenho hoje”, diz Miller. Ou fazer o mesmo trabalho em um centro com metade do tamanho, o que permitiria construí-lo dentro de uma cidade, em vez de instalá-lo em regiões periféricas.
Alguns colaboradores de longa data ficaram um pouco nervosos com o sucesso de Rust. À medida que gigantes da tecnologia adotam a linguagem, vão também ganhado influência sobre ela. Eles têm dinheiro para pagar engenheiros para trabalhar em tempo integral desenvolvendo em Rust; diversos líderes das equipes de Rust, por exemplo, são empregados da Amazon e da Microsoft. Outros colaboradores importantes só podem trabalhar com Rust em seu tempo livre; Bos, por exemplo, faz alguns trabalhos em Rust para a Huawei, além de dirigir sua startup de drones, mas sua função como chefe da equipe da biblioteca de Rust não é remunerada.
É uma dinâmica comum com projetos de código aberto, diz Bos: grandes companhias podem pagar para participar mais e direcionar o projeto para resolver problemas que importam para elas, mas talvez não para pequenas empresas. “Isso dá a elas alguma influência”, afirma. Mas, até o momento, nenhuma dessas empresas fez qualquer coisa para causar alarme. Klabnik, que manifestou preocupação quanto ao envolvimento da Amazon com Rust (e que deixou o projeto ano passado), concorda. “Se eu me preocupo? Sim. Se eu acho que é particularmente ruim ou uma posição pior que muitas outras? Não.”
Em 2021, grandes empresas da área de tecnologia criaram uma organização sem fins lucrativos chamada Rust Foundation, para dar apoio a programadores voluntários. Liderada pelos primeiros dois anos por Miller, ela oferece US$ 20.000 em bolsas para programadores que queiram trabalhar com algum dos principais recursos de Rust, bem como subvenções para colaboradores passando por necessidades financeiras de curto prazo. Ela também financia os servidores que hospedam o código de Rust e paga uma empresa de tecnologia para garantir que eles estejam em funcionamento 24 horas por dia. No clássico estilo código aberto, esse trabalho era anteriormente realizado por “dois voluntários que ficavam de sobreaviso praticamente 50% de suas vidas”, diz Miller. “Um deles era um estudante na Itália.”
A linguagem cresceu de forma improvável e rápida. Se Rust nasceu em 2006, hoje está saindo da adolescência e chegando à maturidade. Empresas automobilísticas estão adotando Rust para criar código crucial ao funcionamento de seus carros; companhias do setor aeroespacial também estão implementando. “Vai ser usado em todo lugar” prevê Timmerman, do Dropbox. Executivos da Microsoft até mesmo sugeriram publicamente o que muitas outras empresas de tecnologia provavelmente estão ponderando a portas fechadas: que usará cada vez mais Rust para códigos novos – e cada vez menos C e C++. No final das contas, talvez nunca.
Todos esses códigos antigos em C e C++ que já estão por aí não irão desaparecer; continuarão em uso, provavelmente por muitas décadas. Mas se Rust se tornar a forma comum de escrever códigos que precisem ser rápidos e bare metal, é possível que comecemos a notar – muito gradualmente, ano a ano – nosso panorama em softwares se tornando cada vez mais confiável; menos propenso a falhas, menos inseguro.
Isso impressionaria Hoare mais do que qualquer outra pessoa. “A maioria das linguagens”. diz ele “simplesmente não vão pra frente.”
Clive Thompson é jornalista de ciência e tecnologia na cidade de Nova York e autor do livro Coders: The Making of a New Tribe and the Remaking of the World (em tradução livre, Programadores: a Criação de uma Nova Tribo e a Recriação do Mundo).
MIT Technology Review
