Hoje, parece uma verdade incontestável da natureza que computadores sejam máquinas destinadas a executar programas. Compramos um pedaço de hardware, instalamos diferentes softwares e, como mágica, a mesma máquina se transforma em um editor de texto, um videogame, um servidor web ou um simulador de dinâmica molecular. O hardware permanece essencialmente o mesmo, o que muda é apenas um arquivo, mas nem sempre foi assim.
O ENIAC, um dos primeiros computadores eletrônicos programáveis de propósito geral, era operado por meio da conexão de cabos e do posicionamento de chaves em imensos painéis. Para alterar o programa, era necessário, literalmente, mudar a configuração física da máquina, um processo exaustivo que podia consumir dias. Naquela época, o algoritmo não era apenas executado pelo hardware, mas estava materializado na topologia momentânea do próprio equipamento. Programar significava fazer a eletricidade tomar os caminhos certos, em um trabalho que quase se assemelhava a fazer debugging com um alicate.
Curiosamente, a grande ruptura conceitual que mudaria esse cenário havia acontecido anos antes, sem o envolvimento de computador algum. Em 1936, Alan Turing demonstrou que era possível conceber uma única máquina capaz de simular qualquer outra máquina computacional, desde que recebesse tanto os dados quanto uma descrição da máquina a ser simulada. Com isso, a função deixava de ser determinada pela construção física e passava a ser especificada por símbolos.
Embora hoje isso pareça óbvio, na época foi uma revolução. Uma máquina universal significava que não precisaríamos construir um equipamento específico para calcular trajetórias balísticas, outro para fazer contabilidade e um terceiro para jogar xadrez. Bastaria construir uma única máquina suficientemente geral e instruí-la, por meio de um programa, sobre qual papel deveria assumir naquele momento.
Essa intuição matemática foi transformada em engenharia nos anos 1940 com a consolidação da arquitetura de programa armazenado, consagrada como arquitetura de von Neumann. A partir de então, instruções e dados passaram a habitar a mesma memória, representados essencialmente da mesma maneira, e o programa tornou-se dado, dando origem ao software como o conhecemos.
As camadas de abstração que aproximaram humanos das máquinas
Apesar desse avanço, conversar diretamente com a máquina continuava sendo uma atividade desagradavelmente próxima de dialogar com a própria eletrônica e, para contornar essa barreira, surgiram sucessivas camadas de abstração. Primeiro, veio a linguagem de máquina, depois, o assembly, que substituiu números por nomes mais palatáveis.
Em seguida, nasceram o FORTRAN, o C e outras linguagens que permitiram aos programadores falar em variáveis, loops, funções e estruturas de dados, em vez de lidar diretamente com registradores e endereços físicos. Mais tarde, surgiram linguagens ainda mais abstratas, acompanhadas de bibliotecas e frameworks nos quais milhões de instruções de máquina podem ser disparadas por um comando tão inocente quanto “model.fit()”.
Essa escalada mudou drasticamente a escala dos sistemas que conseguimos construir e compreender, pois cada nova camada esconde os detalhes da inferior e oferece ao cérebro humano unidades conceituais maiores. Perdemos algum controle local, é verdade, mas em troca ganhamos um enorme poder de composição, um excelente negócio na maior parte do tempo.
Contudo, apesar de suas diferenças, o binário, o assembly, o C e o Python pertencem à mesma família intelectual, pois, em todos eles, programar significa, em última instância, especificar simbolicamente um procedimento. Existe uma receita composta de operações e regras de controle, e a máquina simplesmente a executa, mantendo viva a linhagem da máquina universal de Turing e do paradigma algorítmico-simbólico.
Quase em paralelo a essa evolução, surgiu uma ideia filosoficamente muito diferente. A partir das décadas de 1940 e 1950, pesquisadores começaram a investigar sistemas inspirados, ainda que de forma muito livre e extremamente conceitual, na organização do cérebro humano. Eram conjuntos de unidades simples conectadas entre si, cujo comportamento global dependia da força dessas conexões.
O perceptron de Rosenblatt foi uma das primeiras manifestações importantes dessa abordagem, que posteriormente ficaria conhecida como conexionismo. A diferença de paradigma era profunda, já que, em vez de ditar à máquina como resolver um problema passo a passo, poderíamos mostrar exemplos do comportamento desejado e ajustar as conexões até que o sistema aprendesse a reproduzi-lo de forma autônoma.
Embora a primeira onda dessa tecnologia tenha terminado mal, com as limitações dos perceptrons simples ficando claras no final dos anos 1960 e o entusiasmo evaporando, o conexionismo ressurgiu nos anos 1980 com métodos eficazes para treinar redes multicamadas por retropropagação. Décadas depois, a abundância de dados, o poder das GPUs e as redes profundas transformariam aquela curiosidade acadêmica em uma robusta infraestrutura industrial.
:quality(85)/8a5613e9-d1bc-421b-b562-f2c0018fb145.png "Editar informações da imagem")
Software 2.0: quando o código passou a ser encontrado
Para ilustrar essa transição, em 2017, Andrej Karpathy propôs uma maneira interessante de enxergar a mudança, chamando o software tradicional de "Software 1.0" e as redes neurais de "Software 2.0". No Software 1.0, um programador escreve o código linha por linha. Já no Software 2.0, ninguém escreve diretamente os milhões ou bilhões de parâmetros que determinam o comportamento da rede. Nós especificamos a arquitetura, os dados, o objetivo e a otimização, enquanto o treinamento se encarrega de procurar os parâmetros ideais.
Trata-se de uma inversão fundamental onde o código executável deixa de ser escrito e passa, em boa medida, a ser encontrado. O conjunto de treinamento passa a atuar como uma especificação, e o otimizador funciona como um compilador, ainda que produza programas que normalmente não conseguimos ler.
Software 3.0: quando a linguagem natural vira programação
Por fim, vieram os Grandes Modelos de Linguagem (LLMs), inaugurando o que Karpathy chamou de "Software 3.0". Enquanto as redes do Software 2.0 eram máquinas treinadas para funções relativamente específicas, como classificar imagens ou reconhecer fala, os LLMs são diferentes. Depois de treinados, eles se tornam máquinas neurais de propósito geral que podem ser reprogramadas em tempo de uso, simplesmente através da linguagem natural.
Após oitenta anos construindo linguagens cada vez mais abstratas para dizer ao computador o que fazer, chegamos a um ponto em que podemos simplesmente descrever o que queremos.
Naturalmente, há uma pegadinha (sempre há). O português ou o inglês não possuem a semântica precisa da linguagem C, e um prompt não é um algoritmo no sentido clássico. Como os LLMs são probabilísticos e aproximados, eles podem interpretar mal nossa intenção com uma desenvoltura que faria um compilador tradicional corar. Dessa forma, por mais que a abstração tenha subido de nível, suas garantias mudaram junto.
A aposta mais radical da história da programação
Ainda assim, o arco histórico é fascinante. Começamos programando computadores movendo chaves e cabos para determinar fisicamente o caminho dos sinais. Depois, representamos programas como símbolos e criamos linguagens cada vez mais abstratas para manipulá-los. Em seguida, aprendemos a produzir programas, ajustando redes a partir de exemplos, até chegarmos ao momento atual, em que programamos essas redes com frases.
Fomos de chaves para opcodes, de opcodes para linguagens, de linguagens para dados, e de dados para a linguagem natural. No fim das contas, a história da programação talvez seja a busca pela resposta a uma pergunta recorrente sobre quanto do mecanismo podemos esconder sem perder a capacidade de dizer à máquina o que queremos, e com os LLMs, estamos fazendo a aposta mais radical até agora.
Confira quais são as 5 principais linguagens de programação no mercado para 2026 e entenda como a lógica de programação se aplica a outras carreiras em tecnologia.
{{WHATSAPP_CHANNEL}}