Será que a mudança frequente dos requisitos de levar a código espaguete?

Question

Se os requisitos estão mudando frequentemente e você deseja entregar o seu código no tempo de modo que é a melhor solução ou metodologia utilizada para superar indo para spaghetti?

Answer 1

Qual é a sua definição de código espaguete? Para mim, código espaguete é um, método desestruturado e caótico / função muito longo. Isto não acontece devido às mudanças de requisitos, mas devido à preguiça dos desenvolvedores. Se você tem que reescrever um método porque as coisas mudaram, você também pode limpá-lo diretamente, sem muita sobrecarga.

Se você quer dizer uma estrutura de objeto mal projetado em vez disso, você pode estar certo. Se os requisitos mudam muito rápido, você pode facilmente acabar com classes que não fazer o que eles tinham a intenção de, hierarquias de objetos maus, e assim por diante.

Há alguns tipps para evitar este:

• Do not superdimensionar no início. Tente manter seus métodos, classes e hierarquias de classe mais simples possível fazer alterações menos difícil.

• Depois de uma exigência mudanças, não começar a implementá-la naquele momento, mas tomar um passo para trás e olhar se as suas necessidades de estrutura de código a ser alterado antes de o novo recurso pode caber em.

• Comunique-se para o seu cliente, que a mudança requer algum tempo. Se você sabe que eles sabem que a mudança do requisito também implica mudanças na estrutura do seu código, você terá menos pressão para apertar o seu código em estruturas existentes.

• Sempre refactor, enquanto a codificação. Na minha experiência, as pequenas refatorações como mover o código redundante de vários lugares em um único método ou classe são mais eficazes para manter seu código limpo. Estar sempre à procura de código de cheiros e removê-los o mais rápido possível para facilitar o seu trabalho. Isso leva um pouco de experiência, mas agora é o momento certo para começar a treinar esta: -)

• Como krosenvold disse, jogar pelo seguro, adicionando casos de teste para o seu código para tirar o seu medo de grandes mudanças. Tendo trabalhado em um grande sistema legado mim, eu sei que este medo e o que se sente ao trabalho sem rede de segurança. Quando você trabalha em sua rede de segurança em primeiro lugar, Ele torna-se menos de uma aventura para fazer mudanças necessário.

Answer 2

Eu acho que um dos pontos-chave é escrever código que é facilmente mutável. Isso normalmente favorece o específico em vez do resumo. Existem também alguns padrões de design que tendem a construir muito grandes pilares através de seu código. Esses pilares têm uma tendência a fazer mudanças acontecem nos lugares errados, porque você começa medo de mudar as peças centrais monumentais de seu código que você realmente deve estar mudando.

A cobertura de teste é realmente um grande auxiliar na permitindo que você faça refactoring destemido. É o pára-quedas que faz a diferença entre o louco e o piloto de avião de teste de sanidade.

Answer 3

Boa cobertura de teste é a melhor defesa contra as mudanças frequentes.

Answer 4

1. antecipar as mudanças, se / quando você pode, e generalizar os requisitos, se possível
2. mais importante, antecipar o tempo entre as mudanças
3. pedaço do trabalho / recursos / iterações para que eles possam ser concluída no tempo entre as mudanças
4. voila! você está fazendo agora ágil na mosca e constante mudança parece normal 8-P
5. tomar aspirina, lamentação pelo patrão, loop de volta para o # 1; -)

Answer 5

As frequentes mudanças nos requisitos de um projeto, incluindo adicionar ou remover recursos, não necessariamente chumbo ao código espaguete, mas provavelmente vai se você não escreve software modular (veja Modular Programação). As coisas para se esforçam para incluir o seguinte:

