<Direto ao Ponto 38> Teste de Mesa manual

Artigos desta série: ( < ) Anterior | Índice | Seguinte ( > )

Olá, dev!

Este é mais um artigo da série DIRETO AO PONTO, que eu estou escrevendo para a DIO. Ele vai tratar do teste de mesa manual, uma simulação da execução de um programa lá no início dos anos 80. Eu vou mostrar o que é e como fazer o teste de mesa.

Sumário

1.   Introdução

2.   Do entendimento do problema até o algoritmo

3.   As ferramentas digitais para o acompanhamento de um programa

4.   Acompanhamento da execução de algoritmos

5.   Considerações finais

6.   Referências

1 – Introdução

Eu criei a série de artigos DIRETO AO PONTO com o objetivo de apresentar, de forma simples e direta, conhecimentos básicos da programação e de computação, principalmente, para os iniciantes.

Aqui, são tratados de temas como lógica de programação, linguagens, hardware dos computadores, história da computação e assuntos relacionados à plataforma da DIO, como a escrita de artigos e os desafios de código.

Neste artigo, eu vou falar do teste de mesa manual. Ele é um teste “jurássico”, usado pelos programadores “Dinossauros” para fazer a simulação da execução de um programa, lá no início dos anos 80.

Como muitos de vocês já sabem, eu sou um dinossauro da programação, pois aprendi a programar em 1980, com a linguagem FORTRAN e perfurando cartões! Eu sou do tempo em que programadores ainda eram chamados de programadores, não de devs!

Naquele tempo, não havia computadores pessoais, interfaces gráficas, Windows, Linux, Android nem IDEs (Ambientes de Desenvolvimento Integrados). Eu já escrevi dois artigos na DIO descrevendo a nossa saga para programar naquela época.

Atualmente, em algumas situações, o teste de mesa ainda é usado e, na falta de ferramentas modernas disponíveis, ajuda no entendimento do objetivo de um programa e facilita a depuração.

Ele é uma ferramenta didática para o programador iniciante começar a entender o funcionamento de um programa, da dinâmica das variáveis e do fluxo de execução. É possível que os programadores mais antigos já tenham ouvido falar do teste de mesa.

Hoje, existem tantas ferramentas digitais de acompanhamento automático de programas, oferecidas nos diversos compiladores e IDEs disponíveis para se programar, que o teste de mesa ficou obsoleto e até é motivo de piada quando alguém fala que ainda usa.

Sem medo de virar meme, por ainda usar essa técnica, eu vou me atrever a falar do teste aqui. Na falta de ferramentas modernas disponíveis, ou em determinadas situações ele pode ser usado.

O teste de mesa tem como base a Lógica de Programação, pois ele permite acompanhar a execução de um programa, que pode ser associado a um algoritmo para a resolução de problemas por meio de programas de computador.

Todo mundo aqui na DIO já sabe (ou já ouviu) que a base da programação é a Lógica de Programação e que aprender a programar sem saber dela é difícil.

Na prática, a Lógica de Programação acaba se confundindo com os algoritmos, que são os passos que devem ser aplicados em sequência para se resolver um problema. Qualquer problema! De qualquer área!

Com o algoritmo escrito, para codificar um programa de computador basta traduzir cada ação descrita pelos seus passos em código de alguma linguagem, de programação. O teste de mesa é o acompanhamento da execução de um programa, em geral, manual, dos valores atribuídos às diversas variáveis que aparecem no programa escrito. 

Além do algoritmo, outras técnicas que ajudam na compreensão de problemas são os desenhos e diagramas, bem como uma leitura atenta ao enunciado.  

Estas técnicas são a elaboração de algoritmos, a divisão e conquista, o uso de desenhos e a interpretação atenta do texto dos enunciados.

2 – Do entendimento do problema até o algoritmo

No artigo anterior, eu resumi os passos para se resolver um problema no seguinte checklist:

1. Ler o enunciado até o entendimento claro do problema e do resultado pedido;

2. Fazer um diagrama do problema, com um desenho à mão livre;

3. Listar as tarefas básicas necessárias para se chegar à solução;

