Embed Size (px)
Citation preview
UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
SISTEMA TUTOR INTELIGENTE PARA AUXÍLIO NO ENSINO DA DISCIPLINA DE ESTRUTURA DE DADOS
Área de Informática na Educação
por
Mauricio Santos
Rudimar Luís Scaranto Dazzi, Dr Orientador
Itajaí (SC), julho de 2007
UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
SISTEMA TUTOR INTELIGENTE PARA AUXÍLIO NO ENSINO DA DISCIPLINA DE ESTRUTURA DE DADOS
Área de Informática na Educação
por
Mauricio Santos 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: Rudimar Luís Scaranto Dazzi, Dr.
Itajaí (SC), julho de 2007
ii
SUMÁRIO
LISTA DE ABREVIATURAS.................................................................. iv
LISTA DE FIGURAS.................................................................................v
LISTA DE TABELAS..............................................................................vii RESUMO..................................................................................................viii ABSTRACT................................................................................................ ix
1 INTRODUÇÃO......................................................................................1 1.1 OBJETIVOS ........................................................................................................ 2 1.1.1 Objetivo Geral ................................................................................................... 2 1.1.2 Objetivos Específicos ........................................................................................ 2 1.2 METODOLOGIA................................................................................................ 3 1.3 ESTRUTURA DO TRABALHO ....................................................................... 4
2 FUNDAMENTAÇÃO TEÓRICA ........................................................5 2.1 ESTRUTURA DE DADOS................................................................................. 5 2.1.1 Tipo Abstrato de Dados.................................................................................... 5 2.1.2 Pilha.................................................................................................................... 7 2.1.3 Fila .................................................................................................................... 12 2.1.4 Lista .................................................................................................................. 15 2.1.5 Árvore............................................................................................................... 18 2.2 INFORMÁTICA NA EDUCAÇÃO................................................................. 20 2.2.1 Educação à Distância...................................................................................... 21 2.2.2 Software Educacional ..................................................................................... 22 2.3 SISTEMAS TUTORES INTELIGENTES ..................................................... 24 2.3.1 Arquitetura de Sistemas Tutores Inteligentes.............................................. 25 2.3.2 Exemplos de Sistemas Tutores Inteligentes.................................................. 29 2.4 INTELIGÊNCIA ARTIFICIAL...................................................................... 33 2.4.1 Sistema Especialista ........................................................................................ 33 2.4.2 Ambiente de Desenvolvimento de Sistemas Especialista ............................ 35 2.5 CONSIDERAÇÕES .......................................................................................... 38
3 DESENVOLVIMENTO ......................................................................40 3.1 ANÁLISE DE REQUISITOS........................................................................... 40 3.1.1 Requisitos Funcionais ..................................................................................... 40 3.1.2 Requisitos Não-Funcionais............................................................................. 41 3.2 DIAGRAMAS DE CASOS DE USO ............................................................... 41 3.2.1 Cenário do Professor ...................................................................................... 41 3.2.2 Cenário do Aluno ............................................................................................ 42 3.2.3 Cenário do Administrador............................................................................. 43 3.3 ARQUITETURA DO SISTEMA..................................................................... 44
iii
3.4 BASE DE DOMÍNIO ........................................................................................ 48 3.5 IMPLEMENTAÇÃO ........................................................................................ 49 3.5.1 Estrutura do Sistema ...................................................................................... 51 3.5.2 Ambiente do Administrador .......................................................................... 51 3.5.3 Ambiente do Professor ................................................................................... 52 3.5.4 Ambiente do Aluno ......................................................................................... 54 3.5.5 Ambiente do Sistema Especialista ................................................................. 57 3.6 VALIDAÇÃO DO SISTEMA .......................................................................... 61
4 CONCLUSÕES ....................................................................................62 4.1 RECOMENDAÇÕES........................................................................................ 64
REFERÊNCIAS BIBLIOGRÁFICAS ...................................................65
A IMPLEMENTAÇÃO DE TAD’s........................................................69 A.1 TAD PONTO...................................................................................................... 69 A.2 TAD PILHA ALOCAÇÃO DINÂMICA ........................................................ 69 A.3 TAD FILA ALOCAÇÃO ESTÁTICA ............................................................ 70 A.4 TAD FILA ALOCAÇÃO DINÂMICA ........................................................... 72 A.5 TAD LISTA ENCADEADA SIMPLES .......................................................... 73 A.6 TAD LISTA DUPLAMENTE ENCADEADA CIRCULAR......................... 76
B. PERFIL CARACTERISTICO DO ALUNO ....................................79 B.1 REGRAS QUE MODELAM O PERFIL DO ALUNO.................................. 79 B.2 REGRAS QUE MODELAM O MÓDULO TUTOR..................................... 81
iv
LISTA DE ABREVIATURAS
ADSL Asymmetric Digital Subscriber Line CAI Computer Assisted Instruction CLIPS C Language Integrated Production System CTTMar Centro de Ciências Tecnológicas da Terra e do Mar EaD Educação à Distância ED Estrutura de Dados ER Entidade Relacionamento FIFO First In, First Out IA Inteligência Artificial ICAI Intelligent Computer Assisted Instruction IE Informática na Educação LIBRAS Linguagem Brasileira de Sinais LIFO Last In, First Out MySQL My Structured Query Language NASA National Aeronautics and Space Administration PC Perfil Característico PHP Hypertext Preprocessor SE Sistema Especialista STI Sistema Tutor Inteligente TAD Tipo Abstrato de Dados TCC Trabalho de Conclusão de Curso TCD Tipo Concreto de Dados UML Unified Modeling Language UNIVALI Universidade do Vale do Itajaí WWW World Wide Web
v
LISTA DE FIGURAS
Figura 1. Implementação de um tipo de dados.....................................................................................6 Figura 2. Inclusão de um TAD em linguagem C .................................................................................6 Figura 3. Arquivo principal “teste.c” chama biblioteca “ponto.h” ......................................................7 Figura 4. Funcionamento da pilha........................................................................................................8 Figura 5. Estrutura da pilha estática .....................................................................................................9 Figura 6. Função para criação ou inicialização da pilha. ...................................................................10 Figura 7. Função empilha...................................................................................................................10 Figura 8. Função desempilha .............................................................................................................10 Figura 9. Função retorna o topo da pilha ...........................................................................................11 Figura 10. Função para pilha vazia ....................................................................................................11 Figura 11. Função para pilha cheia ....................................................................................................11 Figura 12. Estrutura da pilha dinâmica ..............................................................................................11 Figura 13. Funcionamento da fila estática .........................................................................................13 Figura 14. Estrutura da fila.................................................................................................................13 Figura 15. Funcionamento da fila dinâmica.......................................................................................14 Figura 16. Estrutura da fila e do elemento da fila .............................................................................14 Figura 17. Implementação de lista encadeada....................................................................................16 Figura 18. Estrutura da lista dinâmica................................................................................................17 Figura 19. Implementação de lista duplamente encadeada circular...................................................17 Figura 20. Estrutura para lista duplamente encadeada.......................................................................17 Figura 21. Estrutura para árvore.........................................................................................................19 Figura 22. Representação hierárquica de árvore ................................................................................19 Figura 23. Arquitetura Clássica de um STI........................................................................................26 Figura 24. Definição de regra no CLIPS............................................................................................37 Figura 25. Tela de trabalho do CLIPS................................................................................................38 Figura 26. Cenário do Professor.........................................................................................................42 Figura 27. Cenário do Aluno..............................................................................................................43 Figura 28. Cenário do Administrador. ...............................................................................................44 Figura 29. Árvore de decisão do módulo aluno .................................................................................47 Figura 30. Árvore de decisão do módulo tutor...................................................................................48 Figura 31. Diagrama Entidade Relacionamento ................................................................................49 Figura 32. Estrutura do Sistema .........................................................................................................51 Figura 33. Tela do Administrador ......................................................................................................52 Figura 34. Cadastro de material - professor .......................................................................................53 Figura 35. Desempenho – professor...................................................................................................54 Figura 36. Desempenho - aluno .........................................................................................................54 Figura 37. Definindo o perfil do aluno - início ..................................................................................55 Figura 38. Definindo o perfil do aluno - fim......................................................................................55 Figura 39. Visualização de conteúdo - aluno .....................................................................................56 Figura 40. Revisão de Conteúdo - aluno ............................................................................................56 Figura 41. Processo de comunicação da aplicação como o Sistema Especialista..............................57 Figura 42. Implementação da comunicação entre o STI e o SE para definir o PC do aluno .............58 Figura 43. Templates de comunicação para o perfil do aluno............................................................59 Figura 44. Implementação da comunicação entre o STI e o SE para definir o PC do aluno .............60 Figura 45. Templates de comunicação para o módulo tutor ..............................................................60 Figura 46. Como instalar o Clips PHP ...............................................................................................62
vi
Figura 47. Erro ao iniciar o Clips PHP...............................................................................................63 Figura 48. Erro ao buscar as funções do Clips PHP...........................................................................63 Figura 49. Implementação do TAD Ponto .........................................................................................69 Figura 50. Função pilha_cria..............................................................................................................69 Figura 51. Função pilha_empilha.......................................................................................................70 Figura 52. Função pilha_desempilha .................................................................................................70 Figura 53. Função pilha_vazia ...........................................................................................................70 Figura 54. Função criar fila ................................................................................................................70 Figura 55. Função fila cheia...............................................................................................................71 Figura 56. Função inserir na fila ........................................................................................................71 Figura 57. Função fila vazia...............................................................................................................71 Figura 58. Função elimina da fila.......................................................................................................72 Figura 59. Função retorna o primeiro elemento da fila......................................................................72 Figura 60. Função cria fila .................................................................................................................72 Figura 61. Função insere na fila .........................................................................................................72 Figura 62. Função remove da fila.......................................................................................................73 Figura 63. Função para inserir no início da lista ................................................................................73 Figura 64. Função para inserir elemento na posição da lista .............................................................73 Figura 65. Função para inserir elemento no fim da lista ....................................................................74 Figura 66. Função para remover elemento do início da lista .............................................................74 Figura 67. Função para remover elemento da posição da lista ..........................................................75 Figura 68. Função para remover o último elemento da lista..............................................................75 Figura 69. Função para inserir no início da lista ................................................................................76 Figura 70. Função para inserir na posição na posição da lista ...........................................................76 Figura 71. Função para inserir no fim da lista....................................................................................77 Figura 72. Função para remover no início da lista .............................................................................77 Figura 73. Função para remover na posição da lista ..........................................................................78 Figura 74. Função para remover no fim da lista ................................................................................78 Figura 75. Regra para a Pergunta 1, resposta – nenhum / Pergunta 1, resposta - bom ......................79 Figura 76. Regra para a Pergunta 1, resposta – bom / Pergunta 2, resposta - bom............................80 Figura 77. Regras para validação da árvore do módulo tutor ............................................................81
vii
LISTA DE TABELAS
Tabela 1. STI x CAI ...........................................................................................................................25 Tabela 2. Sistemas tutores inteligentes e suas características ............................................................32 Tabela 3. Aplicativos Testados ..........................................................................................................63
viii
RESUMO
SANTOS, Mauricio. Sistema Tutor Inteligente para Auxílio no ensino da Disciplina de Estrutura de Dados. Itajaí, 2006. 90 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í, 2007. A Educação a Distância surge como modalidade de ensino para superar as limitações do ensino presencial. Hoje o estudante, principalmente o adulto, possui o perfil de trabalhador, tendo que dividir seu tempo entre família, trabalho e estudos. O ambiente de ensino-aprendizagem convencional sofreu modificações importantes com o surgimento dos computadores. Devido à facilidade de acesso as tecnologias como internet, ADSL, bibliotecas virtuais e outras, pessoas com sede de conhecimento nas mais diversas áreas de interesse fazem uso da informática para suprir suas necessidades do saber. A disciplina de Estrutura de Dados é tida como base para o desenvolvimento de variados sistemas computacionais, sendo este cenário o enfoque deste trabalho. Sua proposta é a criação de um Sistema Tutor Inteligente (STI) que possa auxiliar os alunos da disciplina de Estrutura de Dados do curso de Ciência da Computação do CTTMar-UNIVALI a ampliarem seus conhecimentos. O sistema foi desenvolvido para a Web com tecnologia PHP e MySQL e dentro do conceito de Educação a Distância os alunos matriculados na disciplina poderão fazer uso do sistema e acessá-lo nas horas em que acharem mais conveniente, terão acesso ao repositório de material, realizarão exercícios e poderão acompanhar seu próprio desempenho. Foi implantado um módulo tutor o qual contém as estratégias de ensino e devido a isto pode decidir quando e como apresentar o conteúdo ao estudante. A metodologia utilizada neste projeto compreende cinco etapas. Na primeira etapa, estudo, foi realizado um levantamento bibliográfico a fim de adquirir o conhecimento necessário sobre soluções similares e tecnologias que foram utilizadas, objetivando desenvolver uma solução adequada e eficiente. Na segunda etapa, modelagem, foi feita a especificação do funcionamento da solução proposta, bem como a análise e o projeto do STI. Na terceira etapa, desenvolvimento, realizou-se a implementação da solução modelada através da codificação das suas funcionalidade em software e da prototipação do sistema. Na quarta etapa, teste e validação, foram realizados experimentos com o protótipo tentando falseá-lo, com o objetivo de eliminar os erros existentes em sua modelagem ou desenvolvimento. Na quinta e última etapa, documentação, foi feito o registro de todo o projeto de pesquisa com a elaboração de uma monografia e de um artigo científico. Atualmente o índice de aprovação dos alunos na disciplina fica em torno de 60% e espera-se que com a utilização do sistema o mesmo aumente consideravelmente. Palavras-chave: Estrutura de Dados, Inteligência Artificial, Sistema Tutor Inteligente.
ix
ABSTRACT
The distance learning appears as modality to overcome the limitations of present education. Today the student, mainly the adult, has worker profile, having that to divide his/her time among family, work and studies. The environment of conventional teach-learning suffered important modifications with the appearance of the computers in the classrooms. Due to access easiness to the technologies as Internet, ADSL, virtual libraries and others, people that wish the knowledge in the most different areas of interest use the computer science to provide their necessities of knowing. The Structure of Data subject is had as base for the development of varied computational systems being this scene the focus of this work. The proposal is the creation of Intelligent Tutor System (ITS) that can aid the pupils of Structure of Data subject of the Computer Science Course of CTTMar-UNIVALI extend their knowledgement. The registered pupils will be able to have access the system at the moment that will be better for them - the system was developed for Web with PHP and MySQL technology - where they will do exercises, will have access to the material repository and they will be followed by a virtual tutor. The methodology, used in this project, divides into five stages. Fisrt, the study, a bibliographical revision was carried out in order to acquire the sufficient knowledge about similar solutions and technologies that were used, aiming to develop an efficient and adequated solution. Second, model, the working specification of proposal solution, as well as ITS analysis and project. Third , development, was done the implementation of modeled system using codification of its functionalities and system prototype. In fourth, validation, were done experiments with the prototype in order to eliminate its errors. Fifth and last stage, documentation, was done a documentation about the entire project. Currently, the rate of pupils’ approval in subject is about 60% and it is believed that can improve. keywords: Structure of Data, Artificial Intelligence, Intelligent Tutor System.
1 INTRODUÇÃO
A facilidade de acesso a novas tecnologias (internet, ADSL-Asymmetric Digital Subscriber
Line, bibliotecas virtuais) tem proporcionado a estudantes, pesquisadores e simpatizantes
facilidades na busca de novas técnicas de aprendizado e estudo da área em que têm interesse. A
informática tem contribuído com essa idéia, disponibilizando aos interessados o máximo de
informações possíveis, melhorando assim as formas disponíveis de ensino e aprendizado. O uso da
hipermídia, da rede e de softwares educativos permitiu também a cooperação, como forma de
trabalho e aquisição de conhecimento (SOBRAL; FERREIRA, 2000, p. 1).
A Educação à Distância (EaD) surge como uma modalidade para superar as limitações do
ensino presencial, trazendo vantagens na medida em que rompe com limitações espaciais e
geográficas, diminuindo o custo por aluno, atendendo a população diversificada, reunindo pessoas
de locais e ocupações diferentes, priorizando o respeito ao ritmo pessoal de aprendizagem e
desenvolvendo a autodisciplina de estudo (LIMA; ROSATELLI, 2003, p. 2).
Segundo Viccari (1990 apud SCHMITZ et al, 2002, p. 3), os Sistemas Tutores Inteligentes
(STI) são programas que modificam suas bases de conhecimento, percebem as intervenções do
aluno e são dotados da capacidade de aprender e adaptar suas estratégias de ensino mediante a
interação com o aluno.
Como exemplo de STI pode-se citar o Wöhler, que é um ambiente inteligente para suporte
ao processo de ensino-aprendizagem na área de Química Orgânica, capaz de avaliar o desempenho
e o progresso do aluno, permitindo manipular, construir e analisar moléculas de acordo com as
questões formuladas na forma de pequenos problemas a serem resolvidos (LUZZI et al, 1997, p.
201).
Pode-se citar também o STI desenvolvido para o ensino de Estrutura de Dados aos Surdos,
que consiste em verificar o tipo de mídia (texto, vídeo ou imagem) que será utilizada para
apresentar o conteúdo ao aluno. São realizadas perguntas objetivas ao aluno para modelar o seu
perfil inicial e durante os exercícios realizados o sistema percebe se o aluno compreendeu melhor o
assunto abordado através de imagens, vídeos ou pela leitura de textos (FRANÇA, 2005, p. 39).
Devido a fatos como os apresentados anteriormente, o ambiente de ensino-aprendizagem
convencional sofre modificações importantes com a utilização de computadores nas salas de aula e
2
fora delas. Percebe-se com isso a necessidade do desenvolvimento de uma ferramenta que auxilie o
aluno a absorver os conteúdos e conceitos durante o processo de ensino-aprendizagem, no caso
deste trabalho, para a disciplina de Estrutura de Dados. Um STI, neste enfoque, é uma boa solução
uma vez que pode ser utilizado tanto como apoio ao professor da disciplina como para estudo dos
alunos em horário extra-aula, pois permite uma adaptação ao aprendizado de cada estudante
modelando o seu perfil, uma vez que nem todos aprendem da mesma forma.
A execução deste projeto de pesquisa se justifica em nível de Trabalho de Conclusão de
Curso (TCC) para o Curso de Ciência da Computação, uma vez que desenvolve uma solução
computacional que faz uso das muitas tecnologias aprendidas durante o curso, dentre as quais,
pode-se citar Estrutura de Dados, Inteligência Artificial, Programação e Banco de dados.
A ênfase do projeto foi desenvolver um sistema computacional para o auxílio no
aprendizado e acompanhamento de acadêmicos da disciplina de Estrutura de Dados, almejando
oferecer um acompanhamento individualizado sobre o desempenho do aluno no aprendizado de
Lista, Fila, Pilha e Árvore, e fornecer aos alunos um repositório de materiais didáticos básicos e
complementares e exercícios práticos.
A razão da escolha pela disciplina de Estrutura de Dados é devido a esta ser base para o
desenvolvimento de variados sistemas computacionais e o índice geral de aprovação da disciplina,
no curso de ciência da computação do CTTMar-UNIVALI, ficar em torno de 60%, o que acredita-
se possa melhorar com outras formas de ensino. Também pode-se ressaltar a disponibilidade do
professor da disciplina de estruturas de dados para auxiliar no processo de geração dos conteúdos
do sistema e nos testes finais (avaliação).
1.1 OBJETIVOS
1.1.1 Objetivo Geral
Desenvolver um Sistema Tutor Inteligente para o acompanhamento e auxílio do estudante
no aprendizado da disciplina de Estrutura de Dados.
1.1.2 Objetivos Específicos Têm-se como objetivos específicos deste projeto de pesquisa:
• Pesquisar práticas de ensino de Estrutura de Dados;
3
• Estudar as ferramentas computacionais necessárias à implementação de STI;
• Pesquisar e analisar sistemas similares;
• Analisar e selecionar as técnicas de Inteligência Artificial a serem utilizadas;
• Realizar a modelagem conceitual do sistema;
• Implementar o sistema; e
• Testar e validar a implementação do sistema.
1.2 Metodologia
O desenvolvimento deste trabalho foi constituído por cinco etapas, estudo, modelagem,
desenvolvimento, validação e documentação.
A primeira, consistiu em obter informações através de uma revisão bibliográfica, realizando-
se uma pesquisa prática de ensino de Estrutura de Dados, onde foram apresentadas informações
sobre Tipo Abstrato de Dados (TAD) e as estruturas Pilha, Fila, Lista e Árvore, também foram
implementados os scripts referente as operações associadas as estas estruturas. Estudou-se as
ferramentas computacionais necessárias à implementação de STI (Sistemas Tutores Inteligentes) e
foram pesquisados e analisados sistemas similares, onde foi feita uma análise de suas
características. Foi descrito uma seção na qual analisou-se e selecionou-se a técnica de Inteligência
Artificial que foi utilizada na implementação do sistema e apresentado o ambiente de
desenvolvimento para esta técnica. Essa etapa foi realizada no intuito de prover boa qualidade no
sistema proposto.
Na segunda etapa tem-se uma descrição sobre as tecnologias e estratégias utilizadas para
desenvolvimento do sistema, apresentadas as árvores de decisão, a modelagem do banco de dados, a
descrição dos casos de uso e os requisitos, imprescindíveis, a vista do especialista para o bom
desempenho do sistema.
A terceira etapa compreendeu a implantação do banco de dados, os casos de uso foram
codificados para a linguagem PHP, foi atribuída inteligência ao sistema ao ser desenvolvida a
modelagem das árvores de decisão para o módulo tutor e módulo do aluno.
Na quarta etapa foram realizados testes de funcionalidade do sistema, buscando corrigir os
erros de implementação e procurando validar cada caso de uso segundo a modelagem definida.
4
Na quinta e última etapa, após a conclusão da modelagem e da implementação, foi realizada
a documentação do sistema, onde foi feito todo o registro do projeto de pesquisa, através da
elaboração de uma monografia e um artigo científico.
1.3 Estrutura do trabalho
Este trabalho está estruturado em quatro capítulos. No primeiro capítulo foi apresentada
introdução, os objetivos, a metodologia e as estrutura do trabalho.
No segundo capítulo é demonstrado um estudo sobre Estruturas de Dados, é descrita a
implementação dos Tipos Abstratos de Dados que representam cada estrutura, estas
implementações são distribuídas na forma de Figura durante a descrição da Fundamentação Teórica
e no Apêndice. Na seqüência é falado sobre Informática na Educação, realizado um embasamento
sobre Educação a Distância no qual foi identificado o perfil do estudante da atualidade. Neste
capítulo também é apresentado um estudo sobre Sistemas Tutores Inteligentes, identificada sua
arquitetura e apresentado exemplos e características de Sistemas Tutores Inteligentes atuais e que
foram importantes no passado. Na seção sobre Inteligência Artificial define-se que o sistema a ser
desenvolvido será baseado em Sistemas Especialistas devido a não se terem casos antigos que
pudessem ser comparados ou dados que influenciassem na escolha de outro tipo de inteligência,
nesta mesma seção é explicado sobre o Ambiente de Desenvolvimento do Sistema Especialista. No
final desse capítulo é feita uma análise geral do que foi descrito durante toda a fundamentação
teórica.
O terceiro capítulo refere-se ao desenvolvimento e validação do sistema. Neste, foram
descritas as análises de requisitos, é apresentado os cenários com os casos de uso que foram
implementados aos atores que trabalham no sistema. Exibida a arquitetura do sistema. Na seção
base de domínio definiu-se que esta pode ser dividida em base do módulo aluno e base do módulo
domínio. Foram descritas as características das tecnologias utilizadas no desenvolvimento do
sistema. Foi apresentada a estrutura do sistema, descrito sobre o seu ambiente e suas características.
No quarto capítulo são apresentadas a conclusões alcançadas com o desenvolvimentos do
sistema e as recomendações para trabalhos futuros.
2 FUNDAMENTAÇÃO TEÓRICA
Este capítulo está dividido em 4 tópicos. Inicialmente é apresentada uma descrição sobre
Estrutura de Dados e logo após são detalhados os pontos relevantes utilizados neste trabalho. Foi
detalhada a apresentação do TAD Pilha.h de forma a explicar a implementação de cada função para
a estrutura de dados Pilha, o que não ocorrerá com a apresentação para a estruturas de Fila, Lista e
Árvore, onde o código fonte completo dos TAD’s mencionados constará em apêndice, sendo
descritas apenas suas características principais. No segundo tópico, Informática na Educação, foi
realizado um apanhado geral sobre a situação do ensino na atualidade. No terceiro tópico, Sistemas
Tutores Inteligentes, foi descrito sobre a arquitetura destes sistemas e apresentadas características
de sistemas que foram e são considerados importantes. No quarto tópico, Inteligência Artificial, é
apresentada uma descrição sobre a inteligência que será apresentada no projeto.
2.1 ESTRUTURA DE DADOS
Drozdek (2002, p. xv) define que o componente fundamental no aprendizado da Ciência da
Computação é o estudo das Estruturas de Dados, pois estas são a base sobre a qual muitos outros
campos da Ciência da Computação são construídos. Acrescenta que é imprescindível a obtenção de
algum conhecimento para os estudantes que têm pretensão de trabalhar em implementação, testes e
manutenção de projetos de qualquer sistema de software.
2.1.1 Tipo Abstrato de Dados
Um tipo abstrato de dados (TAD) é formado por um conjunto de valores e por uma série de
funções que podem ser aplicadas sobre estes valores. Funções e valores, em conjunto, constituem
um modelo matemático que pode ser empregado para modelar e solucionar problemas do mundo
real, servindo para especificar as características relevantes dos objetos envolvidos no problema, a
forma como se relacionam e como podem ser manipulados (PEREIRA, 2004, p. 4).
Para Celes, Cerqueira e Rangel (2004, p. 126) um TAD é descrito pela finalidade do tipo e
de suas operações, e não pela forma como está implementado. A interface de um TAD consiste,
basicamente, na definição do nome do tipo e do conjunto de funções exportadas para sua criação e
manipulação.
6
Tipo concreto de dados (TCD ou simplesmente tipo de dados) é a transformação de um
modelo matemático para ser aplicado na resolução de problemas de computador. Denomina-se
implementação quando ocorre a transformação de um TAD em TCD. “É durante o processo de
implementação que a estrutura de armazenamento dos valores é especificada, e que os algoritmos
que desempenharão o papel das funções são projetados” (PEREIRA, 2004, p. 4). A Figura 1
representa esta afirmação.
Figura 1. Implementação de um tipo de dados
Fonte: Adaptado de Pereira (2004, p. 5).
Para Pimentel e Cristina (2005) a característica essencial de um TAD é a separação entre
conceito e implementação, sendo que a implementação de um TAD escolhe Estrutura de Dados
(ED) para representá-lo. Cada ED é constituída dos tipos básicos (inteiro, real, caracter) ou dos
tipos estruturados (vetor, registro).
Para o exemplo de utilização de um TAD na linguagem “C” é preciso representá-lo através
de uma biblioteca (.h), e para utilizá-lo é necessário incluir uma diretiva “#include TAD.h” no
programa que fará uso da biblioteca, conforme descrito na Figura 2.
Figura 2. Inclusão de um TAD em linguagem C
Fonte: Dazzi (2006).
A Figura 3 mostra as operações para o TAD Ponto implementadas na biblioteca ponto.h. Se
forem conhecidas as interfaces do TAD pode-se criar programas que utilizem as funcionalidades
exportadas, no entanto, o arquivo que utilizará o TAD, no caso teste.c, deve incluir a diretiva de
IMPLEMENTAÇÃO TIPO DE DADOS
ABSTRATO (modelo matemático)
TIPO CONCRETO DE DADOS
(padrão de bits/rotinas)
Prog.c
tad1.h
tad2.h
7
chamada para a biblioteca ponto.h implementada em sua interface. A implementação do TAD para
o arquivo ponto.h é apresentada na Figura 49 no Apêndice A. A.1.
Figura 3. Arquivo principal “teste.c” chama biblioteca “ponto.h”
Fonte: Adaptado de Dazzi (2006).
Da mesma forma como foi apresentado o TAD Ponto, serão apresentados os TAD’s Pilha,
Fila, Lista e Árvore.
2.1.2 Pilha
Uma pilha é uma estrutura linear de dados na qual novos dados podem ser armazenados e
recuperados somente por uma extremidade chamada topo da pilha (DROZDEK, 2002, p. 123).
Toda vez que um elemento é inserido na pilha, acrescenta Pereira (2004, p. 17), ele é
colocado no seu topo, e em qualquer momento apenas aquele elemento posicionado no topo da
pilha pode ser removido. Logo, os elementos da pilha só podem ser retirados na ordem inversa à
ordem em que foram introduzidos: o último que entrou é o primeiro a sair (LIFO – last in, first out).
“A definição da pilha compreende a inserção e a eliminação de itens, de modo que uma
pilha é um objeto dinâmico, constantemente mutável”. Aliás, o nome pilha, usado como sinônimo
Arquivo teste.c
Arquivo ponto.h �
#include <iostream> using namespace std; // Definicao do Tipo Ponto struct Ponto { int X,Y; }; // Inicializa a coordenada void iniciaPonto(Ponto &P) // Mostra a coordenada atual void mostraPonto(Ponto P) // Atualiza a coordenada void atualizaPonto(Ponto &P, int X, int Y)
#include <iostream> using namespace std; #include "ponto.h" int main() { Ponto ponto; iniciaPonto(ponto); mostraPonto(ponto); atualizaPonto(ponto,10,20); mostraPonto(ponto); return 0; }
8
para lista LIFO, provém da semelhança entre o modo como as listas LIFO crescem/diminuem e o
modo como as pilhas, no mundo real, funcionam (TENENBAUM; LANGSAM; AUGENSTEIN,
1989, p. 86).
Um exemplo para utilização de pilha é de uma lanchonete onde há uma pilha de bandejas
que são colocadas e retiradas uma sobre a outra. A última bandeja colocada é a primeira bandeja
removida da pilha. Pode-se pegar uma bandeja somente se existirem bandejas na pilha, e uma
bandeja pode ser adicionada à pilha somente se houver espaço suficiente, isto é, se a pilha não
estiver muito alta (DROZDEK, 2002, p. 123).
2.1.2.1 TAD Pilha
O TAD pilha é composto pelos dados (valores) e pelo conjunto de operações (funções)
pertinentes a estes valores. Neste caso, os dados são a estrutura computacional necessária para
armazenar o conteúdo da pilha e as operações são funções e/ou procedimentos que representam as
operações que se deseja. A Figura 4 ilustra o funcionamento conceitual de uma pilha. A seguir é
apresentado o TAD de forma abstrata, suas operações associadas e suas implementações, por
alocação estática e dinâmica.
Figura 4. Funcionamento da pilha
Fonte: Adaptado de Celes, Cerqueira e Rangel (2004, p. 162).
Tipo de dado
Definição da estrutura: conjunto dos dados e controle do topo da pilha.
• Dados; e
9
• Controle do Topo.
Operações Associadas
• Criar (P) – cria uma Pilha P vazia;
• Vazia (P) – testa se a pilha está vazia;
• Cheia (P) – testa se a pilha está cheia;
• Topo (P) – acessa o elemento do topo da pilha (sem eliminar);
• Empilha (P, x) – insere x no topo da pilha; e
• Desempilha (P) – elimina o elemento do topo da pilha.
Implementação de pilha – alocação estática
Para esta situação é preciso saber de antemão o número máximo de elementos que podem
estar armazenados simultaneamente na pilha, isto é, a estrutura da pilha tem um limite conhecido.
Deve-se ter um vetor para armazenar os elementos da pilha (para os exemplos apresentados o nome
do vetor será dados), onde os elementos inseridos ocupam as primeiras posições do vetor. Dessa
forma, quando têm-se n elementos armazenados na pilha, o elemento dados[n-1] representa o
elemento do topo.
A estrutura que representa o tipo pilha deve, portanto, ser composta pelo vetor e pelo
número de elementos armazenados (Figura 5).
template <class tipo, int TAM> struct pilha{ tipo dados[TAM]; int topo; };
Figura 5. Estrutura da pilha estática
Quando é criada, a pilha é inicializada como sendo vazia para evitar erros. A implementação
desta operação do TAD é apresentada na Figura 6.
10
template <class tipo, int TAM> void pilha_cria(pilha<tipo,TAM> &pl){ pl.topo = -1; }
Figura 6. Função para criação ou inicialização da pilha.
Para inserir um elemento na pilha é usada a próxima posição livre do vetor. É necessário
assegurar que existe espaço para a inserção do novo elemento, tendo em vista que se trata de um
vetor com dimensão fixa. A Figura 7 mostra a implementação do TAD para a operação empilha.
template <class tipo, int TAM> bool pilha_empilha(pilha<tipo,TAM> &pl, tipo valor){ if( pilha_cheia (pl)){ return false; //pilha cheia } else { pl.dados[pl.topo++] = valor; //insere elemento return true; } }
Figura 7. Função empilha
A operação do TAD para eliminar e retornar um elemento da pilha é apresentada na Figura
8. Antes de eliminar um elemento, é preciso também verificar se a pilha está vazia ou não.
template <class tipo, int TAM> tipo pilha_desempilha(pilha<tipo,TAM> &pl){ if( pilha_vazia (pl)){ return(null); //pilha vazia } else { return pl.dados[pl.topo--];// retorna o elemento do topo e decrementa } }
Figura 8. Função desempilha
Para verificar o elemento que se encontra no topo de pilha é necessário uma função que
retorna este valor. É preciso também verificar se a pilha está vazia sendo que neste caso retorna o
valor nulo. A Figura 9 mostra a implementação deste TAD.
11
template <class tipo, int TAM> tipo pilha_retorna_topo(pilha<tipo,TAM> &pl){ if(pilha_vazia (pl))//se estiver vazia return(NULL); else return (pl.dados[pl.topo]);//retorna o elemento do topo sem decrementá-lo }
Figura 9. Função retorna o topo da pilha
Por fim, nas Figura 10 e Figura 11 são apresentadas as implementações das operações de
TAD para verificar se a pilha está vazia ou se está cheia.
template <class tipo, int TAM> bool pilha_vazia(pilha<tipo,TAM> &pl){ return (pl.topo == -1); }
Figura 10. Função para pilha vazia
template <class tipo, int TAM> bool pilha_cheia(pilha<tipo,TAM> &pl){ return (pl.topo == TAM-1); }
Figura 11. Função para pilha cheia
Implementação de pilha – alocação dinâmica
Este tipo de implementação é utilizado quando o número máximo de elementos a serem
armazenados na pilha é desconhecido. Os elementos são armazenados na pilha e ela pode ser
representada simplesmente por um ponteiro para o primeiro nó, que é o topo. A estrutura que
representa a operação deste TAD é mostrada na Figura 12, e as demais estruturas utilizadas na
implementação do TAD Pilha se encontram no Apêndice A. A.2.
template <class tipo> struct pilha{ tipo dado; pilha<tipo>* anterior; };
Figura 12. Estrutura da pilha dinâmica
12
2.1.3 Fila
Drozdek (2002, p. 130) define uma fila como sendo “simplesmente uma linha de espera que
cresce somando elementos ao seu final e que diminui tomando elementos de sua frente”. Uma fila,
como no cotidiano, é uma estrutura na qual ambas as extremidades são usadas. Em uma
extremidade os elementos são inseridos e na outra eles são eliminados; diferentemente da pilha,
onde o último elemento alocado é o primeiro elemento a ser eliminado.
Pereira (2004, p. 57) concorda com esta definição e informa que “cada vez que uma
operação de inserção é executada, um novo elemento é colocado no final da fila”. Acrescenta ainda
que, “na remoção, é sempre retornado o elemento que aguarda a mais tempo na fila, ou seja, aquele
posicionado no começo”. Devido a isto, as filas são denominadas de FIFO (First-In/First out), onde
a ordem de saída é definida diretamente pela ordem de entrada dos elementos na fila, de modo que
os primeiros elementos que entram são os primeiros a sair.
Pode-se usar como exemplo, para implementação de uma Fila, o caso de uma impressora
que é compartilhada para várias máquinas. Deve-se adotar um critério para determinar a prioridade
de impressão dos documentos e a estratégia mais simples, segundo Celes, Cerqueira e Rangel
(2004, p. 171) “é tratar todas as requisições com a mesma prioridade e imprimir os documentos na
ordem em que forem submetidos – o primeiro submetido é o primeiro a ser impresso”.
2.1.3.1 TAD Fila
O TAD fila é composto pelos dados (valores) e pelo conjunto de operações (funções)
pertinentes a estes valores. Os dados são a estrutura computacional necessária para armazenar o
conteúdo da fila e as operações são funções e/ou procedimentos que descrevem a finalidade do
TAD. A seguir é apresentado o TAD de forma abstrata, suas operações associadas, suas estruturas
de implementação e as figuras que representam o seu funcionamento conceitual, por alocação
estática e dinâmica.
Tipo de dado
Definição da estrutura: conjunto de dados e o controle do início e do fim da fila.
• Dados; e
• Controle do Início e Fim.
13
Operações Associadas
• Criar (F) – cria uma fila F vazia;
• Vazia (F) – Testa se a fila está vazia;
• Cheia (F) – Testa se a fila está cheia;
• Primeiro (F) – acessa o elemento no início da fila;
• Inserir (F, x) – insere x no fim da fila; e
• Eliminar (F) – elimina o elemento do início da fila.
Implementação de fila – alocação estática
Figura 13. Funcionamento da fila estática
Fonte: Adaptado de Pimentel e Cristina (2005).
Para implementação da fila estática (Figura 13) é necessário ter na sua estrutura um vetor
com tamanho determinado. Para isso, é preciso fixar o número máximo de n elementos da fila para
o vetor; a Figura 14 mostra a estrutura da fila. O processo de remoção e inserção em extremidades
opostas fará a fila andar no vetor, sendo que neste caso a função de inserir chama uma função
auxiliar que ajuda na organização do vetor. Esta implementação pode ser verificada na Figura 56 do
Apêndice A. A.3, e as demais implementações para o TAD Fila Estática podem ser encontradas no
mesmo apêndice.
template <class tipo, int TAM> struct filaEst{ int inicio, fim, quantidade; tipo dados[TAM]; };
Figura 14. Estrutura da fila
14
Implementação de fila – alocação dinâmica
Figura 15. Funcionamento da fila dinâmica
Fonte: Adaptado de Pimentel e Cristina (2005).
Na alocação dinâmica não existe o problema de limite para o tamanho da fila, estando esta
limitada somente ao tamanho da memória física do computador (Figura 15). Para controle da
posição inicial e final são criados dois elementos do tipo fila, os quais definem a posição inicial e
final da fila respectivamente. A estrutura de um elemento da fila, bem como a estrutura de seus
ponteiros de início e fim são apresentadas na Figura 16.
template < class T > struct ElementoFila { T dado; ElementoFila<T> *prox; }; template <class T> struct TFila { ElementoFila<T> *Inicio,*Final; };
Figura 16. Estrutura da fila e do elemento da fila
Ao inserir um novo elemento na fila basta alocar memória e fazer com que o último
elemento aponte para este, sendo que a implementação pode ser vista na Figura 61. A operação para
retirar um elemento ocorre no início da fila e consiste em fazer com que, após a remoção, o começo
aponte para o sucessor do nó retirado, a implementação para esta função está descrita na Figura 62
do Apêndice A.4, no mesmo Apêndice encontram-se as demais funções para implementação de fila
com alocação dinâmica.
15
2.1.4 Lista
Ao ocupar um espaço contíguo na memória, um vetor permite acesso a qualquer um de seus
elementos a partir do endereço da sua posição inicial, podendo assim ser acessado com o operador
de indexação vet[i]. Desta forma, Celes, Cerqueira e Rangel (2004, p. 134) dizem que “o vetor é
uma estrutura que possibilita o acesso randômico aos elementos, pois é possível acessar qualquer
elemento aleatoriamente”.
O que dificulta é que o vetor não é uma estrutura de dados muito flexível, pois é preciso
sempre ser dimensionado com o número de elementos definidos. Caso seja necessário armazenar
mais elementos do que o número máximo de posições possíveis no vetor começam a surgir os
problemas, “pois não existe uma maneira simples e barata para alterar a dimensão do vetor em
tempo de execução”. No entanto, se o espaço de memória utilizado for menor que o espaço locado
para o vetor, é possível dizer que se está “subutilizando o espaço de memória reservado” (CELES;
CERQUEIRA; RANGEL, 2004, p. 135).
A solução para casos como estes seria utilizar estruturas que cresçam ou diminuam
conforme seja preciso inserir ou remover elementos. Essas estruturas são chamadas dinâmicas e a
vantagem de uma lista sobre um vetor é a possibilidade não só de inserir ou remover elementos em
suas extremidade, mas também no meio de um grupo de elementos (TENENBAUM; LANGSAM;
AUGENSTEIN, 1995, p. 235).
2.1.4.1 TAD Lista
O TAD lista será composto pelos dados (valores) e pelo conjunto de operações (funções)
pertinentes a estes valores. Os dados são a estrutura computacional necessária para armazenar o
conteúdo da lista e as operações são funções e/ou procedimentos que representam as operações que
se deseja. A seguir é apresentado o TAD de forma abstrata, suas operações associadas, suas
estruturas de implementação e as figuras que representam o seu funcionamento conceitual como
lista encadeada simples e duplamente encadeada circular.
Tipo de dado
Definição da estrutura: conjunto de dados e o controle do início e do fim da fila.
• Dados;
• Controle do Próximo; e
16
• Controle do Anterior (duplamente encadeada).
Operações Associadas
• Criar (L) – cria uma lista L vazia;
• Vazia (L) – Testa se a lista está vazia;
• Cheia (L) – Testa se a lista está cheia;
• Insere no Início (L, x) - Insere x no início da lista;
• Insere na Posição (L, x, pos) – Insere x na posição pos da lista;
• Insere no Fim (L, x) – Insere x no fim da lista;
• Remove no Início (L) – Remove o elemento do início da lista;
• Remove na Posição (L, x, pos) – Remove x da posição pos da lista; e
• Remove no Fim (L, x) – Remove x do fim da lista.
Implementação de lista – encadeada simples
Figura 17. Implementação de lista encadeada
Fonte: Adaptado de Pimentel e Cristina (2005).
Numa lista encadeada, para cada novo elemento inserido na estrutura é alocada memória
para armazená-lo. Dessa forma, o espaço total de memória gasto pela estrutura é proporcional ao
número de elementos armazenados. Para percorrer todos os elementos da lista é necessário guardar
o seu encadeamento, o que é feito armazenando-se, junto com a informação de cada elemento, um
ponteiro para o próximo elemento da lista, como mostra a Figura 17. Quando um elemento novo é
inserido, precisa-se definir se ele é adicionado no início, meio ou fim da lista, o que é representado
da Figura 63 à Figura 65 no Apêndice A. A.5. A mesma situação é identificada no caso de remoção,
representada da Figura 66 à Figura 68 encontradas no mesmo Apêndice. A Figura 18 representa a
estrutura para implementação do TAD Lista.
17
template < class T > struct ListaDin { T dado; ListaDin <T> *prox; };
Figura 18. Estrutura da lista dinâmica
Implementação de lista – duplamente encadeada circular
Figura 19. Implementação de lista duplamente encadeada circular
Fonte: Adaptado de Pimentel e Cristina (2005).
Neste tipo de lista cada elemento tem um ponteiro para o próximo elemento e um ponteiro
para o elemento anterior (Figura 19). Assim, dado um elemento podem-se acessar os dois elementos
adjacentes: o próximo e o anterior. Caso seja preciso acessar o último elemento da lista pode-se
percorrê-la em ordem inversa, bastando acessar continuamente o elemento anterior até alcançar o
primeiro elemento da lista. O nó da lista pode ser representado pela estrutura mostrada na Figura 20
e a lista pode ser representada com o ponteiro para o primeiro nó, também identificado na Figura
19.
template < class T > struct ListaDin { T dado; ListaDin <T> *ant; ListaDin <T> *prox; };
Figura 20. Estrutura para lista duplamente encadeada
18
2.1.5 Árvore
É considerada a estrutura de dados adequada para a representação de hierarquias. A forma
mais natural de definir uma estrutura de árvore é usando a recursividade. Uma árvore é composta
por um conjunto de nós. Existe um nó r, denominado de raiz, que contém zero ou mais subárvores,
cujas raízes são ligadas diretamente a r. Esses nós raízes das subárvores são ditos filhos do nó pai, r.
Nós com filhos são chamados de nós internos, e nós que não têm filhos são chamados de folhas ou
nós externos. É tradicional desenhar as estruturas de árvores com a raiz para cima e as folhas para
baixo (CELES; CERQUEIRA; RANGEL, 2004, p. 185).
Drozdek (2002, p. 194) complementa esta informação afirmando que
Cada nó tem que ser atingível a partir da raiz através de uma seqüência única de arcos, chamada de caminho. O número de arcos em um caminho é chamado de comprimento do caminho. O nível de um nó é o comprimento do caminho da raiz ao nó mais 1, que é o número de nós no caminho. A altura de uma árvore não-vazia é o nível máximo de um nó na árvore. A árvore vazia é uma árvore legítima de altura 0 (por definição), e um nó único é uma árvore de altura 1. Esse é o único caso no qual um nó é raiz e folha. O nível de um nó precisa estar entre 1 (o nível de uma raiz) e a altura da árvore, que, em um caso extremo é o nível da única folha em uma árvore degenerada, que se parece com uma lista ligada.
2.1.5.1 TAD Árvore
O TAD árvore é composto pelos dados (valores) e pelo conjunto de operações (funções)
pertinentes a estes valores. Os dados são a estrutura computacional necessária para armazenar o
conteúdo da lista e as operações são funções e/ou procedimento que representam as operações que
se deseja. A seguir é apresentado o TAD de forma abstrata, suas operações associadas, sua estrutura
de implementação e a figura que representa o seu funcionamento conceitual.
Tipo de dado
Definição da estrutura: conjunto de dados e o controle do nó da esquerda e controle do nó da
direita a árvore.
• Dados; e
• Controle do filhoDireita e filhoEsquerda.
Operações Associadas
• Define (T) – define uma árvore vazia;
• Criar (T,x) – Cria o nó raiz com o elemento x;
19
• Vazia(T) – verifica se a árvore está vazia;
• Insere à Direita do Nó (T, item_pai, x) - insere x à direita do item_pai;
• Insere à Esquerda do Nó (T, item_pai, x) – insere x à esquerda do item_pai;
• Nivel (T,x) – retorna o nível onde se encontra o nó como o item x;
• Pai (T,x) – retorna o conteúdo do pai do nó caso ele exista na árvore; e
• Excluir (T,x) – exclui x da árvore.
As Figura 21 representa a estrutura de árvore e a Figura 22 mostra o seu funcionamento
conceitual.
template < class T > struct No { T dado; No<T> *dir,*esq; };
Figura 21. Estrutura para árvore
Figura 22. Representação hierárquica de árvore
Fonte: Adaptado de Pimentel e Cristina (2005).
20
2.2 INFORMÁTICA NA EDUCAÇÃO
Para Gregio (2003, p. 2), “o paradigma educacional emergente requer a inserção de novas
práticas curriculares e metodologias inovadoras, para fazer frente às necessidades de uma sociedade
globalizada”, que faz constantes alterações nos padrões de vida da pessoa, “seja na maneira de se
comunicar, nas habilidades profissionais de atuação ou na forma de aquisição do conhecimento e do
pensar”.
Hoje o estudante, principalmente o adulto, tem o perfil de trabalhador, tendo que dividir seu
tempo entre família, trabalho e estudos, sendo que antes os alunos eram jovens que dispunham de
tempo integral para dedicar-se somente aos estudos. Isso mostra que houve sim uma mudança no
paradigma educacional (CRISTEA; TUDUCE, 2002 apud SOUZA, 2005, p. 6).
Desta forma, o futuro papel do professor não será mais o de difusor do saber, mas o de
“animador da inteligência coletiva” dos estudantes, estimulando-os a trocar seus conhecimentos.
Para falar em tecnologia é necessário cuidar para não usá-la a qualquer custo, mas sim acompanhar
consciente e deliberadamente uma mudança de civilização que questiona profundamente as formas
institucionais, as mentalidades, a cultura dos sistemas educacionais e, sobretudo, os papéis de
professor e de aluno (LÈVY, 1998 apud GREGIO, 2003, p. 3).
Para Souza (2005, p. 7) adotar o computador como ferramenta de ensino implica numa
mudança cultural e uma das principais razões para a sua utilização é a de propiciar situações
desafiadoras de resolução de problemas onde o aluno desenvolve o raciocínio, aprende no seu
tempo e interage com outros estudantes, enriquecendo o processo de aprendizado.
O projeto de um programa educacional implica uma série de decisões que vão desde o
aspecto técnico até o aspecto pedagógico. A escolha da modalidade de programa educacional que se
deseja implementar traz consigo uma série de pressupostos psico-pedagógicos que devem ser
observados pelos projetistas.
Chiab (2002 apud GREGIO, 2003, p. 4) está preocupado com o despreparo dos professores
na adaptação à modernidade e a aversão por parte dos mesmos diante das mudanças necessárias e
impostas pela evolução tecnológica. Afirma que “os professores estão fortemente arraigados à
concepção tradicional do seu papel, do papel da educação e dos métodos de ensino”.
21
Percebe-se então que implantar laboratórios nas escolas, e equipá-los com computadores de
última geração não implica em avanços na qualidade do ensino. Faz-se necessário treinar
professores e alunos, dispor das ferramentas corretas e entender que o computador é um meio e não
um fim (SOUZA, 2005, p. 8).
Desta forma, os professores tornam-se “elemento-chave” para que o trabalho possa cumprir
seus objetivos. Gregio (2003, p. 6) diz que é necessário iniciar um processo contínuo de formação
dos professores, no qual devem ser abrangidos conhecimentos específicos sobre informática e
conhecimentos sobre o processo de ensino-aprendizagem.
O aprendizado é um processo gradual e contínuo e necessita que o conhecimento adquirido
seja aplicado, praticado, de forma a ser fixado e trabalhado na prática. O filósofo chinês Confúcio
certa vez disse: “O que ouço, eu esqueço, o que vejo, eu recordo, o que faço, eu aprendo”, palavras
sábias que retratam o fato real. Conhecimento adquirido, mas não exercitado, perde-se ao longo do
tempo.
Por isso pode-se dizer que as pessoas tendem a aprender melhor quando associam um
conteúdo a algo prático, que aplica na vida real. Segundo Cristea e Tuduce (2002 apud SOUZA,
2005, p. 8) as pessoas aprendem melhor quando são motivadas e desafiadas, ou quando necessitam
do conhecimento para resolver um problema.
Pode-se concluir que, se os esforços no desenvolvimento da Informática na Educação forem
direcionados no sentido de motivar, desafiar e exercitar o estudante, o computador torna-se uma
ferramenta poderosa e aliada do educador. Se o professor continuar a insistir em ser um mero
“transmissor” de conhecimento e transformar os alunos em “espectadores” estáticos, meros
ouvintes, esse professor certamente será substituído. Mas não por máquinas, e sim por outro
professor.
2.2.1 Educação à Distância
O ambiente de ensino-aprendizagem convencional sofreu modificações importantes com o
surgimento dos computadores nas salas de aula (SOBRAL; FERREIRA, 2000, p. 1). Também a
Internet evoluiu, saindo dos laboratórios de pesquisa para os computadores domésticos, e se
mostrou uma fonte riquíssima de informação para os estudantes. Ela revolucionou a obtenção de
22
conhecimento, facilitando o acesso a novas tecnologias, e propôs adaptações ao sistema
educacional, introduzindo novas exigências e competências principalmente aos educadores.
Contudo, a Internet deve ser vista sempre como uma ferramenta de apoio ao ensino e que
permitiu aos softwares educacionais se expandirem, tomando proporções globais e permitindo
conectar alunos de qualquer parte do mundo, minimizando o problema das distâncias geográficas.
O principal objetivo seria a busca por um melhor aproveitamento visando a possibilidade de
maior integração e flexibilidade no processo de ensino-aprendizagem, como descrito por Sobral e
Ferreira (2000, p. 1), o de “promover a motivação do aluno, além de educá-lo, resultando na
remodelação de técnicas e metodologias de ensino”.
É importante que o professor saiba exercer de forma organizada e pedagógica a sua função,
e que o aluno possa trabalhar o conhecimento no seu tempo, sendo o gerenciador do seu próprio
saber, “pois o maior risco é confundir esse processo psico-pedagógico de ambientação on-line com
o mero adestramento técnico operacional” (LÈVY, 1998 apud GREGIO, 2003, p. 3). Utilizar a
informática para o ensino não implica em aprender sobre o computador, mas sim aprender a
explorar recursos do computador para motivar o aprendizado, tomando o cuidado para não
“considerar apto e ambientado um aluno apenas porque sabe clicar nas áreas corretas da tela e não
compreender os aspectos que realmente importam num processo de educação on-line”.
Lima e Rosatelli (2003, p. 2) concluem essa idéia afirmando que,
A EaD surge como uma modalidade para superar as limitações do ensino presencial, trazendo vantagens na medida em que rompe com limitações espaciais e geográficas, diminui o custo por aluno, atende a população diversificada, reúne pessoas de locais e com ocupações diferentes, preconiza o respeito ao ritmo pessoal de aprendizagem e desenvolve a autodisciplina de estudo.
2.2.2 Software Educacional
“Todo programa pode ser considerado um programa educacional, desde que utilize uma
metodologia que o contextualize no processo de ensino-aprendizagem” dizem Vicari e Giraffa
(2003, p. 155), sendo esta uma conceituação cada vez mais aceitável para a comunidade de
informática na educação (IE).
Segundo Vicari e Giraffa (2003, p. 156) as classificações mais tradicionais utilizadas no que
diz respeito aos programas educacionais não contemplam as modalidades que utilizam técnicas de
23
IA e os ambientes cooperativos. Muitas destas classificações não levam em consideração um
aspecto fundamental, que é o tipo de aprendizagem proporcionada pelo ambiente. A necessidade de
se fazer uma reflexão neste sentido gerou a divisão dos programas educacionais em dois grandes
grupos:
1. Aprendizagem de habilidades específicas
o CAI (Computer Assisted Instruction - Instruções Auxiliada por Computador)
• Tutoriais: segue o padrão de ensino da sala de aula tradicional, onde o conteúdo é
previamente organizado pelo professor e o aluno seleciona dentre as diversas
opções disponíveis o conteúdo que deseja estudar;
• Exercício-prática: o aluno pratica e testa o conhecimento de forma dirigida;
• Demonstração; e
• Jogos educacionais e as simulações: o processo de aprendizagem é através de
jogos, onde há um processo competitivo e a simulação é a execução de um
modelo previamente definido.
o ICAI (Intelligent Computer Assisted Instruction - Inteligente Instrução Auxiliada por
Computador)
• Sistemas Tutores Inteligentes: representam o conhecimento e elevam a termo
uma interação com o aluno.
2. Aprendizagem de habilidades cognitivas amplas
o Micromundos: voltados a desenvolver a habilidade cognitiva do aluno, este modelo
sugere que o aluno construa o seu conhecimento. Trabalham basicamente com a
solução de problemas e não apresentam conteúdos pré-fixados e resposta;
o Sistemas de Autoria: ferramenta de criação que possibilita ao aluno explorar um
conjunto amplo de habilidades cognitivas, exercendo a sua criatividade; e
24
o Jogos Educacionais: apresenta uma concepção diferenciada daqueles apresentados
anteriormente. Nestes ambientes existe um modelo de simulação onde o tipo de ação
executada pelo aluno fará diferença no resultado do jogo.
2.3 SISTEMAS TUTORES INTELIGENTES
Com o surgimento da IA foi possível que os desenvolvedores de programas CAI criassem
programas que deixassem de ser meros viradores de páginas eletrônicas e se tornassem um
elemento mais ativo no processo de interação com o aluno, surgindo assim o ICAI cujo nome mais
utilizado na literatura é STI. (VICARI; GIRAFFA, 2003, p. 161).
Esta reformulação, segundo Sobral e Ferreira (2000, p. 4) ocorreu na década de 70 e os
mesmos autores caracterizam os tutores inteligentes como:
[...] ferramentas ou softwares educacionais capazes de assistir a aprendizes nos ambientes de ensino-aprendizagem, objetivam a aquisição de conhecimento de maneira interativa, criando situações que levam o aluno a aprender, desenvolvendo seus próprios meios, de acordo com seu potencial, incentivando a sua autonomia e a sua criatividade.
Como declarado por Giraffa (1999 apud JESUS, 2004, p. 2), acrescentar um I à sigla CAI
não significa apenas agregar técnicas de IA para a construção de sistemas tutores, mas inclui
trabalhar de forma interdisciplinar com as conquistas que outras áreas de pesquisa obtiveram em
relação ao conhecimento da comunicação inteligente, tais como os avanços da psicologia e da
pedagogia.
Esta interdisciplinaridade vem sendo aplicada aos STI. Estes sistemas pertencem a categoria
de software educacionais que se baseiam na aprendizagem interativa. Neste contexto, o aluno passa
a ser o centro do processo ensino-aprendizagem, deixando de ser passivo e tornando-se um ser ativo
no processo, além de tornar relevante o seu conhecimento atual e as suas características de
aprendizado (JESUS, 2003, p. 3).
Os STI e os CAI aparentemente situam-se em um tipo similar de aplicação em educação,
pois ambos partem do princípio da solução de problemas. A fim de identificar diferenças e
semelhanças é apresentado a Tabela 1 abaixo.
25
Tabela 1. STI x CAI
Aspecto CAI STI Origem Educação Ciência da Computação Bases Teóricas Skinner (behaviorista)1 Psicologia Cognitivista2 Estruturação e Funções Uma única estrutura
algoritmicamente pré-definida, onde o aluno não influi na seqüência.
Estrutura subdividida em módulos, cuja seqüenciação se dá em função da resposta do aluno.
Estruturação do Conhecimento Algorítmica Heurística Modelagem do Aluno Avaliam a última resposta. Tentam avaliar todas as respostas
do aluno durante a interação. Modalidades Tutorial, exercício e prática,
simulação e jogos educativos. Socrático3, ambiente interativo4, diálogo bidirecional5 e guia6.
Fonte: Adaptado de Vicari e Giraffa (2003, p. 163).
Para Vicari e Giraffa (2003, p. 162), “as diferenças mais profundas entre os STI e os CAI
tradicionais estão na forma com que se concebe o seu projeto”. Os CAI induzem o aluno a uma
resposta correta mediante uma série de estímulos cuidadosamente planejados, e os STI pretendem
simular algumas das capacidades cognitivas do aluno e utilizar esses resultados como base para as
decisões pedagógicas a tomar.
2.3.1 Arquitetura de Sistemas Tutores Inteligentes
A interação do STI com o usuário oferece considerável flexibilidade e maior habilidade na
apresentação de material e quando há necessidade de fornecer respostas. “Eles procuram não apenas
ensinar, mas aprendem informações relevantes sobre o estudante, proporcionando-lhe um
aprendizado individualizado” (THIRRY, 1999 apud SCHMITZ et al, 2002, p. 3).
Os módulos que compõem a maioria dos STI, bem como seus inter-relacionamentos, são
apresentados na Figura 23.
1 Estudo do comportamento 2 Ato de conhecer ou captar, entregar, elaborar e exprimir informação 3 Pretendem proporcionar instrução através de diálogo com os alunos e detectam erros. 4 Trabalham um determinado assunto através da interação com o aluno, utilizando a abordagem de diagnóstico desse aluno. 5 Utilizam um ambiente interativo com diálogo entre o aluno e o tutor, podendo haver alterações no comportamento do tutor, face às respostas do usuário (aluno). 6 Alguns STI funcionam como guias do aluno e não se utilizam de um diálogo e sim apresentam o conteúdo de outra forma.
26
Figura 23. Arquitetura Clássica de um STI
Fonte: Adaptado de Vicari; Giraffa (2003, p. 169).
2.3.1.1 Módulo Domínio
Contém o conhecimento armazenado do especialista na matéria a ser ensinada. Esse
conhecimento é adquirido a partir do especialista, devendo, portanto, ser transferido para o aluno. É
constituído pelo material instrucional, que podem ser: lições, animações, filmes, exercícios,
exemplos, desafios, dicas, entre outros (VICARI; GIRAFFA, 2003, p.171).
A representação do conhecimento pode se dar por várias formas, por exemplo, regras de
produção, redes semânticas, frames, orientação a objetos, lógica, script. Segundo Oliveira (2002
apud FRANÇA, 2005, p. 10) neste módulo o conteúdo a ser ensinado deve ser armazenado não em
uma base de dados, mas sim numa base de conhecimento; “do contrário, o sistema teria informação
sem possibilidade de raciocinar sobre ela para tomada de decisão”,
De acordo com Castoldi; Sakata (1998 apud CONCEIÇÃO, 2003, p. 66), o conhecimento
contido no Módulo Domínio pode ser classificado de duas formas:
• Declarativo e teórico: consiste das unidades contendo os conceitos do domínio e suas
relações, a metodologia se divide em três fases: determinar quais objetos serão incluídos
no domínio, definir como os objetos se relacionarão entre si e verificar quais relações
estão corretas; e
27
• Procedimental: trata-se de um procedimento explicativo. Explica como fazer uma tarefa,
como diagnosticar um problema ou recomendar uma ação. Para incorporar o
conhecimento num sistema recomenda-se: estabelecer as metas, estabelecer os fatos e
estabelecer as relações entre as metas e os fatos.
2.3.1.2 Módulo Aluno
Contém as informações referentes a cada estudante que faz uso do sistema. Essas
informações estão relacionadas com o nível de conhecimento do estudante sobre a matéria e o seu
ritmo de aprendizagem (SOBRAL; FERREIRA, 2000, p. 2).
De acordo com Vicari e Giraffa (2003, p. 172), muitas técnicas são utilizadas para construir
o modelo do aluno, como por exemplo:
• Reconhecimento de padrões aplicados ao histórico das respostas fornecidas;
• Comparar a conduta do aluno com a de um especialista e verificar os pontos em comum;
• Colocar as preferências do aluno;
• Coisas que ele costuma esquecer quando interage com o tutor; e
• Indicação dos seus desejos, crenças e intenções.
É graças ao Módulo Estudante que o sistema pode ter um atendimento personalizado para
cada usuário, o que leva a crer que este deve ser dinâmico, pois à medida que o aluno participa do
curso, seu estado cognitivo é alterado. Sendo assim, tal módulo deve ser capaz de acompanhar todo
este processo de aprendizagem (CONCEIÇÃO, 2003, p. 64).
2.3.1.3 Módulo Tutor
Dazzi (2004, p. 19) afirma que este módulo determina qual conteúdo será ministrado em
determinado momento. Obtendo informações do módulo do aluno é decidido o que fazer em
seguida, por exemplo, apresentar um novo material ou revisar o material que foi previamente
ensinado.
Jesus (2003, p. 6) concorda com essa idéia afirmando que a partir das informações contidas
no modelo do estudante e no modelo do domínio faz-se a seleção e o seqüenciamento do assunto a
ser apresentado e enviado à interface gráfica. Esse módulo contém as estratégias de ensino e decide
28
quando e como apresentar o conteúdo para o estudante. Expressa ainda sua preocupação com
relação ao módulo tutor afirmando que ele requer uma atenção especial em sua modelagem:
Um processo de aprendizagem depende de uma grande variedade de fatores e o sistema tutorial deve cuidar para não destruir a motivação pessoal do estudante ou o seu senso de descobrimento. Este processo pedagógico requer grande versatilidade e criatividade na modelagem do sistema tutor.
2.3.1.4 Módulo Interface
Também chamado módulo de comunicação ou ambiente de ensino, é a interface entre o STI
e o aluno. Deve ser inteligente e capaz de adaptar-se as diferentes necessidades de cada usuário,
aprender novos conceitos e técnicas, tomar iniciativas. Continuando seu pensamento de Jesus
(2003, p. 6) afirma que “o uso de apresentações gráficas, especialmente animações poderão
contribuir para melhorar o processo de ensino e aprendizagem no aluno”.
De acordo com Dazzi (2004, p. 25), alguns aspectos devem ser observados numa interface,
tais como:
• Escolha de uma linguagem adequada de comunicação de informações vindas tanto do
sistema quanto do aluno;
• Escolha dos elementos de interface;
• Facilidade de uso; e
• Identificação do usuário.
Vicari e Giraffa (2003, p. 178) dizem que “uma boa interface é vital para o sucesso de
qualquer sistema interativo” e afirmam que é na interação que o STI exerce duas de suas principais
funções: a apresentação do material instrucional e a monitoração do progresso do estudante através
da recepção da resposta do aluno. Dessas duas funções, podemos derivar alguns objetivos a serem
cumpridos pelo módulo de interface:
• Evitar que o estudante se entedie;
• O estudante deve poder intervir facilmente no discurso do tutor, e vice-versa;
• O tempo de resposta deve permanecer dentro de limites aceitáveis; e
• A monitoração deve ser feita o máximo possível em background, sem sobrecarregar o
aluno com questionários excessivos.
29
Schmitz et al (2002, p. 3) afirma que o nível de dificuldade de implementação dos STI é
diretamente proporcional aos benefícios trazidos por eles, ou seja, quanto maior sua capacidade de
tutoria, maior será o uso de técnicas complexas aplicadas ao seu desenvolvimento.
2.3.2 Exemplos de Sistemas Tutores Inteligentes
Para Fischetti e Gisolfi (1990 apud COSTA, 2002) os STI são considerados como um livro
ativo, onde o leitor tem uma interação na transmissão do conhecimento e um melhor nível de
entendimento. Neste contexto, julgam compreensível a utilidade que os STI podem vir a
proporcionar nos diversos campos do conhecimento humano.
A seguir são relacionados trabalhos de conclusão de uma série de STI pesquisados e outros
que foram historicamente importantes:
• STEAMER (HARMON; KING, 1988 apud COSTA, 2002): O objetivo deste STI é
ensinar aos oficiais da Armada os problemas referentes à direção de uma central de
propulsão a vapor, existentes nos barcos da marinha americana. Tal treinamento divide-
se em duas partes: uma procedimental e outra conceitual, na qual é dada maior ênfase,
fornecendo ao aluno uma idéia geral do que acontece nestes sistemas de central de
vapor, possibilitando exercitar as medidas de prevenção e controle de conseqüências
geradas por problemas nestas situações, especialmente em casos de emergência. O
STEAMER usa dois computadores. Um deles mostra um diagrama da central de vapor e
o outro exibe informações sobre a central e o STI que supervisiona a interação do aluno
com o sistema. É um software muito interessante, pois proporciona uma simulação
interativa do ambiente de estudo. Foi construído pelo Centro de Pesquisa e Formação de
pessoal da Marinha de San Diego, em colaboração com a Bolt, Beranek & Neuman, Ind.
de Cambridge, Massachusetts;
• GUIDON (HARMON; KING, 1988 apud COSTA, 2002): foi desenvolvido por William
Clancey do Departamento de Informática da Universidade de Stanford. A grosso modo,
o GUIDON pode ser simplesmente classificado como um sistema de diagnóstico médico
e prescrição, altamente especializado, tendo como principal objetivo ajudar os médicos
nas infecções de meningite e de bacteriemia. Este programa é utilizado em faculdades de
medicina auxiliando no treinamento de estudantes e médicos, possuindo, além da base
de conhecimento, as experiências de casos efetivos acumulados por outro sistema
30
anterior, o MYCIN (o qual possui as mesmas características do GUIDON),
possibilitando o fornecimento de bons exemplos para os usuários. Costa (2002) afirma
que a principal deficiência do sistema está no fato de considerar que o aluno já tenha
conhecimento dos termos técnicos utilizados, bem como os resultados dos testes
químicos apresentados;
• SOPHIE (WOOLF, 1988 apud COSTA, 2002): o sistema tem por objetivo auxiliar o
estudante a encontrar falhas em um circuito eletrônico. Desenvolvido por Brown e
Burton, funciona da seguinte forma: o aluno recebe um circuito com uma falha
hipotética e precisa determinar aonde se encontra o defeito. O sistema então gera a
hipótese que foi sugerida pelo estudante, testando se tais propostas estão ou não corretas.
Se a sugestão for incorreta de acordo com os fatos já apresentados pelo sistema como
base para o aluno resolver o problema, então o SOPHIE questiona o aluno e argumenta o
contrário, através de um diálogo amigável;
• MALT (DU BOULAY, 1988 apud COSTA, 2002): este STI opera sobre programas de
código de máquina. Seu funcionamento é extremamente simples. Ele gera e representa
um problema, fornecendo comentários à medida que o aluno fornece uma resposta que
faz parte da seqüência das instruções em código de máquina. Assim que o usuário se
torna mais experiente, o sistema diminui as interrupções ao estudante, supondo que o
mesmo já possui mais controle de suas ações. O questionamento gerado pelo sistema é
dividido em vários problemas menores, com seus pontos centrais e suas funções
primitivas. O sistema, então, gera uma solução ideal e a contrapõe com a tentativa do
aluno. Conforme o desenvolvimento do estudante, o sistema apresenta variantes mais
difíceis do subproblema;
• GREATERP (DU BOULAY, 1988 apud COSTA, 2002): este STI conduz o aluno por
uma lição de Lisp, que se constitui em uma seqüência gradual de problemas a serem
trabalhados. O sistema diferencia alunos experientes de novatos, fornecendo um guia de
procedimentos conforme o grau de experiência. Quando o aluno insere um programa, o
sistema analisa os símbolos e dá exemplos adequados a cada situação. A base do sistema
consiste no fato de que os erros dos alunos devem ser detectados e assinalados assim que
forem constatados, visando a idéia de que os estudantes não persistam em uma solução
incorreta;
31
• SPADE (DU BOULAY, 1988 apud COSTA, 2002): tem por objetivo ensinar LOGO,
pretendendo desenhar uma figura utilizando símbolos primitivos da linguagem de
programação. A idéia consiste na interação do aluno com o sistema através de uma
seqüência de comandos que compõem a solução do problema. As primeiras versões
induzem o aluno a realizar uma decomposição clássica, ao contrário das mais novas, que
permitem uma liberdade maior na solução do problema;
• WÖHLER (LUZZI et al, 1997): é um ambiente inteligente que tem por objetivo dar
suporte ao ensino na área de Química Orgânica. Associado a cada problema existe um
intervalo de tempo, dentro do qual o aluno deverá efetuar a sua resposta. O assistente
avalia o aluno a partir do tempo que ele demorou para solucionar o problema e seleciona
o próximo a partir desta avaliação e do tópico sendo estudado. O sistema fornece, caso o
aluno deseje, o conteúdo associado ao problema onde ele apresentou dificuldade. Possui
uma base de moléculas, radicais e outras estruturas, que podem ser acessadas pelo
estudante durante a realização de uma resposta, a fim de esclarecer duvidas, com ou sem
o auxílio do assistente; e
• Ensino de Estrutura de Dados a Surdos (FRANÇA, 2005): sistema que tem por objetivo
ensinar o conteúdo de ED aos surdos. No primeiro acesso são realizadas duas perguntas
objetivas ao aluno afim de modelar o seu perfil inicial para verificar o tipo de mídia
(texto, vídeo ou imagem) que será utilizada para lhe apresentar o conteúdo. Durante os
exercícios realizados esse perfil é alterado se o sistema percebe que o aluno
compreendeu melhor o assunto abordado através de imagens, vídeos ou pela leitura de
textos. A mídia de vídeo é a gravação de um intérprete que traduz o conteúdo em texto
para LIBRAS.
Além dos sistemas acima listados, é interessante relacionar outros produtos importantes e
disponíveis na literatura, os quais conforme Costa (2002), muitos são resultantes da evolução de
sistemas especialistas mais primitivos, onde a maioria é voltada para a área de treinamento, o que
não pode ser considerado exatamente como um sistema educacional. Entretanto, é importante a
visualização de tais idéias para constatar os avanços que esta ciência está obtendo. Na Tabela 2
encontram-se listados alguns STI existentes e sua características básica.
32
Tabela 2. Sistemas tutores inteligentes e suas características
Sistema Domínio Representação do Conhecimento
Estratégia do Tutor
Scholar Geografia Rede Semântica Socrático Why Tempo
(Causas da chuva) Scripts Socrático
Integrate Matemática (Integração simbólica)
Regras Ambiente reativo com orientação
Sophie Detector de falhas eletrônicas
Rede Semântica Ambiente reativo com orientações guiadas
West Expressões aritméticas Regras Ambiente reativo com treinamento Buggy Subtração Rede Procedimental Ambiente reativo com orientação Wusor Lógica Rede Semântica Ambiente reativo com treinamento Excheck Teoria de conjuntos e
lógica Regras Ambiente reativo com orientação
Bip Programação em Basic
Regra Ambiente reativo com orientação
Spade Programação em Logo Regras Ambiente reativo com treinamento Álgebra Matemática Regras Ambiente reativo com treinamento LMS Matemática Regras Ambiente reativo Quadratic Matemática Regras Ambiente reativo com orientação Guidon Medicina Regras Ambiente reativo com interações
estruturais Proust Programação em
Pascal Rede Semântica Ambiente reativo com orientação
Steamer Propulsão a vapor Modelo Funcional Ambiente reativo com orientação Macavity Engenharia Regras e Frames Treinamento Meno Programação Redes Orientador Wöhler Química Orgânica Regras Socrático Ensino de ED aos surdos
Programação - Estrutura de Dados
Regras Ambiente reativo com treinamento
STI – Proposto
Estrutura de Dados Regras Ambiente reativo com treinamento
Fonte: Adaptado de Park et al. (1987 apud COSTA, 2002).
Na pesquisa, identificou-se diversos tipos de STI, até mesmo um que ensinava ED, mas o
público alvo eram os surdos. Após a realização desta pesquisa foi possível compreender a
importância que os STI exercem no auxílio da educação, foi possível também identificar que
características conterão o STI proposto para este projeto de pesquisa, as quais estão destacadas na
última linha da Tabela 2. Não foram encontrados outros STI para o ensino de ED, o que motiva e
reforça o desenvolvimento deste projeto.
33
2.4 INTELIGÊNCIA ARTIFICIAL
Segundo Stair (1998, p. 256) em uma conferência no Dartmouth College, em 1956, John
McCarthy propôs o uso da expressão inteligência artificial (IA) para descrever os computadores que
tivessem a capacidade de imitar ou replicar as funções do cérebro humano. Muitos pioneiros de IA
compareceram àquela primeira conferência sobre o assunto; alguns previram que os computadores
seriam tão “espertos” quanto os humanos por volta dos anos 60. A predição nunca se realizou, mas
os benefícios da inteligência artificial nos negócios e na vida acadêmica podem ser vistos hoje.
Os sistemas de inteligência artificial incluem as pessoas, procedimentos, hardware, software,
dados e conhecimento necessários para desenvolver sistemas computacionais e máquina que
demonstram características de inteligência. Para Stair (1998, p. 256) o objetivo no desenvolvimento
contemporâneo de sistemas de IA não é substituir completamente a tomada de decisões humana, e
“sim reaplicá-la em certos tipos de problemas bem-definidos”. Desta forma, o propósito das
aplicações de inteligência artificial é auxiliar as organizações a alcançar suas metas.
Para Boose (1994 apud FERNANDES, 2003, p. 2), a IA busca entender a mente humana e
imitar seu comportamento, tendo como objetivo “o estudo e a modelagem da inteligência tratada
como um fenômeno”, pois a inteligência humana é algo extremamente complexo, resultado de
milhões de anos de evolução.
Jesus (2003, p. 4) concorda com essa idéia e diz que a IA tem como objetivo utilizar a
inteligência, ou seja, as faculdades de pensar, raciocinar e compreender para auxiliar na tomada de
decisões, procurando para isto utilizar princípios da inteligência humana.
No que diz respeito a sistemas, Figueiredo (1999) diz que
A grande diferença entre os sistemas que utilizam IA e os sistemas convencionais, é que enquanto os sistemas convencionais têm como principal característica armazenar informações, registrar e controlar eventos, a AI está preocupada em utilizar estas informações para auxiliar nas tomadas de decisões.
2.4.1 Sistema Especialista
Flores (2003, p. 127) declara que o desempenho humano envolve o uso hábil de uma enorme
quantidade de experiências do dia a dia, e o aprendizado, a partir das mesmas, acontece “de forma
bastante inconsciente”. O ser humano aprende a falar sua língua por intermédio da comunicação
com os outros. Aprende a realizar tarefas por tentativas, às vezes com sucesso, às vezes falhando.
34
Em muitos casos o conhecimento adquirido através dessas experiências não é sólido, mas, sem
dúvida, está num formato de regras práticas que são armazenadas em algum lugar, para serem
usadas quando forem relevantes a uma nova situação.
Essas regras práticas são chamadas de heurísticas no linguajar de IA, e representam o
suporte principal do conhecimento que tentamos armazenar para o uso dos sistemas em linguagem
natural, sistemas especialistas (SE) e robôs.
Kandel (1992 apud NASCIMENTO, 2003, p. 11) caracteriza os SE como “sistemas que
reproduzem o conhecimento de um especialista adquirido ao longo dos anos de trabalho”. Devido a
isto, faz-se necessário que este sistema seja construído com o auxílio de um especialista humano, o
qual fornecerá a base de informações, através do seu conhecimento e experiência.
Segundo Nascimento (2003, p. 11), os SE apresentam as seguintes vantagens:
• Possibilidade para construção de regras, o que aumenta sua flexibilidade e eficiência;
• Tomada lógica de decisões sob imprecisão ou na ausência de informações. Nos sistemas
tradicionais, o método de busca é baseado em um conhecimento codificado
anteriormente. Quando surge um novo conhecimento, faz-se necessário reescrever o
código. Já em SE pode-se recuperar novos fatos e regras e usá-los sem modificar a
estratégia de busca;
• Velocidade na determinação de problemas;
• A decisão está fundamentada em uma base de conhecimento; e
• Segurança, estabilidade.
Stair (1998, p. 262) apresenta alguns recursos do SE:
• Melhor resolução de problemas;
• Capacidade de armazenar e aplicar conhecimento e experiência a problemas;
• Reduz tempo de resposta para problemas complexos; e
• Capacidade de examinar problemas a partir de diversas perspectivas.
Os SE podem ser utilizados para resolver problemas em todos os campos e disciplinas e
podem proporcionar auxílio em todos os estágios do processo de solução de problemas. Os SE são
35
bons no estabelecimento de metas estratégicas, planejamento, projetos, confecção de cronogramas,
monitoramento e diagnose. (STAIR, 1998, p. 262).
2.4.2 Ambiente de Desenvolvimento de Sistemas Especialista
Por volta de 1985, a NASA (National Aeronautics and Space Administration) decidiu
unificar o desenvolvimento interno de sistemas especialistas. Como resultado, o setor de tecnologia
de software do Johnson Space Center criou um clone das capacidades de encadeamento progressivo
e da sintaxe do sistema que era utilizado até então, introduzindo o CLIPS (C Language Integrated
Production System) no domínio público. Para Camacho (2005, p. 126), a finalidade era gerar
soluções que apresentassem alta portabilidade, baixo custo e fácil integração com sistemas externos.
Por se ter acesso a outros trabalhos na área e conhecimento da ferramenta, o CLIPS foi a
ferramenta escolhida para se modelar a parte especialista do sistema tutor, pois, segundo Camacho
(2005, p. 126), o sistema CLIPS foi desenvolvido para facilitar a geração de programas que
modelam o conhecimento ou alguma especialidade humana. Existem três maneiras de representar
conhecimento no CLIPS:
• Regras;
• Funções e funções genéricas; e
• Programação orientada a objetos.
É possível desenvolver programas apenas utilizando regras, objetos ou uma combinação dos
dois. Regras e objetos formam um sistema integrado já que regras podem ser utilizadas para
casamento de padrões em fatos e objetos.
O sistema CLIPS utiliza o algoritmo Rete (FORGY, 1982 apud CAMACHO, 2005, p. 127),
“que elimina redundâncias de avaliações das pré-condições das regras”. O autor ainda complementa
com o exemplo e a afirmação de que,
Se uma regra pode ser disparada com um conjunto de objetos, e uma segunda regra é disparada e não altera nenhum dos objetos do primeiro conjunto, então não há necessidade de se testar novamente as pré-condições da primeira, pois ela ainda está ativa com o mesmo conjunto de instância. A idéia por trás do algoritmo é que apenas os objetos modificados no disparo da última regra tenham que ser testados novamente para verificar se tornam alguma outra regra ativa (ou desativa). O algoritmo Rete é usado na maioria dos sistemas de produção existentes, apresentando um ótimo desempenho para aplicações de porte razoável.
36
Segundo o manual, o CLIPS é chamado de ferramenta para SE pois se trata de um ambiente
completo para desenvolvimento deste tipo de IA, o que inclui editor integrado e uma ferramenta de
depuração. O terminal de texto (word shell) é reservado para a parte do CLIPS que realiza
inferência. O shell do CLIPS oferece os elementos básicos para um SE:
1. Lista de fatos e instâncias: memória global para os dados;
2. Base de conhecimento: contém todas as regras, a base de regras; e
3. Motor de inferência: controla a execução das regras.
Um programa escrito no CLIPS consiste de regras, fatos e objetos. O motor de inferência
decide quais regras devem ser executadas e quando. Um SE baseado em regras escrito no CLIPS é
um programa data-driven onde os fatos, e os objetos se desejado, são os dados que estimulam a
execução através do motor de inferência. Este é um exemplo de como o CLIPS difere dos
programas procedurais convencionais como PASCAL, FORTRAN e C. Nas linguagens procedurais
a execução pode ser feita sem a necessidade de dados, isto é, as instruções são suficientes para a
execução. Já no CLIPS, é preciso dos dados para a execução das regras.
2.4.2.1 Criando uma lista de fatos
Para serem adicionados dados na lista de fatos, é preciso usar o comando assert:
• Para um fato com campo único:
o CLIPS> (assert (pato))
• Para múltiplos fatos:
o CLIPS> (assert (pato)(cachorro))
• Para fatos com múltiplos campos:
o CLIPS> (assert (animal-is pato)
o Recomenda-se utilizar o primeiro campo para descrever a relação entre os campos
do fato
• Para números:
o CLIPS> (assert (x 1))
37
2.4.2.2 Definindo regras
Para executar trabalho em um SE, é necessário, além dos fatos, as regras. Uma regra pode
ser definida como mostra a Figura 24.
(defrule duck ; cabeçalho da regra (animal-is duck) ; condição => ; flecha então (assert (sound-is quack) ; ação )
Figura 24. Definição de regra no CLIPS
Uma ação normalmente é uma função sem valor de retorno, porém que executa alguma ação
útil. Como mostrado no exemplo, a ação executada é a função assert. Uma função no CLIPS
normalmente é um trecho de código executável identificado por um nome específico, que retorna
um valor ou executa um efeito colateral útil (como uma impressão).
Uma regra pode ter múltiplos padrões e ações. Zero ou mais padrões podem ser escritos
após o cabeçalho da regra. Cada padrão consiste de um ou mais campos. Na regra duck, o padrão é
(animal-is duck) e os campos são “animal-is” e “duck”. O CLIPS tenta casar os padrões das regas
com os fatos na lista de fatos. Se todos os padrões de uma regra casam, a regra é ativada e colocada
na agenda. A agenda é uma coleção de ativações que representam as regras que casam com as
entidades padrão.
A última parte de uma regra é a lista de zero ou mais ações que serão executadas quando a
regra for disparada. O disparo significa que o CLIPS selecionou uma certa regra para execução na
agenda.
38
2.4.2.3 Exemplo de uso
A Figura 25 mostra a tela de console do CLIPS onde é apresentado um exemplo de uso.
Figura 25. Tela de trabalho do CLIPS.
Começa com a definição de uma regra (linha 1), definição de um fato (linha 2), na linha 3
mostra a ativação do fato e um disparo de ação pela agenda (linha 9). Nas linhas 5 até 7 é mostrada
a lista de fatos que possui apenas o fato inserido na linha 2. Das linhas 11 à 14 é mostarda a lista de
fatos após a execução do run (linha 8). O padrão definido pela regra (lado esquerdo da linha 1) casa
com o fato (linha 2), é ativado na agenda e disparado. O disparo executa a ação definida pela regra
(lado direito da linha 1) e um novo fato é inserido na lista de fatos.
2.5 CONSIDERAÇÕES
Ao final desse capítulo pode-se ter um correto entendimento do que é um TAD. Foram
descritas, mostradas através de figuras e apresentadas estruturas que formam os TAD: lista, fila,
pilha e árvore. Também pode-se ter um embasamento sobre a situação em que se encontra a IE, foi
identificado o perfil do estudante da atualidade e percebeu-se que este tem um perfil de trabalhador,
tendo de dividir o seu tempo entre família, trabalho e estudos.
Ainda na seção sobre IE foi identificada a preocupação de alguns autores quanto ao
despreparo e a aversão dos professores com relação a este assunto. Pode-se entender que se usado
39
corretamente o computador torna-se um aliado do educador mas a aversão ao seu uso pode acarretar
numa futura dificuldade de desempenho de sua ações como professor.
Pois no tópico sobre EaD percebeu-se que esta é uma fronteira que não tem limites e com
isso surge a necessidade de aprimoramento e desenvolvimento de sistemas e profissionais para este
filão de mercado, seja na área de treinamento ou educacional. Com isso faz-se a necessidade de
sistemas que tornem o aprendizado interessante e não façam do aluno simplesmente um virador ou
navegador de páginas.
Nesse ponto a seção sobre STI foi importante, onde foi possível, através da pesquisa,
entender a tecnologia que existe voltada para o desenvolvimento de sistemas tutores que sejam
agradáveis aos alunos e façam em background o acompanhamento dos mesmos. Na continuação
dessa seção foi realizado um levantamento de trabalhos relacionados à linha de STI, onde foram
descritos alguns STI e apresentado uma tabela com as suas características, dessa forma foi possível
situar o trabalho em seu contexto atual e identificar o diferencial dele em relação aos demais.
Na seção sobre IA foi identificado e definido o tipo de inteligência que será aplicada no STI
a ser desenvolvido. Por não haverem casos e registros concretos anteriores, optou-se por utilizar SE;
o que segundo Kandel (1992 apud NASCIMENTO, 2003, p. 11) são caracterizados como “sistemas
que reproduzem o conhecimento de um especialista adquirido ao longo dos anos de trabalho” e
como descrito no início desta proposta, uma das escolhas para o desenvolvimento de um STI para
ED é devido a disponibilidade do professor da disciplina de estrutura de dados (especialista) estar
auxiliando no desenvolvimento deste trabalho.
3 DESENVOLVIMENTO
Este capítulo está dividido em 6 tópicos. Inicialmente são apresentados os requisitos
funcionais e não-funcionais que foram levantados para o sistema. Em seguida é descrita a
modelagem do sistema, utilizando UML(Unified Modeling Language), descrevendo os casos de
uso. Posteriormente é apresentada a arquitetura do sistema. Em seguida é descrito sobre a base de
domínio. No tópico implementação foi apresentado a descrição de como o sistema foi desenvolvido.
Por último, foi falado sobre a validação do sistema
3.1 ANÁLISE DE REQUISITOS
Durante a descrição deste projeto realizou-se uma observação crítica sobre o que seria
necessário para o desenvolvimento de um sistema para o ensino de ED, sendo possível destacar as
excelências e também as limitações. A partir dessa observação e das solicitações do professor
especialista que acompanhou o projeto, definiu-se os requisitos para o STI a ser desenvolvido. Esses
requisitos são divididos em duas categorias: requisitos funcionais e não-funcionais e serão descritos
neste capítulo.
3.1.1 Requisitos Funcionais
Os requisitos funcionais compreendem as funcionalidades que os usuários querem ou
precisam que o sistema ofereça. Como requisitos funcionais para o STI de ED foram considerados
os seguintes como essenciais:
• O sistema deve permitir a inclusão de novos conteúdos teóricos;
• O sistema deve permitir o cadastro de novos exercícios;
• O sistema deve permitir o cadastro de novos alunos;
• O sistema deve permitir o cadastro de novos professores;
• O sistema deve permitir que o aluno analise os conteúdos teóricos;
• O sistema deve permitir que o aluno faça exercícios de determinado conteúdo;
• O sistema deve permitir que o professor verifique os conteúdos já vistos pelo aluno;
• O sistema deve permitir ao professor verificar o desempenho do aluno;
41
• O sistema deve permitir ao aluno visualizar seus dados;
• O sistema deve permitir que o aluno verifique seu desempenho; e
• O sistema deve selecionar um novo problema baseado na análise ou desempenho do
aluno (adaptar ao aluno).
3.1.2 Requisitos Não-Funcionais
Os requisitos não-funcionais compreendem propriedades do sistema, como
manutenibilidade, desempenho, custos e várias outras. Como requisitos não-funcionais para o
sistema definiram-se os seguintes:
• O sistema via WEB deve possuir um mecanismo de segurança para evitar que pessoas
não autorizadas tenham acesso ao sistema ou a dados privados;
• O sistema deve permitir níveis de privilégio;
• As informações geradas nos relatórios devem ser confiáveis; e
• O sistema deve funcionar sobre uma base de dados MySQL, que é gratuita.
3.2 DIAGRAMAS DE CASOS DE USO
Caso de uso é uma seqüência de ações executadas por um determinado processo que produz
um resultado para um determinado ator, com a sua utilização, as funções disponíveis para um
determinado ator ficam simples de entender (BOOCH; RUMBAUCH; JACOBSON, 2000, p. 220).
3.2.1 Cenário do Professor • UC 2.01 - Consultar posição do aluno: o professor poderá se informar da posição em que
o aluno se encontra dentro do conjunto de material exposto para o aprendizado. Os
locais onde o aluno visitou os exercícios realizados, dia e hora em que foram realizados;
• UC 2.02 – Relatório de desempenho: será gerado um relatório com o desempenho do
aluno, avaliação dos exercícios, exercícios que precisou fazer novamente, tempo gasto
para realização dos exercícios;
• UC 2.03 – Logar no sistema: interface característica do professor que é identificado
quando faz o login no sistema. Serão apresentados dados correspondentes aos casos de
uso de professor; e
42
• UC 2.04 – Gerenciar conteúdo: interface onde o professor (especialista para o caso do
STI baseado em SE) poderá incluir, alterar ou excluir os conteúdos teóricos e os
exercícios, fazendo assim a modelagem do módulo domínio do STI.
O diagrama que apresenta os casos de uso relacionados as ações do professor é mostrado na
Figura 26.
Figura 26. Cenário do Professor.
3.2.2 Cenário do Aluno • UC 3.01 – Logar no sistema: ao efetuar o login o aluno será direcionado para sua
interface característica;
• UC 3.02 – Visualizar dados: o aluno poderá visualizar seus dados cadastrais;
• UC 3.03 – Visualizar conteúdo teórico: o aluno poderá aprimorar seu conhecimento
visualizando o conteúdo teórico. No primeiro acesso ao conteúdo teórico o sistema tutor
procura identificar o perfil do aluno, interagindo com o módulo especialista o sistema
poderá realizar 5 perguntas para identificar o seu conhecimento com relação a disciplina
de ED, sendo que o número de perguntas dependerá das resposta do aluno. As respostas
das perguntas alimentam as regras e determinam a seqüência com que elas são
apresentadas. Com base nas respostas do aluno, o sistema fornecerá orientações para que
43
ele possa ter um melhor aproveitamento da matéria a ser explicada em ED. As perguntas
questionadas ao aluno bem como a árvore de decisão são apresentadas na Seção 3.3;
• UC 3.04 – Visualizar desempenho: possibilita ao aluno acompanhar seu desempenho
durante o aprendizado com o STI; e
• UC 3.05 – Fazer exercício: este caso de uso será regido pelo módulo tutor que será
modelado pela árvore de decisão que se encontra na Figura 30.
O diagrama que apresenta os casos de uso relacionados as ações do aluno é mostrado na
Figura 27.
Figura 27. Cenário do Aluno.
3.2.3 Cenário do Administrador • UC 4.01 – Logar no sistema: ao efetuar login no sistema o administrador será
direcionado para sua interface característica, e suas funções serão básicas como descrito
nos demais casos de uso;
• UC 4.02 – Gerenciar aluno: incluir, alterar, excluir o cadastro do aluno; e
44
• UC 4.03 – Gerenciar professor: incluir, alterar, excluir o cadastro do professor.
O diagrama que apresenta os casos de uso relacionados as ações do professor é mostrado na
Figura 28.
Figura 28. Cenário do Administrador.
3.3 ARQUITETURA DO SISTEMA
O desenvolvimento do STI para ensino de ED seguiu a arquitetura clássica proposta por
Vicari e Giraffa (2003, p. 169), ilustrada na Figura 23, onde através de uma interface amigável,
chamada de Módulo Interface, os usuários que utilizam o sistema interagem com os módulos
propostos pela arquitetura.
O Módulo Aluno contém as informações referentes a cada estudante que faz uso do sistema.
Também gerencia a base de dados que armazena as informações relacionadas ao nível de
conhecimento do estudante sobre a matéria e seu ritmo de aprendizado. Ao identificar o primeiro
acesso do aluno ao material de estudos, este módulo aciona o Sistema Especialista integrado ao
Sistema Tutor, o qual irá modelar o perfil do aluno conforme explicado na Seção 3.2.2 . Para
formular a árvore que definirá o perfil de conhecimento (PC) do aluno foram fornecidas pelo
especialista questões objetivas e possíveis respostas, como apresentado a seguir:
45
1. Conhecimento de Programação ?
• Ótimo,
• Bom;
• Razoável; ou
• Nenhum.
2. Conhecimento em C++ ?
• Ótimo,
• Bom;
• Razoável; ou
• Nenhum.
3. Já usou ponteiro ?
• Nunca;
• Muitas vezes; ou
• Poucas vezes.
4. Já usou alocação dinâmica de memória ?
• Nunca;
• Muitas vezes; ou
• Poucas vezes.
5. Já usou “Template” ?
• Nunca;
• Muitas vezes; ou
• Poucas vezes.
Com base nas respostas das questões, é formado o Perfil Característico (PC) do aluno que
será modelado da seguinte maneira:
• PC1 – Teórico;
46
• PC2 – Teórico/Programador; ou
• PC3 – Programador.
O sistema também fornece informações que servirão para orientar o aluno sobre possíveis
ações que ele deve tomar no sentido de obter um melhor aproveitamento no aprendizado da matéria
durante o semestre. As sugestões fornecidas pelo sistema podem ser:
• Propor estudo de Programação;
• Sugerir rever programação;
• Sugerir estudar ponteiro;
• Sugerir revisar C++;
• Sugerir estudar alocação dinâmica de memória;
• Propor estudo de ponteiro, alocação dinâmica de memória e tamplate;
• Propor estudo de ponteiro e alocação dinâmica de memória; e
• Apto a cursar.
A árvore que modela toda a situação de realizar as perguntas, definir o perfil e propor
possíveis ações para o aluno é mostrada na Figura 29.
No Módulo Domínio está contido o conhecimento do especialista que pode ser incluído,
excluído ou alterado de forma a melhorar o material instrucional que será fornecido ao aluno
através do Módulo Tutor. Conforme Dazzi (2004, p. 19), é o Módulo Tutor que informa qual
conteúdo é ministrado em determinado momento. A tarefa de identificação da ação a ser tomada é
realizada por um sistema especialista integrado a este módulo, desenvolvido utilizando o CLIPS,
será descrito mais detalhadamente sobre a criação do sistema especialista ainda neste capítulo. A
árvore modelada para apresentação do conteúdo do Módulo Domínio ao aluno é apresentada na
Figura 30.
Figura 29. Árvore de decisão do módulo aluno
Conteúdo completo?Unidade/Tópico
Teste efetuado?
Apresenta Exercício
Apresentar conteúdos
Sim
Concluídos corretamente?
Sim
Próximo Assunto
Sim
>= 70% de Acertos?
Apresentar Respostas
corretas e sugerir leitura de “link”
Sim
>= 50% de Acertos?
Revisar conteúdo com erro
Rever todo o conteúdo
Sim Não
Não
Não
Não
Não
Figura 30. Árvore de decisão do módulo tutor
3.4 BASE DE DOMÍNIO
A modelagem da árvore de decisão do Módulo Tutor permite proporcionar formas
alternativas de ensino e interações personalizadas entre o sistema e o aluno, através de diferentes
formas de exposição e abordagem de conteúdo. O objetivo é contribuir de forma eficiente no
processo de ensino e promover um aprendizado individualizado para o estudante.
Para atender a esses requisitos a base de domínio foi dividida, conceitualmente, em dois
módulos: a Base do Módulo Aluno (tabelas com fundo branco) e Base do Módulo Domínio (tabelas
com fundo cinza). Fisicamente, tudo foi implementado em um único banco de dados. A divisão é
uma abstração para facilitar o entendimento do sistema, bem como facilitar a modelagem dos dados,
conforme ilustra a Figura 31.
49
Figura 31. Diagrama Entidade Relacionamento
A Base do Módulo Aluno corresponde à persistência das informações relevantes ao aluno,
identificada nos requisitos funcionais, conteúdos já acessados pelo aluno, desempenho, visualização
dos dados, seu perfil, bem como o histórico dos exercícios que resolveu. A Base do Módulo
Domínio refere-se as informações sobre os recursos disponíveis que são cadastrados pelo professor,
como os assuntos a serem estudados e os exercícios a serem realizados.
3.5 IMPLEMENTAÇÃO
Visto que o sistema é desenvolvido para Web, optou-se por utilizar a linguagem de
programação PHP. Trata-se de uma linguagem interpretada, e não compilada. Consiste em ser uma
tecnologia gratuita e relativamente rápida em relação a outras tecnologias Web. Também um dos
motivos pela escolha do PHP como linguagem de desenvolvimento é que ele pode ser obtido
gratuitamente no site www.php.net, sendo compatível com muitos tipos de banco de dados. O PHP
50
possui algumas características que o tornam uma linguagem popular (AULBACH, 2004 apud FEY,
2005, p. 37):
• Código aberto: todo o código fonte do PHP está disponível;
• Custo zero: é uma linguagem de programação gratuita e disponível no site oficial para
download;
• Multiplataforma: pode ser executado em ambiente Unix, Linux, Windows, entre outros;
• Eficiência: consome poucos recursos do servidor e evita chamadas externas;
• Acesso a Banco de Dados: é compatível com os principais bancos de dados existentes,
entre eles o MySQL que é gratuito e está disponível para download em www.mysql.com;
e
• Processamento de linguagens: permite a criação de imagens dinamicamente e o envio
delas ao browser do usuário.
Para o projeto de banco de dados e a base de conhecimento do sistema optou-se por utilizar
MySQL. Também é uma tecnologia gratuita, de código fonte aberto, segura, possui bom
desempenho e é detentora de muitos recursos para os desenvolvedores. O MySQL é um servidor de
banco de dados multitarefa e multiusuário que oferece recursos não existentes em outros servidores,
possuindo boa integração com o PHP. Segundo MySQL AB (2003), o MySQL possui as seguintes
características:
• Capacidade de lidar com um número ilimitado de usuários;
• Capacidade de manipular mais de cinqüenta milhões de registros;
• Multitarefa e Multiplataforma;
• Escrito em C e C++;
• Testado com vários compiladores diferentes;
• As tabelas são baseadas em árvores binárias extremamente rápidas;
• Aceita diversos tipos de campos;
• Possui técnicas avançadas de segurança;
• Registros de tamanho fixos ou variáveis;
51
• Fácil conectividade;
• Sistema de segurança simples e funcional; e
• Distribuição gratuita para o público em geral.
O sistema pode ser acessado via internet, e está disponível no endereço
http://200.169.53.253/~634298 , no entanto, possui acesso restrito podendo ser liberado apenas por
um usuário com acesso administrativo.
3.5.1 Estrutura do Sistema
A Figura 32 mostra a estrutura que foi desenvolvida para o sistema seguindo o modelo de
atores e seus casos de uso conforme descrito na modelagem deste projeto na Seção 3.2.
Figura 32. Estrutura do Sistema
3.5.2 Ambiente do Administrador
Após realizar o login o sistema identifica que o usuário tem o perfil de administrador e então
lhe direciona para o ambiente correto. O Administrador tem a possibilidade de ativar, desativar ou
remover usuários do sistema. Lembrando que o usuário só terá acesso ao sistema após a liberação
deste pelo Administrador. O Administrador tem a possibilidade ainda de alterar os dados de
cadastro de qualquer outro usuário. Caso o Administrador também seja um professor, no ambiente
de administração foi colocado um link onde o administrador tem acesso ao ambiente do professor.
O usuário com perfil de Administrador/Professor sempre é direcionado primeiro para o ambiente de
Módulo Interface
Aluno - Visualizar dados - Visualizar conteúdo teórico - Visualizar desempenho - Fazer exercício
Professor - Consultar Posição do aluno - Relatório de desempenho - Gerenciar conteúdo
Administrador - Gerenciar aluno - Gerenciar professor
52
administrador e deste ambiente ele acessa o ambiente do professor. Estas informações podem ser
confirmadas na Figura 33.
Figura 33. Tela do Administrador
3.5.3 Ambiente do Professor
O professor, que também é administrador do sistema, tem no menu a opção de chamar a tela
de administração. Na área de gerência de conteúdo o professor alimenta a base de domínio
realizando o cadastro de unidades, tópicos e exercícios, como pode ser verificado no Figura 34 onde
está sendo cadastrado um exercício que pertence a unidade Pilha, tópico TAD Pilha. Apesar de os
exercícios serem cadastrados para uma unidade e tópico, o aluno só poderá realizá-los após o
término de toda a unidade.
53
Figura 34. Cadastro de material - professor
O sistema identifica a quantidade de exercícios que existem cadastrados para a
unidade/tópico que esta sendo estudado pelo aluno e desses escolhe 5 (cinco) exercícios, e então
solicita ao aluno que os resolva. Após realizados, os exercícios são avaliados e submetidos as regras
da árvore de decisão do módulo tutor descritas na Seção 3.3.
Na seção de relatórios, o professor pode verificar o desempenho do aluno na unidade,
também quando ele começou e terminou o estudo da unidade e qual foi o seu aproveitamento
quando foi submetido aos exercício, mostrado na Figura 35. Na opção de material estudado o
professor pode ver detalhadamente a situação em que o aluno se encontra interagindo com o
sistema, todos os tópicos que estudou e também os exercícios realizados.
54
Figura 35. Desempenho – professor
3.5.4 Ambiente do Aluno
O usuário tipo Aluno deve entrar com sua senha para ter acesso ao ambiente do aluno. Neste
ambiente o aluno poderá verificar seu cadastro e seu desempenho. A visualização do desempenho
em uma unidade será possível somente após o aluno ter concluído todos os tópicos e exercícios
pertencentes a esta unidade. No link para acesso a verificação do desempenho, o aluno verifica seu
aproveitamento em todas as unidades completadas. No caso do exemplo da Figura 36 o aluno
completou somente a unidade Pilha.
Figura 36. Desempenho - aluno
55
Na área de estudos, será possível ao aluno iniciar estudos ou rever conteúdo. Quando acessar
a opção de iniciar estudos pela primeira vez, o aluno é direcionado a responder a algumas perguntas
como já explicado na Seção 3.2.2 , onde o SE interage com o aluno e com base nas suas respostas é
modelado o seu perfil. O início dessa interação pode ser visto na Figura 37.
Figura 37. Definindo o perfil do aluno - início
O Sistema Tutor utiliza este perfil afim de orientar o aluno, para que ele possa obter um
melhor aproveitamento durante o estudo da disciplina. A definição do perfil do aluno e a sugestão
oferecida pelo sistema é mostrada na Figura 38.
Figura 38. Definindo o perfil do aluno - fim
56
No caso do aluno fazer login, clicar na opção iniciar estudos e não sendo sua primeira
interação com o sistema, o módulo tutor identifica se o aluno está começando uma unidade nova ou
está continuando a estudar os tópicos de uma unidade já iniciada. Neste caso o sistema irá continuar
a partir do último ponto estudado, inclusive durante os exercícios. Se o aluno não completou o
exercício ele irá volta para o mesmo ponto acessado antes do logout. A Figura 39 mostra o sistema
apresentando a unidade Pilha ao aluno.
Figura 39. Visualização de conteúdo - aluno
Na opção de rever conteúdo, mostrado na Figura 40, são apresentados os tópicos da unidade já estudados pelo aluno (neste caso a unidade Pilha). Clicando no tópico é apresenta a sua descrição, onde o aluno tem a possibilidade de recapitular o conteúdo.
Figura 40. Revisão de Conteúdo - aluno
57
3.5.5 Ambiente do Sistema Especialista
O STI para Ensino de Estrutura de Dados foi desenvolvido para acompanhamento e auxílio
do estudante no aprendizado da disciplina de ED e não para ser uma ferramenta única para o estudo
desta disciplina.
Com base neste objetivo e com o auxílio de um especialista, foi desenvolvida a árvore de
decisão para modelar o PC do aluno, implementada no módulo aluno e apresentada na Figura 29; e
a árvore de decisão que foi implementada no módulo tutor, mostrada na Figura 30. A função de
cada árvore e dos módulos já foi explicado na Seção 3.3.
Afim de implementar as regras das árvores nos seus respectivos módulos e validar o sistema
na categoria de SE, foi utilizado o ambiente de desenvolvimento CLIPS. A representação do
conhecimento é na forma de regras de produção e a maneira como o STI comunica com o SE é
basicamente a mesma, o que muda são as regras e os fatos devido às árvores serem diferentes.
O processo utilizado para ligação entre o STI desenvolvido em PHP e o SE desenvolvido em
CLIPS é mostrado na Figura 41. A explicação de como ocorre a comunicação e a passagem de
dados do STI para o CLIPS é apresentado a seguir.
Figura 41. Processo de comunicação da aplicação como o Sistema Especialista
Fonte: Camacho (2005, p. 142).
58
3.5.5.1 Modelagem do perfil característico do aluno
Quando o aluno inicia os exercícios o STI verifica na base de dados se o aluno já possui um
PC, sendo esta resposta positiva o módulo tutor é acionado para que se possa dar seqüência nos
estudos do aluno.
Caso o PC do aluno ainda não tenha sido definido, o STI inicia a comunicação com o aluno
como mostra a Figura 37. As respostas do aluno servirão para abastecer a seção de fatos do STI,
mostrado na Figura 42 - linhas 10 à 16. O STI utiliza as informações armazenadas na sua seção de
fatos para comunicar e informar esses fatos ao SE, mostrado na mesma Figura - linhas 17 à 20. O
SE roda a máquina de inferência, analisa sua base de fatos e dispara as regras. As regras modeladas
para a árvore de decisão do módulo aluno podem ser lidas no Apêndice B. B.1. Após o
processamento das regras pode ser gerado um Fato Resultante, caso alguma regra tenha sido
validada, que irá definir o PC do aluno. Caso isto não ocorra, o STI irá incrementar “1” a variável
$perg – linha 36, Figura 42 – e o sistema realizará a próxima pergunta ao aluno.
Figura 42. Implementação da comunicação entre o STI e o SE para definir o PC do aluno
59
Foi necessário criar uma seção que armazenasse o histórico das respostas fornecidas pelo
aluno, chamada aqui de “seção de fatos do STI”. Antes da implementação desta seção, quando
ocorria comunicação entre o STI e o SE foi identificado sujeira na base da fatos do SE, o que gerava
um falso Fato Resultante do SE para o STI.
Para a comunicação (entrada e saída de dados) entre a aplicação e o SE, no conjunto de
regras foram implementada Templates (deftemplate) como é mostrado na Figura 43.
(deftemplate perfil_definido (slot perfil)(slot sugestao)) (deftemplate definindo_perfil (slot pergunta)(slot resposta))
Figura 43. Templates de comunicação para o perfil do aluno
A template “perfil_definido” retorna a informação do SE para o STI. Após ocorrer uma
validação das regras no SE novos fatos são gerados na base de conhecimento, o SE captura esse
fatos e com os Fatos Resultantes inicializa a Seção [Perfil]. Através das expressões regulares, o STI
captura essas informações e armazena no banco da dados. Essa informações podem ser vista na
Figura 42, linhas 23 à 33.
A template “definindo_perfil” fornece ao SE a pergunta em questão e a resposta selecionada
pelo aluno. A forma como a template é implementada para receber as informações pode ser visto na
Figura 43 e a forma como ela é implementada para enviar as informações é mostrado na Figura 42,
linha 19.
3.5.5.2 Modelagem do módulo tutor
Quando o sistema é inicalizado ocorre a troca de informações entre a aplicação e o banco de
dados para construir o conjunto de fatos iniciais do usuário que está utilizando o sistema, estes fatos
são armazenados numa seção (Fatos), implementado conforme Figura 44, linhas 2 à 7.
Toda explicação a seguir é baseada na Figura 44. A medida que o usuário interage com o
sistema e o módulo tutor é acionado, este fornece ao SE os Fatos armazenados na seção (Fatos). O
SE utiliza as regras modeladas para o seu funcionamento (linha 10), o módulo tutor fornece ao SE
as informações atualizadas (linhas 12 à 17) e novos fatos internos são gerados. Após o
processamento das regras (linha 19) é gerado um Fato Resultante que o SE fornece ao módulo tutor
(linha 20). Então o módulo tutor captura este Fato Resultante (linhas 22 à 27), atualiza a seção Fatos
(linhas 28 e 29) e o banco de dados com a resposta recebida do SE e continua a sua seqüência de
60
trabalho através da análise das expressões regulares (linhas 30 e 31). As regras do SE que interage
com o módulo tutor estão no Apêndice 0.
Figura 44. Implementação da comunicação entre o STI e o SE para definir o PC do aluno
Para uma boa comunicação (entrada e saída de dados) entre a aplicação e o SE, no conjunto
de regras foram implementadas Templates (deftemplate) como é mostrado na Figura 45.
(deftemplate retorno_especialista (slot retorno)) (deftemplate resultado (slot total_unidade_topico)(slot teste)(slot nota_exercicio)) (deftemplate resposta (slot resposta_aluno))
Figura 45. Templates de comunicação para o módulo tutor
61
A template “retorno_especialista” retorna a informação do SE para o módulo tutor. A
template “resultado” fornece ao SE as informações capturadas do banco de dados e a template
“resposta” fornece ao SE a posição onde o aluno se encontra dentro do sistema.
3.6 VALIDAÇÃO DO SISTEMA
Foram realizados testes de implementação e testes de funcionamento de forma a validar o
sistema. Durante a implementação percebeu-se que seria necessário realizar modificações no banco
de dados para que o mesmo atendesse todos os requisitos solicitados.
O PHP é uma linguagem dinâmica, (após o script ser desenvolvido e salvo é possível
verificar o seu funcionamento acessando a URL), desta forma vários problemas foram identificados
e solucionados em tempo de desenvolvimento. Os requisitos solicitados no projeto se encontram
implementados e funcionando.
Foi realizado teste da caixa preta onde foi verificado o funcionamento de cada rotina que foi
implementada no sistema, verificado se os dados armazenados na base de dados e de conhecimento
eram confiáveis. Verificado o funcionamento de cada regra implementada para o SE conforme a
modelagem sugerida para as árvores do módulo tutor e módulo aluno.
4 CONCLUSÕES
Foram apresentados neste trabalho vários conceitos permitindo o embasamento necessário
para o desenvolvimento de um STI para o ensino de Estrutura de Dados. Os levantamentos teóricos,
bem como a modelagem do projeto foram de fundamental importância para o seu desenvolvimento.
Após a revisão bibliográfica sobre os principais tópicos abortados em ED e Informática na
Educação foi possível entender que a EaD é uma fronteira que não tem limites abrindo caminho
para sistemas que tornem o aprendizado interessante e não façam do aluno um simples virador ou
navegador de páginas.
Neste ponto, foi-se criando cada vez mais gosto para o desenvolvimento do projeto, pois a
idéia de desenvolvimento de um sistema que pudesse interagir a auxiliar no aprendizado de alunos,
recebendo e fornecendo informações a eles, como que tendo por assim dizer uma vida própria, é
algo que fascina qualquer pesquisador.
Para que o sistema pudesse ter esse tipo de liberdade, o auxílio de um especialista para o seu
desenvolvimento foi de fundamental importância, especialmente na implementação da árvore de
decisão que foi utilizada para modelar o Módulo Tutor, local onde são tomadas as principais
decisões do sistema e que é responsável por fazer o mesmo interagir diretamente como o aluno.
Infelizmente, seguindo o modelo de instalação para o Clips PHP, encontrado na página
http://phlips.sourceforge.net/documentation.php#fact, mostrado na Figura 46, e respeitando a
Figura 46. Como instalar o Clips PHP
compatibilidade de versões sugeridas para PHP 5.0.2 e Apache 2.0, ocorreu erro quando foi rodado
o script que utiliza a biblioteca do Clips como pode ser visto na Figura 47.
63
Figura 47. Erro ao iniciar o Clips PHP
Clicando no “OK” para dar seqüência no procedimento, apareceu a tela de que o sistema não
pode encontrar a biblioteca que valida as funções do Clips implementadas no script, esta situação é
mostrada na Figura 48.
Figura 48. Erro ao buscar as funções do Clips PHP
Para os testes de instalação do Clips foram utilizadas as versões de Apache e PHP
encontrados nos sites como apresentados na Tabela 3:
Tabela 3. Aplicativos Testados
Aplicativo Url Encontrada xampp-win32-1.4.14-installer.exe http://www.apachefriends.org/pt_br/xampp.html phptriad2-2-1.exe http://www.phpgeek.com/wordpress/ easyphp1-8_setup.exe http://sourceforge.net/project/downloading.php
A solução encontrada para este problema foi abandonar a plataforma Windows e realizar
teste na plataforma Linux, Até que por fim conseguiu-se a instalação do Clips em um servidor
instalado em ambiente Linux, com a versão RedHat 9.
64
Por fim, considerando que todos os objetivos específicos do trabalho foram alcançados
observa-se a importância das contribuições que este proporciona, integrando a linguagem de
programação PHP com as regras de produção desenvolvidas no console do CLIPS, validando este
sistema na categoria de Sistema Especialista.
4.1 RECOMENDAÇÕES
A partir dos resultados apresentados neste trabalho, constatou-se a necessidade de
aperfeiçoamentos e trabalhos futuros a fim e aprimorar a arquitetura proposta e fornecer suporte
mais amplo ao processo de tomada de decisão do Módulo Tutor. Desta forma pode-se destacar os
seguintes trabalhos futuros:
• Implementação de um agente de interface para se comunicar com o usuário através de
dicas ou outras formas de comunicação, talvez colocando emoção e interagindo de
forma direta com o usuário;
• Implementar um agente que utilize o perfil do aluno, modelado na sua primeira interação
com o sistema, auxiliando o seu aprendizado dentro do ambiente do STI. A modelagem
deste perfil pode variar conforme o aluno evolui na disciplina; e
• Implementar um processo de decisão do Módulo Tutor utilizando técnicas de IA mais
abrangentes, como Raciocínio Baseado em Casos, para que a base de conhecimento
possa ter um aprendizado.
REFERÊNCIAS BIBLIOGRÁFICAS
BOOCH, Grady; RUMBAUCH, James; JACOBSON, Ivar. UML: guia do usuário. Rio de Janeiro: Campus, 2000. ISBN 85-352-0562-4. CAMACHO, Cecília. Gerenciando Conflitos em Reuniões: uma estratégia para a elicitação de requisitos de software. PUC-Rio, 2005. 169p. Dissertação de Mestrado – Departamento de Informática, Pontifícia Universidade Católica do Rio de Janeiro, Rio de Janeiro, 2005. CELES, Waldemar; CERQUEIRA, Renato; RANGEL, José Lucas. Introdução a estrutura de dados: com técnicas de programação em C. Rio de Janeiro: Elsevier, 2004. ISBN 85-352-1228-0. CONCEIÇÃO, Katilene Nunes da. TEIA: tecnologia de ensino com inteligência aplicada. 2003. 132 f. Dissetação (Mestrado em Engenharia de Produção) – Programa de Pós-Graduação em Engenharia de Produção, Universidade Federal de Santa Catarina, Florianópolis, 2003. COSTA, Raimundo José Macário. Sistemas tutores inteligentes. Rio de Janeiro, 2002. Disponível em:< http://www.nce.ufrj.br/ginape/publicacoes/trabalhos/MacarioMaterial/index.htm>. Acesso em: 11 nov. 2006. DAZZI, Rudimar Luis Scaranto. Tad.ppt. 2006. Formato Power Point. 1 disquete, 3 ½ pol. DAZZI, Rudimar Luís Scaranto. Uma nova abordagem multiagentes para a construção de STI. 2004. Tese (Doutorado)-Faculdade de Engenharia Elétrica, Universidade Federal de Santa Catarina, Florianópolis, 2004. DROZDEK, Adam. Estruturas de dados e algoritmos em C++. São Paulo: Pioneira Thomson Learning, 2002. ISBN 85-221-0295-3. FERNANDES, Anita Maria da Rocha. Visão geral. In: ______. Inteligência artificial: noções gerais. Florianópolis: Visual Books, 2003. cap. 1, p. 1-10. ISBN: 85-7502-114-1. FEY, Vilson Cristian Hoffmann. Sistema de Acompanhamento do Desenvolvimento de Pessoas com Necessidades Educacionais Especiais. Itajaí, 2005. 132 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í, 2005. FIGUEIREDO, Júlio. Inteligência artificial. Jornal Viva. n.6, 1999. Disponível em:< http://www.jornalviva.com.br/edicoes/99/09/mat_02_cie.htm>. Acesso em: 1 nov. 2006. FLORES, Cecília Dias. Fundamentos dos Sistemas Especialistas. In: BARONE, Dante (Org). Sociedades artificiais: a nova fronteira da inteligência nas máquinas. Porto Alegre: Bookman, 2003. p.127-154. ISBN 85-363-0124-4. FRANÇA, Anderson José. Desenvolvimento de um Sistema Tutor Inteligente para o Ensino de Estrutura de Dados aos Surdos. Itajaí, 2005. 68 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í, 2005.
66
GIARRATANO, Joseph C. CLIPS: user’s guide. [S.l.: s.n.], mar. 2002. 6.2 v. Disponível em < http://www.ghg.net/clips/download/documentation/>. Acesso em 6 jun. 2007. GREGIO, Bernadete Maria Andreazza. A informática na educação: as representações sociais e o grande desafio do professor frente ao novo paradigma educacional. Colabor@, Campo Grande, 1. sem., 2003. Disponível em:<http://www.ricesu.com.br/colabora/n6/artigos/n_6/pdf/id_02.pdf>. Acesso em: 24 out. 2006. GOULART, Rodrigo Rafael Villarreal; GIRAFFA, Lucia Maria Martins. Arquitetura de sistemas tutores inteligentes. Technical Report Series, Porto Alegre, n.11, jun. 2001. Disponível em:<http://www.pucrs.br/inf/pos/tr/tr011.pdf>. Acesso em: 06 nov. 2006. JESUS, Andréia de. Sistemas tutores inteligentes uma visão geral. Revista Eletrônica de Sistema de Informação. 3.ed. Campo Largo, ano 2, v.2, n.2, dez. 2003. ISSN: 16773071. Disponível em:< http://www.inf.ufsc.br/resi/edicao3.html>. Acesso em: 06 nov. 2006. LIMA, Demetrius Ribeiro; ROSATELLI, Marta Costa. Um sistema tutor inteligente para um ambiente virtual de ensino aprendizagem. In: WORKSHOP DE INFORMÁTICA NA ESCOLA, 9, 2003, Campinas. Anais do XXIII Congresso da Sociedade Brasileira de Computação. Porto Alegre: SBC, 2003. p. 129-139. LUZZI, Fábio et al. WÖHLER: Assitente Inteligente para Suporte ao Ensino de Química. In: SIMPÓSIO BRASILEIRO DE INFORMÁTICA NA EDUCAÇÃO, 8, 1997, São José dos Campos. Anais do VIII Simpósio Brasileiro de Informática na Educação. São José dos Campos: Instituto Tecnológico de Aeronáutica, 1997. v.1, p. 201-217. Disponível em:< http://lsm.dei.uc.pt/ribie/docfiles/txt200342413447120.pdf>. Acesso em: 06 nov. 2006. MySQL AB. MySQL reference manual [S.I], SQL Magazine, 2003. Disponível em: http://www.sqlmagazine.com.br/apostilas.asp> Acesso em: 03 jun 2007. NASCIMENTO, Raphael Luiz. Sistemas especialistas In: FERNANDES, Anita Maria da Rocha. Inteligência artifical: noções gerais. Florianópolis : Visual Books, 2003. cap. 2, p. 11-26. ISBN: 85-7502-114-1. PEREIRA, Sílvio do Lago. Estrutura de Dados Fundamentais: Conceitos e Aplicações. 1996. 8.ed. São Paulo: Érica, 2004. PIMENTEL, Graça; CRISTINA, Maria. Algoritmos e estruturas de dados. São Paulo, 2005. Disponível em:< http://www.icmc.usp.br/~sce182/index.html>. Acesso em: 06 nov. 2006. SCHMITZ, Ademar et al. Ferramenta de autoria de sistemas tutores inteligentes - construindo o modelo do domínio do conhecimento com redes semânticas. In: CONGRESSO BRASILEIRO DE COMPUTAÇÃO, 2, 2002, Itajaí. Anais ..., 2002.
67
SOBRAL, Maria Emília Gomes; FERREIRA, Maria Alice Grigas Varella. O uso de tutores inteligentes cooperativos na internet para ambientes de ensino-aprendizagem. In: Semana da Computação, 11., 2000, São José do Rio Preto (SP). Anais eletrônicos. São José do Rio Preto: UNESP, 2000.1 CD. SOUZA, Osmar Júnior. Sistema Inteligente para Ensino de Histologia Bucal. 2005. 152 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í, 2005. STAIR, Ralph M. Princípios de Sistemas de Informação: uma abordagem gerencial. 2. ed. Rio de Janeiro: Livros Técnicos e Científicos Editora, 1998. ISBN: 85-216-1132-3. VICARI, Rosa Maria; GIRAFFA, Lucia Maria Martins. Fundamentos dos Sistemas Tutores Inteligentes. In: BARONE, Dante (Org). Sociedades artificiais: a nova fronteira da inteligência nas máquinas. Porto Alegre: Bookman, 2003. p.155-208. ISBN: 85-363-0124-4.
TENENBAUM, Aaron M.; LANGSAM, Yedidyah; AUGENSTEIN, Moshe J. Estruturas de Dados usando C. São Paulo: Makron Books, 1995. ISBN 85-346-0348-0.
APÊNDICES
A IMPLEMENTAÇÃO DE TAD’S
A.1 TAD PONTO #include <iostream> using namespace std; // Definição do Tipo Ponto struct Ponto { int X int Y; }; // Inicializa a coordenada void iniciaPonto(Ponto &P) { P.X = P.Y = 0; }; // Mostra a coordenada atual void mostraPonto(Ponto P) { cout << P.X << "," ; cout << P.Y << endl; }; // Atualiza a coordenada para os valores de X e Y passados por parametro void atualizaPonto(Ponto &P, int X, int Y) { P.X= X; P.Y= Y; } // Mostra a coordenada atual void mostraPonto(Ponto P) { cout << P.X << "," ; cout << P.Y << endl; };
Figura 49. Implementação do TAD Ponto
A.2 TAD PILHA ALOCAÇÃO DINÂMICA template <class tipo> void pilha_cria(pilha<tipo>* &p){ p = NULL; }
Figura 50. Função pilha_cria
70
template <class tipo> void pilha_empilha(pilha<tipo>* &p, tipo dado){ pilha<tipo>* aux = new pilha<tipo>; aux->dado = dado; aux->anterior = p; p = aux; }
Figura 51. Função pilha_empilha
template <class tipo> tipo pilha_desempilha(pilha<tipo>* &p){ tipo valor = p->dado; pilha<tipo>* aux = p; p = p->anterior; delete aux; return valor; }
Figura 52. Função pilha_desempilha
template <class tipo> bool pilha_vazia(const pilha<tipo>* &p){ return (p == NULL) ? true : false; }
Figura 53. Função pilha_vazia
A.3 TAD FILA ALOCAÇÃO ESTÁTICA template <class tipo, int TAM> void inicializaFilaEst(filaEst<tipo,TAM> & f){ f.inicio = 0; f.fim = -1; f.quantidade = 0; }
Figura 54. Função criar fila
71
template <class tipo, int TAM> bool seCheia(filaEst<tipo,TAM> &f){ return (f.fim == TAM-1); }
Figura 55. Função fila cheia
//insere na fila fazendo o deslocamento, se for necessário template <class tipo, int TAM> void insereNaFila( filaEst<tipo,TAM> &f, tipo valor){ if(!seCheia(f) || f.inicio > 0){ if(!seCheia(f)){ f.dados[f.fim++] = valor; f.quantidade++; } else { passinhoPraFrente(f); insereNaFila(f,valor); } } } template <class tipo, int TAM>m void passinhoPraFrente(filaEst<tipo,TAM> &f){ while(f.inicio > 0){ int x = f.inicio; for(int y = f.quantidade; y > 0; y--) f.dados[x-1] = f.dados[x++]; f.inicio--; f.fim--; } }
Figura 56. Função inserir na fila
template <class tipo, int TAM> bool seVazia(filaEst<tipo,TAM> &f){ return (f.inicio == f.fim); }
Figura 57. Função fila vazia
72
template <class tipo, int TAM> tipo removeDaFila(filaEst<tipo,TAM> &f){ if(!seVazia(f)){ f.quantidade--; return (f.dados[f.inicio++]); } }
Figura 58. Função elimina da fila
template <class tipo, int TAM> bool retornaPrimeiro(filaEst<tipo,TAM> &f){ if(!seVazia(f)){ return (f.dados[f.inicio + 1]; } else return false; }
Figura 59. Função retorna o primeiro elemento da fila
A.4 TAD FILA ALOCAÇÃO DINÂMICA template < class T > void CriaFila(TFila<T> &Fila) { Fila.Inicio = NULL; Fila.Final = NULL; }
Figura 60. Função cria fila
template < class T > void InsereFila(TFila<T> &Fila, T valor) { ElementoFila<T> *aux = new ElementoFila<T>; if (aux != NULL) { if (Fila.Inicio == NULL) Fila.Inicio = aux; else Fila.Final->prox = aux; aux->dado = valor; aux->prox = NULL; Fila.Final = aux; } }
Figura 61. Função insere na fila
73
template < class T > T RemoveFila(TFila<T> &Fila) { if (Fila.Inicio == NULL) return 0; T valor = Fila.Inicio->dado; ElementoFila<T> *aux = Fila.Inicio; Fila.Inicio = Fila.Inicio->prox; if (Fila.Inicio == NULL) Fila.Final = NULL; delete aux; return valor; }
Figura 62. Função remove da fila
A.5 TAD LISTA ENCADEADA SIMPLES template <class tipo> bool insereNoInicio(ListaDin<tipo>* &l, tipo dado) { ListaDin<tipo>* aux = new ListaDin<tipo>; if(aux == NULL) return false; aux->dado = dado; aux->prox = l; l = aux; return true; }
Figura 63. Função para inserir no início da lista
template <class tipo> bool insereNaPos(ListaDin<tipo>* &l, tipo dado, int pos){ if(pos == 1) return (insereNoInicio(l,dado) ); ListaDin<tipo>* atual = l; int cont = 1; while(cont < pos-1){ atual = atual->prox; cont++; if(atual == NULL){ return false; } } ListaDin<tipo>* aux = new ListaDin<tipo>; aux->dado =dado; aux->prox = atual->prox; atual->prox = aux; return true; }
Figura 64. Função para inserir elemento na posição da lista
74
template <class tipo> bool insereNoFim(ListaDin<tipo>* &l, tipo dado){ if(l == NULL)//se for a primeira inserção insereNoInicio(l,dado); else{ ListaDin<tipo>* atual = l; while(atual->prox != NULL) atual = atual->prox; ListaDin<tipo>* aux = new ListaDin<tipo>; if(aux == NULL) return false; aux->dado = dado; aux->prox = atual->prox; atual->prox = aux; return true; } }
Figura 65. Função para inserir elemento no fim da lista
template <class tipo> bool removeNoInicio(ListaDin<tipo>* &l){ if(l != NULL){//se existe pelo menos um item para ser deletado ListaDin<tipo>* aux = l; l = l->prox; delete aux; return true; } return false; }
Figura 66. Função para remover elemento do início da lista
75
template <class tipo> bool removeNaPos(ListaDin<tipo>* &l, int pos){ if(pos > 0){ if(pos == 1) return (removeNoInicio(l)); ListaDin<tipo>* atual = l; int cont =1; while(atual->prox != NULL && cont < pos-1){ atual = atual->prox; cont++; } if(atual->prox == NULL ) //pos informado não existe return false; ListaDin<tipo>* aux = atual->prox; atual->prox = aux->prox; delete aux; return true; } return false; }
Figura 67. Função para remover elemento da posição da lista
template <class tipo> bool removeNoFim(ListaDin<tipo>* &l){ if(l == NULL)//se estiver vazia return false; if(l->prox ==NULL) return (removenoInicio(l)); ListaDin<tipo>* atual = l; ListaDin<tipo>* anterior = l; while(atual->prox != NULL){ anterior = atual; atual = atual->prox; } ListaDin<tipo>* aux = atual; anterior->prox = NULL; delete aux; return true; }
Figura 68. Função para remover o último elemento da lista
76
A.6 TAD LISTA DUPLAMENTE ENCADEADA CIRCULAR template <class tipo> bool insereNoInicio(ListaDinD<tipo>* &l, tipo dado){ ListaDinD<tipo>* aux = new ListaDinD<tipo>; if(aux == NULL) return false; if(l == NULL){//se é a primeira inserção l = aux; aux->ant = aux; aux->prox = aux; } else{ aux->prox = l; aux->ant = l->ant; l->ant->prox = aux; l->ant = aux; l = aux; } l->dado = dado; return true; }
Figura 69. Função para inserir no início da lista
template <class tipo> bool insereNaPos(ListaDinD<tipo>* &l, const tipo dado, const int pos){ ListaDinD<tipo>* aux = new ListaDinD<tipo>; if(aux == NULL)//se estiver vazia return false; if(pos == 1)//se é a primeira inserção return (insereNoInicio(l,dado)); ListaDinD<tipo>* atual = l; int cont = 1; //procura a posição indicada em pos while(cont < pos && atual != l->ant){ atual = atual->prox; cont++; } if(cont < pos) //se a posição pretendida não existe return false; aux->dado = dado; aux->prox = atual; aux->ant = atual->ant; atual->ant->prox = aux; atual->ant = aux; return true; }
Figura 70. Função para inserir na posição na posição da lista
77
template <class tipo> bool insereNoFim(ListaDinD<tipo>* &l, tipo dado){ ListaDinD<tipo>* aux = new ListaDinD<tipo>; if(aux == NULL) return false; if(l == NULL){//se é a primeira inserção l = aux; aux->dado = dado; aux->ant = aux; aux->prox = aux; } else{ aux->dado = dado; aux->prox = l; aux->ant = l->ant; l->ant->prox = aux; l->ant = aux; } return true; }
Figura 71. Função para inserir no fim da lista
template<class tipo> bool removeNoInicio(ListaDinD<tipo>* &l){ if(l != NULL){//se não estiver vazia ListaDinD<tipo>* aux = l; if(l->prox == l)//se é o último elemento l = NULL;//deixa a lista vazia else{ l->prox->ant = l->ant; l->ant->prox = l->prox; l = l->prox; } delete aux; return true; } return false; }
Figura 72. Função para remover no início da lista
78
template <class tipo> bool removeNaPos(ListaDinD<tipo>* &l, const int pos){ if(pos == 1)//se é a primeira inserção return (removeNoInicio(l)); ListaDinD<tipo>* aux = l; int cont = 1; //procura a posição indicada em pos while(cont < pos && aux != l->ant){ aux = aux->prox; cont++; } if(cont < pos)//se a posição pretendida não existe return false; aux->ant->prox = aux->prox; aux->prox->ant = aux->ant; delete aux; return true; }
Figura 73. Função para remover na posição da lista
template <class tipo> bool removeNoFim(ListaDinD<tipo>* &l){ if(l != NULL){//se não estiver vazia ListaDinD<tipo>* aux = l->ant; if(l->prox == l)//se é o último elemento l = NULL;//deixa a lista vazia else{ l->ant = aux->ant; aux->ant->prox = l; } delete aux; return true; } return false; }
Figura 74. Função para remover no fim da lista
B. PERFIL CARACTERISTICO DO ALUNO
B.1 REGRAS QUE MODELAM O PERFIL DO ALUNO ;- Pergunta 1 -------------------------- (defrule define-perfil_01 ?f1 <- (definindo_perfil (pergunta "1")(resposta "nenhum")) => (retract ?f1) (assert (perfil_definido (perfil PC1)(sugestao S1)))) ;- Pergunta 1 (razoavel) e 2 ---------- (defrule define-perfil_02 ?f1 <- (definindo_perfil (pergunta "1")(resposta "razoavel")) ?f2 <- (definindo_perfil (pergunta "2")(resposta "nenhum")) => (retract ?f1 ?f2) (assert (perfil_definido (perfil PC1)(sugestao S1)))) (defrule define-perfil_03 ?f1 <- (definindo_perfil (pergunta "1")(resposta "razoavel")) ?f2 <- (definindo_perfil (pergunta "2")(resposta "bom"|"otimo")) => (retract ?f1 ?f2) (assert (perfil_definido (perfil PC1)(sugestao S1)))) (defrule define-perfil_04 ?f1 <- (definindo_perfil (pergunta "1")(resposta "razoavel")) ?f2 <- (definindo_perfil (pergunta "2")(resposta "razoavel")) => (retract ?f1 ?f2) (assert (perfil_definido (perfil PC2)(sugestao S2)))) ;- Pergunta 1 (bom) e 2 --------------- (defrule define-perfil_05 ?f1 <- (definindo_perfil (pergunta "1")(resposta "bom")) ?f2 <- (definindo_perfil (pergunta "2")(resposta "nenhum")) => (retract ?f1 ?f2) (assert (perfil_definido (perfil PC2)(sugestao S2)))) (defrule define-perfil_06 ?f1 <- (definindo_perfil (pergunta "1")(resposta "bom")) ?f2 <- (definindo_perfil (pergunta "2")(resposta "razoavel")) => (retract ?f1 ?f2) (assert (perfil_definido (perfil PC2)(sugestao S4))))
Figura 75. Regra para a Pergunta 1, resposta – nenhum / Pergunta 1, resposta - bom
80
;- Pergunta 1 (bom), 2 (bom) e 3 -------- (defrule define-perfil_07 ?f1 <- (definindo_perfil (pergunta "1")(resposta "bom")) ?f2 <- (definindo_perfil (pergunta "2")(resposta "bom")) ?f3 <- (definindo_perfil (pergunta "3")(resposta "nunca")) => (retract ?f1 ?f2 ?f3) (assert (perfil_definido (perfil PC2)(sugestao S3)))) (defrule define-perfil_08 ?f1 <- (definindo_perfil (pergunta "1")(resposta "bom")) ?f2 <- (definindo_perfil (pergunta "2")(resposta "bom")) ?f3 <- (definindo_perfil (pergunta "3")(resposta "muitas_vezes")) => (retract ?f1 ?f2 ?f3) (assert (perfil_definido (perfil PC3)(sugestao S5)))) ;- Pergunta 1 (bom), 2 (bom), 3 (poucas_vezes) e 4 ---------- (defrule define-perfil_09 ?f1 <- (definindo_perfil (pergunta "1")(resposta "bom")) ?f2 <- (definindo_perfil (pergunta "2")(resposta "bom")) ?f3 <- (definindo_perfil (pergunta "3")(resposta "poucas_vezes")) ?f4 <- (definindo_perfil (pergunta "4")(resposta "nunca")) => (retract ?f1 ?f2 ?f3 ?f4) (assert (perfil_definido (perfil PC2)(sugestao S6)))) (defrule define-perfil_10 ?f1 <- (definindo_perfil (pergunta "1")(resposta "bom")) ?f2 <- (definindo_perfil (pergunta "2")(resposta "bom")) ?f3 <- (definindo_perfil (pergunta "3")(resposta "poucas_vezes")) ?f4 <- (definindo_perfil (pergunta "4")(resposta "muitas_vezes")) => (retract ?f1 ?f2 ?f3 ?f4) (assert (perfil_definido (perfil PC3)(sugestao S5)))) ;- Pergunta 1 (bom), 2 (bom), 3 (poucas_vezes), 4 (poucas_vezes) e 5 ---- (defrule define-perfil_11 ?f1 <- (definindo_perfil (pergunta "1")(resposta "bom")) ?f2 <- (definindo_perfil (pergunta "2")(resposta "bom")) ?f3 <- (definindo_perfil (pergunta "3")(resposta "poucas_vezes")) ?f4 <- (definindo_perfil (pergunta "4")(resposta "poucas_vezes")) ?f5 <- (definindo_perfil (pergunta "5")(resposta "nunca")) => (retract ?f1 ?f2 ?f3 ?f4 ?f5) (assert (perfil_definido (perfil PC3)(sugestao S7)))) (defrule define-perfil_12 ?f1 <- (definindo_perfil (pergunta "1")(resposta "bom")) ?f2 <- (definindo_perfil (pergunta "2")(resposta "bom")) ?f3 <- (definindo_perfil (pergunta "3")(resposta "poucas_vezes")) ?f4 <- (definindo_perfil (pergunta "4")(resposta "poucas_vezes")) ?f5 <- (definindo_perfil (pergunta "5")(resposta "poucas_vezes")) => (retract ?f1 ?f2 ?f3 ?f4 ?f5) (assert (perfil_definido (perfil PC3)(sugestao S8))))
Figura 76. Regra para a Pergunta 1, resposta – bom / Pergunta 2, resposta - bom
81
B.2 REGRAS QUE MODELAM O MÓDULO TUTOR ; clips_assert ('(total_unidade_topico <valor>)->Qtd de und top info pelo sist ; (teste <valor>) -> Teste efetuado ? ; (nota_exercicio <valor>)', resultado) -> Nota do exercicio ; clips_assert ('(resposta_aluno <valor>)', resposta) -> Informa poso do aluno ; retorno_especialista -> retorno do sistema ao módulo tutor (deftemplate retorno_especialista (slot retorno)) (deftemplate resultado (slot total_unidade_topico)(slot teste)(slot nota_exercicio)) (deftemplate resposta (slot resposta_aluno)) (defrule Conteudo_completo ?f10 <- (resultado (total_unidade_topico ?tup)) ?f11 <- (resposta (resposta_aluno ?ra)) => ; (retract ?f10 ?f11) (if (< ?ra ?tup) then (assert (retorno_especialista (retorno "Apresentar conteudo"))) else (assert (verificar_teste)) ) ) (defrule Teste_efetuado (verificar_teste) ?f12 <- (resultado (teste ?tst)) => ; (retract ?f12) (if (eq ?tst "sim") then (assert (avaliar_exercicios)) else (assert (retorno_especialista (retorno "Apresentar exercicio"))) ) ) (defrule Concluidos_corretamente (avaliar_exercicios) ?f13 <- (resultado (nota_exercicio ?nex)) => ; (retract ?f13) (if (eq ?nex 10) then (assert (retorno_especialista (retorno "Proximo assunto"))) else (if (>= ?nex 7) then (assert (retorno_especialista (retorno "Apresentar Respostas coretas e sugerir leitura de link"))) else (if (>= ?nex 5) then (assert (retorno_especialista (retorno "Revisar conteudo com erro"))) else (assert (retorno_especialista (retorno "Rever todo o conteudo"))) ) ) ) )
Figura 77. Regras para validação da árvore do módulo tutor
