Como devo planejar minha base de código? [fechadas]

Atualmente, estou trabalhando em um projeto que está prestes a atingir mais de 5.000 linhas de código, mas nunca pensei completamente no design. Quais métodos devo usar para estruturar e organizar meu código? Papel e caneta? Diagramas UML? Algo mais?

Você provavelmente terá tantas opiniões diferentes quanto respostas. Mas aqui está a minha perspectiva.

Para iniciantes, mais de 5000 linhas de código são um projeto muito pequeno. Agora, como você desenvolve projetos que crescem? Primeiro, você projeta seu sistema e não um código. O código é na verdade secundário à arquitetura. Comece apoiando os requisitos atuais mínimos. Coloque um desenho simplista dos componentes envolvidos. Eu pessoalmente gosto da UML, mas qualquer coisa visual será boa. Idealmente, você deseja aderir às boas práticas de design aqui (interfaces, separação de preocupações etc.).

Depois de oferecer suporte a requisitos mínimos em seu design, codifique-o. Novamente, tente aderir às boas práticas de codificação.

Depois disso, adicione iterativamente mais funcionalidades à medida que novos requisitos surgem. Idealmente, você deseja atualizar seu design também.

O que é importante, com base na minha experiência, não é projetar seu sistema antecipando requisitos inexistentes. Caso contrário, seu projeto crescerá muito rapidamente e ficará muito complexo em pouco tempo. Novamente - aderir às boas práticas e começa com requisitos atuais concretos.

Diagrama de fluxo, diagrama de classes e diagrama de casos de uso são os diagramas obrigatórios para grandes projetos. Pesquise e selecione quais bibliotecas externas você precisa e procure códigos de código aberto semelhantes que você possa usar (para aprender e reduzir o tempo de desenvolvimento).

Sugiro que você compre um quadro branco e alguns ímãs coloridos e um post-it. Isso o ajudará a identificar suas tarefas.

PS 5000 + linhas de códigos não são "grandes", no entanto. Um software CMS / Forum possui muito mais de 5000 linhas de códigos.

Eu criaria diagramas de pacote e classe. No diagrama de pacotes, eu estaria interessado em agrupar classes e interfaces de maneira lógica. Eu também gostaria de criar pacotes internos etc ...

Mas primeiro você precisa pensar no que o programa deve fazer. Você pode criar diagramas de casos de uso ou fazê-lo manualmente. Faço isso manualmente com o diagrama de classes porque prefiro obter o código imediatamente e é mais fácil trocar para diagramas de classes de pacotes posteriormente. Usar o diagrama de classes me dá meu java. Se eu não gostar, altero-o manualmente. O novo código é atualizado automaticamente em meus diagramas. Eu tenho uma representação visual atualizada de alto nível do meu código. Realmente útil porque, mesmo que eu codifique, sempre posso levar alguns minutos para analisar o andamento do meu projeto de maneira gráfica. Eu apenas arrasto e solto as entidades no pacote certo manualmente para organizá-lo. Eu acho que meu código é melhor usando diagramas de pacotes e classes de nível mais alto.

_{(fonte: ejb3.org )}

alguns dos meus colegas disseram que minha maneira de trabalhar é uma porcaria .... mas eu gosto :-)

Definitivamente. Eu tenho uma pequena placa de "apagamento a seco" para usar nesse tipo de coisa, mas use o que você quiser. O importante é que você possa entender seus pensamentos facilmente e ver a imagem geral de como tudo se encaixa.

Algumas pessoas preferem planos mais formais, como diagramas de UML, mas acho que é muito fácil descobrir como gerenciar cada método. Mais uma vez, porém, use o que você quiser.

EDIT: Você também pode estar interessado em programação alfabética . A idéia é que você possa planejar tudo e gradualmente se tornar mais específico. Por exemplo, você pode dizer que seu programa consiste em:

1. Obtendo texto do usuário
2. Convertendo o texto em uma imagem
3. Salvando a imagem resultante no disco

Então você pode refinar sua ideia de converter o texto em uma imagem. Então, isso pode parecer com:

1. Determine o número de linhas que o texto deve ocupar
2. Escolha cores aleatórias para o texto e o plano de fundo
3. Processe-o em um formato adequado

Depois, você pode refinar a ideia de escolher cores aleatórias e logo estará escrevendo um código comum.

Para mim, a atividade de desenvolvimento de software é uma série de projetos progressivamente mais refinados para resolver um problema específico. Quando você tem apenas uma idéia de alto nível do que está criando, seu design pode ser algo muito alto, como "haverá um aplicativo da Web que conversará com um banco de dados SQL e vários serviços da Web" ou algo assim. Depois, ao detalhar os detalhes de cada peça, você obtém uma granulação mais fina no design. Dependendo da complexidade da solução, haverá mais ou menos iterações do esforço de design. A iteração final envolve a criação do código real que implementa os níveis mais altos do design.

Para mim, a diferença entre arquitetura e design é mínima e são apenas iterações diferentes do processo que descrevi acima. A linha entre os dois é confusa e diferente para pessoas diferentes.

Existe uma maneira de decidir em que nível de detalhes do design entrar, para quais partes do aplicativo e em quais pontos do ciclo de vida do projeto. Para projetos de alto risco e alta complexidade, convém ter um design muito detalhado antes de escrever uma linha de código. Para projetos menores, você pode se dedicar muito pouco ao design inicial e apenas inserir algum código e ver o que não funciona e redesenhar essas áreas. Não há apenas uma resposta de gravação aqui. Geralmente está em algum lugar entre esses dois extremos.

Tenho um post no blog que fala sobre alguns dos princípios que utilizo ao abordar a arquitetura. Pode ser útil quando você pensa nesse sentido. Parte do artigo é específica para .NET, mas a maioria não é.

Eu costumava me fazer a mesma pergunta. Agora, apenas pratico o desenvolvimento orientado a testes e não me preocupo com isso. Eu não "planejo" o código, exceto para seguir os padrões da arquitetura escolhida. Quando inicio um projeto, tenho alguma idéia do que será necessário, mas, à medida que o desenvolvimento avança, tento manter a mente aberta. Seguindo o desenvolvimento orientado a testes e refatorando continuamente o código, não preciso "planejar" o código. Apenas satisfizo um caso de teste após o outro, e o design surge da refatoração. Esse é sempre um design melhor do que qualquer plano que eu poderia ter feito antes da codificação.