• Cada módulo (se é uma função, classe, biblioteca, ou a aplicação integral) tem um propósito bem definido .
• Cada módulo é idealmente não maior do que ele precisa ser para servir o seu propósito definido.
• Os módulos são fracamente acoplados , o que significa que pode ser substituído por outros módulos de software sem causar a quebrar.
• Os módulos podem ser testados individualmente para verificar se eles servem o seu propósito sem erro.
• Os módulos são organizado de uma forma que ajuda a tornar o intuitivo domínio do problema para outros programadores.

Dada módulos bem organizados (mais uma vez, estes podem ser funções, classes, bibliotecas e aplicativos completos) que trabalham juntos enquanto está a ser fracamente acoplado, a maneira de lidar com mudanças nos requisitos é escrever novos módulos, expandir módulos existentes e módulos de conexão de novas maneiras.

Quanto à forma como você chegar a uma situação de ter esses módulos de software bom, em primeiro lugar, refatoração é fundamental. Outras práticas, como testar unidade e uma metodologia de desenvolvimento (como Scrum ) também são úteis, mas refatoração é o seu pão e manteiga - e é uma coisa que muitos ambientes de negócios não dar tempo suficiente para.

Para uma boa conselhos sobre como escrever código de baixo acoplamento, fazer alguma pesquisa sobre injeção de dependência .

Answer 6

Para qualquer exigência, projetar seu código para alterações máximas possíveis. Isto pode ser realizado por separação da parte invariável a partir da parte variável. Isso não vai demorar muito tempo antes do desenvolvimento. código espaguete aparece na maioria das vezes por causa da mudança exigência, e seu design e programação deve ser capaz de resistir a ela.

http://www.dreamsongs.org/Files/DesignBeyondHumanAbilitiesSimp.pdf seria útil.

Answer 7

rastejamento do espaço / mau análise de requisitos (sempre em mudança):

evitá-lo como a peste é o melhor conselho pode dar para garantir alguma qualidade (código ou não), ele sempre terá efeitos negativos (em todos os lados), independentemente de quão bem você tentar planejar seus projetos de desenvolvimento.

A melhor solução é a de marcos definidos e para saber quando para mostrar este link para quem continua a mudar os requisitos.

Você pode ser super-humano na sua abordagem a pensar fora da caixa e tornando o código mais fácil para a mudança possível, mas você ainda vai falhar horrivelmente se você acabou de dizer sim a todos os recursos sem entender como isso deve afetar do projeto qualidade-Time-Scope pirâmide.

Answer 8

requisitos frequentes mudança é um problema que métodos ágeis foram desenvolvidos para punho -. Eles foram criados, pelo menos em parte, no reconhecimento do problema que os requisitos do mudança, muitas vezes por razões muito boas

Se um requisito mudanças que você ainda não tenha implementado, então o impacto deve ser mínimo, se você não investir muito esforço em design up-front, mas gerenciar evolução do design por pequenas iterações, testes constantes e refatoração.

Se uma exigência que já foi implementado mudanças, e você não pode mover sua data de conclusão, então você tem três opções: trabalhar mais horas para recuperar o tempo perdido, gota requisitos (reduzir o escopo) para pagar o trabalho extra, ou reduzir a qualidade do produto (que pode ser o "spaghetti" opção ").

Answer 9

Se você está saindo com um conselho: Refactor, refatorar, refactor! Muitas vezes!

Tudo o resto é detalhes sobre como fazer a refatoração mais fácil.

Answer 10

Catering para os requisitos de mudanças freqüentes é o propósito do seguinte:

• O projeto orientado a objeto (domínio abstraindo Negócios e dividindo-a em conceitos orientados a propósito gerenciáveis)
• Projeto padrões (reutilização de soluções de codificação estabelecidos)
desenvolvimento (separação de dados, lógica de negócios e Vista / apresentação)
• MVC-base
• desenvolvimento baseado na estrutura de arquitetura (Você projetar uma estrutura arquitetônica primeiro antes de cometer qualquer desenho específico do projeto e desenvolvimento)

Então, se você quer evitar spaghetti, aprender e aplicar o acima conceitos mencionados.