|
Segunda, 9 de Dezembro de 2024 |
|
|
|
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:
|
|
|