Área de compiladores por higor hostins andré luís alice ...siaibib01.univali.br/pdf/higor...
TRANSCRIPT
UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
UMA FERRAMENTA PARA APOIO A CONSTRUÇÃO E TESTE DE ALGORITMOS
Área de Compiladores
por
Higor Hostins
André Luís Alice Raabe, Dr. Orientador
Itajaí (SC), dezembro de 2006
UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
UMA FERRAMENTA PARA APOIO A CONSTRUÇÃO E TESTE DE ALGORITMOS
Área de Compiladores
por
Higor Hostins Relatório apresentado à Banca Examinadora do Trabalho de Conclusão do Curso de Ciência da Computação para análise e aprovação. Orientador: André Luís Alice Raabe, Dr.
Itajaí (SC), dezembro de 2006
ii
DEDICATÓRIA
Dedico esse trabalho a todas as pessoas que posso
contar todos os dias e que estiveram e estão presentes
nos momentos mais importantes da minha vida.
Dedico aos meus pais, Gilberto e Aparecida pelo
exemplo de vida e pela dedicação que tornaram
possível completar mais essa etapa da minha vida e a
minha namorada Andréa por me amar e me apoiar.
Obrigado a Todos!
iii
AGRADECIMENTOS
A construção de uma tese de conclusão de um curso de graduação é um momento
importante, principalmente tratando-se da primeira formação superior na vida acadêmica de um
aluno, em vista disso gostaria de agradecer a todos que contribuíram para construir esse momento.
A minha namorada Andréa Espíndola, por estar presente e comemorar todos os momentos
de glória e por propiciar consolo e apoio em todos os momentos difíceis.
A minha família pelo amor que recebo, pelos valores éticos que herdei e por fornecer os
meios que tornaram possível esse momento tão especial.
A meu orientador André Raabe, que sempre deu um voto de confiança ao trabalho por mim
desempenhado, por ter acreditado na minha capacidade técnica, pela disposição e assiduidade nas
orientações.
Ao meu amigo Rômulo Nunes por sempre ter idéias criativas nos momentos necessários.
Ao pessoal da prefeitura de Itajaí pelo apoio.
A professora Anita Fernandes por ter incentivado, apoiado e cobrado desde o início do
projeto.
A todos os professores que juntos passaram ensinamentos importantes ajudando assim a
construir uma base sólida de conhecimentos.
A todos os meus amigos que sempre acreditaram que esse momento seria possível.
iv
SUMÁRIO
LISTA DE ABREVIATURAS..................................................................vi LISTA DE FIGURAS...............................................................................vii LISTA DE TABELAS.............................................................................viii RESUMO....................................................................................................ix
ABSTRACT.................................................................................................x
1 INTRODUÇÃO ......................................................................................1 1.1 PROBLEMATIZAÇÃO................................................................................... 3 1.2 FORMULAÇÃO DO PROBLEMA ................................................................ 3 1.2.1 Solução Proposta ............................................................................................ 3 1.3 OBJETIVOS ..................................................................................................... 4 1.3.1 Objetivo Geral................................................................................................ 4 1.3.2 Objetivos Específicos...................................................................................... 4 1.4 METODOLOGIA............................................................................................. 4 1.5 ESTRUTURA DO TRABALHO ..................................................................... 5
2 FUNDAMENTAÇÃO TEÓRICA ........................................................6 2.1 APRENDIZAGEM DE ALGORITMOS ........................................................ 6 2.1.1 Importância de Algoritmos............................................................................ 6 2.1.2 Principais Problemas Relacionados à Aprendizagem de Algoritmos.......... 7 2.1.3 Métodos para Facilitar a Aprendizagem de Algoritmos.............................. 8 2.2 CONSTRUÇÃO DE COMPILADORES E INTERPRETADORES............. 9 2.2.1 Análise Léxica............................................................................................... 10 2.2.2 Análise Sintática........................................................................................... 10 2.2.3 Análise Semântica ........................................................................................ 14 2.2.4 Interpretadores ............................................................................................ 15 2.2.5 Árvores Sintáticas Abstratas ....................................................................... 15 2.3 ESTUDO DE FERRAMENTAS SIMILARES ............................................. 19 2.3.1 Happy Portugol ............................................................................................ 19 2.3.2 CIFluxProg I e CIFluxProg II ..................................................................... 20 2.3.3 Portugol/Plus ................................................................................................ 22 2.3.4 AWTM.......................................................................................................... 23 2.3.5 G-Portugol .................................................................................................... 23 2.3.6 Síntese das Características das Ferramentas Analisadas .......................... 25 2.4 TECNOLOGIAS A SEREM UTILIZADAS................................................. 26 2.4.1 NetBeans ....................................................................................................... 26 2.4.2 Applets .......................................................................................................... 27 2.4.3 Gals ............................................................................................................... 28
3 DESENVOLVIMENTO ......................................................................31
v
3.1 LEVANTAMENTO DE REQUISITOS ........................................................ 31 3.1.1 Requisitos Funcionais .................................................................................. 31 3.1.2 Requisitos não Funcionais ........................................................................... 32 3.1.3 Regras de Negócio ........................................................................................ 32 3.2 GRUPOS DE TESTE ..................................................................................... 33 3.3 DIAGRAMAS DE CASOS DE USO ............................................................. 34 3.4 DIAGRAMA DE CLASSE............................................................................. 35 3.4.1 Classes de Recurso ....................................................................................... 35 3.4.2 Classe do Applet e Compilador .................................................................... 36 3.4.3 Classes do Interpretador.............................................................................. 37 3.5 INTERFACE DO SISTEMA ......................................................................... 39 3.5.1 Construção de Algoritmos ........................................................................... 39 3.5.2 Parar Execução ............................................................................................ 40 3.5.3 Executar Algoritmo...................................................................................... 40 3.5.4 Execução Passo a Passo................................................................................ 41 3.5.5 Validar Algoritmo ........................................................................................ 42 3.6 IMPLEMENTAÇÃO ..................................................................................... 43 3.6.1 Construção de uma ASA orientada a objetos ............................................. 44 3.6.2 Execução do Algoritmo................................................................................ 45 3.6.3 Verificação dos Algoritmos.......................................................................... 47 3.6.4 Aspectos de Interface ................................................................................... 49
4 EXPERIMENTO REALIZADO ........................................................52 4.1 PROCEDIMENTO E REALIZAÇÃO.......................................................... 52 4.2 COLETA DE DADOS.................................................................................... 53 4.3 ANÁLISES REALIZADAS ........................................................................... 54 4.3.1 Testes de Hipóteses....................................................................................... 54
5 CONSIDERAÇÕES FINAIS ..............................................................62
REFERÊNCIAS BIBLIOGRÁFICAS ...................................................65
vi
LISTA DE ABREVIATURAS
API Application Programming Interface ASA Árvore Sintática Abstrata BNF Backus Naur Form - Forma Normal de Backus DOS Disk Operating System GLC Gramática Livre de Contexto HCI Human Computer Interaction HTML Hyper Text Markup Language IDE Integrated Development Environment JVM Java Virtual Machine LMS Learning Managment Systems LL Left-to-right Leftmost LR Left-to-right Rightmost LALR Look Ahead Left-to-right Rightmost SLR Simple Left-to-right Rightmost TCC Trabalho de Conclusão de Curso UML Unified Modeling Language UNIVALI Universidade do Vale do Itajaí WWW Word Wide Web
vii
LISTA DE FIGURAS
Figura 1. Etapas de um compilador/ interpretador............................................................................9 Figura 2. Árvore sintática ..............................................................................................................12 Figura 3. Árvore sintática abstrata .................................................................................................16 Figura 4. Árvore sintática abstrata para desvio condicional............................................................17 Figura 5. Construção de árvore sintática abstrata ...........................................................................18 Figura 6. Interface do Happy Portugol ...........................................................................................19 Figura 7. Módulo de fluxograma ...................................................................................................20 Figura 8. Módulo de programação em portugol .............................................................................21 Figura 9. Ambiente de programação do Portugol/Plus ...................................................................22 Figura 10. Ambiente de programação GPTEditor ..........................................................................24 Figura 11. Construção de Analisador Sintático com a Ferramenta Gals..........................................30 Figura 12. Modelo XML................................................................................................................33 Figura 13. Digrama de Casos de uso..............................................................................................34 Figura 14. Diagrama de classes de recursos do sistema..................................................................36 Figura 15. Diagrama de classes do applet e compilador .................................................................37 Figura 16. Diagrama de classes do interpretador ............................................................................38 Figura 17. Construção de Algoritmos ............................................................................................39 Figura 18. Parar Algoritmo............................................................................................................40 Figura 19. Executar Algoritmo ......................................................................................................41 Figura 20. Execução passo a passo ................................................................................................42 Figura 21. Validar Algoritmo ........................................................................................................43 Figura 22. Algoritmo para soma de dois valores ............................................................................44 Figura 23. Árvore Sintática Abstrata orientada a objeto .................................................................45 Figura 24. Fluxo de execução de um algoritmo..............................................................................46 Figura 25. HTML para utilização do applet com passagem de arquivo XML .................................47 Figura 26. Mensagem de erro durante uma verificação de algoritmo..............................................48 Figura 27. Área de informações do sistema....................................................................................50 Figura 28. Mensagem de erro ........................................................................................................51 Figura 29. Enunciados dos testes realizados...................................................................................52 Figura 30. Equação de erro padrão.................................................................................................55 Figura 31. Equação do Teste Z ......................................................................................................55 Figura 32. Equação do Teste de Student ........................................................................................56 Figura 33. Aplicação de t-Student para hipótese 1..........................................................................57 Figura 34. Aplicação de t-Student para hipótese 2..........................................................................58 Figura 35. Calculo do erro padrão da hipótese 3. ...........................................................................59 Figura 36. Cálculo do valor d Z da hipótese 3. ...............................................................................59 Figura 37. Calculo do erro padrão da hipótese 3. ...........................................................................61 Figura 38. Cálculo do valor de Z da hipótese 4. .............................................................................61
viii
LISTA DE TABELAS
Tabela 1. Regras de Produção e Ações Semânticas ........................................................................17 Tabela 2. Características das Ferramentas Analisadas ....................................................................25 Tabela 3. Tabulação dos dados do experimento .............................................................................54
ix
RESUMO
HOSTINS, Higor. Uma Ferramenta para Apoio a Construção e Teste de Algoritmos. Itajaí, 2006. 87 f. Trabalho de Conclusão de Curso (Graduação em Ciência da Computação) – Centro de Ciências Tecnológicas da Terra e do Mar, Universidade do Vale do Itajaí, Itajaí, 2006. Uma das grandes dificuldades enfrentada por alunos nas disciplinas iniciais de cursos como Ciência da Computação, Sistema de Informação, Engenharia de Computação e afins, está ligada a aprendizagem de lógica de programação, normalmente decorrente da falta de estímulos ao desenvolvimento dessa habilidade durante a formação escolar ou até mesmo do desconhecimento da importância dessa capacidade. Pensando em auxiliar nessa aprendizagem este trabalho relata o desenvolvimento de um ambiente de programação que possibilita aos alunos realizar a construção de algoritmos em português estruturado (Portugol), compilar e executar os algoritmos construídos visualizando de uma forma clara as mensagens associadas aos possíveis erros cometidos, executar passo a passo acompanhando os valores das variáveis contidas no algoritmo (teste de mesa), além de permitir ao professor disponibilizar arquivos em XML (Extensible Markup Language) com enunciados de questões, valores de entrada e valores de saídas que permitirão ao usuário verificar a corretude do algoritmo. O sistema em questão foi desenvolvido utilizando tecnologia Java através de Applets visando a portabilidade e permitindo o acesso através de ambiente Web. Alguns testes realizados consolidaram as funcionalidades desenvolvidas no trabalho e demonstraram a importância da ferramenta no auxílio ao aprendizado de Portugol e lógica de programação. Palavras-chave: Compiladores; Interpretadores; Algoritmos.
x
ABSTRACT
One of the great difficulty faced for pupils in the initial disciplines of courses as Computer Science,
Information System, Computer Engineering and similars, is learning programming logic, normally
decurrent of the lack of stimulatons to the develop this ability during the school formation or even
though the unfamiliarity of the importance of this capacity. Thinking about assisting this kind of
learning this work shows the development of a programming environment that makes possible the
pupils to carry through the construction of algorithms in structured Portuguese (Portugol), to
compile and to execute the constructed algorithms visualizing messages associates to the possible
committed errors, to execute step by step tracking the values of the variables contained in the
algorithm, beyond allowing the teacher to leave available archives in XML (Extensible Markup
Language) with enunciated of questions, values of entrance and values of exits that will allow the
user to verify the construction of the algorithm. The system was developed using Java technology
through Applet aiming at th portability and allowing the access through the Web environment.
Some tests had been carried through making possible to consolidate the functionalities and the
importance of the tool in the aid of learning Portugol and logic of programming.
Keywords: Compilers; Interpreters; Algorithms.
1
1 INTRODUÇÃO
A aprendizagem de algoritmos é considerada fundamental para o acadêmico dos cursos da
área computacional como Ciência da Computação, Sistemas de Informação, Engenharia da
Computação e Licenciatura em Computação. Seu objetivo é iniciar o desenvolvimento do raciocínio
lógico e da prática com a programação que será necessária no decorrer de todo o curso. No entanto,
a disciplina de Algoritmos é considerada desafiadora pela maioria dos alunos em virtude de possuir
um alto índice de problemas de aprendizagem, desistências e reprovações (RAABE, 2005).
Para Mendes (2005) existem problemas variados, sendo que muitos deles são comuns entre
os alunos, como o elevado nível de abstração envolvido, falta de conhecimento e prática de técnicas
de resolução de problemas, turmas heterogêneas resultando em aprendizagem diversificada,
exigência de prática para auxiliar o estudo, ausência de representação visual dos algoritmos e
sintaxes complexas.
Dentre as dificuldades vivenciadas pelos professores de algoritmos em sala de aula,
Menezes e Nobre (2002) relacionam: (i) a capacidade de reconhecer habilidades inatas de seus
alunos; (ii) apresentar técnicas de resolução de problemas; (iii) promover o desenvolvimento da
capacidade de abstração do aluno, permitindo-o selecionar as estruturas de dados coerentes; e (iv)
facilitar a cooperação e colaboração entre os alunos. Do ponto de vista de Rodrigues (2005) é a falta
de motivação gerada pelos métodos tradicionais de ensino que leva a tais resultados, pois não fica
clara ao aluno a importância desses conteúdos para sua formação.
Em vista da necessidade de minimizar as dificuldades na aprendizagem tanto da parte do
educador quanto da parte do educando, utilizam-se ferramentas de programação para representar de
uma forma visual e textual operações e interações dos algoritmos, permitindo aos alunos observar e
perceber o comportamento de um dado algoritmo (Mendes, 2005). Conforme Raabe (2005), a
proposição de ferramentas para auxiliar na aprendizagem de conceitos básicos de programação é
uma abordagem muito comum na área de Ciência da Computação.
A possibilidade de o aluno realizar testes nos algoritmos construídos em pseudocódigo
constitui-se em uma importante vantagem para adoção destas ferramentas. A estratégia de utilizar
diretamente linguagens de programação encontra uma série de dificuldades ligadas à sintaxe das
linguagens e a características pouco intuitivas dos ambientes de programação.
2
No curso de Ciência da Computação da Univali (Universidade do Vale do Itajaí), já foram
realizados esforços no sentido de definir uma linguagem de representação de algoritmos que reduza
os problemas sintáticos enfrentados tradicionalmente nas linguagens de programação. Esta
linguagem foi formalizada e chamada de Portugol. Uma notação equivalente utilizando fluxograma
também foi definida.
Essas formas de representação foram adotadas em ferramentas desenvolvidas na Univali que
foram utilizadas para auxiliar a aprendizagem de programação. Essas ferramentas serão
apresentadas neste trabalho e evidenciam que existe experiência no Curso de Ciência da
Computação da Univali para o desenvolvimento de software dessa modalidade. Nesse sentido, este
trabalho visa criar uma nova ferramenta que integre algumas das principais características dos
trabalhos anteriores e seja acessível via WWW (World Wide Web), característica não contemplada
efetivamente por nenhuma das ferramentas em uso atualmente.
Existem vantagens em utilizar uma ferramenta de programação em um ambiente WWW
como, por exemplo, a possibilidade de acesso através de diferentes plataformas, a independência de
programas proprietários e a possibilidade de integração com LMS (Learning Management Systems)
tais como Teleduc, WebCT e outros.
Dessa forma, o intuito deste projeto é desenvolver uma ferramenta para construção e testes
de algoritmos utilizando um Applet Java, o que possibilitará ao aluno construir um algoritmo em
portugol, compilar seu código, testá-lo acompanhando a mudança dos valores das variáveis
(processo normalmente chamado de teste de mesa).
Pretende-se também incluir a análise pragmática elucidada em Miranda (2004), a qual
possibilita que para um determinado problema sejam definidos valores de entrada e saídas previstas,
e com isso o algoritmo construído pelo aluno pode ser testado através de um interpretador que
utiliza esses dados de entrada e compara com as saídas geradas.
3
1.1 PROBLEMATIZAÇÃO
1.2 Formulação do Problema
O uso de ferramentas no auxílio ao desenvolvimento de lógica de programação é de vital
importância uma vez que possibilitam ao aluno construir algoritmos, compilar recebendo uma
resposta imediata do sistema de uma forma que ajude a identificar os problemas em relação à
sintaxe e ainda viabilizam testes de corretude de suas soluções. O teste de corretude para algoritmos
permite ao usuário avaliar se a solução encontrada está correta através de testes pré-estabelecidos
pelo professor.
Dentre as soluções encontradas existe a carência de uma ferramenta que possua as
características mencionadas e que possibilite seu uso no ambiente WEB facilitando a integração
com ambientes LMS, e apenas uma das ferramentas permitem a verificação da corretude.
Com base em uma análise sobre ferramentas similares, o problema abordado neste trabalho
é a ausência de ferramentas que possam auxiliar a aprendizagem de lógica de programação, através
de ambientes para desenvolvimento de algoritmos que permitam compilar, executar e acompanhar o
valor de variáveis, além de realizar a verificação da corretude algoritmos e que esteja disponível
para acesso utilizando o ambiente WEB.
1.2.1 Solução Proposta
A solução proposta é uma ferramenta que foi desenvolvida em Java com uso de Applets que
permite o desenvolvimento de algoritmos utilizando uma notação de português estruturado
conhecida como Portugol, executar algoritmos passo a passo, visualizar o conteúdo das variáveis
durante o tempo de execução, validar o código criado com auxílio de uma estrutura em XML
disponibilizada pelo professor. Além disso, o software desenvolvido contribuirá para atender as
demandas do novo curso de Tecnologia em Desenvolvimento web com Software Livre da Univali.
4
1.3 OBJETIVOS
1.3.1 Objetivo Geral
Desenvolver uma ferramenta para auxílio à aprendizagem de algoritmos, que realize análise
léxica, sintática, semântica e a interpretação do código e verificação de situações pré-estabelecidas
de teste.
1.3.2 Objetivos Específicos
Os objetivos específicos deste trabalho são:
• Estudar técnicas para construção de compiladores e interpretadores;
• Estudar ferramentas para auxiliar na construção de compiladores;
• Estudar formato de modelagem de compiladores e interpretadores;
• Realizar a modelagem do sistema;
• Implementar o compilador e o interpretador;
• Realizar testes e validar a implementação junto a um grupo de alunos da disciplina de
algoritmos;
• Documentar o desenvolvimento e os resultados do sistema; e
• Disponibilizar a ferramenta via Web em um Applet Java.
1.4 Metodologia
A metodologia de desenvolvimento deste trabalho é composta por cinco etapas. Na primeira
etapa foi realizado um levantamento bibliográfico que abordou o estudo da aprendizagem de
algoritmos, ferramentas similares, técnicas de implementação de compiladores e interpretadores,
bem como estudo das ferramentas utilizadas para construção do projeto. A segunda etapa consistiu
na modelagem da aplicação fazendo uso de diagramas da UML (Unified Modeling Language). A
terceira etapa é caracterizada pela implementação da ferramenta baseada na modelagem já
realizada. Na quarta etapa foram realizados testes para validação a fim de eliminar possíveis erros
existentes, e por fim a quinta etapa do projeto foi constituída da redação da monografia.
5
1.5 Estrutura do trabalho
Este trabalho está estruturado em cinco capítulos. O Capítulo 2 engloba toda a etapa de
fundamentação teórica, sendo abordados temas importantes para entender o trabalho como a
construção de compiladores e interpretadores aprofundando a etapa de análise léxica, sintática e
semântica. Também nesse capítulo são mostradas as ferramentas similares e uma introdução às
ferramentas que foram utilizadas para o desenvolvimento do projeto e assuntos relacionados ao
ensino e aprendizagem de algoritmos e lógica de programação. O Capítulo 3 apresenta a
modelagem do sistema e o desenvolvimento do mesmo. No quarto capítulo são apresentados os
testes realizados e hipóteses levantadas e no quinto e último capítulo são apresentadas as
considerações finais do trabalho.
2 FUNDAMENTAÇÃO TEÓRICA
Na fundamentação teórica são apresentados tópicos relacionados a este projeto. A Seção 2.1
apresenta a aprendizagem de algoritmos. A seção 2.2 foca a construção de compiladores e
interpretadores, detalhando etapas como a construção de analisador léxico, sintático e semântico,
bem como o uso de árvores sintáticas abstratas para interpretação. Na seção 2.3 são apresentadas
ferramentas similares, realizando-se um levantamento dos pontos positivos que devem ser
adicionados ao projeto e procurando-se evitar erros cometidos em projetos anteriores. A última
seção apresenta as ferramentas utilizadas para o desenvolvimento do projeto.
2.1 Aprendizagem de Algoritmos
Esta seção abrange assuntos relativos à aprendizagem de algoritmos, como a importância do
algoritmo e lógica de programação para formação de profissionais relacionados a área de
informática, métodos e técnicas para auxiliar na aprendizagem, principais problemas em relação a
aprendizagem de algoritmos.
2.1.1 Importância de Algoritmos
Aprendizagem de algoritmos é fundamental para desenvolver a lógica de programação
necessária em cursos como Ciência da Computação e afins, mas a falta do domínio dessa habilidade
é um fator responsável por grande parte da desistência dos alunos em cursos ligados à área de
informática e computação. Segundo Santos e Costa (2006), afirmam que atualmente o ensino de
algoritmos busca sustentação em cursos da área de informática, pois, cursos dessa área despertam o
raciocínio lógico e matemático durante a resolução de problemas.
Para Santiago e Dazzi (2003) a lógica de programação é ponto crucial para que o individuo
tenha as qualidades de um bom programador, sendo necessário praticar continuamente para possuir
domínio do assunto.
De acordo com Dormer (2006 apud Crook, 1994), pesquisas sugerem que os benefícios para
crianças que possuem a programação integrada ao currículo são de natureza cognitiva e afetiva,
incentivando o desenvolvimento de habilidades sociais como instinto de cooperação, motivação,
confiança, auto-estima entre outras. O uso da programação requer do aluno analisar a tarefa,
7
planejar a solução com base no seu conhecimento, modificar os planos para atingir o resultado e
revisar o produto final adquirido (DORMER, 2006 apud HARPER, 1989).
Aprender a programar computadores é importante em todas as carreiras relacionadas com a
informática, e principalmente para profissionais que tem como resultado de seu trabalho o
desenvolvimento de sistemas (PIMENTEL et al, 2003).
2.1.2 Principais Problemas Relacionados à Aprendizagem de Algoritmos
Diversos problemas surgem durante o processo de aprendizagem de algoritmos, muitos
relacionados falta de habilidade e conhecimento por parte dos alunos e outros relacionados a
dificuldades no ensino por parte do corpo docente.
Para Rodrigues (2005) existem alguns problemas relacionados com a aprendizagem de
algoritmos, sendo os principais:
• Motivação: Um dos grandes problemas está relacionado ao método tradicional de
ensino, uma vez que esse não consegue motivar o aluno a interessar-se pela matéria,
pois, não fica clara a importância de tal conteúdo durante o primeiro ano de curso;
• Avaliações: O método tradicional de avaliação do conteúdo envolve provas extensas
em relação ao tempo disponível, prática essa que desenvolve no aluno um certo
temor, prejudicando a aprendizagem;
• Comunicação: Professores preocupados em mostrar competência esquecem da
importância de uma comunicação afetiva, a qual é muito importante no processo de
aprendizagem; e
• Falta de Planejamento: A falta de planejamento das aulas, associada à falta de uma
boa bibliografia contribuem para o insucesso na aprendizagem.
Outro fator de insucesso durante o aprendizado de algoritmos é a grande quantidade de
alunos em uma mesma turma, o que dificulta a interação entre o aluno e o professor reduzindo o
auxílio as dificuldades existentes e dificultando o professor de acompanhar o desenvolvimento dos
alunos e avaliar corretamente sua evolução.
8
Para Pimentel et al (2003) a dificuldade de ensinar algoritmos surge da falta de
metodologias de ensino que permitam tratar cada aprendiz de uma maneira diferente. Visto que
cada aluno possui origem, habilidades e experiências distintas, a submissão dos mesmos as mesmas
condições apresentam resultados distintos.
Os principais problemas apresentados por iniciantes durante o aprendizado está associado a
erros de sintaxe e semântica, dificuldades na compreensão de enunciados e concepção do algoritmo
e falta de capacidade de encontrar erros de lógica de programação (PIMENTEL, 2003 apud
GOMES e MENDES, 2000).
2.1.3 Métodos para Facilitar a Aprendizagem de Algoritmos
Dormer (2006) descreve os passos que devem ser seguidos por professores durante o ensino
de algoritmos e programação, sendo eles:
• Introduzir a idéia de programação;
• Permitir aos alunos a prática em sala de aula, para concretizar os conceitos;
• Introduzir planos de programação, definindo diagramas, pseudocódigos e testes de
mesa;
• Deixar que os alunos desenvolvam seu próprios projetos;
• Criar projetos interessantes que permitam aos alunos desenvolverem na nova
linguagem; e
• Introduzir a linguagem e sintaxe correta e dar a oportunidade de realizar
programação utilizando essa nova prática.
Outra técnica é do campo de HCI (Human Computer Interaction) que presa por alguns
princípios e heurísticas que podem ser aplicados para resolver os problemas de aprendizagem de
algoritmos, como ser consistente a explicar, manter o ensino de forma simples, falar na linguagem
do aluno, prevenir erros, ajudar ao usuário a se iniciar no mundo da programação PANE (2002).
9
2.2 Construção de Compiladores e Interpretadores
A função central de um compilador é o processo de tradução (transformação do código fonte
em código objeto), processo esse que conta com uma etapa de análise onde o código fonte é
analisado, verificado e compreendido e outra etapa de síntese ou geração de código na qual um
texto de saída é gerado (RANGEL, 2006). A Figura 1 ilustra as etapas de construção de um
compilador/ interpretador.
Figura 1. Etapas de um compilador/ interpretador
Fonte: Aho et al. (1995).
Algumas ferramentas constituem a etapa de análise do código fonte, dentre elas o analisador
léxico, analisador sintático e o analisador semântico. A etapa de síntese por sua vez conta com um
gerador de código intermediário, otimizador de código e gerador de código que construirá o
programa alvo (LOUDEN, 1997).
Um compilador distingue-se de um interpretador justamente na fase de síntese. O primeiro é
orientado a construir um código objeto que será executado diretamente pela máquina, já o segundo
gera uma representação intermediária que depende de uma máquina virtual para ser transformada
em um programa, ou seja, para ser interpretada.
10
Nesta seção serão mostrados conceitos comuns à construção de compiladores, porém, com
ênfase aos aspectos ligados a construção de interpretadores.
2.2.1 Análise Léxica
Conforme Raabe (2006), durante a análise léxica ocorre o processo de identificação dos
itens léxicos, sua função é percorrer o código da esquerda para direita agrupando esses itens e
determinando sua classe. Aho et al. (1995), define que sua principal função é produzir uma
seqüência de tokens que são utilizados durante a etapa de análise sintática.
No geral a função do analisador léxico resume-se em realizar a leitura do código fonte da
esquerda para direita e agrupar os símbolos encontrados em classes ou tokens. Classes essas que
podem ser exemplificadas como um identificador (eg. VAR1, V20), uma palavra reservada, número
inteiro, número real entre outros (SETZER e MELO, 1989).
Os analisadores léxicos são reconhecedores de linguagens regulares e para sua modelagem
autômatos finitos deterministas e não-deterministas podem ser utilizados (CRESPO, 1998). De
acordo com Aho et al. (1995), um autômato finito é um reconhecedor de linguagem capaz de
responder se uma dada sentença pertence ou não a linguagem em questão.
Tanto o analisador léxico quanto o sintático trabalham em conjunto durante a análise do
código. Crespo (1998), associa o analisador léxico como uma sub-rotina do analisador sintático,
onde sempre que necessário, o analisador sintático faz uma requisição e o analisador léxico retorna
o elemento léxico e informações extras.
2.2.2 Análise Sintática
Para Crespo (1998), a análise sintática é o segundo passo no processo de compilação, tendo
como meta verificar se o conjunto de tokens ou palavras detectadas pelo analisador léxico faz parte
da linguagem. De acordo com Lacerda (1996 apud MIRANDA, 2004), na fase de análise sintática
ocorre a transformação da seqüência de palavras encontradas em estruturas de palavras que
demonstram o relacionamento entre as palavras. Louden (1997), complementa que os resultados da
análise sintática são normalmente representados como uma árvore sintática.
Também é esperado que durante a etapa de análise sintática o analisador relate os erros
sintáticos de forma a serem facilmente compreendidos, e apresente mecanismos que leve à
11
recuperação dos erros normalmente cometidos, não interrompendo assim a continuação da
verificação (AHO et al., 1995).
A grande maioria dos analisadores sintáticos utiliza gramática livre de contexto (GLC) em
uma notação conhecida por BNF (Backus Naur Form - Forma Normal de Backus) ou alguma
variante dessa notação para descrever a sintaxe de uma linguagem de programação (RANGEL,
2006).
Conforme Aho et al. (1995) uma gramática livre de contexto possui quatro componentes:
• Conjunto de tokens, conhecidos como símbolos terminais;
• Conjuntos de símbolos não terminais;
• Conjuntos de produção, onde cada produção é formada por um símbolo não terminal
posicionado ao lado esquerdo, uma seta, e ao lado direito uma seqüência de tokens
terminais ou não terminais; e
• Um símbolo não terminal designado símbolo de partida.
Podemos ver a seguir um exemplo de gramática livre de contexto que é capaz de identificar,
entre outras, a cadeia a + a * a:
E → E + T | T
T → T * F | F
F → ( E ) | a
Como resultado da análise sintática da cadeia de entrada citada acima pode-se obter a árvore
sintática da Figura 2.
12
E
E
T
F
a
T +
* T F
a F
a
Figura 2. Árvore sintática
O processo do analisador sintático utiliza árvores de derivação para verificar se uma cadeia
pertence à gramática em questão. Existem dois tipos de análise sintática, ascendente e descendente
que diferem na maneira em que a árvore de derivação é construída (RANGEL, 2006).
Análise Sintática Ascendente (Bottom-Up)
Na análise sintática ascendente o analisador tenta encontrar uma árvore de derivação
partindo das folhas da árvore, realizando as reduções necessárias. Se todas as reduções forem
realizadas e o símbolo resultante é o símbolo inicial então podemos considerar a cadeia validada
(RAABE, 2006).
Crespo (1998), complementa que a árvore de derivação na análise ascendente é construída
percorrendo os símbolos da frase, da esquerda para a direita, operação esta denominada
deslocamento ou shift. Quando uma seqüência de símbolos encontrada do lado direito da produção
é idêntica ao símbolo não terminal do lado esquerdo, então essa seqüência é substituída pelo não
terminal, numa operação designada redução ou reduce.
Existem diversos algoritmos de análise sintática ascendentes, destacando-se o CKY,
precedência de operadores, precedência simples, precedência fraca e outros, porém o mais utilizado
é o LR (CRESPO, 1998). Sendo o algoritmo denotado LR o mais utilizado na construção de
analisadores sintáticos, será mostrado mais detalhadamente o seu significado e diferentes técnicas
de construção.
13
No método LR, “L” tem o significado de realizar uma varredura da esquerda para direita
(left-to-right), e “R” construir uma derivação mais à direita (rightmost) invertida (RANGEL, 2006).
Existem três diferentes técnicas de implementação da tabela sintática para a gramática em
algoritmos LR. LR simples ou SLR (o mais simples de construir, porém o menos eficiente) em
algumas gramáticas pode falhar ao construir a tabela sintática, LR canônico o mais poderoso e
complexo de construir e LALR que tem uma eficiência intermediária entre o SLR e o LR canônico
(AHO et al., 1995).
Análise Sintática Descendente (Top-Down)
Objetiva a partir do símbolo inicial da gramática, encontrar derivações válidas que permitam
atingir a cadeia de entrada, sendo que esse conjunto de derivações pode ser representado por árvore
de derivação (RAABE, 2006).
De acordo com Aho et al. (1995), a construção da árvore de derivação top-down começa a
partir da expansão do símbolo inicial da gramática e segue os seguintes passos:
1. Escolher um não-terminal a partir do símbolo inicial.
2. Escolher uma produção deste não terminal.
3. Expandir o nodo da árvore.
4. Se existir um não-terminal a expandir voltar ao passo 2.
Para evitar retrocessos ou backtrack causados por erros na escolha do não-terminal a
expandir é feito uso de uma classe restritiva da gramática livre de contexto, denominada LL(1)
(CRESPO, 1998), onde de acordo com Rangel (2006) “L” significa que a cadeia de entrada é
analisada da esquerda para a direita (left to right), o segundo “L” representa que o analisador
procura construir uma derivação a esquerda ou leftmost e o “1” significa apenas que o próximo
símbolo do resto da cadeia é examinado.
Aho et al. (1995), levanta alguns requisitos que devem ser atendidos em relação a
gramáticas LL(1), que são: gramática fatorada a esquerda, e não recursiva a esquerda.
14
2.2.3 Análise Semântica
A última etapa de análises é a análise semântica do código fonte (CRESPO, 1998). Durante
a análise semântica é feita uma verificação se os elementos que compõe a árvore sintática abstrata
satisfazem as regras de semântica da linguagem (LORHO, 1984 apud LUZ, 2004). Conforme
Rangel (2006), a parte que cabe ao analisador semântico é a verificação de todos os aspectos que
não podem ser analisados na linguagem através de gramáticas livres de contexto como, por
exemplo, verificar se uma variável foi previamente declarada antes de ser devidamente utilizada.
Segundo Raabe (2006), algumas das verificações possíveis de serem realizadas durante a
análise semântica são:
• Verificação de tipos: os tipos das variáveis em uma atribuição não podem ser
incompatíveis, por exemplo, deve ser reportado um erro ao somar um caractere a uma
variável inteira;
• Verificação de fluxo de controle: código inatingível; "break" dentro do "while"
impossibilitando acesso ao resto do código do loop;
• Verificação de unicidade: um identificador só pode ser declarado uma vez para o
escopo;
• Verificação de variáveis não usadas: variáveis declaradas e não usadas podem ser
avisadas ao usuário;
• Verificação de variáveis não inicializadas: variáveis que participam de uma expressão
sem terem recebido um valor inicial; e
• Verificação de nomes: em Ada um bloco deve ter o mesmo nome no início e no fim,
essa verificação deve garantir a premissa.
Uma técnica abordada é a análise semântica dirigida à sintaxe, na qual são associadas às
regras sintáticas ações semânticas que são disparadas quando o analisador sintático faz uso da regra.
Estas ações semânticas possibilitam também a tradução do código fonte para representações
intermediárias ou até conjuntos de instruções de uma máquina alvo. Desta forma, a análise
semântica torna-se o centro do processo de tradução de uma linguagem, e através das ações
semânticas é que serão construídas as representações que possibilitarão a transformação do código
em programa executável ou interpretável por uma máquina virtual (RANGEL, 2006).
15
2.2.4 Interpretadores
Diferentemente de um compilador, o interpretador executa o programa fonte diretamente
sem ter que gerar um código objeto para ser executado após a tradução de todo o programa
(LOUDEN, 1997). Crespo (1998), relata que todo o procedimento de um interpretador inicialmente
é igual ao de um compilador, porém na etapa de síntese onde seria gerado um código final, esse é
substituído por uma máquina virtual que interpreta uma linguagem intermediária, normalmente uma
notação de árvore.
Uma possibilidade para representar a linguagem intermediária no interpretador é a árvore
sintática, porém conforme Louden (1997), e como pôde ser visto na Figura 2 (apresentada
anteriormente) esse tipo de notação é útil para visualizar a sintaxe da gramática uma vez que ela
contém em seus nós internos os nomes das estruturas gramaticais (marcas) que ela representa, e as
folhas da árvore contém os símbolos terminais da gramática, porém esse tipo de árvore possui uma
orientação sintática, e contém informações que não são necessárias para a construção de um
interpretador.
Existem outras notações de linguagens intermediárias tais como máquina virtual de pilha
(utilizadas em ferramentas comercias como Java e Framework. net), código de três endereços e
árvores abstratas. Este último será apresentado em detalhes a seguir.
2.2.5 Árvores Sintáticas Abstratas
Uma árvore sintática abstrata (ASA) é caracterizada por árvore finita, rotulada e direcionada,
onde seus nodos internos contém os operadores, e as folhas carregam os operandos ligados aos
operadores. É uma representação intermediária entre uma árvore sintática e a estrutura de dados
interna utilizada para otimização de códigos em compiladores e interpretadores. Em geral o que
difere uma árvore sintática abstrata e uma árvore sintática é a omissão de nodos que não afetam a
semântica do programa (WIKIPEDIA, 2006).
A criação de uma ASA em um compilador é feita de forma que a maioria das regras de
produção da gramática geram novos nodos contendo os símbolos de cada regra. As regras que não
contribuem semanticamente (tais como regras de recursão e agrupamento) não são incluídas na
ASA.
16
Conforme Louden (1997), nesse tipo de árvore ocorre uma abstração das marcas do código
fonte onde as características semânticas são mantidas. É uma das técnicas mais utilizadas para
construção de interpretadores uma vez que gera uma estrutura do programa em memória. Através
de algoritmos que percorrem esta estrutura pode-se realizar a interpretação do código realizando as
mesmas ações do programa compilado. A Figura 3 mostra uma árvore sintática abstrata para
representar a expressão (3+4) * 5.
3 4
+
*
5
Figura 3. Árvore sintática abstrata
Fonte: Aho et al. (1995).
A Figura 4 mostra outro exemplo de ASA para representar o seguinte desvio condicional:
SE (A > B)
ENTAO
A = B
SENAO
B = A
FIMSE
17
SE – ENTAO - SENAO
+
A B
> +
A B
=
B A
=
Figura 4. Árvore sintática abstrata para desvio condicional
A Tabela 1 demonstra as regras de produção para a construção de uma árvore sintática
abstrata para a cadeia 5-4+8 através da associação de ações semânticas às regras de produção da
gramática. A Tabela 1 apresenta as regras de produção, suas respectivas ações semânticas bem
como uma breve descrição de cada ação.
Tabela 1. Regras de Produção e Ações Semânticas
Produção Ação Semântica Descrição E -> E1 + T E.nptr := cria_no ('+', E1.nptr, T.nptr) Cria um nó da árvore com
token identificador '+' e dois ponteiros.
E -> E1 – T E.nptr := cria_no ('-', E1.nptr, T.nptr) Cria um nó da árvore com token idenficador '-' e dois ponteiros.
E -> T E.nptr := T.nptr O ponteiro E aponta para o ponteiro T.
T -> (E) T.nptr := E.nptr O ponteiro T aponta para o ponteiro E
T -> id T.nptr := cria_folha (id, id.entrada) Cria uma folha como token identificador 'id' e o valor de entrada do identificador.
T -> num T.nptr := cria_folha (num, num.val) Cria uma folha com token identificador 'num' e o valor da constante.
Fonte: Adaptado de Aho et al. (1995).
18
A construção dessa árvore ocorre de baixo para cima onde
primeiramente é realizada a chamada das funções respectivamente Aho
et al. (1995):
• p1 = cria_folha(num, 5) ;
• p2 = cria_folha(num,4);
• p3 = cria_no('-',p1,p2);
• p4 = cria_folha(num,8);
• p5 = cria_no('+', p3, p4);
De acordo com Aho et al. (1995), a Figura 5 exibe na parte inferior a construção de uma
árvore sintática abstrata enquanto a árvore pontilhada uma representação de árvore gramatical que
pode existir somente em sentido figurado.
E
T nptr
id
E nptr
E nptr
-
+
num 5
-
T nptr
num
num 4
+
T nptr
id
num 8
Figura 5. Construção de árvore sintática abstrata
Fonte: Adaptado de Aho et al. (1995).
19
2.3 Estudo de Ferramentas Similares
Nesta seção são apresentadas algumas ferramentas estudadas que auxiliam na aprendizagem
de programação.
2.3.1 Happy Portugol
O Happy Portugol é uma ferramenta que visa facilitar o ensino da lógica de programação,
através de uma interface que possibilita ao usuário escrever códigos em português estruturado
(portugol), converter para linguagem C++, além de possuir mecanismos para execução do
programa.
A Figura 6 apresenta a interface do Happy Portugol. É simples de utilizar, possui uma área
para descrever o código em portugol, área para visualizar o código em C++, área para verificação
das mensagens de erros geradas no processo de compilação, algumas ferramentas para edição do
texto, possibilidades de salvar e abrir códigos previamente salvos, menu de testes constituído pelas
opções de transformação e execução do código gerado em C++.
Figura 6. Interface do Happy Portugol
20
A ferramenta possui uma certa carência no que tange a apresentação de mensagens de erros
que sejam simples de serem compreendidas, bem como a ausência de mecanismos que permitam
executar algoritmos passo a passo realizando o acompanhamento dos valores das variáveis de um
algoritmo durante a sua execução.
2.3.2 CIFluxProg I e CIFluxProg II
De acordo com Santiago e Dazzi (2004), o CIFluxProg é um ambiente de programação que
tem como intuito auxiliar estudantes de computação no aprendizado de lógica de programação de
uma maneira fácil e intuitiva. Conciliando na ferramenta dois módulos: módulo de construção e
testes de fluxograma e um módulo para construção e testes de algoritmos em Portugol.
O CIFLuxProg aborda no módulo fluxograma a possibilidade de criação de variáveis
(inteiro, real, caractere, cadeia), uso de laço de repetição, entrada e saída de dados e desvio
condicional. A Figura 7 demonstra o módulo de programação em fluxogramas.
Figura 7. Módulo de fluxograma
No módulo de programação em portugol variáveis como inteiro, caractere e real podem ser
utilizadas, laços de repetição (enquanto, para, faça enquanto) e desvio condicional (se e senão). A
Figura 8 mostra a interface do CIFLuxProg no modo de programação em portugol.
21
Figura 8. Módulo de programação em portugol
O CIFluxProg é um ambiente de programação completo que permite além de compilar os
algoritmos, realizar execução, executar passo a passo acompanhando os valores das variáveis
declaradas, porém apresenta alguns pontos negativos como não poder ser utilizado em diferentes
plataformas, tornando-se restrito ao ambiente Windows e não possuir nenhum tipo de salientador de
sintaxe para a gramática, o que torna mais atrativo aos alunos e facilita a identificação de palavras
reservadas da linguagem.
A continuação do trabalho desenvolvido por Santiago e Dazzi (2004) é o CIFluxProg II ,
que tem como intuito auxiliar o professor a realizar correção de avaliação de algoritmos sem perder
o padrão inicialmente utilizado, é uma extensão do CIFLuxProg incorporando maiores
funcionalidades (MIRANDA, 2004), tais como:
• Campo para visualizar enunciado de questões, erros, comentários; e
• Implementação de uma nova tela que permite ao professor realizar a entrada de um novo
enunciado de exercício, algoritmo modelo, e pontos chaves que serão utilizados para
verificação e correção dos algoritmos criados pelos alunos.
22
A ferramenta agrega ao compilador do CIFLuxProg a análise semântica e análise
pragmática, além de um sistema especialista responsável pela leitura de um arquivo gerado após as
análises que verifica os tipos de erros cometidos e fornece como saída a nota e comentários
(MIRANDA, 2004).
2.3.3 Portugol/Plus
Conforme Esmin (1998), o Portugol/Plus é um ambiente para desenvolvimento de
programas em portugol visando apoiar e estimular o ensino de lógica de programação, sem redução
nos estudos teóricos.
O ambiente está constituído de duas partes principais, um editor de algoritmos que pode ser
visto na Figura 9 e um compilador, sendo desenvolvido para operar sobre a plataforma DOS (Disk
Operating System).
Figura 9. Ambiente de programação do Portugol/Plus
O editor de algoritmos possui apenas algumas funcionalidades básicas de um editor, como
manipulação de arquivos, localização e substituição de trechos de código dentro de um arquivo, e
disponibiliza menu para compilação e execução do código. O compilador do Portugol/Plus faz a
23
verificação da sintaxe das instruções e gera um programa objeto em Pascal que será executado
através de um compilador Pascal.
2.3.4 AWTM
AWTM (Aplicação WEB para Realizar Teste de Mesa em Algoritmos) é um ambiente
composto por um conjunto de ferramentas, incluindo analisador léxico e sintático, que trabalham
para realizar teste de mesa sobre algoritmos e apresentar informações sobre a análise dos mesmos.
A ferramenta foi desenvolvida em Delphi 5 e implementa um componente ActiveX que
pode ser disponibilizado em HTML (Hyper Text Markup Language) através da Web (MEDEIROS,
2001 apud MEDEIROS e DAZZI, 2002).
Conforme Medeiros e Dazzi (2002), além de realizar análise e teste de mesa o software
apresenta possibilidade de gravar o algoritmo no banco de dados para que possa ser utilizado
posteriormente pelo proprietário ou por qualquer outra pessoa interessada no código se o mesmo for
salvo sem senha.
Dentre os softwares analisados, o AWTM foi o único encontrado que tem como foco a
atuação em ambiente WEB, no entanto o processamento ocorre no lado do servidor e não possui
nenhuma versão funcional a disposição.
2.3.5 G-Portugol
O G-Portugol é um dialeto da linguagem portugol, que tem como proposta disponibilizar um
ambiente que ofereça recursos de edição, compilação, execução e a depuração de programas
escritos nessa linguagem (SILVA, 2006).
De acordo com Silva (2006), a linguagem não difere fundamentalmente do portugol e
apresenta alguma semelhança a linguagens como Pascal e C. Algumas características da linguagem
são listadas abaixo:
• Linguagem Imperativa;
• Tipos de dados suportados: inteiro, real, caractere, literal, lógico, vetores e matrizes de
dimensão variável;
24
• Estruturas de controle: se/ então/ senão, enquanto e para; e
• Permite o uso de funções.
Duas ferramentas são disponibilizadas para trabalhar com a linguagem G-Portugol, o GPT e
o GPTEditor. Algumas características importantes que podem ser destacadas do GPT é sua função
de compilar os algoritmos, capacidade de realizar a tradução dos programas para linguagem C,
interpretar os algoritmos, além de possibilitar a depuração dos programas, função essa que se faz
recomendável associada à ferramenta GPTEditor. A associação entre os dois módulos serve de
front-end para a compilação, execução e depuração de programas, permite a inspeção da pilha de
execução e variáveis, uso de Breakpoints, é um editor com suporte de cores para as palavras chaves,
operadores e comentários e possibilita analisar um código em segundo plano enquanto se está
escrevendo outro algoritmo. A Figura 10 exibe uma imagem do ambiente de programação
GTPEditor.
Figura 10. Ambiente de programação GPTEditor
Fonte: Silva (2006).
25
O G-Portugol por ser desenvolvido na linguagem de programação Java é um sistema multi-
plataforma, porém a tentativa de avaliar a ferramenta não foi possível pelo fato da versão disponível
não ser funcional.
2.3.6 Síntese das Características das Ferramentas Analisadas
Algumas das ferramentas possuíam um protótipo funcional ou informações disponíveis
possibilitando o levantamento de algumas informações adicionais. A Tabela 2 agrupa algumas
características importantes analisadas que serão adicionadas a este trabalho e algumas
características negativas que serão evitadas.
Tabela 2. Características das Ferramentas Analisadas Ferramenta
Característica Happy Portugol
CIFluxProg
I e II AWTM G-Portugol
Ano de Produção 2004 2004 2001 2006
Linguagem de
Desenvolvimento C++ C++ DELPHI JAVA
Representação de
Algoritmo Usada Portugol
Portugol e
Fluxograma Portugol G-Portugol
Plataformas em que Roda Windows Windows Windows Windows/Linux
Possibilidade de Executar
passo a passo Não Não Sim Sim
Ilustração de Variáveis
(Teste de Mesa) Não Sim Sim Sim
Gera Executável Sim Não Não Sim
Necessita software ou
plug-in Sim Não Sim Sim
Possui Editor Sim Sim Sim Sim
Possui Pacote Instalador Sim Sim Não Não Encontrada
Executa em Ambiente WEB Não Não Sim Não
Mensagens de Erros
Explicativas Não Não Não Não Encontrada
Possui Versão Funcional Sim Sim Não Não
Verifica Algoritmos Não Sim Não Sim
26
Como pode ser visto na Tabela 2, existe uma grande carência no que tange ferramentas para
uso em ambiente web, bem como grande parte das ferramentas analisadas não permite
portabilidade, tendo sido desenvolvida focada em um único sistema operacional.
A portabilidade apresentada por algumas ferramentas, a ilustração de variáveis, a
possibilidade de verificar os algoritmos construídos e executá-los são alguns pontos fortes
encontrados nas ferramentas estudadas e que devem ser adotados neste projeto.
2.4 Tecnologias a serem Utilizadas
Nesta seção serão mostradas as ferramentas que foram utilizadas para o desenvolvimento do
projeto.
2.4.1 NetBeans
Para o desenvolvimento desse projeto foi escolhida a linguagem de programação Java,
primeiramente por ser Open Source, outro motivo para tal escolha está relacionado ao fato de não
necessitar de um servidor e ser executado diretamente no lado cliente, outro fator de vital
importância é devido ao código gerado pela ferramenta GALS para analisador léxico e sintático ser
em Java. Para a implementação da ferramenta em Java foi escolhido o ambiente de programação
Netbeans.
O Netbeans é um projeto de código livre (Open-Source) que visa prover aos usuários, um
software para auxiliar os desenvolvedores e usuários a realizar o desenvolvimento de seus produtos.
Os dois produtos básicos dentro do projeto são o NetBeans IDE (Integrated Development
Environment) e o NetBeans Plataform (NETBEANS, 2006).
De acordo com Silva (2006), o NetBeans Plataform é uma ambiente para o desenvolvimento
de projetos e a criação de “modules”, que possui as seguintes funcionalidades:
• Interface com o usuário: menus, barras de ferramentas e outros componentes de
interação com usuário;
• Editor: recursos para desenvolvimento de aplicações visuais com Swing e AWT,
aplicações WEB;
• Gerenciamento: Views para gerenciar a estrutura do projeto, uso de projects, CVS, FTP
ou base de dados remota;
27
• Cross-Plataform: permite seu uso em diferentes plataformas por ser escrito totalmente
em Java; e
• Wizards: ferramentas para gerenciamento de código, criação de templates entre outros.
Conforme NetBeans (2006), o NetBeans IDE é um ambiente rápido e completo para o
desenvolvimento de aplicações em Java que é executado em qualquer sistema operacional que tenha
uma máquina virtual Java. Silva (2006) caracteriza a ferramenta como um conjunto de bibliotecas,
módulos e APIs (Application Programming Interface) que formam um ambiente para
desenvolvimento visual com funções para compilar, depurar além de outros recursos como:
• Depurar e compilar programas;
• Autocompletar, depurador de erros e Servlets;
• Salientador de sintaxe para XML, CSS, JSP, HTML e IDL;
• Suporte as linguagens Java, C e C++;
• Macros de abreviação;
• Identação automática de código; e
• Refatoração básica de código Java.
2.4.2 Applets
Segundo Lemay e Perkins (1997), applets são códigos escritos em Java que são executados
dentro de um navegador no ambiente WWW através de tags especiais do HTML. Para Deitel e
Deitel (2003) são pequenos programas que ficam armazenados em computadores remotos e são
carregados quando um navegador se conecta e eliminados ao fim de sua execução.
Applets são programas escritos em Java que utilizam JVM (Java Virtual Machine) da
máquina do cliente ou até mesmo no próprio navegador para interpretar o seu código, são
geralmente usados para adicionar interatividade em aplicações web que não podem ser obtidas
apenas com uso de HTML (WIKIPEDIA, 2006).
28
Algumas vantagens em relação ao uso de applets:
• Permitem construir pacotes sofisticados de processamento de gráficos, desenhos e
imagens uma vez que possuem os mesmo recursos do navegador;
• O processamento ocorre do lado cliente;
• É Multi-plataforma;
• Executam em ambiente web com uso de navegador; e
• Permite o uso de threads.
Levando em consideração que os applets podem ser carregados em qualquer computador,
existem algumas restrições que devem ser realizadas para aumentar a segurança em seu uso, tais
como (LEMAY e PERKINS, 1997):
• Não tem acesso ao sistema de arquivos do computador no qual está sendo executado;
• Não podem trocar informações com servidores diferentes do servidor que originalmente
o armazenou;
• Não podem acessar ou carregar programas nativos da plataforma; e
• Necessitam de uma máquina virtual para serem executados.
Segundo Indrusiak (1996), o applet possui um ciclo de vida que pode ser definido pelas
funções init, start, stop e destroy. O método init é executado no momento em que o applet é
carregado, o método start é invocado no instante em que o applet é desenhado na tela, a função stop
é usada no momento em que o applet deixa de ser visível e a função destroy deve ser chamada
quando os recursos alocados pelo applet precisam ser liberados.
2.4.3 Gals
Gals é uma ferramenta de código livre, que tem como propósito agregar no mesmo sistema
recursos para construção do analisador léxico e sintático, diferentemente de outras soluções
existentes que implementam apenas uma das abordagens, levando o usuário a ter a necessidade de
conhecer duas ferramentas distintas (GESSER, 2003). O ambiente foi desenvolvido em Java, o que
permite sua execução em qualquer plataforma que possua uma máquina virtual Java.
29
Construção de analisadores Léxicos com Gals
De acordo com Gesser (2003), a geração de analisadores léxicos é feita através de
especificações léxicas, baseadas em expressões regulares. Na ferramenta pode ser feita a
especificação de tokens através de expressão regular e especificação de definições léxicas, que
podem ser vistas como macros na definição dos tokens.
Exemplo de macro ou definição léxica:
Letra: [a-zA-Z]
Digito: [0-9]
A definição acima de Letra e Digito servem apenas para facilitar a construção das
especificações de tokens, sem que seja necessário reescrever a expressão regular que gera uma letra
ou digito toda vez que essa tiver que ser utilizada. O exemplo a seguir mostra o uso de uma
definição léxica na especificação de token.
ID: {Letra} ({Letra}| {Digito})*
INT: {Digito}+
Construção de analisadores Sintáticos com Gals
Na construção de um analisador sintático na ferramenta Gals são necessárias três etapas:
definição de tokens ou símbolos terminais, definição de símbolos terminais e definição das regras
da gramática (GESSER, 2003).
Na Figura 11 é especificado um analisador sintático para operações de soma e subtração
com números inteiros e variáveis, a notação adotada pela ferramenta para descrição da gramática é a
BNF.
30
Figura 11. Construção de Analisador Sintático com a Ferramenta Gals
A ferramenta além de construir o código para o analisador léxico e sintático, gera um
esqueleto do analisador semântico e possibilita ao usuário inserir ações semânticas no lado direito
da regra de produção da gramática. Durante a análise sintática toda vez que uma regra semântica é
encontrada o analisador sintático repassa o número da ação e o último token lido para o analisador
semântico. Cabe ao desenvolvedor do compilador ou interpretador realizar as demais etapas de
síntese, trabalhando em uma abordagem dirigida pela sintaxe.
31
3 DESENVOLVIMENTO
Diversas fontes foram estudadas durante a elaboração da modelagem do projeto como Aho
et al. (1995), Processadores de Crespo (1998) e Louden (1997). Além de outros materiais, os
diagramas tradicionais para a modelagem de compiladores estão relacionados às Árvores de
Derivação e Sintaxe Abstrata. Ainda assim resolveu-se abordar neste projeto alguns artefatos da
UML para especificar partes do sistema que não estão ligadas especificamente à construção do
núcleo do compilador, mas sim as funcionalidades acessíveis ao usuário.
Na sessão 3.1 é apresentado o levantamento de requisitos, onde são exibidos requisitos
funcionais, não funcionais e as regras de negócio que constituem o sistema. Na sessão 3.2 está a
especificação do modelo do grupo de casos de testes necessário para realizar a verificação do
algoritmo. As duas sessões posteriores apresentam consecutivamente o modelo de casos de uso e
diagramas de classes. A sessão 3.5 contém o protótipo do sistema e a última sessão deste capítulo
trata a implementação do projeto.
3.1 LEVANTAMENTO DE REQUISITOS
Nesta sessão são apresentados os requisitos da ferramenta, limitando a função da ferramenta
e como ela deve realizar seu trabalho. Os requisitos estão divididos em três partes: requisitos
funcionais, requisitos não funcionais e regras de negócio.
3.1.1 Requisitos Funcionais
Os requisitos funcionais compreendem as características do sistema, descrevendo os
serviços que a ferramenta oferecerá.
Lista dos requisitos funcionais
• RF01: O sistema deverá permitir ao usuário a construção de algoritmos em portugol;
• RF02: O sistema deverá permitir ao usuário compilar o algoritmo;
• RF03: O sistema deverá permitir ao usuário executar o algoritmo;
• RF04: O sistema deverá possibilitar ao usuário a execução do algoritmo passo a passo;
• RF05: O sistema deverá emitir mensagens caso existam erros léxicos, sintáticos e
semânticos;
32
• RF06: O sistema deverá permitir a passagem de um arquivo XML contendo o enunciado
e os grupos de testes;
• RF07: O sistema deverá permitir ao usuário verificar a corretude do seu algoritmo
utilizando os dados de testes contidos no arquivo XML passado como parâmetro; e
• RF08: O sistema deverá possibilitar ao usuário acompanhar o valor das variáveis durante
a execução (teste de mesa).
3.1.2 Requisitos não Funcionais
Os requisitos não funcionais listados abaixo descrevem como será o acesso à ferramenta e
linguagem de programação na qual será desenvolvida.
Lista dos requisitos não funcionais
• RNF01: O sistema deverá ser desenvolvido utilizando tecnologia Java com uso de
Applets;
• RNF02: O sistema deverá ser acessível via ambiente WEB com uso de navegador;
• RNF03: Apenas algoritmos em portugol poderão ser gerados;
• RNF04: Os arquivos XML para correção de algoritmos deverão seguir o mesmo padrão.
3.1.3 Regras de Negócio
As regras de negócio definem como é o funcionamento do negócio, e servem para delimitar
e esclarecer a amplitude do sistema em questão.
Lista das regras de negócio
• RN01: O programa não poderá ser executado nem verificada a sua corretude caso possua
erros;
• RN02: A entrada e saída de dados devem ocorrer por meio de um console simulado
durante a execução; e
• RN03: Uma vez encontradas falhas durante a verificação da corretude, o sistema deverá
informar ao usuário o valor (ou conjunto de valores) que ocasionou o erro.
33
3.2 GRUPOS DE TESTE
O modelo XML presente no levantamento de requisitos do sistema diz respeito ao arquivo
que será utilizado no sistema para definir o enunciado de uma questão que será desenvolvida pelo
aluno, bem como para definir os grupos de valores de teste que serão usados para verificar a
corretude do algoritmo desenvolvido. O arquivo deverá seguir o padrão mostrado na Figura 12.
Figura 12. Modelo XML
A verificação de corretude tem a função de analisar se o algoritmo escrito pelo aluno para
determinada situação imposta pelo professor está correta para os grupos de testes informados no
arquivo de teste. Durante a verificação será executado o algoritmo diversas vezes de acordo com a
quantidade de grupos disponibilizada pelo professor. Durante um comando de leitura ao invés do
sistema solicitar ao usuário a entrada de um valor via console, o sistema utilizará um valor de
entrada contido em um grupo de testes do XML. Durante um comando de escrita do resultado no
console o sistema substituirá pela comparação com o valor contido entre a tag <saída>. Caso todas
as entradas dos grupos de testes sejam utilizadas e todas as saídas informadas pelo algoritmo
<?xml version="1.0" encoding="ISO-8859-15" ?>
<query xmlns="questao">
<enunciado>Enunciado do problema</enunciado>
<grupo>
<entrada>10</entrada>
<entrada>15</entrada>
<entrada>20</entrada>
<saida>25.5</saida>
<saida>55</saida>
<saida>12</saida>
</grupo>
<grupo>
<entrada>10</entrada>
<entrada>15</entrada>
<entrada>20</entrada>
<saida>25.5</saida>
<saida>55</saida>
<saida>12</saida>
</grupo>
<grupo>
<entrada>10</entrada>
<entrada>15</entrada>
<entrada>20</entrada>
<saida>25.5</saida>
<saida>55</saida>
<saida>12</saida>
</grupo>
</query>
34
estejam iguais aos valores de saída do grupo, então considera-se o algoritmo escrito de maneira
correta.
3.3 DIAGRAMAS DE CASOS DE USO
Um caso de uso pode ser entendido como uma série de ações que visam completar uma
atividade, devendo ser bem detalhado, pois será utilizado em diversas outras etapas da modelagem
orientada a objetos com uso de UML (MEDEIROS, 2004). A Figura 13 mostra o diagrama de casos
de uso que será utilizado neste projeto, o detalhamento dos casos de usos podem ser vistos nos
anexos apresentados no fim do trabalho.
Figura 13. Diagrama de Casos de uso
Diagrama de Caso de Uso
Usuário
Algoritmos UC02 - Parar
Execução
UC03 - Executar
Algoritmo
UC04 - Verificar
Algoritmo
UC05 – Gerar XML
UC01. Elaborar
Professor
35
3.4 DIAGRAMA DE CLASSE
Do ponto de vista de Medeiros (2004) o diagrama de classes pode ser dividido em diagrama
conceitual, onde é abordado o negócio em questão, diagrama de especificação no qual as classes são
tratadas como software indicando os parâmetros de entrada e saída e os diagramas de
implementação onde são escritos os códigos das classes. Este projeto utiliza para construção do
diagrama de classes uma abordagem que inclui tanto o diagrama conceitual como o diagrama de
implementação.
O diagrama de classes do projeto está dividido em pacotes para melhor visualização. No
primeiro pacote denominado “Recursos” encontram-se a modelagem de classes como “tabela de
variáveis” e “XML” que tem como objetivo dar suporte a etapa de compilação e interpretação. No
segundo estão as classes relativas ao applet e ao compilador e no terceiro pacote estão as classes
para montagem da árvore abstrata que será utilizada na etapa de execução.
3.4.1 Classes de Recurso
A classe questão na Figura 14 tem a função de armazenar a questão contida no arquivo
XML, bem como relacionar-se com a classe atributos de maneira que uma questão possa ter vários
atributos. No caso da tabela de variáveis e da classe variável a sua função é armazenar as variáveis
declaradas no sistema para serem utilizadas durante a execução do algoritmo.
36
cd 1. Recursos
2. Applet / Compilador::
Semantico
+ executeAction() : void
TabelaVariaveis
- tabela: Vector
+ addVariavel(boolean, char, char, char) : boolean
+ getTipoPorNome(char) : char
+ getValorPorNome(char) : char
+ trocaValor(char, char) : void
Variavel
- constante: boolean
- nome: char
- utilizado: boolean
- valor: varchar
- inicializado: boolean
+ getNome() : char
+ getTipo() : char
+ getValor() : char
+ setValor(char) : void
+ Variavel(char, boolean, char, char) : void
questao
- xml_path: char
- descricao_questao: char
+ carregaConteudoXml()
+ getProximaEntrada() : char
+ getProximaSaida() : char
atributos
- grupo_teste: int
- tipo: char
- utilizado: boolean
- valor: char
+ conteudoXml(char, boolean, char, int) : void
+ getEntrada(int) : void
+ getQtdGrupos() : int
+ getSaida(int) : void
1
0..1
1
0..*
1
0..*
1 0..1
Figura 14. Diagrama de classes de recursos do sistema
3.4.2 Classe do Applet e Compilador
No pacote descrito no diagrama da Figura 15 são armazenadas as classes referentes a
interface da aplicação e as classes geradas automaticamente pela ferramenta GALS para realizar a
compilação dos algoritmos.
37
cd 2. Applet / Compilador
Applet
+ compilar() : void
+ executar() : void
+ executarPassoPasso() : void
+ init() : void
Semantico
+ executeAction() : void
Sintatico
- scanner: lexico
- semanticAnalyser: semantico
- passo_passo: boolean
+ parser(Semantico, Lexico) : void
+ step() : void
Lexico
+ hasInput() : boolean
+ nextChar() : char
+ nextState(int, char) : void
+ nextToken() : void
+ setInput(string) : void
+ setPosition(int) : void
+ tokenForState(int) : void
1
0..1
1 0..1
0..11
Figura 15. Diagrama de classes do applet e compilador
3.4.3 Classes do Interpretador
Na Figura 16 são mostradas as classes que formam a árvore sintática abstrata que será
utilizada para a interpretação do algoritmo.
Das classes do pacote serão explicadas as classes de maior complexidade. A classe LCMD
tem a função de lista de comando, a qual traz em um de seus filhos um comando e no outro aponta
para uma outra lista de comando. No caso de classe CMD (comando) é apenas uma classe de
agregação para todos os comandos, onde uma classe comando pode ser transformada através de
polimorfismo para qualquer comando do compilador e por fim classe operação que também possui
a finalidade de agregar duas outras classes, a classe denominada operador e a classe valor.
38
Figura 16. Diagrama de classes do interpretador
39
3.5 INTERFACE DO SISTEMA
Esta sessão apresenta a interface do sistema desenvolvido com a versão final das
funcionalidades.
3.5.1 Construção de Algoritmos
A Figura 17 mostra uma visão da tela inicial do sistema, evidenciando a área de construção
do algoritmo identificada pelo número 1, área destinada para exibir o enunciado da questão
identificado pelo número 2.
Figura 17. Construção de Algoritmos
Na área de construção do algoritmo a ferramenta disponibiliza um mecanismo responsável
por salientar palavras reservadas e variáveis declaradas pelo usuário, fornecendo uma resposta para
o usuário e agrega facilidades pedagógicas uma vez que o usuário consegue identificar erros de
programação ao digitar o algoritmo.
1
2
40
3.5.2 Parar Execução
Durante qualquer momento de uma execução normal, passo a passo ou uma verificação de
algoritmo é possível parar o processo simplesmente pressionando o botão identificado na Figura 18
pelo número 1, ou pressionando qualquer tecla na área de descrição do código identificada pelo
número 2.
Figura 18. Parar Algoritmo
3.5.3 Executar Algoritmo
Durante a execução de uma aplicação representada na Figura 19 é no campo número 1,
denominado console, que serão exibidos os comandos de saída da linguagem. O campo número 2
tem a funcionalidade de iniciar o processo de execução do algoritmo e o campo número 3 serve
para realizar interação de entrada quando o algoritmo requisitar um valor para o usuário.
2
1
41
Figura 19. Executar Algoritmo
3.5.4 Execução Passo a Passo
Para iniciar uma execução passo a passo basta clicar no botão indicado pelo número 1 da
Figura 20, para prosseguir a execução deve ser pressionado a tecla F7 ou apertando o botão
instrução por instrução, podendo ser acompanhado o valor das variáveis declaradas na tabela
identificada pelo número 2. Os campos de console (3) e o campo de interação (4) com o algoritmo
também poderão ser utilizados.
1
2
3
42
Figura 20. Execução passo a passo
A vantagem de visualizar a tabela de variáveis, área de construção do algoritmo e o console
na mesma tela é poder acompanhar os valores das variáveis ao mesmo tempo em que o sistema
exibe as mensagens no console e destaca a instrução que está sendo executada através de um
highlight da linha em que o comando se encontra.
3.5.5 Validar Algoritmo
Na Figura 21 é exibida a interface durante o processo de validação do algoritmo, o qual deve
ser iniciado através do botão identificado pelo número 1 e o feedback para o usuário ocorre através
do campo debug (2). O processo de validação é responsável por testar o algoritmo implementado
pelo usuário utilizando como entrada os valores definidos pelo professor no arquivo XML e
verificar se as saídas apresentadas pelo algoritmo são as mesmas saídas definidas nos casos de
testes contidos no XML.
2
1
3
4
43
Figura 21. Validar Algoritmo
A presença dessa funcionalidade no sistema apresenta vantagens como prover ao professor
um ambiente onde poderá disponibilizar questões e casos de testes para alunos, facilitar aos alunos
codificar e testar seus algoritmos com base nos testes criados pelos professores, o que dará mais
confiança e garantia ao aluno.
3.6 IMPLEMENTAÇÃO
Nesta sessão será primeiramente relatado o processo de construção de uma árvore sintática
abstrata orientada a objeto, a seguir será mostrado o processo seguido durante a execução do
algoritmo e por fim a verificação de algoritmos e aspectos relativos a interface da aplicação
desenvolvida.
2
1
44
3.6.1 Construção de uma ASA orientada a objetos
Devido a não existência de ponteiros na linguagem Java, a qual foi escolhida para o
desenvolvimento do projeto, houve a necessidade de implementar a árvore sintática abstrata que
será utilizada para a execução do código de uma forma orientada a objetos. Vale ressaltar que na
literatura pesquisada para o desenvolvimento deste projeto não foi encontrado nenhum exemplo de
ASA construída de maneira orientada a objetos, sendo portanto um desafio a mais para este
trabalho.
Seguindo a modelagem do sistema mostrada na Figura 17 foi implementada uma classe para
cada um dos comandos existentes na linguagem, uma classe para armazenar variáveis e constantes e
uma classe para armazenamento de operadores utilizados em expressões. Cada classe gerada é uma
thread que permite a execução da mesma em paralelo com outras threads.
A construção da árvore inicia a partir de uma classe denominada Lista de Comando
(LCMD), onde cada lista de comando possui o comando que irá executar e a próxima lista de
comando na seqüência de execução. A Figura 22 representa um algoritmo que solicita duas entradas
inteiras e escreve o resultado da soma de ambas.
Figura 22. Algoritmo para soma de dois valores
Com base no algoritmo da Figura 22 o sistema gera uma ASA constituída por listas de
comandos (LCMD) e por um conjunto de comandos associados às LCMD’s, como pode ser
observado na Figura 23.
programa soma
declaracoes
inteiro a,b, resultado
inicio
leia(a,b)
resultado <- a + b
escreva(resultado)
fim
45
LCMD
A
B
RESULTADO
A
LEIA
LCMD
LEIA
LCMD B
ATRIBUICAO
OPERADOR +
ESCREVA
LCMD
RESULTADO
Figura 23. Árvore Sintática Abstrata orientada a objeto
3.6.2 Execução do Algoritmo
Como visto anteriormente para cada algoritmo que é compilado, é gerada uma árvore
sintática abstrata com o uso das classes para realizar a execução. Cada classe é responsável por sua
própria execução, sendo assim a ferramenta inicia a execução requisitando a classe LCMD (raiz da
árvore) para que se execute. Essa, por sua vez, verifica se o comando ligado diretamente a ela ainda
não foi executado e solicita que o mesmo inicie a execução de sua parte, logo após o comando
concluir sua execução a LCMD continua a sua execução requisitando que a próxima LCMD ligada
a ela execute e assim sucessivamente.
Como exemplo, pode-se analisar novamente a figura 23. A execução inicia requisitando que
o primeiro objeto LCMD se execute. Este, por sua vez, solicita que o objeto LEIA se execute e esta
execução preenche o objeto A com o valor digitado. Após a execução do LEIA, o controle retorna
para a LCMD que estava aguardando a execução deste ramo da árvore e que passa o controle para o
próximo LCMD que realiza a execução de outro ramo da árvore.
Um dos problemas encontrados nessa abordagem de execução da árvore foi em como pausar
uma classe enquanto outra classe está executando. A solução encontrada foi o uso de threads, onde,
46
assim que uma classe solicita que outra comece a executar, a solicitante entra em estado de espera
(o estado de espera é implementado por um loop onde a thread entra em estado de sleep por alguns
milisegundos e cada vez que acaba o tempo, ela acorda e verifica se o objeto que estava executando
já concluiu a operação) até que a classe solicitada informe que sua execução terminou. Na Figura 24
pode ser acompanhado o fluxo de execução de um algoritmo que requisita duas entradas para o
usuário.
LCMD LCMD CMD LEIA CMD LEIA
Figura 24. Fluxo de execução de um algoritmo
Sem o uso das threads, durante a execução de um algoritmo o Applet ficaria inacessível uma
vez que todo o processamento estaria voltado para a execução. Isso impossibilitaria acesso a botões
da interface responsáveis por pausar a execução ou até mesmo modificar o código durante uma
execução.
Outro fator importante na decisão do uso dessa abordagem é a necessidade de pausar a
execução assim que se inicia o comando leia, uma vez que tal comando necessita de interação do
usuário via teclado com a interface do aplicativo. Durante o comando leia é solicitado à classe que
entre em modo de espera até que o usuário forneça o valor no console e confirme, tendo a
confirmação que o usuário conclui a ação a classe retoma de onde parou.
47
3.6.3 Verificação dos Algoritmos
A verificação de algoritmos é a funcionalidade que permite aos usuários estar checando se
seu algoritmo atende aos requisitos solicitados pelo professor, através de testes com entradas em
saída especificadas em um arquivo XML.
O arquivo XML utilizado nos testes deve seguir o modelo apresentado na Figura 12, e a
passagem do arquivo para o Applet deve ser feita através de uma tag HTML denominada “param”
conforme a Figura 25.
Figura 25. HTML para utilização do applet com passagem de arquivo XML
A tag “param” possui dois identificadores denominados “name” e “value”, o identificador
“name” deverá ter como valor a palavra xml e o identificador value deve conter o endereço onde o
arquivo XML está hospedado, é importante salientar que apenas um arquivo de testes poderá ser
utilizado por vez. Tendo encontrado o arquivo especificado o sistema irá construir uma tabela com
entradas e saídas separadas em grupos de testes, cada grupo servirá para testar o algoritmo uma
única vez.
Durante a verificação do algoritmo o sistema substitui cada operação de leitura via teclado
por uma entrada do arquivo de teste e cada operação de escrita, que contenha variáveis, será
comparada a um elemento de saída do arquivo de teste. Caso todas as entradas sejam utilizadas e
todas as saídas estejam de acordo com os valores especificadas no grupo de teste o sistema emitirá
uma mensagem informando que não foi detectado nenhum erro durante a verificação do algoritmo,
no caso de possuir algum erro o sistema emitirá mensagens informando o grupo de testes que
<HTML>
<HEAD>
<TITLE>Applet HTML Page</TITLE>
</HEAD>
<BODY>
<APPLET code="hcompiler/HCompiler.class" width=475 height=480>
<param name="xml" value="http://200.169.53.134/webPortugol/ex1.xml">
</APPLET>
</BODY>
</HTML>
48
apresentou erro. A Figura 26 mostra a mensagem de erro durante a verificação de um algoritmo que
deveria exibir o fatorial de um número solicitado através de um comando de leitura.
Figura 26. Mensagem de erro durante uma verificação de algoritmo
Uma vez encontrado algum tipo de erro durante a verificação o sistema mostra as entradas e
saídas esperadas pelo algoritmo construído pelo aluno, possibilitando assim que o mesmo teste os
valores manualmente na verificação passo a passo.
Um aspecto importante refere-se a ter que colocar valores que devem ser verificados durante
o comando escreva dentro de variáveis. No caso de um algoritmo que escreve na tela a palavra
“positivo” quando um valor de entrada é positivo ou “negativo” quando um valor de entrada é
negativo, para que esse algoritmo possa ser verificado é preciso que a palavra “positivo” seja
atribuída a uma variável e depois seja usado o comando “escreva” com essa variável.
Verificando Algoritmo
Número de verificações: 2
Erro na verificação
O algoritmo não está de acordo com o solicitado no
enunciado.
Ele fornece resposta incorreta quando são fornecidos como
entrada: <0>
Neste caso as respostas esperadas seriam: <1>
respectivamente
Erro na verificação
O algoritmo não está de acordo com o solicitado no
enunciado.
Ele fornece resposta incorreta quando são fornecidos como
entrada: <2>
Neste caso as respostas esperadas seriam: <2> respectivamente
49
A necessidade de ter de colocar valores sempre dentro de variáveis para que possam ser
verificados, deve-se ao fato que de outra maneira todas as operações de escrita estaria sendo
verificada, mesmo operações de escrita que tem o intuito apenas de informar algo ao usuário.
3.6.4 Aspectos de Interface
Alguns aspectos da interface são importantes e facilitam tanto o uso da ferramenta quanto a
compreensão da linguagem de programação. O salientador de sintaxe (syntax highlight) é uma
funcionalidade da interface em que cada palavra reservada da gramática e variáveis declaradas pelo
usuário são coloridas com cores específicas. Dessa forma fica simples e fácil para o usuário
identificar quando digitou de forma correta ou incorreta comandos da gramática, pois, somente os
comandos escritos corretamente serão salientados. Além disso, a ocorrência de equívocos de
digitação tais como o a falta de aspas e parênteses é minimizada.
Outra característica importante é o foco no campo de entrada de dados. A área de entrada de
dados via teclado permanece desabilitada durante toda execução do sistema, tornando-se habilitada
para o usuário apenas durante uma requisição de leitura, quando isso acontece o sistema muda o
foco para o campo de entrada facilitando ao usuário a digitação de valores uma vez que não precisa
movimentar o mouse e clicar no campo. Ao terminar de digitar o valor o usuário pode simplesmente
pressionar a tecla Enter do teclado ou clicar com o mouse sobre o botão OK.
Uma vez que área de entrada de dados não está situada diretamente no console, achou-se
importante que toda entrada seja transferida para o console facilitando assim ao usuário verificar
quais valores já foram digitados.
A interface do sistema é dividida em várias áreas, na parte inferior do sistema situa-se a área
utilizada pelo sistema para informar o enunciado de questões, console de entrada de dados e saída
de informações do código implementado pelo usuário e mensagens de erros (debug). Na Figura 27
pode ser observada a separação da área de enunciado, console e debug por abas.
50
Figura 27. Área de informações do sistema
Durante a execução do programa o sistema alterna automaticamente entre as abas para
facilitar ao usuário a compreensão do estado atual do uso da ferramenta, ou seja, durante uma
execução caso algum erro sintático, semântico ou léxico tenha sido detectado o foco muda para o
campo de debug onde a mensagem de erro estará sendo exibida para o usuário. No início da
execução o sistema focaliza no campo console para exibir mensagens criadas por comandos de
escrita, e na abertura do sistema o foco fica no campo enunciado para que o usuário tenha
conhecimento da questão que deverá desenvolver.
Uma das maiores dificuldades para a construção da interface de um compilador que busca
facilitar a aprendizagem dos usuários menos experientes é emitir mensagens de erros que sejam
simples de compreender. Exibir mensagens informando apenas os tokens que poderiam ser usados
para substituir o erro é simples, porém, exibir mensagens informando e sugerindo ao usuário o que
fazer é um processo manual e complicado uma vez que o estado interno de erro do compilador
51
ocorre para diversos erros diferentes. A Figura 28 mostra um exemplo de mensagem de erro onde se
buscou dar orientações ao usuário sobre um erro específico.
Figura 28. Mensagem de erro
Na tentativa de execução do código da Figura 28 o sistema detectou que o código escrito
para realizar o desvio condicional estava de forma incorreta e no lugar do elemento “entao" foi
encontrado o comando escreva, logo a linha em que foi encontrado o erro foi realçada e o erro foi
exposto junto com uma sugestão de como escrever corretamente um desvio condicional.
52
4 EXPERIMENTO REALIZADO
A seguir são apresentadas as etapas que foram realizadas durante a condução do
experimento para validação da ferramenta desenvolvida, a fim de encontrar possíveis erros de
implementação e verificar as dúvidas e sugestões dos usuários.
4.1 Procedimento e Realização
Para validação do sistema foi realizado um experimento com a turma do primeiro período de
Ciência Computação da Univali do semestre 2006/2. O experimento contou com 33 alunos, teve
duração de 2 horas e foi realizado no laboratório de informática do curso. No início do
procedimento foi realizada uma explicação pelo professor da disciplina sobre a ferramenta e as
funcionalidades por ela contempladas.
Durante o teste foi solicitado aos usuários a implementação de quatro algoritmos diferentes
usando a ferramenta, sendo os dois primeiros assuntos já conhecidos pelos participantes e os dois
últimos assuntos ainda não consolidados. Além da implementação foi solicitado que os alunos
realizassem a execução e a verificação dos algoritmos. A Figura 29 apresenta os quatro enunciados
dos algoritmos utilizados nos testes.
Figura 29. Enunciados dos testes realizados
1) Escreva um algoritmo que solicite ao usuário três números reais,
calcule e exiba a média aritmética dos valores.
2) Faça um algoritmo que solicita ao usuário um número inteiro e exiba o conteúdo de uma variável do tipo cadeia contendo: "positivo" caso o
número seja positivo, ou "negativo" caso o número seja negativo ou
"zero" caso o número seja zero.
3) Preencha um vetor de 10 posições inteiras com os dez primeiros
múltiplos de 3. Ex (3,6,9,...,30) e exiba os números em ordem inversa.
4) Solicite ao usuário cinco números inteiros e armazene-os em um
vetor. A seguir altere o vetor multiplicando todos os elementos pelo elemento que está na primeira posição. Exiba o vetor após a alteração.
53
4.2 Coleta de Dados
Para coletar dados do experimento foi acoplado temporariamente na ferramenta um botão no
qual o usuário deveria clicar ao fim de cada algoritmo construído para que as informações
armazenadas na ferramenta durante a construção, fossem enviadas através de um socket para um
servidor.
As informações coletadas referentes à construção do algoritmo foram:
• Quantidade total execuções;
• Quantidade de execuções com erros sintáticos;
• Quantidade de execuções bem sucedidas;
• Quantidade total de execuções passo a passo;
• Quantidade de execuções passo a passo com erros sintáticos;
• Quantidade de execuções passo a passo bem sucedidas;
• Quantidade total de verificações;
• Quantidade de verificações com erros sintáticos;
• Quantidade de verificações mal sucedidas(não atingiram o objetivo);
• Quantidade de verificações bem sucedidas (atingiram o objetivo);
Estes dados foram armazenados em arquivos texto. Posteriormente foram integrados e
organizados em uma tabela a fim de permitirem a realização de análises e testes estatísticos.
54
4.3 Análises Realizadas
Os dados coletados durante o experimento permitiram caracterizar a forma na qual os
estudantes utilizaram a ferramenta. A Tabela 3 apresenta estas informações de forma resumida.
Tabela 3. Tabulação dos dados do experimento
Questão Realizaram (%) Verificaram (%) Tempo Médio (min)
Execuções (vezes)
Depurações (vezes)
Questão 1 84,85 67,86 8,47 5,68 1,27 Questão 2 81,82 44,44 14,43 7,02 1,39 Questão 3 51,52 58,82 14,73 8,11 2,98 Questão 4 24,24 37,50 15,68 5,87 7,57
As questões relativas aos assuntos conhecidos pelos alunos foram realizadas pela grande
maioria dos alunos participantes do experimento (84,85%), na medida em que se aproxima das
questões em que os alunos não possuem o domínio do assunto o índice de realização diminuiu para
apenas 24,24%.
Além da quantidade de alunos que implementaram os exercícios é possível notar um
declínio na quantidade de alunos que realizaram a verificação dos algoritmos, nas questões finais
apenas 37,50% dos participantes que construíram uma solução chegaram a verificar.
Outra informação que pode ser observada na Tabela 3 é o número médio de execuções nas
questões bem como o número médio de depurações passo a passo executadas pelos alunos durante
os testes.
4.3.1 Testes de Hipóteses
Uma vez tendo realizado um experimento em que dados sobre a realização dos algoritmos
puderam ser coletados, vislumbrou-se a possibilidade de realizar testes de hipóteses que possam
explicar melhor os aspectos ligados ao benefício pedagógico do uso da ferramenta. Quatro hipóteses
foram levantadas:
• Hipótese 1: As verificações que obtiveram resultados mal sucedidos levaram os alunos a
uma depuração passo a passo da solução.
• Hipótese 2: As soluções bem sucedidas reduziram o tempo de construção da solução
pelos alunos.
55
• Hipótese 3: Os alunos que verificaram as soluções depuraram passo a passo mais dos
que os que não verificaram.
• Hipótese 4: Os alunos que verificaram as soluções dedicaram mais tempo as questões
dos que os que não verificaram.
Para a verificação das hipóteses levantadas foram necessários testes estatísticos que
permitem decidir pela aceitação ou rejeição. Para as duas primeiras hipóteses foram realizados
testes de correlação com distribuição de Student onde com grau de confiança de 95% e para as duas
ultimas hipóteses foi escolhido o Teste Z. O objetivo do Teste Z é a comparação entre duas médias
ou proporções. O seguinte roteiro foi aplicado para o calculo do teste.
1. Definir as hipóteses nula e alternativa da análise.
2. Para cada variável foi definido o tamanho da amostra (η), a média (χ) e o desvio padrão
(σ).
3. Realizado o cálculo do erro padrão constante na Figura 30
nnxx
2
22
1
21
21σσ
σ +=−
Figura 30. Equação de erro padrão
4. Realização do Teste Z através da fórmula da Figura 31.
σ xx
xxz
21
)21(
−
−=
Figura 31. Equação do Teste Z
5. Por fim comparação entre o Z encontrado e o Z crítico que para o nível de confiança de
95% tem o valor de -1.96. Caso Z encontrado seja menor que-1.96 é possível rejeitar a
hipótese nula aceitando assim a hipótese alternativa.
56
No caso do teste de Student a fórmula para encontrar o resultado pode ser encontrada na
Figura 32.
21
2
r
Nrt
−
−=
Figura 32. Equação do Teste de Student
4.3.1.1 Hipótese 1
A primeira hipótese a ser verificada é aquela que diz que as verificações que obtiveram
resultados mal sucedidos levaram a uma depuração passo a passo da solução, o método estatístico
adotado foi t-Student, para tal hipótese o tamanho da amostra é de 44 elementos.
O valor encontrado na tabela de dispersão de t-Student para o grau de confiança de 95%
com o grau de liberdade de 42 é de 1,68, ou seja caso o valor de t seja maior que 1,68 é possível
rejeitar a hipótese nula.
• Hipótese nula:
H0 = As verificações que obtiveram resultados mal sucedidos não levaram a uma depuração
passo a passo da solução.
• Hipótese alternativa:
Hα = As verificações que obtiveram resultados mal sucedidos levaram a uma depuração passo
a passo da solução.
O primeiro passo é encontrar o valor da correlação que no caso da hipótese 1 é 0.30.
A Figura 33 apresenta o desenvolvimento do segundo passo com a aplicação de t-Student.
57
230,01
24430,0
−
−=t
→ 95,0
48,630,0=t
04,2=t
Figura 33. Aplicação de t-Student para hipótese 1
Com base no resultado do teste (2,04) que é maior do que o valor de 1,68 encontrado na
tabela de dispersão de t-Student é possível rejeitar a hipótese nula, assim comprovando a existência
de uma correlação entre as verificações mal sucedidas e a depuração passo a passo confirmando
assim a hipótese.
4.3.1.2 Hipótese 2
Outra hipótese a ser investigada é: As soluções bem sucedidas reduziram o tempo de
construção da solução, onde o método estatístico é a correlação de Pearson assim como na primeira
hipótese estudada.
Assim como na hipótese 1 o valor de t deverá ser maior do que 1,68 para ocorrer a rejeição
da hipótese nula.
• Hipótese nula:
H0 = As soluções bem sucedidas não reduziram o tempo de construção da solução.
• Hipótese Alternativa:
Hα = As soluções bem sucedidas reduziram o tempo de construção da solução.
O primeiro passo é encontrar o valor da correlação que no caso da hipótese 2 é 0.11.
A Figura 34 apresenta o desenvolvimento do segundo passo com a aplicação de t-Student.
58
211,01
24411,0
−
−=t
→ 98,0
48,611,0=t
72,0=t
Figura 34. Aplicação de t-Student para hipótese 2
Com base no resultado de 0,72 encontrado com o teste de Student, sendo esse valor menor
do que 1,68, não é possível rejeitar a hipótese nula confirmando assim que para a amostra utilizada
não é possível afirmar que as soluções bem sucedidas tiveram um tempo de construção menor.
4.3.1.3 Hipótese 3
Para verificar a terceira hipótese abordada durante a etapa de análise foi utilizado o Teste Z,
com intuito de comparar as médias da quantidade de depurações entre alunos que verificaram suas
soluções e alunos que não verificaram.
• Hipótese nula:
H0 = Os alunos que verificaram a solução depuraram menos dos que os que não verificaram.
Hipótese Alternativa:
Hα = Os alunos que verificaram a solução depuraram mais dos que os que não verificaram.
A primeira etapa foi a definição das hipóteses nulas e alternativas, o próximo passo é definir
para cada variável da amostra (η), a média (χ) e o desvio padrão (σ), os valores são os seguintes:
• Alunos que verificaram
η = 44
χ = 2,66
σ = 4,84
59
• Alunos que não verificaram
η = 36
χ = 1,97
σ = 7,16
O terceiro passo do processo de descobrir o valor de Z é encontrar o erro padrão, a Figura 35
mostra o desenvolvimento da equação do erro padrão.
nnxx
2
22
1
21
21σσ
σ +=− → 36
16,7 2
44
84,4 2
21+=
−σ xx
9564,121
=−σ xx → 3987,1
21=
−σ xx
Figura 35. Calculo do erro padrão da hipótese 3.
O passo 4 é o calculo do Teste Z que pode ser acompanhado na Figura 36.
σ xx
xxz
21
)21(
−
−
=
→ 3987,1
)97,166,2( −
=z
49,0=z
Figura 36. Cálculo do valor d Z da hipótese 3.
60
Para rejeição da hipótese nula o valor do Z encontrado deveria ser menor do que -1,96
entrando na área de rejeição da hipótese, sendo o valor encontrado 0,49 não é possível rejeitá-la,
resultando na conclusão de que os alunos que verificaram depuraram menos ou igual aos alunos que
não verificaram.
4.3.1.4 Hipótese 4
Na verificação da quarta hipótese, assim com na terceira foi utilizado o Teste Z, com intuito
de comparar o tempo da construção da solução entre alunos que verificaram a solução e alunos que
não verificaram.
• Hipótese nula:
• H0 = Os alunos que verificaram as soluções dedicaram menos tempo as questões dos que
os que não verificaram.
Hipótese Alternativa:
• Hα = Os alunos que verificaram as soluções dedicaram mais tempo as questões dos que os
que não verificaram.
A primeira etapa foi a definição das hipóteses nulas e alternativas, o próximo passo é definir
para cada variável da amostra (η), a média (χ) e o desvio padrão (σ), os valores são os seguintes:
• Alunos que verificaram
η = 44
χ = 821,55
σ = 516,36
• Alunos que não verificaram
η = 36
χ = 656,61
σ = 263,47
61
O terceiro passo do processo de descobrir o valor de Z é encontrar o erro padrão, a Figura 37
mostra o desenvolvimento da equação do erro padrão.
nnxx
2
22
1
21
21σσ
σ +=− → 36
47,263 2
44
36,516 2
21+=
−σ xx
94,798721
=−σ xx → 37,89
21=
−σ xx
Figura 37. Cálculo do erro padrão da hipótese 3.
O passo 4 é o calculo do Teste Z que pode ser acompanhado na Figura 38.
σ xx
xxz
21
)21(
−
−
=
→ 37,89
)61,65655,821( −
=z
84,1=z
Figura 38. Cálculo do valor de Z da hipótese 4.
Assim com na hipótese anterior o valor do Z encontrado deveria ser menor do que -1,96 para
rejeição da hipótese nula, sendo o valor encontrado 1,84 não é possível rejeitá-la, não podendo
comprovar que os alunos que verificaram a solução dedicaram mais tempo a construção do que os
que não verificaram.
62
5 CONSIDERAÇÕES FINAIS
Durante as fases iniciais do projeto desenvolvidas no decorrer do TCC I, foram realizados
estudos de técnicas de construção de compiladores e interpretadores, tendo sido adotados para a
construção do compilador a ferramenta GALS utilizando o método SLR na análise sintática.
Além do estudo relativo a compiladores e interpretadores, também foi realizado estudo a fim
de conhecer metodologia de modelagem de compiladores e interpretadores, chegando a uma
modelagem UML com uso de casos de uso e diagrama de classes, bem como levantamento de
requisitos da ferramenta.
A etapa relativa à implementação do compilador foi auxiliada com uso da ferramenta
GALS, a qual possibilitou gerar o código do analisador léxico e sintático, o código relativo ao
analisador semântico não é contemplado pela ferramenta de apoio, e foi realizado através de
associação de ações semânticas incluídas na gramática.
Como técnica de implementação de interpretadores foi adotada a árvore sintática abstrata
(ASA), devido a característica da Linguagem escolhida (Java) não foi possível adotar o uso de
ponteiros e foi abordada a construção da ASA orientada a objetos.
A ferramenta desenvolvida durante todo o decorrer do projeto possibilitará maior
aprendizagem dos alunos iniciantes no que diz respeito a programação em portugol e lógica de
programação. Através das mensagens de erros escritas de uma maneira simples, o sistema fornece
suporte ao usuário ajudando a resolver os problemas de sintaxe encontrados. Outro ponto crucial da
ferramenta é o salientador de sintaxe contido na interface da ferramenta que possibilita ao usuário
identificar os elementos da linguagem de uma forma intuitiva colorindo de forma diferente os
tokens.
Uma das principais funcionalidades que agregadas na ferramenta e que vem a contribuir
com o ensino de algoritmos, é a possibilidade de disponibilizar exercícios para os alunos e prover
casos de testes para validar a construção dos algoritmos.
O experimento realizado para validação do sistema desenvolvido contou com uma amostra
de 33 alunos do primeiro período de ciência da computação e teve uma duração de 2 horas. Durante
o procedimento foi solicitado aos participantes que implementassem quatro algoritmos utilizando a
63
ferramenta. Com os dados coletados durante esta fase pode-se verificar que todas as funcionalidades
propostas como execução do algoritmo, execução passo a passo, verificação, parar execução, além
de salientador de sintaxe e mensagens de erros intuitivas foram contempladas em tempo hábil e
estão operando sem nenhum problema e através dos testes foi possível levantar quatro hipóteses, e
através de testes estatísticos levando em consideração o tamanho reduzido da amostra foi possível
comprovar a hipótese a seguir: As verificações que obtiveram resultados mal sucedidos levaram a
uma depuração passo a passo da solução.
Uma das grandes dificuldades encontradas no desenvolvimento do trabalho está relacionada
a construção da árvore sintática abstrata orientada a objetos e uso de threads, além da emissão de
mensagens de erros explicativas, o que resultou em um trabalho manual em busca das melhores
mensagens que poderiam ser emitidas em cada estado do compilador. A dificuldade em
disponibilizar boas mensagens está no fato de que em gramáticas pequenas com muito
reaproveitamento das regras de produção uma mesma mensagem pode ser usada em diferentes tipos
de erros. Com isso conclui-se que gramáticas menos compactas tendem a facilitar o trabalho de
construir mensagens de erros de simples compreensão, no entanto tornam-se mais difíceis de
realizar a análise e a interpretação.
Uma das limitações e indicações para trabalhos futuros é a ampliação da gramática para
possibilitar a programação de algoritmos em mais de uma função e não apenas com uso de função
principal como foi idealizada a priori. Neste escopo é importante constar que alterações na
gramática resultam necessariamente em mudanças em todo o analisador, pois, pode-se alterar ordem
de tokens e produções gerando novos estados na gramática e conseqüentemente modificando as
mensagens de erros. Além de novas funcionalidades a serem agregadas ao projeto, outro foco de
trabalho futuro é a ampliação dos testes para grupos maiores de usuários.
Em relação às ferramentas estudadas nas fases iniciais do projeto vale ressaltar que o
WebPortugol agregou funcionalidades como verificação do algoritmo que está presente na
ferramenta CIFluxProg II, execução passo a passo como na ferramenta CIFluxProg I e além dessas
agregou novas características não presentes nos ambientes similares como o salientador de sintaxe,
mensagens de erros intuitivas, salientador de linha de execução durante a depuração passo a passo,
além de disponibilizar via WEB com independência de plataforma.
64
Espera-se que este trabalho constitua-se em um produto que possa auxiliar na aprendizagem
dos alunos da disciplina de algoritmos, e que possa ser integrado aos esforços de assistir de uma
maneira melhor as dificuldades de aprendizagem dos alunos através de sistemas computacionais.
REFERÊNCIAS BIBLIOGRÁFICAS
AHO, A. et al. Compiladores: princípios, técnicas e ferramentas. Rio de Janeiro: LTC, 1995. 343p.
CRESPO, R. G. Processadores de linguagens: da concepção à implementação. Lisboa: IST Press, 1998. 435 p.
DEITEL, H. M.; DEITEL, P.J. Java: como programar. 4. ed. Porto Alegre: Bookman, 2003. 1386 p. ISBN 8536301236.
DORMER, S. Programming: Embedding Learning Technologies Module. Australian Capital Territory, Autralia. Disponível em: <http://activated.det.act.gov.au/learning/word/elt/5.0_Programming.pdf>. Acesso em: 29 Jul. 2006.
ESMIN, A. A. A. Portugol/Plus: uma ferramenta de apoio ensino ao de lógica de programação baseado no portugol. In: CONGRESSO DA REDE IBEROAMERICANA DE INFORMÁTICA EDUCATIVA (RIBIE), 4. 1998, Brasília. Anais... [S.l.: s.n.], 1998. 7 p.
GESSER, C. E. GALS: gerador de analisadores léxicos e sintáticos. 2003, 150 f. (Trabalho de Conclusão de Curso)–Bacharelado em Ciências da Computação, Universidade Federal de Santa Catarina, Florianópolis, 2003.
INDRUSIAK, L. S. Linguagem Java. Porto Alegre: UFRGS, 1996. 15 p. Disponível em: <http://www.inf.ufrgs.br/tools/java/introjava.pdf>. Acesso em: 24 abr. 2006.
LEMAY, L.; PERKINS, C. L. Aprenda Java em 21 Dias. Rio de Janeiro: Campus, 1997. 552 p. ISBN 8535216855.
LOUDEN, K. C. Compiladores: princípios e práticas. São Paulo: Thomson, 1997. 584 p. ISBN 8522104220.
LUZ, J. C. Tecnologia adaptativa aplicada à otimização de código em compiladores. 2004, 158 f. (Mestrado) – Programa de Pós-Graduação em Engenharia Elétrica, Universidade de São Paulo. São Paulo, 2004.
MEDEIROS, C.; DAZZI, R. Aprendendo algoritmos com auxílio da web. In: CONGRESSO BRASILEIRO DE COMPUTAÇÃO, 2, 2002, Itajaí. Anais..., Itajaí, 2002.
MEDEIROS, E.; Desenvolvendo software com UML: Definitivo.São Paulo: Pearson Makron Books, 2004. 264 p. ISBN 8534615292.
MENDES, Dr. A. J. N. Software educativo para apoio à aprendizagem de programação. Universidade de Coimbra, Portugal. Disponível em: <http://www.c5.cl/ieinvestiga/actas/tise01/pags/charlas/charla_mendes.htm>. Acessado em: 01 Nov. 2005.
MENEZES, C. S.; NOBRE, I. A. M. Um ambiente cooperativo para apoio a cursos de introdução a programação. In: WORKSHOP DE EDUCAÇÃO EM COMPUTAÇÃO, 5, 2002, Florianópolis. Anais do Congresso da Sociedade Brasileira de Computação. Porto Alegre: SBC, 2002.
66
MIRANDA, E. M. de. Uma ferramenta de apoio ao processo de aprendizagem de algoritmos. (Mestrado) – Programa de Pós-Graduação em Ciência da Computação, Universidade Federal de Santa Catarina. Florianópolis, Brasil, 2004.
NETBEANS. Tutorials, Guides, and Articles. Disponível em: <http://www.netbeans.org>. Acessado em 15 Mar. 2006.
PANE, F.J. et al. Using HCI Techiniques to Design a More Usable Programming System. In: IEEE Symposia on Human Centric Computing Languages and Environments. 2002, Arlington, Anais..., Arlington, 2002.
PIMENTEL, E. P. et al. Avaliação Contínua da Aprendizagem, das Competências e Habilidades em Programação de Computadores. In: XXIII Congresso da Sociedade Brasileiro de Computação, 2003, Florianópolis, Anais..., Florianópolis, 2003.
RAABE, A. L. A. Uma proposta de arquitetura de sistema tutor inteligente baseada na teoria das experiências de aprendizagem mediadas. (Doutorado) – Programa de Pós-Graduação em Informática na Educação, Universidade Federal do Rio Grande do Sul. Porto Alegre, Brasil, 2005.
RAABE, A. L. A. Material de apoio da disciplina de linguagens formais e compiladores. Universidade do Vale do Itajaí, Itajaí. Disponível em: < http://siaiacad05.univali.br/~araabe/compil/>. Acessado em: 15 Mar. 2006.
RANGEL, J. L. Material didático relativo à disciplina de compiladores (graduação). PUC-Rio, Rio de Janeiro. Disponível em: <http://www-di.inf.puc-rio.br/~rangel/comp.html.>. Acessado em: 20 Mar. 2006.
RODRIGUES Jr., M.C. Experiências positivas para o ensino de algoritmos. Centro de Ciências Formais e Tecnologia – Universidade Tiradentes. Aracaju, Sergipe. Disponível em: <http://www.uefs.br/erbase2004/documentos/weibase/Weibase2004Artigo001.pdf>. Acessado em: 31 Nov. 2005.
SANTIAGO, R.; DAZZI, R. Ferramenta de apoio ao ensino de algoritmos. In: SEMINÁRIO DE COMPUTAÇÂO - SEMINCO, 13, 2004, Blumenau. Anais..., Blumenau, 2004.
SANTIAGO, R.; DAZZI, R. Ferramentas que auxiliam o desenvolvimento da lógica de programação. In: SEMINÁRIO DE COMPUTAÇÂO - SEMINCO, 12, 2003, Blumenau. Anais..., Blumenau, 2004.
SANTOS, R.P. dos; COSTA, H.A.X. Análise de Metodologias e Ambientes de Ensino para Algoritmos, Estruturas de Dados e Programação aos iniciantes em Computação e Informática. In: JOURNAL OF COMPUTER SCIENCE - INFOCOMP, 5, 2006.
SETZER, W.W.; MELO, I.S.H.; A construção de um compilador. Rio de Janeiro: Campus, 1989. 176 p.
SILVA, T. G-Portugol: site oficial da linguagem G-Portugol. Disponível em: <http://gpt.berlios.de/>. Acessado em: 27 Mar. 2006.
WIKIPEDIA. A Enciclopédia Livre. Disponível em: <http://www.wikipedia.org>. Acessado em: 20 Mar. 2006.
67
ANEXOS
I GRAMÁTICA MODIFICADA DO PORTUGOL
A gramática do compilador é baseada no Portugol, porém com algumas modificações
necessárias para restringir o tamanho do projeto.
I.1 DEFINIÇÕES REGULARES coment: "/*"([^\*]|\*[^/])*"*/"
coml: [/][/].*
I.2 LISTA DE TOKENS
// Operadores
"<-"
">"
"<"
"<="
">="
"<>"
"!="
"="
"^"
"::"
";"
"["
"]"
","
"("
")"
"+"
"-"
"*" "/"
69
// Palavras Reservadas
: {coment}|{coml}
ID: [a-zA-Z][a-z0-9_]*
PROGRAMA = ID : "programa"
DECLARACOES = ID : "declaracoes"
DEFINA = ID : "defina"
DEFINATIPO = ID : "definatipo"
INICIO = ID : "inicio"
FIM = ID : "fim"
INTEIRO = ID : "inteiro"
REAL = ID : "real"
CARACTER = ID : "caracter"
LOGICO = ID : "logico"
CADEIA = ID : "cadeia"
SE = ID : "se"
ENTAO = ID : "entao"
SENAO = ID : "senao"
FIMSE = ID : "fimse"
ENQUANTO = ID : "enquanto"
FACA = ID : "faca"
FIMENQUANTO = ID : "fimenquanto"
REPITA = ID : "repita"
PARA = ID : "para"
ATE = ID : "ate"
PASSO = ID : "passo"
FIMPARA = ID : "fimpara"
LEIA = ID : "leia"
ESCREVA = ID : "escreva"
E = ID : "e"
OU = ID : "ou"
NAO = ID : "nao"
DIV = ID : "div" MOD = ID : "mod"
70
I.3 GRAMÁTICA
// Gramática
<programa> ::= PROGRAMA ID <dec> INICIO <lista_cmdo>
FIM;
<dec> ::= DECLARACOES <lista_decl>
| î;
<lista_decl> ::= <lista_decl> <decl>
| <decl>
;
<decl> ::= <dec_const>
| <dec_var>
;
<dec_const> ::= DEFINA ID_CONST <valor>;
<valor> ::= VALOR_INTEIRO
| VALOR_REAL
| VALOR_CARACTER
| VALOR_LOGICO
| VALOR_CADEIA
;
<tipo> ::= INTEIRO
| REAL
| CARACTER
| LOGICO
| CADEIA
;
<id_decl> ::= ID
| ID "[" ID_CONST "]"
| ID "[" ID_CONST "]" "[" ID_CONST "]"
| ID "[" VALOR_INTEIRO "]"
| ID "[" VALOR_INTEIRO "]" "[" VALOR_INTEIRO "]"
;
<lista_dec_var> ::= <lista_dec_var> <dec_var>
| <dec_var>
;
<dec_var> ::= <tipo> <lista_var>
;
71
// Gramática
<lista_cmdo> ::= <lista_cmdo> <cmdo>
| <cmdo>
;
<cmdo> ::= SE "(" <exp> ")" ENTAO <lista_cmdo> FIMSE
|SE "(" <exp> ")" ENTAO <lista_cmdo> SENAO <lista_cmdo> FIMSE
| ENQUANTO "(" <exp> ")" FACA <lista_cmdo> FIMENQUANTO
| REPITA <lista_cmdo> ENQUANTO "(" <exp> ")"
| PARA ID "<-" <exp> ATE <exp> PASSO <exp> <lista_cmdo> FIMPARA
| LEIA "(" <lista_id> ")"
| ESCREVA "(" <lista_saida> ")"
| <id> "<-" <exp>
;
<lista_id> ::= <lista_id> "," <id>
| <id>
;
<lista_saida> ::= <id> "," <lista_saida>
| <valor> "," <lista_saida>
| <id>
| <valor>
;
<exp> ::= <exp> OU <exp1> | <exp1>;
<exp1> ::= <exp1> E <exp2> | <exp2>;
<exp2> ::= NAO <exp2> | <exp3>;
<exp3> ::= <exp3> <op_rel> <exp4> | <exp4>;
<exp4> ::= <exp4> <op_arit_baixa> <exp5> | <exp5>;
<exp5> ::= <exp5> <op_arit_alta> <exp6> | <exp6> ;
<exp6> ::= <valor> | <id> | ID_CONST | "(" <exp> ")" | "-" <valor>;
<op_rel> ::= ">" | "<" | ">=" | "<=" | "=" | "!=";
<op_arit_baixa> ::= "+" | "-";
<op_arit_alta> ::= "*" | "/" | DIV |MOD;
<id> ::= ID
| ID "[" <exp> "]"
| ID "[" <exp> "]" "[" <exp> "]"
;
72
II CASOS DE USO
II.1 UC01 – ELABORAR ALGORITMO
Cenários:
Pré-requisito: Ter executado o <UC01>.
01. Escrever Algoritmos {Principal}.
1. O usuário preenche o campo de código com o algoritmo que deseja compilar.
02. Copiar e Colar {Alternativo}
1. O usuário preenche o campo de código copiando valores de um arquivo e colando.
II.2 UC02 – PARAR EXECUÇÃO
Cenários:
01. Parar Execução{Principal}.
Pré-requisito: Estar executando um algoritmo.
1. O usuário clica no botão: [Parar] <TEL01> número 3.
2. O sistema para a execução de um algoritmo tanto em execução passo a passo ou
execução normal.
II.3 UC03 – EXECUTAR ALGORITMO
Cenários:
01. Execução completa {Principal}.
Pré-requisito: Ter executado o <UC02>.
1. O usuário clica no botão: [Executar] <TEL01> número 1.
2. O sistema compila o código informado e executa a aplicação escrita pelo usuário, postando todas as mensagens de saída e entrada no console.
73
02. Execução passo à passo { Alternativo }.
Pré-requisito: Ter executado o <UC02>.
1. O usuário clica no botão: [Passo a Passo] <TEL01> número 2.
2. O sistema compila o código informado e executa a aplicação escrita pelo usuário
passo a passo, informando a posição do código que está sendo executada no
momento, disponibiliza no campo de verificação de variáveis o valor das variáveis e
posta todas as mensagens de saída e entrada no campo console.
* Para prosseguir para próxima instrução o usuário deve pressionar o botão F7 do teclado.
03. Solicitação de entrada para execução {Alternativo}.
1. O sistema requisita do usuário durante a execução de sua aplicação a entrada de um valor.
2. O usuário realiza a entrada da informação através do teclado e pressiona a tecla
"Enter".
3. O sistema continua a execução da aplicação.
II.4 UC04 – VERIFICAR ALGORITMO
Cenários:
01. Verificar programa com XML {Alternativo}.
Pré-requisito: Ter executado o <UC02> e ter algum arquivo XML de correção associado
ao programa.
1. O usuário clica no botão: [Verificar Algoritmo] <TEL01> número 4.
2. O sistema executa o algoritmo substituindo as entradas que deveriam ser feitas com
uso do teclado pelos valores presentes no arquivo XML e compara as saídas do
algoritmo com os valores de saídas também constam no arquivo.
* A passagem do arquivo XML para o sistema deverá ser feita através do uso de uma tag
especial do applet.
74
02. Erros no programa {Exceção}.
1. Caso no passo 2 do cenário: "Verificar Programa" os valores de saída não confiram, o
sistema exibe mensagem informando ao usuário que o programa não está correto e
exibe para o usuário o conjunto valores que ocasionou o problema.
03. Programa executado com sucesso {Exceção}.
Caso no passo 2 do cenário: "Verificar Programa" os valores de saída estejam corretos,
o sistema exibe mensagem informando ao usuário o sucesso da verificação e exibe os
conjuntos de valores utilizados para o teste.
II.5 UC05 – GERAR XML
Cenários:
01. Novo XML{Principal}.
Pré-requisito: Ter executado a ferramenta WebPortugolAssistent.
1. O sistema exibe a interface da ferramenta com as áreas de enunciado e grupos de teste
além dos botões: novo grupo, excluir grupo e salvar.
2. O usuário preenche a área de enunciado e alterna para área de grupos de teste.
3. O sistema exibe a área de configuração do grupo de teste com os campos de entrada e
os campos de saídas além dos botões: adicionar entrada, excluir entrada, adicionar
saída e excluir saída.
4. O usuário configura o grupo.
.
02. Novo Grupo de Teste{Alternativo}.
75
1. O usuário clica no botão: adicionar grupo.
2. O sistema adicionar uma nova área de grupo de teste para que o usuário possa
configurar um novo grupo de teste.
03. Salvar{Alternativo}.
3. O usuário clica no botão: salvar.
4. O sistema requisita o nome do arquivo xml.
5. O usuário informa o nome do arquivo e confirma.
6. O sistema gera o arquivo xml.
03. Nome Inválido{ Exceção }.
1. Caso usuário informe um nome de arquivo inválido o sistema exibe uma mensagem
informando o que nome é inválido.
76
III PROTÓTIPO DE TELAS
III.1 TEL01
1
23
4