Código de verificação futura

Onde trabalho, os desenvolvedores sempre me dizem que "eu adicionei isso apenas para o futuro" ou "acho que é uma boa idéia fazer isso porque eles provavelmente o desejarão algum dia". Eu acho ótimo que eles sejam proativos na tentativa de antecipar mudanças futuras, mas não posso deixar de pensar que é desnecessário e corre o risco de escrever código que talvez nunca seja necessário e, portanto, improdutivo (também acho que alguns desenvolvedores só querem experimentar algo novo por causa disso). Os argumentos para provas futuras são inválidos se você acabou de escrever um código organizado e limpo?

Bem, primeiro de tudo, há algumas coisas que precisam de esclarecimentos:

• Prova futura não está adicionando coisas.
• A prova futura é garantir que você possa adicionar facilmente código / recursos sem interromper a funcionalidade existente.

Isso significa que escrever um código "à prova de futuro" garante que o código seja escrito de maneira flexível, suficientemente abstrata, mas também um código que não oculte completamente os níveis de abstração; portanto, sempre há um caminho para os níveis mais baixos de abstração se necessário.

Escrever código à prova de futuro é uma arte por si só e está fortemente associado às práticas do SOLID para versões de componentes, separação de preocupações, camadas e abstração de funcionalidade. A verificação futura não tem nada a ver com adicionar recursos antecipadamente, mas garantir que você possa adicionar recursos no futuro de maneira ininterrupta , através do bom design dos códigos / bibliotecas existentes.

My 2c

Não escreva código que não será usado por muito tempo. Será inútil, pois provavelmente não atenderá às necessidades naquele momento (que você por definição ainda não conhece).

Torne o código robusto contra situações inesperadas de problemas que permitam recuperação normal ou com rapidez de falha, mas não escreva código para possíveis usos futuros.

Uma boa maneira de garantir isso é usar o design e o desenvolvimento orientados a testes. Os casos de teste são derivados da especificação e dos casos de uso. Todo o código deve passar no teste. Código desnecessário não deve ser escrito. Fazendo dessa maneira, é simples determinar se é necessário ou não.

É importante perceber que tornar o código à prova do futuro e escrever o código , caso seja necessário no futuro, são duas coisas muito diferentes. O primeiro é crucial para uma boa aplicação, o menor geralmente não é uma boa prática de codificação.

• Para mim, a prova futura do código, é escrevê-lo de uma maneira que ele possa interagir com as tecnologias em evolução. Isso envolve modularizar seu código, para que cada parte do seu aplicativo possa interagir independentemente do idioma e da tecnologia do aplicativo como um todo. Um bom exemplo disso seria usar XML ou JSON para transmitir dados entre diferentes partes do aplicativo. No entanto, a tecnologia evolui, é muito provável que ela sempre consiga ler XML e JSON.

• Semelhante ao acima, expor uma parte do seu aplicativo por meio de uma API SOAP ou REST alcança algo semelhante. Qualquer que seja a evolução das tecnologias, você não precisará necessariamente reescrever todas as partes do aplicativo, porque as novas tecnologias ainda poderão se comunicar com as antigas.

• No que diz respeito à escrita do código , caso seja necessário , acho que é muito perigoso, pois é provável que o código tenha pouco ou nenhum teste.

Portanto, faça o código à prova de futuro (a NASA ainda envia naves espaciais usando o Fortran), mas não escreva código 'apenas por precaução'.

Pense em quanto tempo você ativou um pedaço de código no ambiente de produção e pensou: "Graças a Deus eu escrevi isso há 2 anos!".

O código deve ser modificável / extensível facilmente. Não adicione código desnecessário, pois isso dá uma sensação muito falsa de segurança e desperdiça recursos de desenvolvimento / teste em um mundo de requisitos em constante mudança.

Muitas das outras respostas abordam problemas maiores de design ou são bastante abstratas. Se você pensar em termos do que acontecerá no futuro, poderá definir algumas técnicas claras para ajudar a proteger o código no futuro .

Pense principalmente que no futuro alguém tentará adicionar um recurso ao código ou tentará reutilizá-lo em outro lugar. Eles também podem tentar corrigir um recurso no código. Obviamente, apenas ter um bom código limpo é um ponto de partida necessário, mas também existem algumas técnicas específicas que podem ser feitas.

