É um mau sinal que estou frequentemente redesenhando à medida que desenvolvo um projeto?

Quando comecei a programar, presumi que um dia chegaria ao ponto em que iniciaria um projeto, sentando-me e desenhando um diagrama UML de todas as classes, depois segui-o bastante. Estou programando há alguns anos e não está saindo dessa maneira. À medida que passo por um projeto, costumo dizer

• "Ei, eu preciso de uma aula para fazer _ _. Eu não pensei nisso antes."
• "Espere, essa função deve realmente estar nessa classe, em vez desta. Eu vou passar para ela."
• "Na verdade, devem ser duas aulas em vez de uma. Vou dividir."
• "Eu devo fazer com que essas três classes independentes herdam todas de uma classe abstrata".
• Etcetera, etcetera.

É um mau sinal de que estou sempre redesenhando assim à medida que avança? Isso significa que eu sou um programador ruim ou isso é normal?

Esta é uma parte normal do desenvolvimento. Dois dos principais princípios do Design Contínuo é o seguinte:

1. Você não é onisciente, não pode conhecer todo o sistema do começo ao fim antes de começar.
2. O design não é estático. Isso é mais prevalente quando um projeto está em uso há muito tempo e os problemas que está resolvendo agora não são os problemas que estava solucionando quando foi escrito pela primeira vez.

Minha opinião pessoal sobre o assunto é que você deve ter uma boa idéia do design macro , mas permitir que o micro design evolua. Outra maneira de expressar isso é que o design de alto nível (que é o mais longe possível das ferramentas de modelagem / UML) provavelmente permanecerá bastante estático ao longo da vida de um projeto. O design detalhado de quais métodos fazem o quê e a hierarquia de classes precisa ser livre para ser maleável.

Quando você realmente não sabe muito sobre o problema que está resolvendo, fará muito mais erros iniciais. No entanto, depois de trabalhar com ele por tempo suficiente, o design geral começará a se estabelecer e as refatorações de que você está falando são tudo o que será necessário para manter o código organizado.

O que você está fazendo é conhecido popularmente como "refatoração". Se você parar de fazer isso, estará com problemas.

O fato é que a maior parte do código é complexo e os seres humanos, mesmo os mais inteligentes, não conseguem descobrir tudo de uma vez.

Não, você parece estar seguindo o YAGNI e refatorando -se dos exemplos dados. Você não acha que é melhor ter essa solução melhor e ser capaz de fazê-lo do que simplesmente nunca mais pensar em algo?

O desenvolvimento ágil de software geralmente possui práticas para acomodar isso bastante diferente do modelo em cascata.

Isso é perfeitamente bom (a menos que essas reformulações sejam sempre grandes revisões ou sejam reconstruídas do zero). Não se preocupe. Pode ser bom começar com um diagrama UML no início do projeto, mas não o esculpe, pois você quase sempre descobrirá que as coisas mudam à medida que trabalha. Você pode aprender novas técnicas que você não conhecia no início, pode querer aprimorar alguns recursos de maneiras que não conhecia durante o design inicial, os requisitos de negócios mudam, às vezes há incógnitas durante o design inicial que só podem ser contabilizado mais tarde, etc ...

O que é importante é ir e atualizar esses documentos iniciais UML para que elas reflitam quaisquer mudanças significativas no projeto, desenvolvedores futuras resto (incluindo a si mesmo) pode acabar muito confuso. Isso pode ser difícil e geralmente requer boa diciplina (e tempo).

É muito, muito, muito raro começar com um design e segui-lo 100% até a implementação. Eu pessoalmente nunca vi uma coisa dessas acontecer, exceto programas muito pequenos e triviais.

O que você está fazendo é perfeitamente normal (desde que você não comece completamente do zero todas as vezes). Eu estive nisso por mais de vinte anos, e ainda é um processo iterativo.

A única vez em que você conseguirá projetar tudo de antemão e cumpri-lo é se estiver resolvendo exatamente o mesmo problema que resolveu da última vez e, mesmo assim, provavelmente poderá encontrar espaço para melhorias.

Eu nunca sou um desenvolvedor altamente experiente, mas faço isso também. Nos últimos anos, minha capacidade de construir mentalmente a arquitetura necessária melhorou bastante. No entanto, ao escrever um software, não importa quanto planejamento eu faça, sempre há lugares que precisam de um novo design. Pontos que eu não sabia que estaria me repetindo até que o código estivesse realmente sendo escrito.

O que quero dizer neste post é dizer que eu faço tudo na sua lista e não sinto que essas coisas sejam necessariamente ruins, a menos que estejam acontecendo constantemente e tenham um efeito negativo real na sua produtividade.

Isso chamou processo iterativo e é um conceito básico em todas as técnicas modernas de desenvolvimento de software.