Summary
Highlights
O vídeo inicia alertando sobre uma crise sem precedentes na engenharia de software, onde programadores estão perdendo a capacidade de raciocinar e projetar soluções sólidas. A inteligência artificial, que prometia produtividade, trouxe efeitos colaterais, levando a uma regressão disfarçada de produtividade. Metodologias ágeis, originalmente criadas para dar leveza, foram corrompidas e transformadas em ferramentas de microgerenciamento. A cultura dominante é a 'entrega a qualquer custo', resultando em códigos porcos, sistemas frágeis e vulneráveis. O autor afirma que essa doença não é nova, mas um monstro desenterrado que a comunidade técnica lutou para vencer no passado.
No final da década de 60, os computadores eram enormes e o desenvolvimento de software era manual e propenso a erros. Em 1968, na Alemanha, foi reconhecida a 'crise do software', onde projetos atrasavam, excediam orçamentos e falhavam sem explicação. O código era caótico, sem organização ou padrões, com a mentalidade de 'se funcionou, deixa assim'. A manutenção era um pesadelo e não existiam testes, versionamento ou controle. Desse cenário caótico, surgiu a necessidade de criar métodos, princípios e estruturas formais para lidar com a complexidade e projetar software de verdade.
Na década de 70, a programação começou a ser tratada como uma disciplina estruturada. Em 1970, Edger Dijkstra publicou um artigo sobre programação estruturada, baseada em sequência, condição e repetição, para criar um fluxo de programa previsível e seguro. Em 1972, David Parnas introduziu o encapsulamento de decisões, defendendo interfaces limpas e protegidas, base para a orientação a objetos. Linguagens como Pascal surgiram, incentivando a modularização e legibilidade. Apesar de a indústria ainda usar linguagens mais antigas, as sementes para a transformação da engenharia de software foram plantadas.
A década de 80 marcou a ascensão dos computadores pessoais e a formalização da engenharia de software como disciplina. A programação orientada a objetos (POO), que já existia, começou a se popularizar com C++ e Objective C. A POO propunha quebrar o software em partes menores, reutilizáveis e isoladas, cada uma com responsabilidade única, mudando a mentalidade do programador de executor para arquiteto de soluções. Surgiram os primeiros embriões do pensamento SOLID e a documentação de boas práticas. Muitos consideravam isso uma 'frescura', mas a sustentabilidade dos sistemas estava em jogo, pois sistemas mal projetados não escalam nem evoluem.
A década de 90 consolidou a confiança técnica, com a POO e a ideia de separar responsabilidades já sendo amplamente aceitas. O livro 'Design Patterns' (1994) catalogou 23 padrões de projeto, criando um vocabulário comum para a comunidade. O lançamento do Java em 1995 popularizou ainda mais a POO, com sua promessa de 'escreva uma vez e rode em qualquer lugar'. A orientação a objetos tornou-se o padrão do mercado. No final da década, com o surgimento de linguagens como Python, PHP e Ruby, a sensação era de que a crise do software era coisa do passado.
Os anos 2000 trouxeram o C# e os princípios SOLID, sintetizados por Robert Martin, para evitar código frágil e bagunçado. Em 2001, nasceu o Manifesto Ágil, uma alternativa flexível e colaborativa às metodologias rígidas da época, com nomes como Robert Martin e Martin Fowler entre seus criadores. Em 2003, Eric Evans lançou o Domain-Driven Design (DDD), focando na modelagem de software a partir do domínio do negócio. O livro 'Clean Code' (2008) de Robert Martin pregava código limpo, testável e arquitetura clara. Apesar de tantos avanços, como Object Calisthenics e TDD, a simplicidade foi sufocada pelo medo de errar, levando ao 'Over-Engineering' (excesso de engenharia). A crise financeira de 2008-2009 desviou o foco da qualidade do código para a sobrevivência das empresas.
A década de 2010, após a recessão global, viu a ascensão dos smartphones e a necessidade das empresas de estarem online. Frameworks como Spring ganharam força. No entanto, os erros do passado se repetiram: pequenos projetos eram super-arquitetados (Over-Engineering), e o Manifesto Ágil foi distorcido. A cultura da 'entrega a qualquer custo' levou ao 'Under-Engineering', com sistemas feitos sem estrutura, regras de negócio desorganizadas e classes que faziam de tudo. Isso gerou uma geração de desenvolvedores focada apenas em entregar rápido, sem se preocupar em projetar sistemas, resultando em débito técnico e sistemas frágeis, mas a comunidade técnica teve que pausar essas discussões devido a uma nova crise global: um vírus.
A pandemia transformou o software em infraestrutura essencial, impulsionando o mercado de tecnologia. Programadores se tornaram valiosos, definindo seus termos de trabalho. Em 2020, a OpenAI lançou o GPT-3, seguido pelo GitHub Copilot em 2021 e outras IAs generativas como ChatGPT. A promessa era agilizar a escrita de código. No entanto, as IAs começaram a gerar código duplicado, vulnerável e de procedência duvidosa. O problema, segundo o autor, é que as IAs aprenderam com a 'mediocridade' do código público, regurgitando lixo. Uma nova geração de programadores, os 'pedintes de código', descreve problemas para a IA resolver, sem entender a lógica ou arquitetura. Surge o 'Vibe Coding', uma filosofia que prega que 'pensar demais atrasa', transformando a superficialidade em virtude. Os sistemas se tornam retalhos imprevisíveis e inmanuteníveis. O autor alerta que a próxima crise do software é iminente, causada pela preguiça e burrice da nova geração, que abandona a responsabilidade técnica e o pensamento crítico. Ele enfatiza que a IA não pensa, não projeta e não entende o impacto de um sistema crítico, e essa responsabilidade ainda é do engenheiro de software.