Programação defensiva : faça a verificação de entrada além do que o aplicativo atual realmente precisa. Sempre que você chamar APIs, verifique se a entrada deles é algo que você esperaria. No futuro, as pessoas estarão misturando novas versões de código, para que o escopo de erros e retornos da API mude do que é agora.

Elimine o comportamento indefinido : Muitos códigos possuem comportamentos que meio que evoluem do nada. Certas combinações de entrada levam a uma saída que ninguém realmente pretendia, mas acontece. Agora, inevitavelmente, alguém confiará nesse comportamento, mas ninguém o saberá, pois não está definido. Qualquer pessoa que tente mudar o comportamento no futuro quebrará inadvertidamente as coisas. Use as verificações de segurança agora e tente remover / bloquear todos os usos indefinidos do código.

Conjunto de testes automatizados : Tenho certeza de que você pode encontrar volumes escritos sobre a necessidade de testes de unidade. Em referência a provas futuras, no entanto, este é um ponto crítico para permitir que alguém refatore o código. A refatoração é essencial para manter o código limpo, mas se não houver um bom conjunto de testes, você não poderá refatorar com segurança.

Isolamento e Segregação : Encapsulamento e modularização adequada são um bom princípio de design, mas você precisa ir além disso. Você encontrará muitas vezes que precisa usar uma biblioteca, API ou produto, que pode ter um futuro questionável. Talvez devido a preocupações com a qualidade, problemas de licenciamento ou desenvolvimento contínuo pelos autores. Nesses casos, tire um tempo extra para colocar uma camada entre você e esse código. Corte a API exatamente do que você precisa, para que o acoplamento seja muito baixo para permitir uma substituição mais fácil no futuro.

Um código bom, limpo e bem organizado é à prova de futuro, no sentido de facilitar as implementações e alterações.

"Prova do futuro" significa, na melhor das hipóteses, "design fracamente acoplado". 80% das vezes as pessoas querem dizer "flexível" quando dizem "prova do futuro". Às vezes, eles dizem para tentar parecer legal. Mas pelo menos eles estão entregando algo dentro do prazo que funciona.

"Prova do futuro", na pior das hipóteses, não tem sentido. 20% do tempo, é uma desculpa para perder tempo pesquisando tecnologias alternativas em vez de simplesmente entregar algo. Eles não estão entregando nada (ou o que estão entregando é muito complexo para o problema em questão).

Existem dois casos extremos.

1. Prontidão infalível. Na verdade, pode-se prever o futuro com precisão. Nesse caso, aplique esta poderosa previsão para prova futura do código. Melhor, aplique a previsão infalível para prever as tendências do mercado e se aposentar cedo e parar de codificar.

2. Um está "dirigindo" o futuro. Ou seja, existe uma nova tecnologia pronta para implantar no futuro que exigirá uma reescrita da coisa que está sendo entregue no momento. É estranho que alguém não esteja implantando esse futuro legal primeiro.

   Devemos entregar o projeto "A", sabendo que o projeto "B" levará a uma reescrita imediata de "A". Somente neste caso, poderemos comprovar "A" no futuro.

YAGNI = Você não precisa disso .

Seus instintos estão corretos: o código deles é supérfluo, adiciona uma carga de manutenção e teste e desperdiça tempo com coisas que não têm um valor comercial concreto.

Veja também: Chapeamento de ouro .

Ignorando o título da pergunta e mantendo o ponto principal sobre "colocar coisas porque alguém pode querer isso algum dia" ...

A resposta é não. Nunca. Não escreva um ponto do código que você não precisa hoje. Aqui está o porquê:

1. O programa agora é mais complicado do que precisa ser.
2. Você pode nunca precisar do recurso, por isso perdeu seu tempo.
3. Você não sabe quais serão os requisitos para o recurso se alguém o solicitar no futuro. Então você terá que descobrir e modificar de qualquer maneira.

Eu acho que o primeiro ponto é o mais importante. Se você já trabalhou com um sistema repleto de códigos genéricos para diferentes clientes ou repleto de recursos desnecessários, então sabe quanto tempo e esforço extra são necessários para manter ou estender a funcionalidade por causa de aquele. Portanto, evite a todo custo.