Desenvolvimento
Depuração: a arte de encontrar e remover bugs
Um estudo de caso com o IDE Eclipse
De que se trata o artigo: Apresentação dos principais conceitos de depuração de código fonte e demonstração de um estudo de caso utilizando o Eclipse, visando mostrar as principais funcionalidades deste IDE na depuração de código.
Para que serve: A depuração é o processo que vai desde a localização do erro até a sua correção. Com menos defeitos, pode-se obter um produto final com maior qualidade.
Em que situação o tema é útil: Depois de detectar erros no software a partir de seus testes, por exemplo, é preciso rastreá-los e corrigi-los. Essa é a finalidade da depuração.
Por mais experiente que seja, é natural ao programador introduzir defeitos durante a construção de um software. Além disto, esses estão se tornando cada vez mais complexos, aumentando a probabilidade de inserção de mais defeitos. Ao mesmo tempo, se exige cada vez mais do software, fazendo com que técnicas para aumentar sua qualidade sejam indispensáveis. A depuração pode ser considerada uma dessas técnicas que tem por objetivo localizar e corrigir os defeitos em um software.
Assim, da codificação de um software até suas execuções realizadas pelos usuários, é bem provável que defeitos sejam detectados e, consequentemente, precisam ser corrigidos. Quando um defeito é detectado, não se sabe exatamente onde ele aconteceu, sabe-se apenas que o mesmo existe. O processo de localização e correção destes defeitos é chamado de depuração.
A depuração deveria ser um processo ordenado. Porém, há situações em que isto não é possível, pois, muitas vezes, a manifestação externa do problema ocorrido pode não ter relação óbvia com sua causa interna. Por essa dificuldade em formalizar a depuração, alguns autores como Pressman, por exemplo, a consideram mais que uma técnica, uma arte.
Definitivamente, a depuração não é uma tarefa simples e a dificuldade em depurar é enfatizada pelo fato de não podermos contar com técnicas confiáveis.
Apensar disso, alguns cuidados devem ser tomados no momento da correção de defeitos para evitar retrabalho e aumentar a eficiência da depuração. Ao detectar um defeito, é importante analisar se há outra parte do programa com a mesma causa. Por exemplo, se foi detectado que algum problema está ocorrendo por uma inicialização errada de uma variável, todas as outras inicializações devem ser analisadas. Ou, caso não seja viável, deve-se analisar todas as inicializações de variáveis do módulo onde o defeito foi encontrado. Com isso, defeitos que possuem a mesma causa podem ser corrigidos até mesmo antes de se manifestarem.
Além disto, também é importante verificar se a alteração que está sendo realizada para corrigir o defeito encontrado não irá causar problemas em outras partes do sistema que estão funcionando. Apesar de ser importante fazer este tipo de verificação, em sistemas com baixo acoplamento, onde os módulos são mais independentes, é mais difícil desses problemas acontecem.
Outra verificação importante de se fazer é identificar o que poderia ter sido feito para que o defeito não ocorresse. Com isto, futuros problemas semelhantes aos já encontrados vão sendo evitados.
Como mencionado anteriormente, a tarefa de depuração não é simples e ainda não existem técnicas com eficiência comprovada. No entanto, ferramentas de depuração vêm sofrendo constantes evoluções e se mostrando cada vez mais indispensáveis nesta tarefa.
Estudo de Caso
Um estudo de caso será utilizado com o IDE Eclipse apresentando uma aplicação que contém uma classe chamada Aluno com seus atributos, métodos de acesso a esses atributos e um método calcularAprovacao() que retorna verdadeiro caso o aluno seja aprovado e falso caso seja reprovado. Além dessa, será desenvolvida uma classe de testes chamada CalcularAprovacaoTeste contendo cinco casos de testes que executam o método calcularAprovacao(). A aplicação calcula se um aluno foi ou não aprovado levando em consideração sua freqüência, nota 1, nota 2 e nota final. Os valores para as notas e freqüência podem variar de 0 a 100. Se um aluno não atinge um mínimo de 75 na freqüência, ele é reprovado. Caso ele possua um valor igual ou maior que 75 de freqüência suas notas serão avaliadas. Caso o aluno tenha a média das duas primeiras notas menor que 30, ele é reprovado. Caso essa média seja maior ou igual que 70, ele é aprovado. Caso contrário, a terceira nota é considerada e, caso a média entre a primeira média e a nota final seja inferior a 50, o aluno é reprovado, caso contrário, é aprovado.
O primeiro passo para iniciar o estudo de caso é criar um projeto Java com o nome CalcularAprovacao.
Depois disto, o pacote br.com.esmagazine.calcularAprovacao.model deve ser criado e também deve ser criada a classe Aluno dentro desse pacote. Essa é a classe de domínio da aplicação que contém os atributos frequencia, nota1, nota2 e notaFinal, bem como o método calcularAprovacao() que verifica se um aluno foi ou não aprovado. É possível criar um pacote clicando com o botão direito sobre a pasta src e, logo em seguida, acessando o menu New / Package.
Também deve ser criado o pacote br.com.esmagazine.calcularAprovacao.testes com a classe CalcularAprovacaoTeste, que é a classe que contém os casos de teste.
Neste ponto, a organização do projeto deve estar semelhante à Figura 1.
Figura 1. Organização do Projeto
Agora é preciso escrever o conteúdo das classes criadas. Como o intuito do artigo é a depuração, vamos apenas apresentar nas Listagens 1 e 2 o conteúdo das classes Aluno e CalcularAprovacaoTeste.
|
package br.com.esmagazine.calcularAprovacao.model;
public class Aluno {
private String nome; private int frequencia; private float nota1; private float nota2; private float notaFinal;
public String getNome() { return nome; } ... |