4. Extrair os dados informados no enunciado e indicar o dado pedido;

5. Listar as possíveis fórmulas usadas para a resolução do problema;

6. Escolher as fórmulas e a sequência de aplicação delas para fazer os cálculos;

7. Substituir os valores dos dados para chegar a resultados intermediários e o resultado final;

8. Em uma linha final, responder ao questionamento pedido para o problema;

9. Grifar essa última linha (circundar, sublinhar, desenhar uma seta, etc.)

No caso de problemas para resolução pelo computador, um passo essencial é a elaboração do algoritmo. Para o teste de mesa, podemos partir do algoritmo ou do código.

3 – As ferramentas digitais para acompanhamento de algoritmos

A tecnologia avançou muito desde que eu aprendi a fazer testes de mesa, em 1980. Então, você pode perguntar por que eu ainda uso essa técnica antiga de resolver problemas ao invés de usar ferramentas digitais para fazer o mesmo desenho ou diagrama.

Bem, em algumas situações é mais comum você ter disponível um papel e uma caneta do que um computador para usar o Paint, Photoshop ou programa semelhante.

Um exemplo disso foi quando eu fiz um concurso público e uma questão pedia para fazer um acompanhamento de um código e informar o valor de uma variável ao final da sua execução. Fiz o teste de mesa e acompanhei direitinho, acertando a resposta.

Em outro concurso, tinha uma questão de matemática que tratava da interseção entre figuras geométricas. Um desenho que eu rabisquei no canto da prova esclareceu tudo!

Além disso, nem todo mundo tem a agilidade para fazer desenhos claros em uma ferramenta digital da mesma forma que rabisca um desenho no papel.

No caso da programação, a maioria das IDEs já têm ferramentas de depuração, com acompanhamento de valores de variáveis, execução sequencial do código, execução do código interno de uma função, etc.

No entanto, em alguns momentos estas ferramentas não estão disponíveis ou são muito complexas para o entendimento básico de um programa simples.

4 – Acompanhamento da execução de um programa

O Teste de mesa propriamente dito representa o acompanhamento da execução de um programa por meio da evolução dos valores de suas variáveis, seguindo o fluxo das instruções que são executadas. É uma simulação de um programa, de forma manual, geralmente feito com papel e caneta.

Os desenhos e diagramas que foram citados anteriormente ajudam no entendimento do problema a ser representado por um algoritmo, que deve ser codificado em alguma linguagem de programação.

Com o código escrito em mãos, o teste consiste de seguir o seu fluxo, linha a linha, instrução a instrução, anotando-se os valores atribuídos às variáveis em cada instrução, até o encerramento do programa. As instruções de saída (escrita) também podem ser anotadas, ajudando no entendimento das saídas e do atendimento ao resultado pedido.

Como exemplo, vamos rever o problema que foi usado como exemplo no artigo anterior:

Dado um número inteiro, escreva um código que calcule o seu quadrado, se ele for positivo, e calcule o seu cubo, se ele for negativo. No final, escreva o valor lido e o valor calculado. Se o número for zero, escreva zero na saída.

Nós partimos deste enunciado e elaboramos o seguinte algoritmo para sua solução que resultou em:

a) Segue um algoritmo para a solução:

1. Ler u número de entrada;
2. Testar se o número é positivo, negativo ou zero;
3. Se for positivo, a solução é o quadrado desse número;
4.        Se for negativo, a solução é o cubo desse número;
5.        Se for zero, a solução tem o mesmo valor da entrada
6. Escrever o valor de entrada
7. Escrever o valor do resultado

b) Atribuindo variáveis para os valores do algoritmo:

Número de entrada: num

Número do resultado: result

c) Traduzindo o algoritmo em pseudo-código:

ler num

result = 0

se (num > 0) // o número é positivo!

       result = num * num

se (num < 0) // o número é negativo!

       result = num * num * num

escrever(num)

escrever(result)

d) Realizando o teste de mesa para a execução deste código, com a entrada igual a 3:

Esse foi o teste de mesa que eu fiz, à mão, com caneta e papel. Por clareza, eu acho melhor postar figuras dos acompanhamentos feitos no Excel. Em verde, as respostas pedidas.

