Sexta, 20 de Outubro de 2017




 Desenvolvimento de Software

Para que um sistema seja bem feito ele deve funcionar bem e ser de fácil entendimento e manutenção. Essas preocupações devem ser levadas em consideração em todo o projeto, desde a análise até a programação e até mesmo na manutenção futura. Abaixo seguem alguns métodos para facilitar esse trabalho.

Uma boa maneira de iniciar um sistema é dividi-lo em camadas. As camadas podem ser entendidas como grupo de funções que fazem uma determinada atividade, como pode ser visto no exemplo da figura abaixo.



Neste caso o sistema foi dividido em três camadas, a saber:

  • Apresentação:

  • Camada responsável pela "ponta cliente" ou o lado visível do sistema. Ela representa as rotinas responsáveis pelo desenho de tudo aquilo que o cliente verá no seu terminal.

  • Processamento:

  • Camada responsável pela parte de lógica e processamento dos dados envolvidos no sistema.

  • Básico:

  • Camada com funcões básicas de I/O, formatação, cálculo, etc.

Note que cada camada também poderia ser dividida em subcamadas. Essa divisão varia conforme o sistema. Um exemplo clássico disso é a divisão em sete camadas dos protocolos de comunicação de dados.

A análise deste sistema hipotético em três camadas, iniciaria pelo escopo da Apresentação, seguida do processamento e depois do Básico. Dessa forma teríamos primeiro uma visão global do sistema, seguida de uma visão cada vez mais detalhada. Essa metodologia é conhecida por "Top-Down" por vir de cima (camada mais alta) para baixo (camada mais baixa).

Feito a análise a melhor maneira de fazer o desenvolvimento, é seguir a ordem inversa. Essa é a metodologia conhecida como "Down-Top".

Inicia-se criando as rotinas Básicas. A maneira mais segura é desenvolvê-las e testá-las separadamente. Note que, ao fazer isso, estaremos garantindo que toda a camada desenvolvida já estará garantida contra erros.

Para fazer os testes na camada Básica pode ser feita uma "camada falsa" que se acomode sobre a camada básica de forma a testá-la em toda extensão, como sugerido na figura abaixo:



Em seguida partimos para o desenvolvimento da camada imediatamente superior (No exemplo, Processamento). Essa camada também poderá ser testada isoladamente utilizando novamente uma "camada falsa" que se acomode sobre ela. Por baixo poderemos utilizar ou uma camada falsa que simule as funções básicas ou a própria camada básica que, por já ter sido testada isoladamente, garantirá a veracidade dos testes dessa camada superior.

Da mesma forma, repetimos a operação para a camada imediatamente superior. Esta, por ser a última (mais alta), não requer uma camada falsa superior para os testes. Como camada inferior ela poderá utilizar ou uma camada falsa, ou a camada intermediária real com a básica por baixo, ou ainda a camada intermediária com a falsa básica por baixo.

A possibilidade de trocas as camadas do software aumenta a maleabilidade para testes, manutenção e futuras expansões.

Além disso, se forem feitas camadas falsas para todos os níveis, poderemos distribuir o desenvolvimento em grupos. Quando cada um entregar sua parte já testada, existe grande possibilidade de sucesso ao se integrar as camadas uma sobre as outras.

Note que a camada falsa básica pode ser muito útil quando é necessário acessar I/O de periféricos, pois podemos simular o envio e recepção de dados ao mesmo, sem ter a necessidade de tê-los presente. Isso facilita muito a distribuição do desenvolvimento.

Para permitir que essa concepção de desenvolvimento em camadas funcione corretamente, é necessário que as funções criadas dentro das camadas sejam "bem-educadas", ou seja:

  • Tenham uma interface de entrada e saída bem definidas (Parâmetros de Entrada e Saída);


  • Sejam isoladas do restante do sistema. A execução de uma função não deve gerar efeitos colaterais no sistema. O uso de variáveis locais (internas) é a melhor opção.


  • Evitar o uso indiscriminado de variáveis globais. Este item está intimamente ligado ao anterior. Uma boa sugestão para manter os dados de uma variável global atualizada, sem ter de disponibilizar o seu uso livremente ao sistema, é criar funções que unicamente leiam ou escrevam os dados na variável. Esse é o chamado Acoplamento por função, que permite um maior isolamento entre módulos de programa.


É claro que para o sistema ser de fácil entendimento e manutenção, além da correta distribuição do código no desenvolvimento é necessário a correta escrita do mesmo, ou seja:

  • Ao escrever um código, mantenha a mesma padronagem de estruturação, endentação e Comentários em toda extensão do mesmo.


  • Tente dividir o código em funções pequenas que são mais fáceis de entender. Se não for possível, divida o código em blocos separados com linhas em branco (se a linguagem permitir), devidamente comentados.


  • A distribuição de comentários também é crítica. A ausência deles ou o excesso prejudica muito o entendimento do sistema no futuro. A melhor maneira é descrever o que um determinado bloco de código faz, resumidamente, mas sem utilizar abreviações.


  • Comente o cabeçalho de cada função com uma breve descrição do que ela faz. Quais são parâmetros de entrada/saída e o que ela retorna.




¤ Links Relacionados:
- Dicas de JavaScript
- Padronização de Página ASP
- Padronização de Página PHP


Gostou?   Compartilhe ou comente: