Universidade Estadual de Campinas – UNICAMP Centro Superior

Universidade Estadual de Campinas – UNICAMP
Centro Superior de Tecnologia – CESET
Comunidade do Sistema Gene de Apoio ao Aprendizado de
Genética
Henrique da Mota Silveira
Limeira – SP
2008
i
Universidade Estadual de Campinas – UNICAMP
Centro Superior de Tecnologia – CESET
Comunidade do Sistema Gene de Apoio ao Aprendizado de
Genética
Discente: Henrique da Mota Silveira
Orientador: Prof. Dr. Marcos A. F. Borges
Trabalho
de
Graduação
Interdisciplinar apresentado ao
Centro Superior de Educação
Tecnológica – CESET, como
requisito de conclusão do Curso
Superior
de
Informática.
Limeira – SP
2008
Tecnologia
em
ii
“O único lugar onde o sucesso vem
antes do trabalho é no dicionário.”
Albert Einstein
iii
AGRADECIMENTOS:
Agradeço aos professores e
funcionários do CESET pela
formação e serviços de qualidade
excelente que me foram prestados.
À minha amiga e namorada Nathalia,
que sempre me ajudou em tudo.
A toda família de amigos Mamutes,
que sempre me apoiaram de forma
direta ou indireta.
Ao professor Marcos Borges pela
paciência, confiança e orientação
para realizar este trabalho da melhor
forma possível.
iv
Sumário
Sumário ...................................................................................................................... iv
Índice Geral ................................................................................................................. v
Lista de Figuras.........................................................................................................viii
Lista de Tabelas .......................................................................................................... x
Resumo ...................................................................................................................... xi
1 – Introdução .............................................................................................................1
2 – Embasamento Teórico ..........................................................................................3
3 – Projeto Gene .......................................................................................................10
4 – Resultados ..........................................................................................................32
5 – Conclusão ...........................................................................................................42
6 – Referências Bibliográficas ...................................................................................43
Apêndice ...................................................................................................................47
v
Índice Geral
Sumário ...................................................................................................................... iv
Índice Geral ................................................................................................................. v
Lista de Figuras.........................................................................................................viii
Lista de Tabelas .......................................................................................................... x
Resumo ...................................................................................................................... xi
1 – Introdução .............................................................................................................1
2 – Embasamento Teórico ..........................................................................................3
2.1 – Computadores na Educação......................................................................3
2.2 – Construcionismo e Construtivismo.............................................................3
2.3 – Jogos Educativos.......................................................................................4
2.4 – Influência dos Jogos no Desenvolvimento .................................................5
2.5 – Jogos Educativos Digitais ..........................................................................6
2.6 – Combinação Genética ...............................................................................8
3 – Projeto Gene .......................................................................................................10
3.1 – Materiais e Métodos.................................................................................10
3.1.1 – Java ..............................................................................................10
3.1.2 – Integrated Development Environment (IDE) Eclipse ....................12
3.1.3 – Servidor de Aplicação Tomcat......................................................12
3.1.4 – JavaServer Pages (JSP) ..............................................................13
vi
3.1.5 – JSP Standard Tag Library (JSTL)................................................13
3.1.6 – Framework Struts 2 ......................................................................14
3.1.7 – Application Programming Interface (API) AJAX............................15
3.1.8 – Corel Draw e Gif Movie Gear........................................................15
3.1.9 – Documentação Javadoc ...............................................................15
3.1.10 – Arquitetura ePING ......................................................................16
3.1.11 – Padrão Model View Controller (MVC).........................................16
3.1.12 – MySQL........................................................................................17
3.1.13 – Framework Hibernate .................................................................18
3.1.14 – Padrão Data Access Object (DAO) ............................................20
3.2 – Arquitetura e Modelagem do Sistema......................................................21
3.3 – Persistência e Internacionalização...........................................................29
3.4 – Comunidade Gene...................................................................................30
4 – Resultados ..........................................................................................................32
4.1 – Resultados da Ferramenta.......................................................................32
4.2 – Resultados de Dinâmica com Usuários ...................................................40
5 – Conclusão ...........................................................................................................42
6 – Referências Bibliográficas ...................................................................................43
Apêndice ...................................................................................................................47
Caso de Uso Criar Conta..................................................................................47
vii
Caso de Uso Solicitar Relacionamento dos Bichinhos .....................................50
Caso de Uso Avaliar Relacionamento dos Bichinhos .......................................53
viii
Lista de Figuras
Figura 1 – Estrutura do Padrão DAO ........................................................................21
Figura 2 – Arquitetura Física do Sistema ..................................................................22
Figura 3 – Ambiente do Projeto.................................................................................22
Figura 4 – Diagrama de Entidade Relacionamento do Gene ....................................23
Figura 5 – Arquitetura Lógica do Sistema .................................................................23
Figura 6 – Dependência entre as Famílias de Classes .............................................24
Figura 7 – Detalhamento da Camada de Apresentação do Projeto ..........................25
Figura 8 – Detalhamento da Camada de Negócio do Projeto ...................................26
Figura 9 – Detalhamento da Camada de Persistência do Projeto.............................26
Figura 10 – Diagrama de Classes do Relacionamento Atributos / Bicho ..................28
Figura 11 – Diagrama de Classes de Atualização do Bichinho .................................28
Figura 12 – Tela Inicial do Sistema ...........................................................................32
Figura 13 – Cadastro do Usuário ..............................................................................33
Figura 14 – Perfil do Usuário.....................................................................................34
Figura 15 – Funcionalidade Célula............................................................................35
Figura 16 – Tela de Ajuda .........................................................................................35
Figura 17 – Escolhendo um de seus Bichinhos.........................................................36
Figura 18 – Comunidade Gene .................................................................................36
Figura 19 – Aviso de Nova Mensagem .....................................................................37
ix
Figura 20 – Correio do Usuário .................................................................................38
Figura 21 – Tela do Jogo ..........................................................................................39
Figura 22 – Relatório do Bichinho .............................................................................39
Figura 23 – Fim de Jogo ...........................................................................................40
Figura 24 – Caso de Uso Criar Conta .......................................................................47
Figura 25 – Diagrama de Sequência UC - Criar Conta .............................................49
Figura 26 – Caso de Uso Solicitar Relacionamento dos Bichinhos...........................50
Figura 27 – Diagrama de Sequência UC - Solicitar Relacionamento dos Bichinhos.52
Figura 28 – Caso de Uso Avaliar Relacionamento dos Bichinhos.............................53
Figura 29 – Diagrama de Sequência UC - Avaliar Relacionamento dos Bichinhos...54
x
Lista de Tabelas
Tabela 1 – Comparação Entre Nível e Atividades.....................................................30
Tabela 2 – Comparação Entre Nível e Características Genética ..............................31
xi
Resumo
Em sua primeira versão, o sistema Gene demonstrou capacidade em apoiar
seus usuários no aprendizado de conceitos de genética, mas foi pouco utilizado,
entre outros motivos, por não possuir recursos multimídia muito atraentes, necessitar
de instalação e não possuir evolução durante jogo. Este projeto provê uma segunda
versão do sistema, sendo a interatividade um dos meios de evolução do ambiente,
em que o usuário desenvolve seu jogo e aprendizado a partir de relacionamentos
com outros usuários. A Comunidade Gene, proposta no projeto, realiza a
interatividade entre os usuários, sendo a partir de um relacionamento com um
bichinho de outro usuário, mais genes para a manipulação e atividades do jogo são
habilitadas, proporcionando assim o jogo em um estágio mais evoluído. O projeto
conduz as dinâmicas de aprendizagem e viabiliza seu uso livre através da Internet,
sem a necessidade de instalação. Em dinâmica realizada com possíveis usuários do
sistema durante o evento Unicamp de Portas Abertas (UPA) 2008, o Gene se
mostrou capaz de apoiar os usuários no aprendizado de genética. Outro ponto
relevante desta segunda versão é a internacionalização para as línguas Espanhola
e Inglesa, além da língua Portuguesa que é a padrão do sistema, contribuindo assim
para a difusão do conhecimento e uso do Gene como uma ferramenta de apoio a
genética.
1
1 – Introdução
Sucesso na década de 90, o jogo tamagotchi ou “Bichinho Virtual”, deu
origem à proposta de uma ferramenta de apoio à aprendizagem para formação em
genética (Borges e Oliveira, 2000). Esta ferramenta é um ambiente de aprendizado
interativo, chamado Gene, cujo foco principal de aprendizagem é a genética. Nele, o
usuário faz o papel de um cientista genético, manipulando os genes de um “bichinho
virtual” e depois simula o nascimento, resultante das manipulações.
O sistema Gene tem como idéia base o tamagotchi (Besser, 1997). O uso de
um jogo como este como material complementar na aprendizagem de genética
motiva seus usuários (normalmente crianças e jovens) que, assumindo o papel de
pais, são os atores, os sujeitos responsáveis pela situação. Brincando com
tamagotchis os usuários desenvolvem a inteligência emocional vivendo experiências
em uma realidade virtual (Fagundes, 1997). Para Stahl (1991) e Bongiolo (1998) um
ambiente que propõe um jogo educativo digital deve atrair o jogador, mantendo seu
interesse e entusiasmo, permitindo-o controlar a interação e a continuação do jogo,
a taxa de avanço e a possibilidade de repetir segmentos. Além disso, deve explorar
efeitos auditivos e visuais, para manter a curiosidade, a fantasia e facilitar o alcance
do objetivo educacional proposto
A
primeira
versão
do
Gene
apresentava
algumas
desvantagens
principalmente na questão de motivação do usuário. Os recursos multimídia não
eram muito atraentes (imagens com baixa resolução, quase sem animações e sons),
o sistema tinha uma forma muito peculiar de instalação dificultando sua difusão. A
não evolução do jogo também criava certo desânimo nos usuários.
A proposta da segunda versão do Gene aborda a reconstrução do sistema
explorando tecnologias mais modernas, condução das dinâmicas de aprendizagem
e inclusão de recursos para evolução do jogo propondo um sistema mais motivador.
Desta forma, optou-se por reconstruir toda parte multimídia, acrescentar mais
atividades e ainda tornar o sistema disponível para web, livre de instalação. Além
disso, o projeto dispõe de internacionalização de sua parte textual para as línguas
Espanhola e Inglesa, a fim de difundir ao maior número de pessoas o seu propósito.
Porém o objetivo principal deste projeto é criar uma comunidade que permita certo
2
nível de interação entre os usuários do sistema, contribuindo assim para o
desempenho evolutivo do jogo de cada um.
Em paralelo, o sistema tentou seguir os padrões de acordo com a arquitetura
ePING (ePING, 2007), a fim de identificar a viabilidade ou não de se construir
sistemas totalmente aderentes ao que se está padronizando em âmbito do governo
federal.
Este trabalho está dividido da seguinte maneira: o capítulo 2 contém o
embasamento teórico; no capítulo 3 é apresentado o Projeto Gene; os resultados
estão no capítulo 4; no capítulo 5 está a conclusão; as referências bibliográficas
utilizadas neste trabalho estão listadas no capítulo 6 e por último o apêndice, que
contém maiores detalhes do projeto, mostrando casos de uso dos processos mais
relevantes do sistema.
3
2 – Embasamento Teórico
Este capítulo aborda uma coleção de referências, que contribuíram para a
motivação, definição do escopo e relevância deste projeto. Primeiramente é
apresentada a visão dos computadores no contexto educacional; a seguir são
levantadas as idéias dos paradigmas educacionais construcionista e construtivista;
os jogos educacionais e a influência deles no desenvolvimento de uma criança são
apresentados a seguir, assim como a importância e motivação da existência de
jogos educativos digitais. Por fim estão as definições de combinações genéticas e
como elas surgiram.
2.1 – Computadores na Educação
Segundo Valente (1995), o uso de computadores na educação tem provocado
uma verdadeira revolução na concepção de ensino e de aprendizagem. A
quantidade de programas educacionais e funcionalidades diferentes que o
computador tem na educação deixam mais evidente que essa tecnologia pode ser
bastante útil no processo de aprendizagem.
No entanto, o foco da utilização dos computadores na educação não é mais
como “máquina de ensinar”, mas sim um complemento para ensino. Hoje em dia o
mundo é dominado pela informação e por processos que acontecem de forma
imperceptível. Não basta aos estudantes apenas decorar informações, mas sim
entendê-las, sendo estimulados a buscar e utilizar as informações compreendidas
(Valente, 1995).
2.2 – Construcionismo e Construtivismo
Vários paradigmas tradicionais de ensino-aprendizagem sugerem que o
conhecimento seja repassado de uma pessoa para outra pelo contato entre elas,
seja
de
forma
oral,
escrita,
gestual.
Em
confronto
a
essas
linhas
de
ensino/aprendizagem existem outros paradigmas que são o construtivismo de Piaget
e o construcionismo de Papert. Segundo Papert (1990), construcionismo é entendido
como o que Piaget denomina Construtivismo, porém vai além deste. O
Construtivismo expressa a teoria de que o conhecimento adquirido pelo aluno foi
4
construído por ele próprio. Já no Construcionismo, além do conhecimento adquirido
por conta própria, o indivíduo conta com o apoio de algo externo, como objetos
(computador, por exemplo) e/ou pessoas. Para Ackermann (2008) os pontos chaves
do construtivismo de Piaget são que as visões evoluem continuamente e que o
conhecimento
expande
e
se
estabelece
(transforma-se
e
reconfigura-se),
internamente, enquanto o construcionismo de Papert trabalha mais com as
dinâmicas de mudança.
Uma forma interessante de se aplicar o Construcionismo é fazendo de um
jogo uma ferramenta de apoio à aprendizagem. Segundo Wang (2006), os jogos
podem motivar o aprendizado, aumentando o desejo de aprender do estudante,
apresentando oportunidades de não somente se aprender os conceitos e conteúdos
tradicionais, mas também de executar a habilidade de pensamento lógico, enquanto
os usuários estão se divertindo.
2.3 – Jogos Educativos
Os jogos educativos baseiam-se no interesse pelo lúdico, que independe da
faixa etária. Considerando-se este aspecto, os jogos podem promover ambientes de
aprendizagem atraentes e gratificantes, constituindo-se num recurso poderoso de
estímulo para o desenvolvimento integral do aluno. Segundo Rizzo (1988), os jogos
desenvolvem a atenção, disciplina, autocontrole, respeito a regras e habilidades
perceptivas e motoras relativas a cada tipo de jogo oferecido.
Conforme Negrine (1994, p. 9), “(...) jogo se origina do vocábulo latino iocus,
que significa diversão, brincadeira. Em alguns dicionários aparece como sendo a
‘atividade lúdica com um fim em si mesma, embora ocasionalmente possa se
realizar por motivo extrínseco’”.
Uma criança tem por principal motivo o ato de jogar por que este causa
entretenimento e também porque o jogo representa esforço e conquista. Grande
parte do tempo da infância é dedicada ao jogo, o qual é uma maneira de preparação
para a vida, possibilitando o equilíbrio entre o mundo externo e o interno. Para
Lebovici e Deatkine (1985) e Rodrigues (1992), o ato de jogar é uma atividade muito
importante na vida da criança.
5
O jogo é um possível caminho para estimular ou reforçar tanto as situações
familiares como comunitárias, sendo a atividade de jogar uma alternativa de
realização pessoal que, além de possibilitar a expressão de sentimentos e emoções,
contribui para a aprendizagem de comportamentos adequados e adaptativos,
aumentando a possibilidade de êxito na aprendizagem (Kotliarenco, 1997).
Chapman e Martin (1995) afirmam que os jogos dão oportunidades para a
descoberta de soluções para os mais variados problemas, pois estimulam o
estabelecimento de estratégias e implicações, encorajando os jogadores a resolvêlos.
2.4 – Influência dos Jogos no Desenvolvimento
Segundo Grossi (1986, p. 86), “O jogo é uma atividade rica e de grande efeito
que responde às necessidades lúdicas, intelectuais e afetivas, estimulando a vida
social e representando, assim, importante contribuição na aprendizagem”. Santos
(1998) afirma que as atividades lúdicas podem contribuir significativamente para o
processo de construção do conhecimento da criança e que o jogo é uma fonte de
prazer e descoberta.
Para Leif e Brunelle (1978, p. 114), “Desde Claparède e Dewey, Wallon e
Piaget, está bastante claro que a atividade lúdica é o berço obrigatório das
atividades intelectuais e sociais superiores”. Rizzi (1994) diz que jogando a criança
forma suas atitudes sociais tais como: respeito mútuo, solidariedade, cooperação,
obediência às regras, senso de responsabilidade, iniciativa pessoal e grupal.
Segundo Clunie (1996), a função do jogo é “treinar o sujeito para a convivência
social no mundo regido por leis que precisam ser conhecidas, simulando situações
que ele vivencia, onde pode extrapolar o concreto. Um único jogo pode desenvolver
e aperfeiçoar diversos tipos de conceitos, sendo aplicável em diversas áreas do
conhecimento”.
Piaget afirma que a importância do jogo está na satisfação das necessidades
das crianças quanto à assimilação da realidade à sua própria vontade. Estas
necessidades originam-se da estranheza de coisas que as crianças não
compreendem no mundo dos adultos, como regras, por exemplo: hora de dormir,
6
comer, tomar banho, não mexer em certos objetos, entre outras. O jogo tem uma
relação estreita com a construção da inteligência e possui uma efetiva influência
como instrumento incentivador e motivador no processo de aprendizagem.
Segundo Negrine (1994, p.18), “(...) Piaget entende que a inteligência é uma
forma de adaptação ao meio, e o jogo é basicamente uma forma de relação da
criança com o contexto no qual ela está inserida; neste sentido, adverte que a
criança elabora e desenvolve suas estruturas mentais através das diversas
atividades lúdicas”. Para Piaget, conforme Brenelli (1996, p. 21), “(...) por meio de
atividade lúdica, a criança assimila ou interpreta a realidade própria, atribuindo,
então, ao jogo um valor educacional muito grande. Neste sentido, propõe-se que a
escola possibilite um instrumental à criança, para que, por meio de jogos, ela
assimile as realidades intelectuais, a fim de que estas mesmas realidades não
permaneçam exteriores à sua inteligência”. Baseando-se nestas afirmações, podese verificar a importância que Piaget atribui às atividades lúdicas, reforçando a idéia
de que os educadores devem utilizá-las no contexto educacional.
2.5 – Jogos Educativos Digitais
Os jogos educativos digitais são elaborados para divertir os alunos e
potencializar a aprendizagem de conceitos, conteúdos e habilidades embutidas no
jogo. Um jogo educativo digital pode propiciar ao aluno um ambiente de
aprendizagem rico e complexo. Estes jogos podem ser denominados micro mundos,
porque fornecem um mundo imaginário a ser explorado e no qual os alunos podem
aprender.
As características que tornam os jogos educativos digitais motivadores são o
desafio, a fantasia e a curiosidade. Os jogos podem fornecer alguns resultados
educativos não previstos e que são tão importantes quanto os previamente
determinados. Podem oferecer oportunidades para o aluno usar lógica, raciocínio e
habilidades de organização para resolver problemas de maneira mais interessante
do que seriam expostos em um exercício comum. Um jogo simples pode ensinar
várias habilidades e conceitos, propiciando o desenvolvimento de novas habilidades
cognitivas.
7
Segundo resultados de uma pesquisa realizada sobre a utilização de jogos
educativos digitais (Geller e Silveira, 1998), os professores pesquisados consideram
que a utilização destes jogos é vantajosa para o processo de ensino e
aprendizagem. A justificativa é de que os jogos educativos digitais servem como
estímulo e reforço à motivação, reforçam os conteúdos estudados, despertam o
interesse dos alunos, desenvolvem o raciocínio lógico, atraem os alunos,
potencializam a aprendizagem, possibilitam a construção do conhecimento de forma
prazerosa e propiciam uma forma diferenciada de aprendizagem.
Stahl (1991) e Bongiolo (1998) relacionam características importantes que
devem estar presentes em um jogo educativo digital, das quais se destacam as
seguintes:
•
As instruções do jogo devem estar claras para os participantes e os
objetivos dele devem ser compreendidos pelos alunos;
•
O jogo deve atrair e manter o interesse e o entusiasmo;
•
O jogo deve explorar efeitos auditivos e visuais, para manter a curiosidade
e a fantasia e facilitar o alcance do objetivo educacional proposto;
•
Explorar a competição;
•
Permitir ao jogador controlar a interação e a continuação do jogo, o nível
de dificuldade desejado, a taxa de avanço e a possibilidade de repetir
segmentos;
•
Deve oferecer reforço positivo nos momentos adequados;
•
Incorporar o desafio, através da utilização de diferentes níveis para
solucionar um determinado problema, pontuação, velocidade de resposta,
feedback do progresso, entre outros aspectos;
•
Deve manter os alunos informados do nível de seu desempenho durante o
jogo, fornecendo resumos do desempenho global ao final;
•
Utilizar mecanismos para corrigir possíveis erros dos alunos e melhorar o
desempenho dos mesmos;
8
•
Fornecer instruções inequívocas, exceto quando a descoberta de regras
for parte integrante do jogo;
•
Propiciar um ambiente rico e complexo para resolução de problemas,
através da aplicação de regras lógicas, da experimentação de hipóteses e
antecipação de resultados e planejamento de estratégias.
Franciosi (citado por Bongiolo, 1998) coloca que, além das características
apresentadas anteriormente, um jogo educativo digital precisa observar requisitos de
qualidade didático-pedagógica e também de qualidade técnica, tais como:
•
Requisitos de qualidade didático-pedagógica: objetivos bem definidos,
encadeamento
lógico
do
conteúdo,
adequação
do
vocabulário,
possibilidade de formação de conceitos, ortografia e gramática corretas,
feedback apropriado, clareza e concisão dos textos apresentados,
possibilidade de acesso direto a diferentes níveis do programa e
possibilidade do professor interagir com o sistema, incluindo, excluindo ou
alterando o conteúdo proposto;
•
Requisitos de qualidade técnica: execução rápida e sem erros, resistência
a respostas inadequadas, tempo suficiente de exibição das telas,
possibilidade de acesso à ajuda, possibilidade de trabalho interativo,
possibilidade de controle do usuário sobre a seqüência de execução do
jogo, possibilidade de correção das respostas, possibilidade de sair do
sistema a qualquer momento e uso de telas com diagramação seguindo
um modelo único de organização.
2.6 – Combinação Genética
Gregor Mendel foi o primeiro cientista a elucidar os mecanismos básicos da
hereditariedade. Ele obteve com êxito devido a uma adequada escolha do material
de pesquisa. Além disso, usou um método que empregava indivíduos de linhagens
puras, observando um caráter de cada vez e não todos os caracteres ao mesmo
tempo, como fizeram seus predecessores. Ele interpretou os dados de suas
experiências empregando análises estatísticas de modo a obter resultados
quantitativos sobre suas pesquisas. A primeira lei de Mendel conclui que os fatores
9
(genes) seriam transmitidos aos descendentes através dos gametas. Entretanto,
esses “fatores” se separam durante processo de formação dos gametas de forma
que cada gameta herdaria apenas um “fator” de cada par. (Mori e Pereira, 2008).
Para se obter uma combinação genética, é necessário combinar as
características que são representadas por um gene. Este por sua vez é composto de
dois alelos. De acordo com Pazza (2006), uma característica que pode se manifestar
quando há uma combinação de dois alelos diferentes ou dois alelos iguais é
chamada de dominante, pois possui pelo menos um alelo dominante, representado
por letra maiúscula. Quando tal característica se manifesta apenas quando dois
alelos são iguais, esta é recessiva e é representada por letra minúscula, ou seja, se
tal característica tem como alelo dominante A, a mesma pode se manifestar quando
os alelos forem Aa, aA ou AA. Porém, a característica recessiva só ocorrerá se os
alelos forem aa.
Na maioria das vezes, a letra que representa os alelos é equivalente à
primeira letra do aspecto recessivo. Por exemplo: se o aspecto recessivo de uma cor
é a cor rosa, a letra que corresponde à combinação genética de cor é a letra R.
Assim, como o sistema atual do Gene possui apenas a possibilidade de duas cores
(amarelo e rosa), quando a combinação feita for RR, Rr ou rR, a cor do bichinho
virtual será amarelo (característica dominante); e terá a característica recessiva
apenas quando ambos os alelos forem representados com letra minúscula, rr.
Este
capítulo
tratou
de
apresentar
o
embasamento
teórico,
mais
especificadamente a importância dos jogos educativos, das necessidades que os
jogos educativos digitais devem suprir, além dos conceitos dos paradigmas de
aprendizagem construcionista e construtivista e da influência dos jogos no
desenvolvimento infantil. Por fim, a seção de combinação genética ilustrou como são
feitas as manipulações genéticas do bichinho, fundamentadas na primeira lei de
Mendel.
10
3 – Projeto Gene
O Projeto Gene é abordado neste capítulo, que contém todas as ferramentas,
padrões e softwares que foram utilizados no desenvolvimento, incluindo a
modelagem e a arquitetura do sistema, que inclui a arquitetura física e lógica. A
seguir são apresentadas a persistência do jogo e a internacionalização da parte
textual, que visa provocar maior motivação nos usuários e difundir o conhecimento
do sistema, respectivamente. O funcionamento da Comunidade Gene também é
apresentado neste capítulo, mostrando como é realizada a evolução do jogo e a
interatividade entre os usuários.
3.1 – Materiais e Métodos
As ferramentas e softwares que foram utilizados no projeto são: Java 1.6,
Eclipse, Tomcat 6, JSP, JSTL, Struts 2, AJAX, Javadoc, Corel Draw X3, Gif movie
gear, Padrão MVC de Camadas, Arquitetura ePING, MySQL, Hibernate e o Padrão
DAO. As subseções a seguir irão apresentar maiores informações sobre cada uma
delas.
3.1.1 – Java
A utilização da linguagem Java no desenvolvimento do Gene se deve a
algumas vantagens, enumeradas por Fernandéz (1998):
•
Simples: em Java existe um número reduzido de formas claras para
abordar uma tarefa dada. Oferece toda a funcionalidade de uma
linguagem potente, mas sem as características menos usadas e mais
confusas destas, ou seja, elimina tópicos como: aritmética de ponteiros,
registros
(struct),
definição
de
tipos
(typedef),
macros
(#define),
necessidade de liberar memória (free), herança múltipla, sobrecarga de
operadores, estrutura ou uniões;
•
Orientado a objetos: maior facilidade para reutilização de código,
possibilidade de trabalhar em um nível mais elevado de abstração;
11
•
Distribuído: permite aos programadores acessarem a informação através
da rede com tanta facilidade como aos arquivos locais;
•
Robusto: Java é fortemente tipado, o que permite verificar o código em
tempo de compilação. Também verifica o código em tempo de execução.
A realocação de memória é realizada de forma automática, já que
proporciona um coletor de lixo automático para os objetos que não estão
sendo utilizados;
•
Arquitetura neutra: o código Java é compilado a um código de bytecodes
de alto nível independente da máquina;
•
Seguro: Java proporciona segurança através de várias características de
seu ambiente em tempo de execução, como um verificador de bytecodes,
disposição de memória em tempo de execução, restrições de acesso aos
arquivos, etc.;
•
Portável: independente da arquitetura de onde é implementado (UNIX, PC,
Mac);
•
Interpretado: o compilador gera um código intermediário (bytecodes). Este
código pode ser executado em qualquer sistema que possua um
interpretador;
•
Multitarefa: com Java podemos escrever programas que façam várias
coisas ao mesmo tempo;
•
Dinâmico: tenta agregar todos os módulos que compõem uma aplicação
até o momento da execução. Isto permite agregar dinamicamente o código
de uma forma segura e conveniente.
De acordo com Paulo e Graça (2003), a linguagem Java foi projetada com
base em 10 anos de experiência de C++, aproveitando suas melhores
características. A linguagem ainda oferece tratamento de exceções hierárquicas e a
memória dinâmica é gerenciada automaticamente. Programas em Java podem ser
executados na maioria das plataformas sem necessidade do código-fonte ou
recompilação.
12
3.1.2 – Integrated Development Environment (IDE) Eclipse
O Integrated Development Environment (IDE) ou Ambiente Integrado de
Desenvolvimento escolhido foi o Eclipse (Eclipse, 2008). Segundo Gallardo et al.
(2003), o Eclipse é um ambiente para desenvolvimento Java com todas as
ferramentas necessárias para o desenvolvedor, inclusive um depurador, o que ajuda
a verificação de erros. Por se tratar de uma ferramenta gratuita, muitas outras
ferramentas adicionais específicas também gratuitas já foram distribuídas e podem
ser agregadas ao Eclipse.
3.1.3 – Servidor de Aplicação Tomcat
De acordo com Martins (2003): “(...) um servidor de aplicação é uma
plataforma sobre a qual roda a porção servidora de um aplicativo, incluindo
hardware e software”.
O servidor de aplicação do Gene é o Apache Tomcat, na sua versão 6, pois
oferece estabilidade, segurança e simplicidade ao desenvolvedor e principalmente
ao sistema (Apache, 2008 A).
Segundo DataSynapse (2008), Tomcat é uma ferramenta gratuita e de código
aberto (open-source) que foi desenvolvida em um projeto cujo foco é desenvolver
diversas soluções de software livre baseadas em Java, denominado Jakarta, da
Apache Software Foundation (Jakarta, 2008). A ferramenta está disponível para uso
comercial sob a licença ASF (Apache Software Foundation), no site da Apache
(Apache, 2008 B), nas versões binária e source.
O Tomcat está disponível para qualquer empresa ou desenvolvedor para ser
utilizado como ferramenta de apoio a desenvolvimento de sites dinâmicos e
interativos e como servidor, ou seja, como uma aplicação disponível para receber
solicitações de outros programas ou computadores e as processar através de uma
rede de computadores (CNS, 1999).
13
3.1.4 – JavaServer Pages (JSP)
Este projeto fez uso da tecnologia JavaServer Pages (JSP), que é utilizada no
desenvolvimento de aplicações Web, desenvolvida pela Sun Microsystem. Seu
conteúdo pode ser puramente estático HyperText Markup Language (HTML) ou
conter elementos dinâmicos, que são processados pelo servidor de aplicação Web
antes da página HTML ser enviada (Jendrock et al., 2006).
Segundo SUN (2008), a página JSP é baseada na linguagem de
programação Java, tem a vantagem de portabilidade de plataforma, que permite a
sua execução em diversos sistemas operacionais; como o Windows e o Linux.
Permite ainda a produção de aplicações que acessem o banco de dados, manipulem
arquivos no formato texto, capturem informações a partir de formulários e a captura
de informações sobre o visitante e o servidor. Para desenvolver aplicações que
utilizem JSP é necessário o conhecimento prévio sobre a especificação Java
Enterprise Edition (JEE), que é um conjunto de padrões e especificações
responsável por receber as requisições do cliente (browser), entendê-las e
direcioná-las aos responsáveis pelas respostas às ações solicitadas.
A tecnologia JSP fornece um poderoso recurso na confecção de páginas web:
as bibliotecas de tags ou taglibs. Através delas, é possível encapsular trechos de
código Java em tags, facilitando a manutenção, aumentando a clareza do código e
estimulando o reuso das páginas (SUN, 2008).
3.1.5 – JSP Standard Tag Library (JSTL)
A tecnologia JSTL foi utilizada no projeto por meio do uso de suas tags nas
páginas JSP. Segundo Leme (2006), a JSTL é a Application Programming Interface
(API) que encapsulou em tags toda a funcionalidade que diversas páginas web
precisam, como controle de laços (fors), controle de fluxo do tipo if else,
manipulação de dados XML e a internacionalização da aplicação.
14
3.1.6 – Framework Struts 2
Um framework é uma aplicação reusável, semi-completa que pode ser
adaptada para fazer parte de aplicações completas (Johnson, 1988).
Segundo Husted et al. (2003), assim como as pessoas, aplicações possuem
comportamentos mais parecidos do que se parecem esteticamente. Rodam no
mesmo computador, esperam dados de entrada dos mesmos dispositivos, retornam
dados de saída para os mesmos dispositivos de saída, e salvam informações no
mesmo disco rígido. Desenvolvedores trabalhando em aplicações para desktop
convencionais estão acostumados a ferramentas e ambientes de desenvolvimento
que geralmente têm o mesmo comportamento nas aplicações. Desta forma,
frameworks permitem que desenvolvedores obtenham uma estrutura reutilizável, útil
para desenvolvimento de seus próprios sistemas com seus requisitos específicos.
Determinado framework pode ser bastante utilizado por ser conhecido por sua
funcionalidade em determinada aplicação, estando pronto para ser utilizado para um
projeto posterior e pode ainda ser utilizado por outras equipes da empresa, seja ela
em um mesmo projeto ou em outros.
O framework escolhido para o desenvolvimento do Gene foi o Struts 2 (Struts,
2008) devido à sua organização de arquitetura.
Struts 2 é um framework de código aberto, pertencente à Apache Software
Foundation, que tem como função auxiliar o desenvolvedor a fazer aplicações web
de modo mais fácil e rápido. É composto de tecnologias como JavaBeans, Java
Servlet e JavaServer Pages, utilizadas pela maioria dos programadores web. Outra
vantagem do Struts 2 é economizar tempo a cada novo projeto que é iniciado, pois
agiliza parte da codificação de um sistema (Husted et al, 2003).
Outros pontos positivos são a validação de formulários das páginas JSP e
muita documentação disponível em Livros e na Internet, deixando-o mais simples
para o uso.
15
3.1.7 – Application Programming Interface (API) AJAX
A Application Programming Interface (API) DWR AJAX foi escolhida devido às
suas boas funcionalidades de apoio à camada de interface, economizando tempo de
desenvolvimento e fornecendo classes padronizadas (DWR, 2008).
Segundo Baudisch (2006), AJAX (Asynchronous Javascript And XML) é um
conjunto de tecnologias, para tornar páginas mais interativas com o usuário,
utilizando-se de solicitações assíncronas de informações. AJAX não é somente um
novo modelo, é também uma iniciativa na construção de aplicações web mais
dinâmicas e criativas.
3.1.8 – Corel Draw e Gif Movie Gear
O software Corel Draw X3 (Corel, 2008) foi utilizado para desenhar o bichinho
virtual e todo o layout de página, incluindo imagens estáticas que foram depois
animadas com Gif Movie Gear (Gamani, 2008).
Esses programas foram usados por possuírem grandes funcionalidades de
efeitos, edição e manipulação de imagens, além da facilidade de uso.
3.1.9 – Documentação Javadoc
Segundo Medeiros (2006), documentar pontos estratégicos dos códigos
fontes é uma necessidade, indiferente do paradigma de programação ou da
plataforma de desenvolvimento. É crescente a necessidade de se reutilizar como
documentação comentários feitos em alguns pontos nos códigos fontes. Javadoc é
um recurso útil para isso em linguagem Java, fornecendo uma linguagem específica
para os comentários que introduzem classes, atributos e métodos e seu
funcionamento. Javadoc baseia-se na inserção de textos explicativos em forma de
um comentário especial, que antecedem uma classe ou método.
Ainda de acordo com Medeiros (2006), o interessante deste recurso é que ele
nos permite combinar linhas de comandos da própria especificação HTML, com as
linhas de comandos oferecidas pelo Javadoc tornando possível a criação de
documentos completos gerados a partir dos comentários do próprio código.
16
Segundo Graça e Paulo (2003), Javadoc tem a vantagem de deixar a
documentação próxima ao código, facilitando a sincronização entre as versões do
código e as versões da documentação. Assim, cada vez que alguma parte do código
é modificada, basta atualizar os comentários correspondentes e utilizar ferramenta
correspondente para gerar nova documentação.
3.1.10 – Arquitetura ePING
A arquitetura ePING consiste em uma infra-estrutura que serve como alicerce
para criação de serviços de melhor qualidade a custos reduzidos em sistemas do
governo brasileiro.
Segundo ePING (2008), esta arquitetura tem como principais características:
alinhamento com a internet, onde todos os sistemas de informação da administração
pública deverão estar alinhados com as principais especificações usadas na
Internet; adoção do XML como padrão de intercâmbio de dados para todos os
sistemas do setor público; adoção de navegadores (browsers) como principal meio
de acesso; taxonomia de navegação, que contemple, numa estrutura de diretório, os
assuntos relacionados com a atuação de governo; suporte de mercado;
escalabilidade; adoção preferencial de padrões abertos e garantia à privacidade de
informação.
A arquitetura ePING cobre as áreas segmentadas em interconexão,
segurança, meios de acesso, organização e intercâmbio de informações e áreas de
integração para Governo Eletrônico. A partir do momento que um sistema está
validado de acordo com a arquitetura ePING, há uma maior tendência para que o
serviço seja prestado à sociedade da melhor forma possível e com custo mais baixo.
(ePING, 2007).
3.1.11 – Padrão Model View Controller (MVC)
O MVC é um padrão de arquitetura de software. Com o aumento da
complexidade das aplicações desenvolvidas torna-se fundamental a separação entre
os dados e o layout. Desta forma, alterações feitas no layout não afetam a
manipulação de dados, e estes poderão ser reorganizados sem alterar o layout.
17
Segundo Martins (2006), MVC é dividido em três abstrações centrais: Model,
View e Controller:
•
Camada de persistência (Model): Esta camada será responsável pelo
tráfego de informações entre o sistema e fontes de dados.
•
Camada de apresentação (View): Esta camada será responsável pela
interface do sistema web para interação direta com o usuário e
comunicação com a camada de negócio para aquisição de dados.
•
Camada de controle (Controller): Esta camada será responsável por
prover ao usuário funções para a obtenção, organização e atualização de
dados.
A modelagem do projeto utilizando o padrão de camadas MVC ajuda a
promover a modularidade pois os objetos podem ter reduzidas as dependências
entre si ficando assim fracamente acoplados, proporcionando um código mais fácil
de manter e evoluir.
3.1.12 – MySQL
O Sistema Gerenciador de Banco de Dados (SGBD) usado no projeto foi o
MySQL. Ele é um sistema de gerenciamento de banco de dados, que utiliza a
linguagem SQL (Structured Query Language - Linguagem de Consulta Estruturada)
como interface. É atualmente um dos bancos de dados mais populares, com mais de
10 milhões de instalações pelo mundo.Entre os usuários do banco de dados MySQL
estão: NASA, Friendster, Banco Bradesco, Dataprev, HP, Nokia, Sony, Lufthansa,
U.S Army, US. Federal Reserve Bank, Associated Press, Alcatel, Slashdot, Cisco
Systems e outros. (MySQL, 2008)
O MySQL é um dos sistemas de gerenciamento de banco de dados mais
populares que existe e, por ser otimizado para aplicações Web, é amplamente
utilizado na internet.
Outro fator que ajuda na popularidade do MySQL é sua disponibilidade para
praticamente qualquer sistema operacional, como Linux, FreeBSD (e outros
sistemas baseados em Unix), Windows e Mac OS X. Além disso, o MySQL é um
18
software livre (sob licença GPL), o que significa que qualquer um pode estudá-lo ou
alterá-lo conforme a necessidade.
Segundo MySQL (2008), entre as características técnicas principais do SGBD
MySQL, estão:
•
Alta compatibilidade com linguagens como PHP, Java, Python, C#, Ruby e
C/C++;
•
Baixa exigência de processamento (em comparação como outros SGBD);
•
Vários sistemas de armazenamento de dados, como MyISAM, MySQL
Cluster, CSV, Merge, InnoDB, entre outros;
•
Recursos
como
transactions
(transações),
conectividade
segura,
indexação de campos de texto, replicação, etc;
•
Instruções em SQL, como indica o nome.
O principal foco do MySQL é a agilidade. Assim, se a aplicação necessita de
retornos rápidos e não envolve operações complexas, o MySQL é otimizado para
proporcionar processamento rápido dos dados e tempo curto de resposta sem exigir
muito do hardware.
3.1.13 – Framework Hibernate
O Hibernate é um framework para mapeamento objeto-relacional, escrito na
linguagem Java. Este framework facilita o mapeamento dos atributos entre uma
base tradicional de dados relacionais e o modelo objeto de uma aplicação, mediante
o uso de arquivos (XML) para estabelecer esta relação. Hibernate é um software
livre de código aberto.
Segundo Bauer e King (2005), o objetivo do Hibernate é diminuir a
complexidade entre os programas Java, baseados no modelo orientado a objeto,
que precisam trabalhar com um banco de dados do modelo relacional (presente na
maioria dos SGDBs); em especial, no desenvolvimento de consultas e atualizações
dos dados.
19
Para Hibernate (2008), a principal característica do Hibernate é a
transformação das classes em Java para tabelas de dados (e dos tipos de dados
Java para os da SQL). O Hibernate gera as chamadas SQL e libera o desenvolvedor
do trabalho manual da conversão dos dados resultantes, mantendo o programa
portável para quaisquer bancos de dados SQL, porém causando um pequeno
aumento no tempo de execução.
As questões relacionadas ao gerenciamento de transações e à tecnologia de
acesso à base de dados são de responsabilidade de outros elementos na
infraestrutura do programa. Apesar de existir uma Application Programming Interface
(API) no Hibernate para realizar operações de controle transacional, ele
simplesmente delegará estas funções para a infraestrutura sobre a qual foi instalada.
Hibernate (2008) cita algumas das vantagens oferecidas pelo framework
Hibernate:
•
Controle transacional: o framework deve permitir rollback quando ocorrer
algum erro e commit quando o objeto for persistido com sucesso;
•
Identificadores de objeto: cada objeto deve ter um identificador único para
ser relacionado com o registro correspondente. Um OID (Object Identifier)
garante que o objeto não se duplicará;
•
Mapeamento O-R: se não utilizar um banco de dados orientado a objetos
deve existir um mapeamento de objeto relacional entre a classe e a tabela
do banco de dados. Isso é um dos requisitos principais de um framework
de
persistência
de
objetos
é
responsável
por
transformar
uma
representação de dados não orientada a objetos em um objeto e por
armazenar um objeto persistente no seu mecanismo de persistência como
um banco de dados, por exemplo;
•
Cache: com o uso de cache o objeto é colocado em uma memória local
para obter um maior desempenho; quando for necessário o uso desse
objeto, basta apenas buscá-lo na memória local em que ele foi colocado,
agilizando todo o processo;
20
•
Consultas sob demanda: os objetos são carregados apenas quando
necessário, evitando que registros sejam recuperados todos de uma vez
só. Isso reduz a carga de informações na rede; se a aplicação for utilizada
através da Internet este recurso garante um melhor desempenho;
•
Queries: utilizadas para consultas mais complexas, isto pode ser feito
através de OQL (Object Query Language) que é uma linguagem de
consulta a banco de dados orientados a objetos ou também embutindo
código SQL (Structure Query Language) na aplicação;
•
Portabilidade: um framework de persistência deve ser compatível com
vários tipos de mecanismos de persistência de dados e também
disponibilizar diversas maneiras de conexão, sendo isso muito importante
porque quando for necessário trocar de mecanismo de persistência de
dados não é necessário mudar toda sua aplicação.
3.1.14 – Padrão Data Access Object (DAO)
Na última década tem-se dedicado esforços no estudo e disseminação dos
padrões de projeto para aumentar a reusabilidade de software e por consequência
diminuir o custo de manutenção. Segundo Gamma et al (2000), Valente (2003),
Shalloway e Trott (2004) e Fowler (2006), os padrões de projeto permitem a
reutilização de arquiteturas e projetos bem sucedidos, reaproveitando soluções e a
experiência dos modeladores, assim como estabelecendo um vocabulário comum
para os envolvidos no desenvolvimento, fazendo com que se melhore a
comunicação entre eles. Além disso, a adoção de padrões requer adaptação dos
projetos, e com isso naturalmente as aplicações precisam ser bem arquitetadas para
tal reaproveitamento.
Na busca de uma solução para melhorar a manutenibilidade do projeto quanto
à conexão de banco de dados foi proposto a adoção do padrão de projetos Data
Access Object (DAO), que segundo AECE (2005), abstrai e encapsula os
mecanismos de acesso a banco de dados.
Usando esse padrão, a camada de negócios acessa os dados persistidos
sem ter conhecimento se os dados estão em um banco de dados relacional ou um
21
arquivo XML. O padrão DAO esconde os detalhes da execução da origem dos
dados (SUN, 2007).
A figura 1 apresenta a estrutura do padrão DAO. A classe DataAccessObject
encapsula o acesso aos dados, que por sua vez é mantido pela classe DataSource
que pode ser um arquivo XML, uma base de dados ou algum serviço remoto, ou
seja, a origem dos dados. A classe BusinessObject representa a aplicação (também
conhecida como cliente do padrão), que usa um objeto DataAccessObject. Ao
utilizar esse objeto DataAcessObject, o objeto cliente recebe ou envia um objeto
TransferObject (no projeto chamado de ValueObject). Esse objeto contém os dados
a serem enviados ou trazidos da origem dos dados, e normalmente referem-se aos
campos de um registro.
Figura 1 – Estrutura do Padrão DAO (SUN, 2007)
3.2 – Arquitetura e Modelagem do Sistema
O sistema, por se tratar de uma aplicação web Java Enterprise Edition (JEE),
necessita de um servidor de aplicação para ser utilizado, sendo este o Tomcat para
este projeto. Este servidor possui configurado o componente chamado Gene e o seu
acesso é feito via Internet pelo computador do usuário.
A base de dados pode ficar ou não na mesma máquina física onde o Tomcat
está instalado, pois o acesso a base da dados é facilmente configurável. A figura 2
ilustra a arquitetura física do projeto.
22
Figura 2 – Arquitetura Física do Sistema (Silveira e Borges, 2008 A, pág. 5)
A figura 3 mostra um diagrama de componentes Unified Modeling Language
(UML) (UML, 2008), representando como está organizado o ambiente do projeto. O
Gene funciona como um componente dentro do servidor de aplicação Tomcat e tem
uma relação direta com o Banco de Dados Gene que funciona dentro do Sistema
Gerenciador de Banco de Dados MySQL. O acesso a base de dados é configurada
por meio de um arquivo de propriedades (*.properties), que contém as informações
de localização, nome, usuário e senha do banco de dados.
Figura 3 – Ambiente do Projeto
A figura 4 apresenta o Diagrama de Entidade Relacionamento (DER) do
sistema. A tabela BICHO possui relacionamentos um para muitos com as tabelas
ATRIBUTO e PAR. A tabela USUARIO tem relacionamento um para muitos com
BICHO e MENSAGEM. A tabela ATIVIDADES é uma tabela de configuração do
sistema, que contém todas as atividades possíveis para conduzir o bichinho (comer,
beber, jogar e dar banho).
Esta tabela é carregada no sistema, e com base nos níveis do bichinho, um
filtro separa as atividades disponíveis naquele momento para o bichinho.
23
Figura 4 – Diagrama de Entidade Relacionamento do Gene
Silveira e Borges (2008 A) citam que a arquitetura do Projeto Gene é baseada
no padrão MVC de camadas, no qual o projeto fica dividido por partes e estruturado
de uma maneira mais lógica e fácil de compreender.
A figura 5 mostra o Gene conforme a arquitetura deste padrão, mostrando em
cada camada as tecnologias usadas no sistema. O Framework Struts 2 encontra-se
entre as camadas de Apresentação e Negócio, fazendo uma ponte de comunicação
entre as mesmas.
Figura 5 – Arquitetura Lógica do Sistema (Silveira e Borges, 2008 A, pág. 4)
24
A dependência entre as famílias de classes do projeto é apresentada na
figura 6.
<<Apresentação>>
Tags
<<Apresentação>>
Páginas JSP
<<Apresentação>>
Actions /
ActionsForms
<<Negócio>>
Business Class
<<PersistênciaHibernate>>
...>>
DaoHibernate
<<Persistência>>
ValueObjects
Figura 6 – Dependência entre as Famílias de Classes
A descrição de cada componente da figura 6 é mostrada a seguir:
•
Páginas JSP: são as que de fato o usuário tem contato, é a interface visual
interagindo o usuário com o sistema. É responsabilidade dela a conversão
para o HTML que o browser entende.
•
Tags: devem aplicar a lógica e/ou as reutilizações de visualização HTML.
No sistema foram utilizadas Tags JavaServer Pages Standard Tag Library
(JSTL) (JSTL, 2008), e Tags do framework Struts 2 (Struts, 2008), por
serem pacotes com as principais tags utilizadas e já estarem prontas para
o uso.
•
Actions: correspondem a uma ação junto ao sistema. Realizam a ligação
entre uma ação disparada pelo usuário e a sua execução junto ao
modelos de negócios.
•
ActionForms: são os parâmetros de uma determinada ação do sistema,
que permite a validação dos dados no servidor.
•
BusinessClass: nesta família de classes estão mapeadas as regras do
sistema, como por exemplo, regra de nascimento de um novo Bichinho.
Faz também a comunicação com o componente de PersistênciaHibernate.
25
•
PersistênciaHibernate: é uma família de classes do grupo Hibernate, que
foi adaptado aos moldes de necessidades do projeto. Auxilia a integração
entre o modelo de negócios e o modelo de dados. Com estas foram
possíveis o mapeamento da Base de Dados em objetos, possuindo
métodos prontos para o uso como Inserts, Selects e também flexível
quanto à criação de métodos mais específicos.
•
Persistência: trata-se das classes modeladas conforme as tabelas da base
dados. Para cada tabela foi criado um ValueObject ou mesmo chamado de
VO. Estas classes podem também conter métodos para manipular seus
próprios dados.
O detalhamento da camada de apresentação do projeto, mostrada na figura 7,
é implementada por ações (actions) do framework Struts 2. Esta camada faz a ponte
de comunicação entre a interface visual e as regras de negócio. No pacote
presentation estão as actions do sistema. Elas podem ser chamadas diretamente
pela interface visual ou por outra action. Dentro do pacote presentation.form ficam as
classes que abstraem os formulários do sistema. Os atributos dessas classes são
lidos dentro das actions.
Figura 7 – Detalhamento da Camada de Apresentação do Projeto
26
Todas as operações que precisam acessar a base de dados são
implementadas na camada de negócio do sistema, presente no pacote business,
mostrado na figura 8.
Figura 8 – Detalhamento da Camada de Negócio do Projeto
O detalhamento da camada de persistência do projeto é apresentado a seguir
na figura 9. Para melhor abstração dos dados foi utilizado o padrão DAO, citado na
seção 3.1.14 do trabalho.
Figura 9 – Detalhamento da Camada de Persistência do Projeto
27
Dentro do pacote persistence estão as classes HibernateUtil e DAOFactory. A
primeira é responsável por configurar a sessão para comunicação do Hibernate a
base de dados, através de um arquivo de propriedades que possui: nome, usuário e
senha do banco da dados. A segunda tem em seu construtor a chamada do atributo
session da primeira, métodos para iniciar, fechar e efetivar a transação entre o
software e o banco, e além disso, possui métodos que “fabricam” o DAO, chamados
nas classes de negócio. O pacote persistence.dao possui a classe DAO. Esta é uma
classe genérica, implementada com template, que tem métodos que acessam a
base de dados abstraídos pelo framework Hibernate.
Em persistence.mappings estão os mapeamentos das classes contidas em
persistence.vo, que são modelos das tabelas no sistema. Basicamente é a tradução
de uma classe Java para uma tabela da base de dados. As classes dentro de
persistence.vo.attributes são as classes filhas que herdam a classe Atributo de
persistence.vo, pois cada uma delas possui implementação própria do método
timer(), que atualiza os seus próprios valores. Para uma visualização mais
organizada dos pacotes foi decidido a separação destas classes em outro pacote
(persistence.vo.attributes).
O diagrama de classes parcial do projeto (figura 10) tem como uma das suas
principais classes a classe Bicho que possui uma lista de atributos referentes a
Felicidade, Calorias, Nutrientes, Água, etc. Esses atributos foram classificados como
de primeiro nível e de segundo nível.
Os atributos de primeiro nível não precisam de outros atributos para obter seu
valor; por exemplo, o atributo Calorias pode ser calculado diretamente quando o
bicho ingere algo. Os de segundo nível tem seu valor calculado com base em outros
atributos: o Peso (segundo nível) depende do valor de Nutrientes, Calorias e Água
(primeiro nível).
A classe Atributo possui o método timer(), que é abstrato, assim cada uma
das classes que a herda precisa implementar este método. Esta estrutura foi
definida assim pois cada uma das classes que herdam Atributo (Calorias, Nutrientes,
Água, etc) precisam implementar uma lógica diferente no método timer().
28
Figura 10 – Diagrama de Classes do Relacionamento Atributos/Bicho
(Silveira e Borges, 2008 A, pág. 5)
Para o projeto foi necessária a criação de Listas personalizadas para disparar
o timer de cada um de seus nós (atributos de primeiro e segundo nível) além de um
método de busca chamado pesquisar(“nomeDoAtributo”), que faz uma busca pelo
nome do atributo e retorna o seu objeto.
Figura 11 – Diagrama de Classes de Atualização do Bichinho
29
A ação de atualização dos dados do bichinho no sistema é mostrada na figura
11. A classe TimerServlet é chamada quando é iniciado o jogo com um bichinho.
Esta classe tem o método iniciarTimer() que chama BichoTask. Esta é uma classe
que implementa o método run() da classe abstrata TimerTask do Java, além de ter o
atributo session do tipo HttpSession e por meio deste é recuperada a instância do
objeto Bicho.
A classe TimerService é de fato a responsável pela chamada de atualização.
No seu método update(), é chamado bicho.getListaAtributos().acionaTimers(), que
aciona os timers de todos os atributos adicionados na Lista de Atributos. Este
processo acontece a cada 10 segundos.
3.3 – Persistência e Internacionalização
Segundo Silveira e Borges (2008 B), a persistência do bichinho é outro
atrativo que aumenta a motivação do jogo, pois o usuário pode salvar o estado atual
do bichinho para continuar jogando mais tarde.
Quando o usuário faz o login de sua conta, ele é direcionado para o seu perfil
que possui os bichinhos já criados e salvos. Caso exista algum bichinho mais
habilitado para o usuário jogar, porém o jogo com este bichinho não foi iniciado
ainda, a manipulação dos genes fica a disposição do usuário.
A internacionalização do sistema foi uma estratégia adotada para tentar levar
o projeto para o conhecimento também de países de língua Espanhola e Inglesa.
Primeiramente o sistema captura o objeto locale do navegador do usuário a
fim de saber em que língua o sistema deve iniciar. Porém o usuário tem a liberdade
de escolher uma visualização textual do sistema em outra língua apenas
pressionando os botões representados por bandeiras, disponíveis no canto superior
direito da tela.
Todos os textos disponíveis no sistema encontram-se separados das páginas
JSP, modularizados por língua em arquivos de propriedades do projeto
(*.properties).
30
3.4 – Comunidade Gene
Buscando aumentar a motivação dos usuários, o bichinho criado inicialmente
a partir de uma manipulação genética, em determinado momento de sua vida, podese relacionar com outro bichinho de outro usuário. Desse relacionamento surgem
novos bichinhos, mais evoluídos, um para cada usuário, com mais genes para
manipular e atividades disponíveis para jogar. O critério de seleção da lista de
bichinhos aptos a se relacionar com outro funciona da seguinte maneira:
•
Deve ser do sexo oposto;
•
Ter mais de 10 anos de idade;
•
É dada prioridade aos bichinhos de usuários conectados no sistema.
De acordo com Silveira e Borges (2008 B), a partir do momento que é feita a
escolha de um dos bichinhos da lista, uma mensagem é enviada para o usuário do
bichinho escolhido. Com o intuito de oferecer a opção de decisão ao usuário que
recebeu a mensagem, ele escolhe “Aceitar”, caso queira que um bichinho novo mais
evoluído (com mais genes e atividades) seja disponibilizado para ele. Com isso o
usuário remetente da mensagem também ganha um bichinho mais evoluído. Porém
caso a opção “Recusar” seja a escolhida pelo destinatário da mensagem, nenhuma
ação acontece para os dois usuários.
O controle de evolução dos bichinhos é feito por um nível que aumenta cada
vez que um relacionamento com outro usuário é efetivado com sucesso. Este nível é
responsável por controlar os genes a serem manipulados e atividades disponíveis
para os usuários conduzirem com os bichinhos. As tabelas 1 e 2 ilustram como
foram desenvolvidos esses controles no sistema.
Tabela 1. Comparação Entre Nível e Atividades
Nível do Bichinho
Atividades
0
Comer, Beber
1
Comer, Beber, Jogar
2
Comer, Beber, Jogar, Banhar
31
Tabela 2. Comparação Entre Nível e Características Genéticas
Nível do Bichinho
Características Genéticas
0
Sexo, Cor
1
Sexo, Cor, Antena
2
Sexo, Cor, Antena, Miopia
Para a implementação da comunidade foi decida a criação de contas de
usuários no sistema. Estas são efetuadas preenchendo um formulário com alguns
dados pessoais (Nome, Escolaridade, e-mail, Usuário, Senha, etc). No Apêndice
deste trabalho são abordados maiores detalhes sobre os fluxos de criação de conta
no sistema, além dos fluxos realizados na Comunidade Gene (Solicitar e Avaliar
relacionamento dos Bichinhos)
O Projeto Gene foi abordado neste capítulo, sendo apresentados todos os
materiais e métodos utilizados (padrões, ferramentas e softwares), assim como toda
arquitetura e modelagem do sistema. A persistência do jogo e a internacionalização
da parte textual do sistema para as línguas Portuguesa, Espanhola e Inglesa foram
abordadas neste capítulo também. Foi detalhada a funcionalidade da Comunidade
Gene, que integra e interage os usuários do sistema, cuja finalidade é proporcionar
maior motivação nos usuários do Gene.
32
4 – Resultados
Os resultados são apresentados neste capítulo, que está subdividido em duas
seções: resultados da ferramenta e resultados de dinâmica com usuários. Na
primeira são mostradas as funcionalidades disponíveis aos usuários do Gene, como
criar contar, acesso ao perfil, o jogo, a comunidade Gene, etc. Os resultados da
dinâmica feita com usuários durante o evento Unicamp de Portas Abertas 2008 são
analisados a seguir.
4.1 – Resultados da Ferramenta
Quando o sistema é iniciado é aberta a tela de apresentação (figura 12).
Nesta, o usuário que já possui conta no sistema pode entrar em seu perfil digitando
o Usuário e Senha escolhidos por ele na hora do cadastro.
Figura 12 – Tela Inicial do Sistema
33
Porém caso o usuário não possua conta ainda, ele pode criá-la clicando no
link “Cadastre-se Aqui”, disponibilizado abaixo do botão “Entrar”. A partir daí o
sistema redireciona o usuário para a tela de cadastro para que ele possa criar uma
conta. Na figura 13 é apresentada a tela de cadastro. Alguns campos do formulário
de cadastro são obrigatórios (Nome Completo, Usuário, Senha, Confirmação de
Senha). Quando o usuário não os preenche, uma mensagem de alerta é exibida a
fim de orientá-lo sobre o processo correto de preenchimento do formulário de
cadastro.
Figura 13 – Cadastro do Usuário
O sistema também valida se já existe algum usuário que já tenha o nome de
Usuário escolhido e se os campos Senha e Confirmação de Senha estão com
valores iguais.
Após a validação de Usuário e Senha ou do Cadastro, o sistema abre a tela
de perfil do usuário. Nesta tela de perfil as opções Dados Pessoais, Sair,
Comunidade, Célula, Ajuda e Correio estão disponíveis ao Usuário. A figura 14
mostra essa tela de perfil do usuário depois que ele já possui uma conta no sistema.
34
Neste caso o usuário possui dois bichinhos (esquerda e meio) com a manipulação
genética já realizada e um (direita) ainda não disponível para o jogo.
Figura 14 – Perfil do Usuário
A função Dados Pessoais oferece ao usuário o retorno aos seus dados
cadastrados no sistema, podendo atualizá-los. Os dados são apresentados na tela
de cadastro exibida na figura 13.
Na funcionalidade Célula da tela de perfil, é apresentada uma célula
eucarionte animal, com suas respectivas organelas (figura 15). Ao pressionar cada
organela, o usuário tem à disposição um pequeno texto explicativo sobre aquela
organela e ainda, em alguns casos, uma explicação em áudio.
A funcionalidade Ajuda do abre uma tela com explicação das funcionalidades
do sistema. Conforme mostrado na figura 16 a seguir.
35
Figura 15 – Funcionalidade Célula
Figura 16 – Tela de Ajuda
36
Comunidade oferece ao usuário a funcionalidade de interação com outros
usuários. Quando chamada, é aberta uma tela para escolha de um de seus
bichinhos (figura 17). Após esta escolha o sistema exibe uma tela com os possíveis
bichinhos para o relacionamento (figura 18). Assim o usuário escolhe um dos
bichinhos mostrados para o relacionamento e o sistema envia a solicitação ao
usuário escolhido.
Figura 17 – Escolhendo um de seus Bichinhos
Figura 18 – Comunidade Gene
37
A funcionalidade Correio é o canal que comunica o usuário quando ele foi
escolhido para um relacionamento. Assim que o usuário recebe uma nova
mensagem, um aviso é mostrado como uma barra informativa para ele no perfil com
a mensagem “Você tem mensagem(ns) não lida(s) no seu Correio”, além do
desenho de um envelope ao lado do botão Correio (figura 19).
Partindo do pressuposto que o usuário depois de ter sido informado de que
existe alguma mensagem não lida, clica no botão Correio, o sistema abre uma tela
com as suas mensagens, como mostra a figura 20.
Figura 19 – Aviso de Nova Mensagem
Se o usuário clicar no botão “Aceitar”, um bichinho mais evoluído nasce para
ele e para o solicitante do relacionamento. Caso contrário, a opção seja a do botão
“Recusar”, nada acontece para ambos.
38
Figura 20 – Correio do Usuário
Quando algum dos bichinhos do perfil é pressionado, incia-se o jogo com ele.
Qualquer alteração dele na aparência é refletida no perfil após o término do jogo. A
figura 21 mostra a tela de jogo do primeiro bichinho (esquerda) mostrado na figura
19.
Durante o jogo o usuário pode consultar o Relatório do Bichinho. Neste estão
listados todos seus atributos. Assim o usuário fica sabendo melhor sobre o
andamento do seu jogo (figura 22).
39
Figura 21 – Tela do Jogo
Figura 22 – Relatório do Bichinho
40
O jogo quando mal conduzido ou quando o bichinho chega a certa idade
mostra uma tela (figura 23) de fim de jogo. Esta contém os valores de todos os
atributos do bichinho dando um feedback ao jogador de como foi o seu desempenho
no jogo. Assim novas estratégias, experiências e aprendizados podem ser
construídos visualizando estas informações.
Figura 23 – Fim de Jogo
4.2 – Resultados de Dinâmica com Usuários
Como análise dos resultados do projeto foi feito um estudo da exposição do
Projeto Gene durante o evento UPA 2008 (UNICAMP de Portas Abertas).
Os usuários de faixa etária mais nova (13 a 15 anos), um total de 8 pessoas,
passaram mais tempo fazendo as combinações genéticas e jogando. Questionavam
mais sobre o sistema em termos de como evoluir o bichinho, se ele iria crescer, se
haveria mais genes disponíveis para fazer mais combinações possíveis. Porém
poucos usuários dessa faixa etária perceberam que os números de atividades do
bichinho estavam aumentando (inicialmente comer e beber, depois tomar banho e
por último brincar).
41
Usuários de maior faixa etária (16 a 25 anos), totalizando 25 pessoas,
focaram mais sobre o funcionamento do sistema, verificando mais vezes a
funcionalidade de informações do bichinho (Relatório). Alguns ainda tentaram por
diversas vezes matar o bichinho dando a ele comida e água em excesso. Porém
quando viam que em determinado momento o bichinho não aceitava mais comida
nem água; questionavam em que momento ele morria, que é quando ele fica com
muita fome e/ou sede ou quando chega a certa idade.
A versão apresentada durante o UPA 2008 ainda não tinha a parte da
Comunidade Gene construída. Apenas o jogo com um Bichinho, criado a partir de
uma manipulação genética, estava disponível. A Comunidade Gene não foi testada
em dinâmicas com usuários até o momento, porém trabalhos futuros realizarão
estas dinâmicas.
42
5 – Conclusão
Tendo como base bichinhos virtuais que fizeram grande sucesso na década
de 90, surgiu a idéia de se desenvolver um projeto com “bichinho virtual”, porém com
um diferencial: o de apoiar o aprendizado de genética através de sua manipulação.
Este projeto recebeu o nome de Gene e sua primeira versão tinha recursos
multimídia não muito atraentes, dificuldade de instalação, não evolução no
cruzamento de genes e nas suas atividades.
Devido a tais circunstâncias, decidiu-se fazer a reengenharia do projeto,
fazendo uso de tecnologias mais atuais, disponibilizando o sistema em ambiente
web e ainda acrescentando atividades, cruzamento de genes, etc. Visando deixar o
jogo mais atrativo e contribuindo para uma maior motivação dos usuários, os
recursos de evolução e persistência do jogo foram incorporados ao projeto. A
evolução do jogo acontece de duas maneiras: nos números de genes para se
manipular e no de atividades (comer, beber, jogar e banho) para conduzir o bichinho.
Os resultados apareceram fazendo-se uma análise do uso do sistema durante
o evento Unicamp de Portas Abertas 2008 (UPA), citado na seção 4.2, assim como
uma versão do projeto que fosse mais motivadora e aplicasse o uso de interação
entre os usuários do sistema.
Como um próximo passo, o projeto será disponibilizado na Internet, facilitando
o acesso de terceiros ao conhecimento e ao uso do Gene. Assim o sistema ganhará
maior visibilidade, possibilitando a difusão de diversos conceitos de genética de uma
forma divertida e motivadora. A partir do trabalho realizado, outros trabalhos irão
complementar ou dar continuidade ao tema explorado, tanto na parte de condução
das dinâmicas de aprendizagem como em questões de motivação e interação dos
usuários.
43
6 – Referências Bibliográficas
ACKERMANN, E. Construtivismo ou Construcionismo: Qual é a diferença?
MEDIA
LAB
–
MIT
–
BOSTON/EUA.
Disponível
em:
<http://www.cec.g12.br/artigos/artigo_004.pdf> Acesso em: 15 fev 2008.
AECE, I. Analisando o Microsoft PetShop 3.0. São Paulo. 2005. Disponível em:
<http://www.projetando.net/Sections/ViewArticle.aspx?ArticleID=14> Acesso em:
07 jul. 2008.
APACHE. Apache Tomcat. Disponível em: http://tomcat.apache.org/download60.cgi Acesso em: 12 jun. 2008 A.
APACHE.
The
Apache
Software
Foundation.
<http://www.apache.org> Acesso em: 16 jun. 2008 B.
Disponível
em:
BAUDISCH, A. R. O que é AJAX e como aplicá-lo com PHP, parte 1. 2006.
Disponível em: <http://www.plugmasters.com.br/sys/materias/251/1/O-que-%E9AJAX-e-como-aplic%E1-lo-com-PHP> Acesso em: 16 ago. 2008.
BAUER C.; KING G. Hibernate in Action. São Paulo. Editora Ciência Moderna.
2005.
BESSER, H. Critical Thoughts About Tamagotchi. 1997. Disponível em:
<http://www.sims.berkeley.edu/courses/is296a3/s97/Focus/Identity/FINAL/index.h
tm>
BONGIOLO, C. E. F.; et al. Subindo e Escorregando: jogo para introdução do
conceito de adição de números inteiros. In: CONGRESSO DA REDE
IBEROAMERICANA DE INFORMÁTICA NA EDUCAÇÃO, 4., 1998, Brasília:
Universidade de Brasília, 1998.
BORGES, M. A. F.; OLIVEIRA, S. P. Design de uma ferramenta de apoio ao
aprendizado. Publicado nos Anais do Simpósio Brasileiro de Informática na
Educação, (Ed. Costa, E.B.), Universidade Federal de Alagoas, Maceió-Al, 2000,
pp.
121-127
Disponível
em:
<http:/www.ic.unicamp.br/~maborges/sbie2000/sbie2000.htm>
BRENELLI, R. P. O Jogo como Espaço para Pensar: a construção de noções
lógicas e aritméticas. Campinas, São Paulo: Papirus, 1996.
CHAPMAN, G. M.; MARTIN, J. F. Computerized Business Games in
Engineering Education. Computers & Education, Oxford, v. 25, n. 1/2, p. 67-73,
1995.
CLUNIE, G.; et al. ESCOLA: Meta-ambiente de aprendizagem baseado em
hipertecnologias. In: CONGRESSO DA REDE IBEROAMERICANA DE
INFORMÁTICA NA EDUCAÇÃO, 3., 1996, Colômbia, Barranquilla. Anais... [s.l.:
s.n.], 1996.
CNS.
Glossário,
R
–
Z,
1999.
Disponível
em:
<http://www.estudar.org/pessoa/internet/22glossary/r-z.html> Acesso em: 15 set.
2008.
44
COREL. Suíte de aplicativos gráficos, CorelDraw X3. Disponível em:
<http://www.corel.com.br/pt/mod_produtos.asp?page=prod_draw_x3&click_idfami
lia=2&click_iditem=2> Acesso em: 20 ago 2008
DATASYNAPSE.
Glossário
2008
Disponível
<http://www.datasynapse.com/en/glossary.php> Acesso em: 10 set 2008.
em:
DWR. Direct Web Remoting. Disponível em: <http://getahead.org/dwr> Acesso
em: 12 out 2008.
ECLIPSE. Eclipse, an open development
<http://www.eclipse.org> Acesso em: 12 out 2008.
platform.
Disponível
em:
EPING. Governo Eletrônico, Apresentação ePing. Disponível
<https://www.governoeletronico.gov.br/acoes-e-projetos/e-ping-padroes-deinteroperabilidade> Acesso em: 20 out 2007.
em:
EPING. ePING Padrões de Interoperabilidade de Governo Eletrônico , 2008
Disponível em: <https://www.governoeletronico.gov.br/biblioteca/arquivos/e-pingversao-3.0> Acesso em: 15 jul 2008.
FAGUNDES, L. Jornal Correio Popular, Campinas, 1997.
FERNANDÉZ,
M.
J.
Java.
Parte
I.
1998
Disponível
em:
<http://linuxfocus.org/Portugues/July1998/article57.html> Acesso em: 15 jan.
2008.
FOWLER, M. Padrões de arquitetura de aplicações corporativas. 2006 [s.l.;
s.n.].
GALLARDO, D.; et al. Eclipse in Action A GUIDE FOR JAVA DEVELOPERS.
Manning, 402p. 2003.
GAMANI. Get your animation in gear. Disponível em: <http://www.gamani.com>
Acesso em: 13 out. 2008.
GAMMA, E.; et al. Padrões de projeto: soluções reutilizáveis de software
orientado a objetos. 2000. [s.l.; s.n.].
GELLER, M.; SILVEIRA, S. R. Estudo e Análise de Jogos Educativos
Computadorizados. Relatório de Pesquisa. Canoas: ULBRA, 1998.
GROSSI, E. P. (Org.). Escolas Infantis: leitura e escrita. Erechim: Edelbra,
1986.
HIBERNATE. Relational Persistence for Java and .NET. Disponível em:
<http://www.hibernate.org> Acesso em: 15 nov. 2008.
HUSTED, T.; et al. Struts in Action Building web applications
leading Java framework. Manning, 664p. 2003.
JAKARTA. The Apache Jakarta Project,
<http://jakarta.apache.org> Acesso em: 16 jun. 2008.
2008.
with the
Disponível
em:
JENDROCK, E.; et al. The JavaTM EE 5 Tutorial Third Edition. Addison
Wesley, 2006. Disponível em: <http://java.sun.com/javaee/5/docs/tutorial/doc>
Acesso em: 29 nov. 2008.
45
JOHNSON, R. Designing Reusable Classes. Journal of Object-Oriented
Programming. SIGS, 1, 5 (June/July 1988), 22–35, Disponível em:
<http://www.laputan.org/drc/drc.html> Acesso em: 15 jul. 2008.
JSTL. JavaServer Pages Standard Tag Library. Disponível
<http://java.sun.com/products/jsp/jstl> Acesso em: 10 nov. 2008.
em:
KOTLIARENCO, M. A. El Juego como Posibilidad de Refuerzo a la
Resiliencia. In: Brinquedoteca: o lúdico em diferentes contextos. Petrópolis, Rio
de Janeiro: Vozes, 1997.
LEBOVICI, S.; DIATKINE, R. Significado e Função do Brinquedo na Criança.
Porto Alegre: Artes Médicas, 1985.
LEIF, J.; BRUNELLE, L. O Jogo pelo Jogo: a atividade lúdica na educação de
crianças e adolescentes. Rio de Janeiro: Zahar, 1978.
LEME, F. JSTL – Guia Completo. Java Magazine, Neofício Editora, Grajaú - RJ,
Edição 9 – Ano II, pp. 36–42.
MARTINS, D. F. Apresentando Model-View-Presenter, o MVC focado na
visualização,
2006.
Disponível
em:
<http://www.javafree.org/content/view.jf?idContent=91> Acesso em: 15 dez.
2007.
MARTINS, V. Servidores de Aplicação , 2003. Disponível em:
<http://www.pr.gov.br/batebyte/edicoes/1999/bb87/servidores.htm> Acesso em:
16 ago. 2008.
MEDEIROS, M. P. JavaDoc, Implementando documentação através do
NetBeans,
2006.
Disponível
em:
<http://www.devmedia.com.br/articles/viewcomp.asp?comp=2495> Acesso em:
10 jul. 2008.
MORI, L.; PEREIRA, M. A. Meiose e as leis de Mendel. Disponível em:
<http://www.ib.usp.br/microgene/files/manuais-7-PDF.pdf> Acesso em 15 fev.
2008.
MYSQL. The world's most popular open source database. Disponível em:
<http://www.mysql.com>. Acesso em: 15 nov. 2008
NEGRINE, A. Aprendizagem e Desenvolvimento Infantil: simbolismo e jogo.
Porto Alegre: PRODIL, v. 1, 1994.
PAULO, J. L.; GRAÇA, J. Uma Introdução ao Javadoc, 2003. Disponível em:
<http://mega.ist.utl.pt/~ic-po/2005/apoio/IntroJavadoc.html> Acesso em: 15 jan
2008.
PAPERT, I. H. (Ed.), Constructionist Learning. Cambridge, MA: MIT Media
Laboratory, 1990. p.3.
PAZZA,
R.
Introdução
a
Genética,
2006.
Disponível
em:
<http://www.biociencia.org/index.php?option=com_content&task=view&id=211&It
emid=71> Acesso em: 15 jan. 2008.
RIZZI, L.; et al. Atividades Lúdicas na Educação da Criança. São Paulo, 1994.
Série Educação.
46
RIZZO, G. O Método Natural de Alfabetização. In: Alfabetização Natural. Rio de
Janeiro: Francisco Alves, 1988. p. 33-129.
RODRIGUES, M. O Desenvolvimento do Pré-Escolar e o Jogo. São Paulo:
Ícone, 1992.
SANTOS, C. A. Jogos e Atividades Lúdicas na Alfabetização. Rio de Janeiro:
Sprint, 1998.
SHALLOWAY, A.; TROTT, J. Explicando padrões de projeto: uma nova
perspectiva em projeto orientado a objeto. 2004. [s.l.;s.n.]
SILVEIRA, H. M. ;BORGES, M. A. F. Arquitetura pedagógica do sistema Gene
de apoio ao aprendizado de genética. Publicado nos Anais do XIX Simpósio
Brasileiro de Informática na Educação. Universidade Federal do Ceará,
Fortaleza-CE, 2008 A.
SILVEIRA, H. M. ;BORGES, M. A. F. Comunidade interativa do sistema Gene
de apoio ao aprendizado de genética via internet. Publicado nos Anais do V
Seminário Municipal de Informática Educativa. Universidade Federal do Ceará,
Fortaleza-CE, 2008 B.
STHAL, M. M. Ambientes e Ensino-Aprendizagem Computadorizados: da
sala de aula convencional ao mundo da fantasia. Rio de Janeiro: COPPEUFRJ, 1991.
STRUTS.
About
Struts
Apache
2.
Disponível
<http://struts.apache.org/2.0.9/index.html> Acesso em: 15 jan. 2008.
em:
SUN. Core J2EE patterns: data access object. 2007. Disponível em:
<http://java.sun.com/blueprints/corej2eepatterns/Patterns/DataAccessObject.html
> Acesso em: 15 out. 2008 A.
SUN. Core Javaserver pages technology – white paper. Disponível em: <
http://java.sun.com/products/jsp/whitepaper.html> Acesso em: 29 nov. 2008 B.
UML. Object Management Group - Unified Modeling Language. Disponível
em: <http://www.uml.org>. Acesso em: 15 nov. 2008
VALENTE, J. A. Computadores e Conhecimento: Repensando a Educação.
Campinas. Gráfica Central da Unicamp, 1995.
VALENTE, L. Design patterns: padrões para projetos. 24 f. Dissertação
(Mestrado em Computação) - Universidade Federal Fluminense, Niterói. 2003.
Disponível em: <http://www.ic.uff.br/~lvalente/docs/DesignPatterns_Texto.pdf>
Acesso em: 12 ago. 2008.
WANG, W. O aprendizado através de jogos para computador: por uma
escola mais divertida e mais eficiente. 2006. Disponível em:
<http://www.familiaviva.org.br/artigos/artigo479.shtml> Acesso em: 05 mar. 2008.
47
Apêndice
Estão listados a seguir os casos de uso de alguns processos mais relevantes
do Projeto Gene. Para ajudar na visualização, cada caso de uso tem associado o
diagrama de sequência do fluxo básico. Os casos mostrados a seguir são: Criar
Conta; Solicitar Relacionamento dos Bichinhos e Avaliar Relacionamento dos
Bichinhos.
Caso de Uso Criar Conta
Documento de Caso de Uso
Criar Conta
Usuário
(from Use Case View)
(from Use Case View)
Figura 24 – Caso de Uso Criar Conta
Realização do Caso de Uso
Caso de Uso: Criar conta
Versão do Documento: 1.0
Descrição: Registro dos dados pessoais do usuário, a fim de criar uma conta de
acesso ao sistema para ele.
Pré Condição: O Usuário deve estar na página inicial do sistema, que é a de Login.
Cenário 1: Usuário realiza processo de criação de sua conta com sucesso.
1. Usuário solicita a criação de uma conta no sistema através do link “Cadastrese Aqui!”.
2. Sistema exibe tela de cadastro de usuários.
3. Usuário preenche corretamente o formulário e o submete para a criação da
conta no botão “Enviar dados”.
4. Sistema valida as informações.
48
5. Sistema grava as informações do usuário na base de dados.
6. Sistema mostra tela de perfil do usuário.
7. Caso de uso encerrado.
Fluxo alternativo 3.1: Usuário não preenche alguma das informações
obrigatórias.
3.1.1
Usuário cancela a criação de conta pressionando o botão Voltar.
3.1.2
Sistema mostra página inicial de Login.
3.1.3
Caso de uso encerrado.
Fluxo alternativo 4.1: Usuário não preenche alguma das informações
obrigatórias.
4.1.1
Sistema valida as informações submetidas e exibe mensagem “Digite
os campos marcados com asterisco(*).”
4.1.2
Volta ao passo 3.
Fluxo alternativo 4.2: Usuário tenta cadastrar um usuário já existente no
sistema.
4.2.1
Sistema valida as informações submetidas e exibe mensagem “Usuário
já existente no sistema”.
4.2.2
Volta ao passo 3.
Fluxo alternativo 4.3: Usuário preenche campo senha e confirmação de senha
diferentes.
4.3.1
Sistema valida as informações submetidas e exibe mensagem
“Campos Senha e Confirmação de Senha devem ter informações
iguais”.
4.3.2
Volta ao passo 3.
49
Diagrama de Sequência do Caso de Uso Criar Conta – Cenário 1:
: Usuário
: PaginaCadastroUsuario : PaginaPerfilUsuario
: CadastrarUsuarioAction
Cenário 1, passo
4. Sistema valida
se o usuário
digitado já existe
na bas e de dados.
1: linkCadastrarUsuario()
2: execute()
Cenário 1, passo 1.
3: isCamposValidos()
Cenário 1, passo 4. Sistema
valida se os campos obrigatórios
estão preenchidos e se o campo
Senha e Confirmação de Senha
estão iguais.
4: isSenhasCorretas()
usuarioServices :
UsuarioServices
dao : DAO
5: cadastrarUsuario(Usuario usuario)
6: procurarLogin(String login)
7: Usuario usuario
8: salvaOuAtualiza(Usuario usuario)
9: load()
Cenário 1, passo 6.
A tela de perfil do
usuário é mostrada.
Cenário 1, passo 5.
Sistema persis te as
informações do usuário
na bas e da dados.
Figura 25 – Diagrama de Sequência UC - Criar Conta
50
Caso de Uso Solicitar Relacionamento dos Bichinhos
Documento de Caso de Uso
Usuário
Solicitar Relacionamento dos
Bichinhos
(from Use Case Vi ew)
(from Use Case Vi ew)
Figura 26 – Caso de Uso Solicitar Relacionamento dos Bichinhos
Realização do Caso de Uso
Caso de Uso: Solicitar Relacionamento dos Bichinhos
Versão do Documento: 1.0
Descrição:
Pré Condição: O Usuário deve possui uma conta no sistema e estar conectado na
tela de Perfil.
Cenário 1: Usuário realiza relacionamento com outro bichinho com sucesso.
1. Usuário clica no link “Comunidade” na tela de perfil.
2. Sistema abre tela, que contém a lista de bichinhos do usuário.
3. Usuário escolhe um de seus bichinhos na tela
4. Usuário clica no link “Prosseguir” para solicitar a lista de bichinhos
relacionáveis.
5. Sistema exibe tela com uma lista de bichinhos relacionáveis.
6. Usuário escolhe um bichinho da lista.
7. Sistema faz confirmação para efetivar a solicitação com a seguinte
mensagem: “Deseja relacionar-se com o bichinho escolhido?”.
8. A opção Sim é escolhida pelo usuário.
9. Sistema envia uma mensagem para o usuário do bichinho escolhido na lista.
51
10. Sistema retorna para a tela de perfil do usuário e exibe a mensagem
“Solicitação de relacionamento enviada.”
11. Caso de uso encerrado.
Fluxo alternativo 2.1: Usuário não possui nenhum bichinho seu apto para o
relacionamento na Comunidade.
2.1.1
Sistema exibe a mensagem “Você não possui nenhum bichinho apto
para o relacionamento na comunidade. Jogue mais!”
2.1.2
Caso de Uso encerrado
Fluxo alternativo 3.1: Usuário cancela a escolha de um dos seus bichinhos.
3.1.1
Usuário aperta botão “Fechar”.
3.1.2
Sistema fecha a tela de escolha de um dos seus bichinhos.
3.1.3
Caso de Uso encerrado.
Fluxo alternativo 5.1: Sistema não encontra nenhum bichinho na comunidade
para o relacionamento.
5.1.1
Sistema não exibe nenhum bichinho para o relacionamento.
5.1.2
Sistema exibe mensagem “Nenhum bichinho disponível para o
relacionamento.”
5.1.3
Caso de Uso encerrado.
Fluxo alternativo 8.1: Usuário escolhe a opção Não.
8.1.1
Na caixa de confirmação do relacionamento o Usuário clica no botão
“Não”
8.1.2
Sistema não efetiva a solicitação de relacionamento.
8.1.3
Caso de Uso encerrado.
52
Diagrama de Sequência do Caso de Uso Solicitar Relacionamento dos
Bichinhos – Cenário 1:
: Usuário
: PaginaPerfilUsuario : PaginaEscolherBichinho : PaginaComunidade : SelecionarBichoAction
1: linkComunidade
:
:
BuscarBichosRelacio... SolicitarRelacionam e...
2: execute()
Cenário 1, passo
1.Início da
funcionalidade.
3: load()
Cenário 1, passo 2. Sistema exibe os bichinhos
do usuário que estão aptos a se relacionar.
4: linkProsseguir
5: execute()
6: getBichosRelacionaveis(Bicho)
Assim que usuário escolheu um de
seus bichinhos, ele clica no link
Prosseguir para dar continuidade ao
processo.
bichoServices :
BichoServices
dao : DAO
7: listarBichos()
8: List bichos
9: load()
Tela da comunidade Gene é
mostrada contendo os
bichinhos que o usuário pode
escolher para solicitar o
relacionamento.
Pelo id do bicho
escolhido é buscado
seu usuário.
10: linkBichinho
11: execute()
12: getDestinatario(String idBicho)
Cenário 1, passo 6. Usuário clica em cima
de um dos bichinhos da lista mostrada na
tela.
mensageServices :
MensagemServices
13: gerarMensagem Relacionamento(Usuario remetente, Usuario destinatario)
14: Mensagem mensagem
usuarioServices :
UsuarioServices
15: salvaOuAtualiza(Usuario destinatario)
Cenário 1, passo 10. Usuário retorna a sua
tela de perfil e a mensagem "A Solicitação
de Relacionamento foi enviada."
16: salvaOuAtualiza(Usuario usuario)
17: load()
Cenário 1, passo 9. Atualiza o usuário destinatário
que agora contém uma mensagem de solicitação
de relacionamento associada a ele.
Figura 27 – Diagrama de Sequência UC - Solicitar Relacionamento dos Bichinhos
53
Caso de Uso Avaliar Relacionamento dos Bichinhos
Documento de Caso de Uso
Usuário
Avaliar Relacionamento dos
Bichinhos
(from Use Case Vi ew)
(from Use Case Vi ew)
Figura 28 – Caso de Uso Avaliar Relacionamento dos Bichinhos
Realização do Caso de Uso
Caso: Avaliar Relacionamento dos Bichinhos
Versão do Documento: 1.0
Descrição:
Pré Condição: O Usuário deve possui uma conta no sistema e ter uma solicitação
de relacionamento pendente.
Cenário 1: Usuário aceita a solicitação de relacionamento.
1. Sistema disponibiliza aviso de nova mensagem na tela de perfil.
2. Usuário clica no botão Correio para visualizar a mensagem.
3. Usuário clica no botão “Aceitar” da mensagem para efetivar o relacionamento.
4. Uma mensagem de aceitação do relacionamento é enviada pelo sistema ao
solicitante do relacionamento.
5. Sistema fecha tela de Correio e atualiza tela do perfil.
6. Sistema mostra disponível ao Usuário um novo bichinho para ser criado.
7. Sistema torna disponível um novo bichinho para jogar também para o
solicitante do relacionamento.
8. Caso de Uso Encerrado
54
Fluxo alternativo 3.1: Usuário clica no botão Recusar da mensagem de
relacionamento recebida.
3.1.1
Usuário clica no botão “Recusar”.
3.1.2
Uma mensagem de relacionamento recusado é enviada pelo sistema
ao solicitante do relacionamento.
3.1.3
Caso de Uso encerrado.
Diagrama de Sequência do Caso de Uso Avaliar Relacionamento dos
Bichinhos – Cenário 1:
: Usuário
: PaginaPerfilUsuario : PaginaCorreio
1: linkCorreio
:
:
LoadCaixaMensagens... AceitarRelacionamen...
2: execute()
Cenário 1,
passo 2.
Usuário entra
na página de
correio onde
estão suas
mens agens.
Sistema carrega as mensagens
relacionadas ao usuário logado.
3: load()
Cenário 1, passo 3. Usuário
aceita o relacionamento,
desencadeando o processo
que habilita um bicho mais
evoluído ao usuários
rem etente e destinatário da
mensagem...
mensagemServices :
MensagemServices
usuarioServices :
UsuarioServices
dao : DAO
4: botão Aceitar
5: execute()
6: salvaOuAtualiza(Usuario destinatario)
7: salvaOuAtualiza(Us uario usuario)
8: gerarMensagemRelacionam entoAceito()
9: salvaOuAtualiza(Usuario remetente)
10: salvaOuAtualiza(Usuario usuario)
Cenário 1, pas so 6.Um novo bichinho m ais
evouído é habilitado para o usuário jogar.
11: load()
Atualização feita nos usuários
é salva na base de dados.
Figura 29 – Diagrama de Sequência UC - Avaliar Relacionamento dos Bichinhos