e) Realizando o teste de mesa para este código, com entrada igual a -2:

f) Realizando o teste de mesa para a execução deste código, com a entrada igual a 0:

Como segundo exemplo, vamos ver problema que tenha uma função:

Informe as raízes reais, caso haja, de uma equação de segundo grau, dada por seus coeficientes a, b e c. Ao final, escreva os coeficientes a, b e c, e as raízes encontradas. Se não houver raízes reais, escreva uma mensagem informando esse fato. Os valores dos coeficientes são informados pelo usuário até que um valor zero para o coeficiente a seja informado, encerrando o programa.

Para saber se há raízes reais, delta deve ser positivo ou zero, se for negativo, não existem raízes reais.

a) O entendimento do problema fica mais claro com uma tabela:

b) Agora, vamos elaborar um algoritmo para a solução:

1. Ler valores dos coeficientes;
2. Escrever os valores dos coeficientes
3. Se o valor do coeficiente a for zero, encerrar o programa
4. Calcular o valor de delta;
5. Testar se o valor de delta é positivo, zero ou negativo;
6. Se delta for positivo:
7. Calcular as duas raízes;
8. Escrever os valores das 2 raízes;
9. Se delta for zero:
10. Calcular a raiz única;
11. Escrever os valores da raiz;
12. Se delta for negativo:
13. Escrever “não há raízes reais”;
14. Ler os próximos coeficientes 

c) Traduzindo o algoritmo em pseudo-código:

ler( a, b, c )

escrever( a, b, c )

enquanto( a != 0 )

delta = calcularDelta( a, b, c ) // chama a função calcularDelta()

se ( delta > 0 ) // existem 2 raízes reais

          raiz1 = ( -b + sqrt( delta ) ) / ( 2 * a );

          raiz2 = ( -b - sqrt( delta) ) / ( 2 * a );

escrever( raiz1, raiz2 )

senão

se ( delta == 0 ) // existe 1 raiz real

          raiz1 = ( -b ) / ( 2 * a );

escrever( raiz1 )

senão ( delta < 0 ) // delta < 0. Não existe raiz real

escrever( “Não existe raiz real” )

d) Função calcularDelta( a, b, c )

delta = b * b – 4 * a * c

retornar( delta )

e) Agora vamos fazer o teste de mesa para o programa:

Em verde, as respostas pedidas, em amarelo, os valores retornados pela função para o programa que a chamou.

f) Acompanhamento da execução da função calcularDelta():

Cada vez que a função individual for chamada, a execução passa para as instruções dela, em uma tabela separada, retornando o valor para o programa que chamou.

5 – Considerações finais

Este é mais um artigo da série DIRETO AO PONTO, que eu estou escrevendo para a DIO.

Desta vez, foi apresentada uma ferramenta simples de acompanhamento da execução de um código que eu usava em 1980, logo que aprendi a programar. Era o teste de mesa.

Eu aprendi a programar com a linguagem FORTRAN e perfurando cartões! Naquela época não havia as IDEs nem compiladores de janelas, que hoje permitem uma depuração rápida e automática dos programas de computador.

O teste de mesa também pode ajudar no entendimento do funcionamento de um programa, a dinâmica das variáveis e o fluxo de sua execução.

Na época, o acompanhamento da execução de um programa era feito de forma manual, usando uma técnica chamada Teste de Mesa.

O teste de mesa é uma técnica muito antiga, já superada pelas ferramentas modernas disponíveis, mas ainda pode ser bem útil para os iniciantes na programação ou mesmo na resolução de questões de acompanhamento da execução de códigos em questões de concursos.

No próximo artigo, eu vou mudar de assunto, vou falar sobre a estrutura de um programa de computador.

6 – Referências

Todo o conteúdo deste artigo foi tirado do que eu aprendi (e me lembro) sobre o assunto desde o início da minha carreira como programador, desde os anos 80 até agora. Por isso, não vou listar nenhum a referência de livros nem de sites.

Artigos desta série: ( < ) Anterior | Índice | Seguinte ( > )