Escaping the Quicksand: A Call to Arms

Imagine um mundo onde a maquinaria invisível da vida moderna — nossos bancos, hospitais, redes elétricas e redes de comunicação — é construída sobre uma base que está lentamente afundando. Esta é a realidade enfrentada pela indústria da computação hoje. Durante décadas, a forma padrão de construir software tem sido escrever uma descrição aproximada do que um programa deve fazer, depois escrever o código e, finalmente, testá-lo executando-o com várias entradas para ver se ele falha. Este método, conhecido como desenvolvimento de teste-e-depuração (test-and-debug), permitiu que a tecnologia florescesse, mas deixa os sistemas repletos de falhas ocultas. Como as descrições originais são frequentemente vagas e escritas em linguagem comum, elas não podem ser verificadas por máquinas e, como o teste só pode cobrir uma fração ínfima dos bilhões de maneiras possíveis pelas quais um programa pode se comportar, muitos erros passam despercebidos. À medida que a inteligência artificial começa a escrever mais código, este ciclo ameaça acelerar, criando novos sistemas vastos que são ainda mais complexos e frágeis do que antes, construídos sobre um "areia movediça" de escolhas de design de décadas atrás, quando ataques cibernéticos eram raros e o poder computacional era escasso.

Dois pesquisadores, Peter Sewell, da Universidade de Cambridge, e Jean Pichon-Pharabod, da Universidade de Aarhus, argumentam que a indústria está presa em um ciclo perigoso há setenta e cinco anos. Eles observam que, embora tenhamos nos tornado incrivelmente habilidosos em escrever código, negligenciamos as definições precisas do que esse código deve alcançar. A abordagem atual depende de especificações em prosa — parágrafos de texto que descrevem o comportamento de um sistema. Embora sejam fáceis de ler para humanos, são inerentemente ambíguas e incompletas. Um leitor humano pode interpretar uma frase de uma maneira, enquanto uma máquina ou um humano diferente a interpreta de outra. Como essas descrições não podem ser testadas diretamente por um computador, os desenvolvedores são forçados a adivinhar qual deve ser o comportamento correto, muitas vezes recorrendo a verificações simples como "o programa trava?" em vez de verificar se o programa está realmente fazendo o que deveria. Essa lacuna entre a intenção escrita e o código real cria uma enorme quantidade de dívida técnica, um custo oculto que se manifesta como vulnerabilidades de segurança e falhas de sistema que podem ser exploradas por atacantes.

Os autores sugerem que a solução não é abandonar os testes, mas mudar como usamos as especificações. Em vez de escrever parágrafos vagos, eles propõem a criação de especificações que sejam executáveis, o que significa que são escritas em uma forma que um computador possa executar. Imagine uma especificação que atue como um árbitro ao vivo durante o processo de desenvolvimento. À medida que o código é escrito ou gerado, essa especificação executável roda ao lado dele, verificando instantaneamente se o comportamento do código corresponde às regras pretendidas. Se o código tentar fazer algo que a especificação proíbe, o sistema sinaliza imediatamente. Isso cria um ciclo de feedback muito mais estreito, permitindo que os desenvolvedores capturem erros conforme eles acontecem, em vez de semanas depois. Essa abordagem pode ser aplicada de diferentes maneiras: pode-se começar com o código e escrever uma especificação para corresponder a ele, começar com uma especificação e gerar o código que se ajuste a ela, ou construir ambos juntos. A chave é que a especificação não é apenas um documento para ser lido, mas uma ferramenta para ser usada.

No entanto, os pesquisadores reconhecem que esta não é uma mudança simples de se realizar. Para fazer isso funcionar em escala massiva, a comunidade de computação precisa construir uma nova camada de infraestrutura. Atualmente, não existem definições universalmente aceitas e legíveis por máquina para o comportamento de muitas tecnologias fundamentais, como a linguagem de programação C, a linguagem Rust ou as instruções que rodam em chips de computador. Embora alguns pesquisadores tenham criado com sucesso essas definições para partes específicas do sistema, não existe um framework unificado que as conecte. Os autores apontam que construir essa infraestrutura é um desafio de escala e cooperação. Requer um esforço massivo e coordenado de universidades, governos e empresas de tecnologia para criar, validar e manter essas definições precisas para toda a pilha de tecnologia de computação, desde o hardware até os serviços de nuvem.

O artigo também aborda o papel da inteligência artificial. Os autores alertam que simplesmente usar a IA para escrever mais código sem esses melhores ciclos de feedback apenas tornará o problema pior. A IA pode gerar código mais rápido que os humanos, mas se esse código for construído sobre bases instáveis e testado apenas com os métodos antigos e ineficazes, ela simplesmente criará sistemas maiores com mais erros ocultos. Por outro lado, se a IA for usada para ajudar a gerar e verificar essas especificações executáveis, ela pode se tornar uma ferramenta poderosa para melhorar a qualidade do software. Os autores vislumbram um futuro onde a IA ajude a criar especificações rigorosas, e onde essas especificações sejam usadas para verificar que tanto o código escrito por humanos quanto o gerado por IA estão corretos. Isso permitiria um aumento gradual na confiança, partindo de testes simples para provas matemáticas mais complexas de correção, tudo isso sem exigir que cada desenvolvedor se torne um matemático.

Apesar do caminho claro a seguir, os autores argumentam que a indústria tem sido contida por um descompasso de incentivos. As empresas de tecnologia são motivadas a lançar produtos rapidamente para capturar participação de mercado, enquanto os riscos de falha recaem amplamente sobre a sociedade e os usuários finais. Construir a infraestrutura robusta necessária para prevenir essas falhas é caro e demorado, e nenhuma empresa sozinha quer arcar com o custo total de corrigir problemas que afetam a todos. Os pesquisadores pedem um esforço coletivo, semelhante aos grandes projetos vistos na física ou na biologia, para financiar e coordenar a criação dessa infraestrutura semântica. Eles sugerem que, embora o custo seja significativo, é uma fração minúscula dos gastos atuais com inteligência artificial e é essencial para garantir o futuro da computação. Sem essa mudança, a indústria permanece presa em um ciclo de construção de sistemas cada vez mais complexos sobre bases que são fracas demais para suportá-los, deixando a sociedade vulnerável a riscos constantes.

Os autores concluem que as ferramentas e métodos para resolver este problema já existem. Pesquisadores demonstraram com sucesso como definir o comportamento de sistemas complexos e verificá-los com alta confiança. O que falta é a vontade de trazer esses métodos para a prática cotidiana e construir a infraestrutura compartilhada que os torna acessíveis a todos. O artigo serve como um chamado à ação para a comunidade de pesquisa, líderes da indústria e agências de fomento para colaborarem nesta tarefa. Ao se afastar de descrições vagas e caminhar em direção a especificações precisas e executáveis, o mundo da computação pode escapar da areia movediça da dívida técnica e construir um futuro que não seja apenas mais inovador, mas também fundamentalmente mais seguro e confiável.