Manual do Usuário - LECH-GEIC - Universidade Federal de São

GEIC
Gerenciador de Ensino Individualizado por Computador
Versão 0.21
Manual do Usuário
Alex Fernando Orlando
Deisy das Graças de Souza
Lucas José dos Santos Souza
Maria da Graça Campos Pimentel
Cesar Augusto Camillo Teixeira
Julio Cesar Coelho de Rose
Raquel Melo Golfeto
Elenice Seixas Hanna
Leonardo Brandão Marques
GEIC 0.21 - Manual do Usuário
Copyright © 2016, Universidade Federal de São Carlos e/ou afiliadas. Todos os direitos reservados.
Autores: Alex Fernando Orlando, Deisy das Graças de Souza, Lucas José dos Santos Souza, Maria da Graça
Campos Pimentel, Cesar Augusto Camillo Teixeira, Julio Cesar Coelho de Rose, Raquel Melo Golfeto,
Elenice Seixas Hanna, Leonardo Brandão Marques
Este obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 3.0 Brasil (CC
BY-SA 3.0 BR). Você tem o direito de:
•
Compartilhar: copiar e redistribuir o material em qualquer suporte ou formato
•
Adaptar: remixar, transformar e criar a partir do material para qualquer fim, mesmo que comercial
O licenciante não pode revogar estes direitos desde que você respeite os termos da licença.
De acordo com os termos seguintes:
•
Atribuição: Você deve dar o crédito apropriado, prover um link para a licença e indicar se mudanças
foram feitas. Você deve fazê-lo em qualquer circunstância razoável, mas de maneira alguma que
sugira ao licenciante a apoiar você ou o seu uso
•
Compartilhar igual: Se você remixar, transformar, ou criar a partir do material, tem de distribuir as
suas contribuições sob a mesma licença que o original
•
Sem restrições adicionais: Você não pode aplicar termos jurídicos ou medidas de caráter tecnológico
que restrinjam legalmente outros de fazerem algo que a licença permita
Você não tem de cumprir com os termos da licença relativamente a elementos do material que estejam no
domínio público ou cuja utilização seja permitida por uma exceção ou limitação que seja aplicável.
Não são dadas quaisquer garantias. A licença pode não lhe dar todas as autorizações necessárias para o uso
pretendido. Por exemplo, outros direitos, tais como direitos de imagem, de privacidade ou direitos morais,
podem limitar o uso do material.
A licença completa pode ser consultada em http://creativecommons.org/licenses/by-sa/3.0/br/legalcode
Índice
1 Introdução: o que é o GEIC e para que serve?..........................................................................................................5
2 Usando o GEIC..........................................................................................................................................................8
2.1 Preparando seu computador..............................................................................................................................8
2.2 Java....................................................................................................................................................................9
2.3 VLC.................................................................................................................................................................11
2.4 Credenciais de acesso......................................................................................................................................11
2.5 Site...................................................................................................................................................................12
2.6 Módulos...........................................................................................................................................................13
3 Módulo de Autoria...................................................................................................................................................14
3.1 Estímulos.........................................................................................................................................................18
3.1.1 Recomendações gerais............................................................................................................................18
3.1.2 Figuras.....................................................................................................................................................19
3.1.3 Sons.........................................................................................................................................................20
3.1.4 Textos......................................................................................................................................................21
3.1.5 Frases.......................................................................................................................................................22
3.1.6 GIFs.........................................................................................................................................................23
3.1.7 Vídeos.....................................................................................................................................................24
3.2 Instruções.........................................................................................................................................................25
3.3 Consequências.................................................................................................................................................26
3.4 Tentativas.........................................................................................................................................................26
3.4.1 Conceitos básicos....................................................................................................................................27
3.4.2 Configurações comuns............................................................................................................................29
3.4.3 Tentativas CR..........................................................................................................................................39
3.4.4 Tentativas MTS.......................................................................................................................................41
3.4.5 Tentativas NOM......................................................................................................................................43
3.4.6 Tentativas Mult........................................................................................................................................44
3.4.7 Tentativas Leit.........................................................................................................................................46
3.5 Blocos..............................................................................................................................................................49
3.6 Passos...............................................................................................................................................................60
3.7 Programas........................................................................................................................................................64
4 Módulo de Projetos..................................................................................................................................................70
4.1 Membros da equipe.........................................................................................................................................71
4.2 Escolas.............................................................................................................................................................75
4.3 Todos os alunos...............................................................................................................................................76
4.4 Projetos............................................................................................................................................................80
4.4.1 Matrículas................................................................................................................................................85
4.4.2 Sessões executadas..................................................................................................................................88
5 Módulo de Sessões...................................................................................................................................................92
5.1 Acesso como tutor...........................................................................................................................................93
5.2 Acesso de aluno...............................................................................................................................................99
6 Módulo de Sessões (desconectado).......................................................................................................................101
6.1 Preparação do pendrive.................................................................................................................................101
6.2 Download dos programas de ensino.............................................................................................................102
6.3 Iniciando as sessões.......................................................................................................................................102
6.4 Execução da sessão.......................................................................................................................................103
6.5 Salvamento dos dados da sessão...................................................................................................................103
6.6 Upload dos dados da sessão..........................................................................................................................103
7 Módulo de Análise.................................................................................................................................................104
8 Administrando o Site..............................................................................................................................................114
8.1 Notícias..........................................................................................................................................................114
8.2 Documentos...................................................................................................................................................115
8.3 Publicações....................................................................................................................................................117
9 Notificações e mensagens......................................................................................................................................119
9.1 Notificações...................................................................................................................................................119
9.2 Mensagens.....................................................................................................................................................120
iii
10 Agradecimentos....................................................................................................................................................123
4
1 Introdução: o que é o GEIC e para que serve?
Este manual é um guia para todos os usuários do GEIC, o Gerenciador de Ensino Individualizado por
Computador. Aqui estão descritos em detalhes toda a estrutura do sistema, os recursos disponíveis, dicas
importantes e boas práticas. Mas o que exatamente é o GEIC e como ele surgiu?
O GEIC é uma plataforma de software voltada para a autoria e a aplicação de programas de ensino
individualizados, possuindo também recursos para o gerenciamento de recursos humanos, tais como tutores
e alunos, além de ferramentas para a consulta de resultados e geração de relatórios. O termo “plataforma”
não é usado ao acaso: o GEIC é composto por módulos independentes, cada um voltado para uma finalidade
e um público-alvo específicos. Exemplos incluem os módulos Autoria, Sessões e Projetos.
Seu desenvolvimento veio atender a uma necessidade inicial de ensino e pesquisa sobre aprendizagem de
leitura e escrita, que posteriormente foi expandido para outros processos. Desde meados da década de 80, o
Laboratório de Estudos do Comportamento Humano (LECH), na Universidade Federal de São Carlos
(UFSCar), coordenado por Julio Cesar Coelho de Rose, estabeleceu, como um de seus objetivos,
desenvolver um currículo suplementar para ensino de leitura de fácil aplicação. Esta proposta foi motivada
por duas constatações: o enorme contingente de alunos do ensino fundamental que fracassam na
aprendizagem de leitura e a dificuldade que um professor enfrenta para lidar com muitos alunos e atender
tanto os que avançam rapidamente, como os que demandam um atendimento mais individualizado.
Para enfrentar essa dificuldade, era necessário planejar e avaliar a viabilidade de módulos de ensino que
pudessem ser aplicados individualmente. Os primeiros estudos foram realizados com materiais
convencionais, tais como folhas de papel, mas em 1998 foi desenvolvido um software chamado Progleit que
permitiu informatizar os procedimentos. Contudo, esse software apresentava limitações para gerenciar a
aplicação dos programas de ensino a um grande contingente de alunos e atender ao interesse de escolas em
diferentes locais. O GEIC foi concebido como uma plataforma para atender a esta demanda crescente.
Atendendo a princípios de programação de ensino, o currículo suplementar foi concebido como conjuntos de
tarefas sob a forma de tentativas discretas, organizadas em sequência. Uma tentativa consiste em uma
pequena unidade de trabalho que inclui uma instrução, à qual o aluno deve responder de modo ativo; a
resposta é seguida por um feedback (de acerto ou de erro), que finaliza a tentativa e dá início a um pequeno
intervalo, após o qual tem início uma nova tentativa. Tentativas discretas são, portanto, bastante apropriadas
para apresentação por meio de computador e um conjunto desse tipo de tentativas pode apresentar a
quantidade de conteúdo considerada apropriada para cada etapa de ensino.
Em 2007 o LECH estabeleceu uma parceria com o Laboratório de Inovação em Computação e
Engenharia (LINCE), também da UFSCar e dirigido pelo professor Cesar Augusto Camillo Teixeira.
Juntos, eles atuaram no contexto de um projeto maior denominado Tecnologia da Informação para o
Desenvolvimento da Internet Avançada - Aprendizado Eletrônico (TIDIA-Ae fase 2), financiado pela
Fundação de Amparo à Pesquisa do Estado de São Paulo (FAPESP).
O projeto TIDIA-Ae, de âmbito nacional, era dividido em núcleos com focos e responsabilidades distintos. O
núcleo São Carlos – Intermídia, encabeçado pelo Laboratório Intermídia do Instituto de Ciências
Matemáticas e de Computação (ICMC-USP), dirigido pela professora Maria da Graça Campos
Pimentel, coordenou o projeto, no qual os laboratórios LECH e LINCE participaram, respectivamente, como
Laboratório Associado e como Laboratório de Desenvolvimento Associado. Juntos, esses laboratórios
usaram técnicas de engenharia de software e computação distribuída na busca de uma solução que visasse
proporcionar a redução dos custos envolvidos na criação, aplicação e gerenciamento de programas
individualizados, além de permitir a difusão desses métodos de ensino em larga escala.
5
A equipe do LECH, constituída por Julio Cesar Coelho de Rose, Deisy das Graças de Souza e Drausio
Capobianco, se encarregou da definição das características funcionais esperadas da plataforma. Dois
membros do LINCE, Alex Fernando Orlando e Rodrigo Estevan Bela, à época alunos de mestrado no
Programa de Pós-Graduação em Ciência da Computação, dedicaram seus projetos de pesquisa
integralmente a esse tema: o primeiro voltado para questões como engenharia de software e computação
distribuída, e o segundo voltado para bancos de dados, recuperação da informação e ontologias.
E assim, por volta de 2007, surgiu o GEIC – sigla que descreve os objetivos principais que lhe deu origem:
“gerenciar” atividades de “ensino”, de forma “individualizada”, contando, para isto, com o computador! Em
2008 começou a ser aplicado um primeiro módulo de ensino e foram coletados os primeiros registros e desde
então, têm crescido as demandas por refinamento e ampliação de funções do GEIC; os progressos alcançados
sugerem que ainda há muito por fazer e que as possibilidades são muito promissoras.
Essa plataforma trouxe contribuições aos especialistas de domínio de várias áreas (psicologia, educação
especial, pedagogia etc.) e alunos com dificuldades de aprendizagem. A solução desenvolvida se mostrou
genérica e vem sendo usada em uma ampla variedade de procedimentos, com objetivos de pesquisa, de
ensino, ou de ambos, mostrando-se mais versátil do que o previsto inicialmente. Apesar de concebido para
implementar um currículo de ensino de leitura, o sistema apresenta potencial para o ensino de outros
conteúdos que possam ser apresentados no formato de tentativas discretas, como matemática e até mesmo
para reabilitação auditiva de indivíduos deficientes auditivos e usuários de implante coclear.
Com o fim do projeto TIDIA-Ae, a responsabilidade sobre o GEIC foi assumida pelo Instituto Nacional de
Ciência e Tecnologia sobre Comportamento, Cognição e Ensino (INCT-ECCE). Em paralelo a isso, uma
empresa derivada (spin-off) chamada bluedotsoft foi criada por um dos membros da equipe original para
tratar de assuntos como análise de requisitos, projeto e programação.
A adoção em larga escala da plataforma GEIC trouxe vários desafios ao projeto. Se no início havia algumas
dezenas de alunos executando sessões de aprendizagem, com o tempo esse número saltou para os milhares.
Com isso, foram necessários investimentos tanto na infraestrutura computacional (ex: mais computadores),
gestão de pessoas (mais coordenadores e tutores) e treinamento técnico para a equipe.
Este manual é justamente uma forma de auxiliar o treinamento técnico para que os usuários possam atuar no
GEIC como pesquisadores, coordenadores, analistas de dados, programadores de ensino, gestores e tutores.
Ele não deve ser encarado como uma especificação completa da plataforma mas sim como um tutorial,
amigável e objetivo. Assim, é possível ler apenas os capítulos que tiverem relação com seu dia a dia.
6
O restante do manual está estruturado da seguinte forma:
O Capítulo 2 apresenta os pré-requisitos para que o GEIC possa ser usado e dá uma visão geral dos papéis
de usuário, permissões e módulos disponíveis. Leitura importante para quem está começando a usar o GEIC.
O Capítulo 3 cobre o módulo de autoria e suas atividades, ensinando com exemplos como criar os
componentes de um programa de ensino completo. Voltado principalmente a programadores de ensino.
O Capítulo 4 lida com o módulo de gerenciamento de projetos e com a gerência de recursos humanos e de
projetos do sistema. Essencial para coordenadores, gestores e tutores.
Os Capítulos 5 e 6 mostram como alunos e tutores podem usar o módulo de sessões para executar os
programas desenvolvidos no módulo de autoria.
O Capítulo 7 explica como funciona o módulo de análise e ensina como usá-lo a fim de se obter o máximo
de informações a partir das sessões executadas. Todo analista de dados e coordenador de projeto deveria ler!
O Capítulo 8 descreve o módulo de administração do site, ensinando como cadastrar, editar e remover
notícias, documentos e publicações relacionados ao GEIC. Interessante para os administradores de sistema.
O Capítulo 9 descreve os recursos de notificações e mensagens, ensinando como visualizar notificações e
criar, consultar e enviar mensagens.
O Capítulo 10 enumera algumas das pessoas que fizeram (ou ainda fazem) parte da equipe responsável pelo
GEIC.
O texto está organizado com subtítulos, visando facilitar a identificação dos tópicos e enfatizar o assunto
tratado. Notas que requerem atenção a detalhes técnicos são destacadas em caixas de texto com fundo
colorido como a seguinte:
O conteúdo desta caixa de texto requer atenção redobrada por parte do leitor, já que aqui serão
abordados detalhes técnicos, erros comuns cometidos pelos usuários, situações a se evitar etc.
7
2 Usando o GEIC
Um dos requisitos iniciais que guiaram o desenvolvimento do GEIC foi a facilidade de uso. Diferente de
sistemas anteriores, que em muitos casos forçavam os pesquisadores a usarem interfaces complicadas e
ultrapassadas, no GEIC as interfaces de usuários são gráficas e bastante amigáveis.
Outra facilidade do GEIC é que tudo o que é feito nele, como por exemplo programas de ensino e pesquisas,
é armazenado automaticamente em servidores da UFSCar. Isso significa que seu trabalho não fica salvo no
seu próprio computador, aumentando assim a segurança dos dados e protegendo-os de vírus e de perdas
devido a panes de energia. Significa também que uma vez construído um programa de ensino, este pode ser
executado a partir de qualquer computador conectado à Internet, em qualquer lugar do mundo.
Porém, alguma preparação é necessária para garantir que o sistema seja executado tranquilamente e sem
surpresas. Nas próximas seções é explicado o que seu computador precisa ter para executar o GEIC, como
navegar pelo site, de que papéis (atribuições) e permissões você precisará e como são divididos os módulos.
2.1 Preparando seu computador
Todo o acesso ao GEIC é feito pelo seu computador por meio da Internet, o que significa que duas coisas são
absolutamente essenciais para você começar a usar o sistema: que você tenha um computador compatível e
que ele tenha acesso à Internet.
Por computador compatível entende-se um computador pessoal (PC) com sistemas operacionais Microsoft
Windows, Linux ou Mac OS X. Exemplos de sistemas que se encaixam nessa descrição: Microsoft Windows
8, Ubuntu 14.04, Linux Educacional 5.0, Mac OS X 10.9 etc. Sistemas móveis como iOS, encontrado em
dispositivos iPhone e iPad, e Android, encontrado em celulares e tablets como Samsung Galaxy, Motorola X
etc., ainda não são suportados.
A Internet é outro ponto fundamental. Sem acesso a ela você não conseguirá sequer acessar a página do
GEIC para executar os módulos. Mas isso não significa que seja exigida uma conexão com a Internet muito
poderosa, bastando algo em torno de 512 kbps (metade de 1 mega por segundo) . Há usuários acessando o
GEIC via redes sem fio (Wi-fi), redes cabeadas (aqueles cabos azuis), redes de dados (3G) etc.
Dado que o acesso ao GEIC é feito pela Internet, é necessário também que você tenha instalado no seu
computador um navegador, como por exemplo Mozilla Firefox, Google Chrome, Apple Safari ou Microsoft
Internet Explorer. A experiência sugere que o Firefox é o navegador mais recomendado por ser seguro,
rápido, fácil de usar e gratuito.
Também é necessário tomar nota de alguns detalhes do seu computador, mais especificamente do sistema
operacional. O sistema operacional é aquele primeiro programa exibido na tela após o computador ser ligado,
como por exemplo Microsoft Windows ou Ubuntu. Em geral esses sistemas podem ser classificados como
sendo de 32-bit (mais antigos) ou 64-bit (mais modernos), e será essencial sabermos com qual deles seu
computador se identifica.
Se seu computador estiver operando com o Microsoft Windows 7 clique com o botão direito no “Meu
Computador” e selecione “Propriedades”. Deverá ser exibida uma tela semelhante à da Figura 1, com a
indicação de 32 ou 64-bit em “Tipo de sistema”, conforme destacado. No Microsoft Windows XP, exceto
quando explicitamente informado, o sistema sempre é 32-bit. Por sua vez, no Microsoft Windows 8, digite
“sistema”na página principal.
8
Figura 1: Determinando a arquitetura do Windows
No Linux e no Mac OS X, uma forma simples de descobrir a mesma informação é executando os aplicativos
Terminal ou Console e digitando o comando “uname -m”. Se no texto exibido na tela houver algo parecido
com “i686” ou “i386”, o sistema é 32-bit. Se o texto for “x86_64”, o sistema é de 64-bit.
2.2 Java
Uma vez que a preparação básica tenha sido feita, é hora de partir para configurações mais avançadas e o
próximo passo é a instalação de um programa chamado Java (versão 8). Para isso, comece acessando o site
oficial do Java em http://java.com/pt_BR/download/manual.jsp. Se o seu sistema for 32-bit, baixe a versão
“Windows Off-line” ou “Linux”. Se for 64-bit, a versão correta é “Windows Off-line (64-bit)”, “Mac OS X”
ou “Linux x64”.
Antes de prosseguir, certifique-se de que o Java já não esteja instalado em seu computador.
Geralmente não é boa ideia ter duas versões do Java instaladas em mesmo tempo, porque elas
costumam entrar em conflito e impedir outros aplicativos de executar.
O instalador para Microsoft Windows é bem intuitivo: siga as orientações até concluir. Tome cuidado para
não permitir a instalação de outros programas, propagandas e promoções indesejadas!
Em sistemas baseados em Linux é preciso um pouco mais de habilidade, por isso essa tarefa geralmente é
feita por um administrador de sistemas. Em resumo, é necessário descompactar o instalador (geralmente com
extensão tar.gz) em alguma pasta como /opt/java.
No Mac OS X basta executar o arquivo com extensão dmg baixado. Tão fácil quanto no Microsoft Windows!
9
Para conferir se o Java foi instalado com sucesso, em sistemas Microsoft Windows vá até o Painel de
Controle e certifique-se de que haja um item Java. Em sistemas Mac OS X, confira a mesma coisa, porém
nas Preferências do Sistema. Já em sistemas baseados em Linux, vá até o console e digite:
java -version
Se tudo correr bem, a saída será algo parecido com:
java version "1.8.0_45"
Java(TM) SE Runtime Environment (build 1.8.0_45-b13)
Java HotSpot(TM) Client VM (build 24.45-b03, mixed mode, sharing)
Como o GEIC é acessado on-line, o Java impõe algumas restrições de segurança para que sejam evitados
roubos, fraudes etc. Para autorizar o Java e GEIC a acessarem sua Internet, vá até as configurações do Java.
No Microsoft Windows, acesse o Painel de Controle e selecione a opção Java. Em sistemas Linux, no
Terminal execute “ControlPanel”. No Mac OS X vá até Preferências do Sistema e selecione Java. Você
deverá ver algo parecido com a Figura 2.
Figura 2: Configurações de segurança do Java
Selecione a aba “Segurança” e em seguida “Editar Lista de Sites”. Você verá então uma janela como a da
Figura 3.
10
Figura 3: Adicionando o GEIC às exceções do Java
Clique em “Adicionar”, digite o endereço do GEIC (http://geic.ufscar.br/) e depois em “OK”.
2.3 VLC
O GEIC permite a exibição de vídeos. Para isto é necessário também instalar o tocador de vídeos VLC. O
tocador está disponível em http://www.videolan.org/vlc/#download. Atenção: a versão de VLC baixada deve
ser compatível com o sistema operacional (32 ou 64-bit). Para Microsoft Windows, a versão 64-bit aparece
apenas em http://www.videolan.org/vlc/download-windows.html, na opção “Download VLC for Windows
x64”. Para Linux há diversos links de acordo com sua distribuição (Ubuntu, Mint, Fedora etc.) com
instruções que facilitam a instalação.
A pasta onde o VLC será instalado não deve ser mudada, ou seja, a pasta padrão deve ser mantida.
Em sistemas Microsoft Windows, essa pasta costuma ser “C:\Program Files\VideoLAN\VLC ou
C:\Arquivos de Programas\VideoLAN\VLC”
2.4 Credenciais de acesso
Se você chegou até aqui então provavelmente seu computador está pronto para rodar o GEIC, porém isso não
significa que você tenha permissão para isso! Sem as devidas credenciais (nome de usuário e senha) não será
possível executar módulo algum.
Em geral, se você já participa de um projeto no GEIC, então a coordenação desse projeto é responsável por
cadastrar e credenciar usuários e deverá ser consultada para as devidas permissões.
Caso você ainda não faça parte de um projeto e deseje usar o GEIC em sua pesquisa, entre em contato com
nossa equipe pelo e-mail [email protected]. Para adiantar o processo, informe no corpo do e-mail seus
dados pessoais como nome completo, endereço, telefone, e-mail, assim como os dados do seu orientador,
projeto de pesquisa, escola ou laboratório associado etc. e a razão pela qual pretende usar o GEIC.
11
2.5 Site
O GEIC deve ser acessado diretamente através do site http://geic.ufscar.br/. A página inicial, ilustrada na
Figura 4, contém uma breve descrição do projeto, o formulário para acesso, alguns links com instruções de
como acessar o sistema, documentação (incluindo este manual), publicações acadêmicas que citam ou se
relacionam de alguma forma com o GEIC etc.
Figura 4: Página inicial do site do GEIC
Para continuar, forneça seu nome de usuário e sua senha e acesse a área interna do site. Você
cumprimentado com uma página semelhante à da Figura 5.
será
então
Figura 5: Área interna do site
12
Na parte central da página ficam algumas notícias e avisos, tais como os horários em que o sistema ficará
indisponível (para fins de manutenção), anúncios de novas versões e funcionalidades, entre outros. Já à
direita são exibidas algumas estatísticas sobre o sistema, como quantas cidades atualmente o utilizam,
quantas escolas estão cadastradas e quantas vezes os programas de ensino foram executados.
Há ainda uma observação com um link com dicas sobre formatos recomendados de imagens, sons e vídeos
para serem usados no sistema, informações de direitos autorais etc. Mais sobre isso na seção 3.1.1.
Na parte esquerda da página o usuário tem acesso aos módulos disponíveis.
2.6 Módulos
É através dos módulos do GEIC que um usuário fará seu trabalho, como por exemplo criar um programa de
ensino ou aplicar uma sessão. Dependendo do que lhe for permitido, mais ou menos módulos serão exibidos
nessa tela.
Itens desenvolvidos a partir de um módulo podem ficar disponíveis para outros usuários. Por exemplo, um
usuário pode criar um programa de ensino no módulo de Autoria, e esse programa passa a ser acessado por
outro usuário no módulo de Projetos. Esse outro usuário pode juntar esse e outros programas em um projeto
e matricular alunos e professores para utilizá-lo. Um tutor, em outro momento, pode executar o módulo de
Sessões, onde verá o projeto em que foi cadastrado e acompanhará um aluno que irá executar os programas
de ensino associados ao projeto. Ainda outro usuário, por sua vez, pode executar o módulo de Análise para
verificar o progresso de um aluno e saber quantos e quais programas foram executados em um determinado
período de tempo.
Desta forma, é possível isolar as funcionalidades de cada módulo e gerenciar corretamente os papéis de cada
usuário do sistema, ao mesmo tempo em que tudo o que é produzido fica integrado e organizado, tornando o
ensino (e a coordenação da equipe) muito mais eficientes.
Ao serem executados, alguns módulos exigem algumas confirmações de segurança, como pode ser visto na
Figura 6. Nesses casos, é seguro marcar a opção “Eu aceito o risco...” e clicar em “Executar”, como acontece
normalmente em muitos outros programas confiáveis.
Figura 6: Confirmação de segurança do Java
Nos capítulos seguintes os módulos do GEIC são discutidos, descritos e comentados minuciosamente.
13
3 Módulo de Autoria
No GEIC, um programa é uma sequência planejada de tentativas discretas (tarefas). Há vários razões pelas
quais alguém criaria um programa: para ensinar algo (ex: discriminar entre formas, ler palavras, escrever,
construir sequências de itens), para avaliar as habilidades de alguém (ex: um aluno reconhece, entre
diferentes palavras, a que corresponde a uma palavra ditada?) ou ainda para investigar processos de
aprendizagem (ex: em quantas tentativas uma criança pequena aprende o nome de um objeto?).
Os usuários que interagem com as tentativas são chamados, para fins de simplificação, de “alunos”, mesmo
que o programa não tenha a finalidade de ensino. Em um programa, um aluno interage diretamente com as
tentativas. Dependendo da tarefa, sua resposta pode ser clicar com o mouse sobre uma imagem (figura,
palavra impressa, foto, vídeo), apontar uma imagem ou falar em voz alta. A instrução para a tarefa pode ser
falada ou escrita; as tarefas podem apresentar imagens de diferentes tipos e em diferentes combinações.
Para que um programa atinja seus objetivos (de ensino, de avaliação ou de investigação) é preciso planejá-lo
cuidadosamente. Por exemplo, em um programa de ensino as tentativas podem ser programadas com
dificuldades gradualmente crescentes; ou o programa pode prever procedimentos de correção, como a
repetição de uma tentativa ou a apresentação de uma tentativa similar àquela em que o aluno apresentou uma
resposta incorreta. É comum a pessoa (ou a equipe) que organiza um programa ser uma especialista ou
pesquisadora, familiarizada com métodos de ensino e pesquisa, porém isso não é regra.
Não é simples construir, de uma só vez, um programa com centenas de tentativas. O GEIC permite que
programas sejam divididos em passos (evocando a ideia de “um passo de cada vez”), passos divididos em
blocos e blocos em tentativas. Assim, as tentativas são a menor unidade de um programa. Como será descrito
em outra seção, para construir uma tentativa será necessário prever a apresentação de um ou mais estímulos
(visuais, auditivos ou uma combinação de visuais e auditivos), assim como a apresentação ou não de
instruções e de feedback para as respostas do aluno.
Acessar o módulo de Autoria é muito simples: a partir do site, clique no link “Autoria” no lado esquerdo da
14
tela. Após alguns avisos de segurança, o módulo será apresentado.
Para que um usuário possa acessar o módulo de Autoria pelo site ele precisa ser programador de
ensino em ao menos um projeto (mais detalhes no Capítulo 4).
Uma visão geral do módulo de Autoria pode ser vista na Figura 7. A janela é dividida em abas para cada um
dos tipos de itens que poderão ser trabalhados, sendo uma aba só para programas, outra para passos, blocos,
tentativas etc. Note também o ícone de uma casa na barra da parte superior; essa barra é chamada de
breadcrumb e serve como um guia para saber qual “caminho” o usuário percorreu, isto é, por quais telas ele
passou, até chegar a uma determinada tela.
Figura 7: Aba de estímulos
As telas possuem diversos elementos tais como numerados na figura:
1. Botões gerais: permitem ações tais como criação e edição de um item selecionado na tabela. São
eles:
◦ Criar: permite criar um item que será armazenado no sistema e incluído na lista do GEIC. No
exemplo, como a aba “Estímulos” está selecionada, esse botão possui uma seta ao lado, e clicar
nele faz com que seja exibida uma lista dos tipos de estímulos que podem ser criados, que
incluem figuras, sons, textos, frases, GIFs (figuras animadas) e vídeos. Se a aba “Programas”
estivesse selecionada não haveria opções de criação, já que não há vários tipos de programas, e a
tela de criação seria exibida simplesmente ao clicar no botão.
◦ Editar: permite consultar um item e fazer alterações (ex: corrigir um nome)
15
◦ Duplicar: cria uma cópia idêntica ao item
◦ Remover: remove o item selecionado
◦ Permissões: permite controlar quem pode usar ou acessar um item, ou ainda quem é o dono
dele. Um exemplo pode ser visto na Figura 8
◦ Usos: resume onde o item está sendo usado (ex: um estímulo está sendo usado em várias
tentativas), tal como na Figura 9 (tentativas 18006, 17461, 17998 etc)
2. Buscar: caso o programador precise encontrar rapidamente um estímulo dentre os que aparecem na
lista, ele pode digitar alguma palavra (nome ou identificação). Os resultados serão então exibidos na
lista principal. Além disso, o usuário pode clicar em menus ao lado do texto “Buscar” para aprimorar
a busca; no exemplo, um dos menus permite buscar todos os estímulos, apenas os criados pelo
usuário ou certificados (estímulos escolhidos pela equipe por serem de alta qualidade e terem uso
frequente no sistema), e o outro menu permite buscar estímulos de todos os tipos ou de um tipo
específico, como apenas os de figura, apenas de som, apenas de texto etc.
3. Lista principal: é onde os itens cadastrados no sistema são exibidos. Ao selecionar um deles, o
programador pode clicar nos botões de edição para modificar cada item individualmente.
Independente de qual aba estiver selecionada, alguns campos sempre serão exibidos na tabela:
◦ Nome: o nome escolhido para diferenciar um item. É sempre bom usar nomes que façam
sentido, como por exemplo “gravura – bicicleta” ao invés de termos genéricos como “figura 2”,
pois isso facilita o trabalho de todos no futuro.
◦ Permissões: cada ícone possui um significado. A chave indica que o programador é dono
daquele item (e portanto tem todas as permissões sobre ele), um triângulo (play) indica que o
item pode ser usado para compor coisas mais complexas, o papel com lupa e lápis indica que o
programador pode editar aquele item e a estrela indica que o item é certificado. Essa estrela só é
exibida para estímulos, instruções e consequências, que são os itens que utilizam esse conceito
de certificação.
◦ Identificação: é um número gerado e incrementado automaticamente que o GEIC atribui a tudo
o que é cadastrado, como se fosse um documento. Em geral, é mais fácil se comunicar com sua
equipe dizendo “Remova a tentativa 123” do que “Remova a tentativa de discriminação simples
com modelo de tatu e comparações tatu, aluno e dado”.
4. Filtrar por texto: parecido com o campo de busca, mas serve apenas para filtrar o que já está na
tela, simplificando o trabalho do programador. Muito útil quando há centenas de itens na tabela e
você está interessado apenas naqueles que possuem a palavra “bola”.
5. Paginação: como às vezes há muitos itens na tela (pense em algo maior que 1000), é mais fácil e
eficiente organizá-los em páginas. O programador pode trocar de página usando as setas nessa área,
bem como digitar qual a página exata que deseja consultar, e ainda escolher quantos itens por página
serão exibidos.
16
Figura 8: Permissões de um estímulo
Figura 9: Usos de um estímulo
Muito importante sobre o GEIC é que ele é uma plataforma Web colaborativa, ou seja, várias pessoas podem
acessá-lo simultaneamente pela Internet e participar na criação de um mesmo objeto de aprendizagem. Essa
facilidade às vezes acaba motivando discussões e confusões justamente sobre o compartilhamento de
objetos. Para resolver isto, devem ser tomados cuidados especiais.
Uma vez que você criou um objeto, seja ele um estímulo, tentativa, bloco etc. e outra pessoa passa a usá-lo
(porque você deu permissão explicitamente), você perderá a chance de voltar a editá-lo. Isso serve para
garantir, por exemplo, que um estímulo de figura “bolo”, usado por centenas de tentativas, simplesmente não
seja mudado para “ave” e potencialmente arruíne o trabalho de vários pesquisadores. A mesma regra vale
para tentativas usadas nos blocos de outras pessoas e assim por diante.
Há uma exceção para essa regra: se você é dono de uma unidade (ex: estímulo) ou tem permissão para alterála, e também é dono de / pode alterar todas as tentativas que usam esse estímulo e assim por diante, você fica
17
livre para alterar o que quer que seja. Por conta disso, às vezes é uma boa ideia divulgar seu programa (e
permitir que outras pessoas o usem/alterem) apenas quando ele estiver em um estágio avançado.
Há ainda mais uma regra: se um programa for disponibilizado para uso (mais sobre isso na Seção 3.7) tudo o
que é usado dentro dele (estímulos, tentativas, blocos etc) fica permanentemente bloqueado. Isso porque
no momento em que você cogitar editar um programa disponibilizado ele pode estar sendo executado por
uma criança (e não seria adequado os estímulos mudarem enquanto ela estuda!).
Ok, até agora vimos os elementos comuns a todas as abas. Nas próximas seções discutiremos os detalhes de
cada uma delas, começando pela peça mais fundamental de um programa: o estímulo.
3.1 Estímulos
No contexto do GEIC e dos programas informatizados nesta plataforma, um estímulo é qualquer coisa
apresentada na tela do computador ou por meio de seus alto-falantes. Ele pode ser apresentado nas
modalidades visual, auditiva, ou como uma combinação auditivo-visual.
O GEIC suporta vários tipos de estímulos, tais como figuras, sons, textos, frases, GIFs animados e vídeos. É
possível ainda combinar dois estímulos em um só (gerando um estímulo composto), como por exemplo uma
figura e um texto. Em breve entraremos em mais detalhes.
Voltando à Figura 7, as particularidades da aba de estímulos são:
•
Criar (1): as opções aqui são criar figura, som, texto, frase, GIF e vídeo
•
Buscar (2): no primeiro menu, à esquerda, há a opção “certificados” além das comuns “todos” e
“criados por mim”; no segundo menu, à direita, as opções são figura, som, texto, frase, GIF e vídeo,
além de uma opção TODOS
•
Observe também que na tabela presente na figura há uma coluna “Tipo” à esquerda da coluna
“Nome”. Ela serve para ajudar o programador a diferenciar os estímulos (figura, som, texto, etc)
quando houver vários tipos misturados na tela e, especialmente, quando for importante dar o mesmo
nome para uma figura e um texto (por exemplo, figura de pato e palavra pato)
3.1.1 Recomendações gerais
Antes de prosseguirmos, convém fazer uma pausa e falar sobre a qualidade dos estímulos do GEIC. Todos os
especialistas com acesso ao módulo de Autoria podem inserir seus próprios estímulos, porém a falta de
atenção a alguns detalhes pode prejudicar a experiência de todos os usuários. Por isso, foi elaborada uma
série de sugestões sobre como criar mídias que expressem bem seu conteúdo e que sejam eficientes em
termos computacionais.
Então, antes de criar você mesmo seus estímulos:
•
Consulte outros especialistas (e seu orientador/supervisor) que já tiveram de lidar com esse mesmo
tipo de tarefa. As chances são grandes de que eles saibam como otimizar o processo, ou ainda que
conheçam pessoas ou empresas especializadas.
•
Caso você deseje usar figuras, sons ou vídeos encontrados na Internet, certifique-se de que você
tenha permissão para usá-los. Apesar de poder copiá-los por meio de seu navegador, isso não
significa que você tenha direitos legais para adotá-los em seus programas de ensino.
•
Caso você precise criar seus próprios estímulos, leve em consideração que eles poderão ser
disponibilizados a todos os pesquisadores que usam o GEIC. Então, preocupe-se com a qualidade
18
deles.
• Consulte um especialista no assunto. Há vários estúdios e artistas que podem auxiliá-lo na criação
das imagens, sons e vídeos!
• Como citado anteriormente, existem estímulos, instruções e consequências especiais escolhidos pela
equipe que possuem alta qualidade e diversos usos no sistema, chamados “certificados”. Eles são
disponibilizados para todos os programadores e não podem ser alterados; se eles se encaixarem nas
suas necessidades, procure utilizá-los em vez de criar os seus próprios.
Nas seções a seguir, formato de armazenamento se refere aos estímulos em formato bruto, assim como eles
foram gravados no estúdio ou desenhados, e servem apenas para se ter acesso ao trabalho original (backup).
Esses originais normalmente são muitos grandes (ocupam muito espaço em disco), e é inviável usá-los nos
módulos de Autoria ou de Sessões. Porém, com esses originais garante-se que, no futuro, eles possam ser
editados com mais facilidade.
Por outro lado, o formato de produção se refere aos estímulos em formato pronto para serem inseridos no
módulo de Autoria. Normalmente, para serem facilmente baixados pela Internet e rapidamente apresentados
no módulo de Sessões, esses arquivos precisam ser menores e com pior qualidade, porém ocupam o mínimo
de espaço em disco.
Estímulos que porventura não obedeçam aos critérios de qualidade mínimos estabelecidos pela equipe de
administração do GEIC podem vir a ser removidos. Para obter outras informações e esclarecimentos
adicionais, entre em contato com a equipe pelo e-mail [email protected].
3.1.2 Figuras
São consideradas “figuras” no GEIC todo tipo de imagem estática, seja ela uma gravura ou fotografia. De
modo geral, para se cadastrar uma figura já existente no seu computador basta dar um nome a ela e apontar o
local no seu computador onde ela se encontra, assim como ilustrado na Figura 10.
Figura 10: Criação de estímulo de figura
Algumas recomendações para criar as melhores figuras:
•
Disposição: fazendo face ao usuário, sem uso de perspectiva ou inclinação, com as laterais da
imagem alinhadas aos eixos X e Y.
19
•
Sombras (opcional): leves, com luz primária a mais ou menos a distância do olho do usuário até a
tela, e com a figura suspensa 3 cm.
•
Enquadramento: faça o melhor uso possível da área útil da imagem, mas sem ultrapassar os limites
dela (ex: se for a imagem de uma bicicleta, não deixe as rodas dela de fora!).
•
Fundo: transparente (não deixe fundos em cor sólida, tal como branco ou preto, a não ser que isso
seja relevante para o programa).
Sobre o formato dos arquivos:
Armazenamento
Produção
Tipo de arquivo
SVG (Scalable Vector Graphics) com PNG (Portable Network Graphics)
codificação UTF-8, ou o formato original da
imagem (TIFF, CDR etc.)
Dimensões
tamanho original do desenho
170 x 145 pixels (comparações) e de 170 a
415 x 145 (modelos)
Profundidade de cor
32 bits (RGBA, true color, 8 bits por canal)
Compressão
DEFLATE padrão (zlib)
Tabela 1: Formato dos estímulos de figura
3.1.3 Sons
Sons no GEIC são todos os estímulos exclusivamente audíveis, podendo ser efeitos sonoros (ex: barulho de
explosão), sons de animais (ex: piado de um pássaro), palavras ditadas (ex: pronúncia “bolo”), sentenças
faladas (ex: As duas meninas brincavam de roda no quintal, quando viram a pequena tartaruga escondida sob
a goiabeira) etc.
Cadastrar um estímulo de som é muito parecido com cadastrar uma figura, assim como pode ser conferido na
Figura 11. Para sua comodidade, é possível clicar no botão “tocar” (à esquerda) para conferir se você
selecionou o arquivo correto.
Figura 11: Criação de estímulo de som
20
Recomendações:
•
Sem pausas no começo e no final
•
Normalização de volume para todos os arquivos
•
Mesmo locutor em todos os arquivos
•
Uso de equipamento adequado (prefira microfones ao invés de webcams, headsets etc)
•
Sem ruído de fundo (prefira gravação em estúdio)
Sobre o formato dos arquivos:
Armazenamento
Produção (opção 1)
Produção (opção 2
Tipo de arquivo
WAV
WAV
MP3
Profundidade por amostra
16 bits
16 bits
16 bits
Frequência
44.1 ou 48 KHz
11 a 22 KHz
22 KHz (44 KHz em casos
específicos)
Canais
2 (estéreo)
1 (mono)
1-mono (2-estéreo
específicos)
Codificação
PCM
PCM
MP3
em
casos
Tabela 2: Formato dos estímulos de som
Instruções e consequências também são, teoricamente, estímulos. Porém, a fim de simplificar a
criação de programas, esses tipos de eventos são tratados em abas próprias.
3.1.4 Textos
Estímulos de texto são qualquer conteúdo escrito, sejam eles letras, sílabas, palavras, sentenças ou
parágrafos. Observe, na Figura 12, que o principal a ser feito é preencher os campos “Nome” (ex: “Jornal”) e
um “Conteúdo” (ex: também “Jornal”), ou seja, no caso de texto, o estímulo não precisa lido de um arquivo e
armazenado: ele é simplesmente digitado.
Além desses dois campos, é possível configurar a fonte e seus efeitos; o menu ao lado do texto “Fonte:”
exibe as famílias de fontes instaladas no sistema (ex: Arial, Comic Sans MS, DejaVu Sans etc.) e abaixo dele
há botões e caixas de seleção para efeitos, como deixar a fonte em negrito, itálico, sublinhado e riscado,
definir a cor do texto e a cor de fundo, mudar o espaçamento entre os caracteres e aumentar ou diminuir o
tamanho da fonte. No exemplo, a fonte foi definida como sendo da família “Courier New”, em negrito, com
tamanho 20 e cor vermelha. Se as caixas de seleção estiverem desmarcadas e a família de fonte selecionada
for “<padrão>”, o GEIC usará valores padrão pré-definidos. Ao lado do menu das famílias de fonte, o
conteúdo é repetido com os efeitos aplicados, permitindo a visualização de como esse texto deve aparecer ao
usuário que irá executar uma sessão.
O programador que for utilizar esses efeitos de fonte deve ter em mente que o estímulo pode não caber na
tela, de forma que alguns efeitos inesperados podem acontecer, como apenas parte do texto aparecer seguida
de reticências (ex: um texto “Paralelepípedo” aparecer como “Paral...”) ou um dos textos aparecer por cima
de outro, o que atrapalhará a execução da tentativa. Recomenda-se, portanto, que criações e usos desses
estímulos sejam devidamente testados, como será explicado mais adiante, para prevenir qualquer efeito
inesperado.
21
Vale ressaltar que o nome de um estímulo nunca é mostrado durante as tentativas, servindo apenas para
auxiliar na programação. Ainda no exemplo abaixo, o nome poderia bem ser “Jornal – primeira letra
maiúscula”; o que será efetivamente mostrado na tentativa é o seu conteúdo.
Figura 12: Criação de estímulo de texto
Em uma tentativa, os estímulos de texto são exibidos centralizados e em letras grandes, o que os torna ideais
para representar letras, sílabas e palavras. Já para frases há um outro tipo específico de estímulo.
3.1.5 Frases
Como dito anteriormente, uma frase é, tecnicamente, um estímulo de texto, porém devido a algumas
particularidades, ela ganhou um tipo próprio de estímulo. Perceba na Figura 13 que o campo “Conteúdo” é
bem maior, permitindo tanto textos com mais caracteres quanto quebras de linha.
Assim como na criação de textos, é possível definir a fonte e seus efeitos com os mesmos atributos, como
família de fontes, tamanho, cores etc. Devido a uma limitação do Java, não é possível aplicar o efeito de
espaçamento às frases e nem transparência (no caso de cores do texto que possuem valores de “alfa”), apesar
de o sistema permitir definir esses valores.
22
Figura 13: Criação de estímulo de frase
Nas tentativas, frases são apresentadas com alinhamento à esquerda e com letra menor (exceto se o tamanho
da fonte for definido na criação), tornando-as ideais para testes de múltipla escolha e enunciados.
3.1.6 GIFs
GIFs (ou GIFs animados) são figuras animadas, geralmente bem simples e compostas por uma sequência de
imagens estáticas. Na Internet é muito comum encontrar esses arquivos, principalmente na forma de
“emoticons” e peças de publicidade. Esse formato tem um apelo muito grande junto ao público infantil.
Na Figura 14 ilustra-se um cadastro de GIF. Observe que o processo é muito parecido com o cadastro de um
estímulo de figura.
23
Figura 14: Criação de estímulo de GIF animado
Não há recomendações específicas para GIFs. Como sempre, use um tamanho adequado, com bom
enquadramento etc. Se você perceber que as animações dos seus estímulos GIFs estão rápidas demais, isso é
sinal de que as imagens possuem algum defeito. Para corrigi-las, sugerem-se sites como
http://www.ezgif.com/.
3.1.7 Vídeos
Finalmente, o estímulo mais complexo suportado pelo GEIC: o vídeo, em que você terá a liberdade de, em
um único arquivo, incluir som e imagens em movimento. Não há novidades no cadastro, apenas botões de
controle do vídeo para iniciar e parar a reprodução, como pode ser visto na Figura 15.
Figura 15: Criação de estímulo de vídeo
24
Se por um lado o cadastro de vídeos no GEIC não tem nada de especial, a criação ou a edição do vídeo em si
é muito complexa. Mesmo que você o tenha baixado da Internet, da sua câmera fotográfica ou do celular, é
preciso algum trabalho para que ele seja bem reproduzido nas tentativas.
Caso você precise usar vídeos, ou mesmo criar seu próprio vídeo, contrate um profissional da área.
Há muitas variáveis que precisam ser levadas em conta nos processos de criação e edição de um
bom vídeo, tais como iluminação, som, equipamentos de boa qualidade etc.
De qualquer maneira, as recomendações gerais são:
•
Melhor uso possível da área útil do vídeo, mas sem ultrapassar os limites dela
•
Sem faixas pretas no topo/base ou nas laterais
Como vídeos são compostos por faixas de áudio e vídeo, o formato dos arquivos também precisa ser
dividido. Na parte de áudio:
Armazenamento
Produção
Tipo de arquivo
WAV (preferencialmente), MPEG-AAC ou MPEG-AAC ou MP3
MP3
Profundidade por amostra
16 bits
16 bits
Frequência
44.1 ou 48 KHz
22 KHz (44 KHz em casos específicos)
Canais
2 (estéreo)
1-mono (2-estéreo em casos específicos)
Tabela 3: Formato do áudio nos estímulos de vídeo
Para a parte de vídeo:
Armazenamento
Produção
Tipo de arquivo
AVI (preferencialmente) ou MPEG4-video MPEG4-video
Dimensões
tamanho original do vídeo
170 x 145 pixels
Quadros por segundo
30 a 60
30 (60 em casos muito específicos)
Kbps
200-500 (valor subjetivo: na maioria dos
casos costuma ser suficiente)
Tabela 4: Formato do vídeo
Atualmente os estímulos de vídeo não funcionam em sistemas Mac OS X, levando inclusive o
módulo de Autoria a fechar caso você tente fazê-lo. Nesses casos use outros sistemas, tais como
Microsoft Windows e Ubuntu Linux.
3.2 Instruções
As instruções no GEIC são as mensagens de áudio que dão comandos ao aluno. Elas podem ser usadas para
configurar uma tentativa e são tocadas nos seguintes momentos:
•
No início: explicando qual o objetivo da tentativa ou o que o aluno precisa fazer. Exemplos:
“Aponte a figura”, “Escreva igual”, “Que animal é este?” etc.
25
•
Em intervalos regulares: lembrando o aluno do objetivo da tentativa (caso ele tenha se distraído ou
esteja demorando muito), como por exemplo “Não se esqueça de apontar uma figura”. Pode ser
usado ainda para alertá-lo de algum evento próximo (ex: “Adivinhe qual figura vai aparecer”).
Mais detalhes sobre como usar instruções em uma tentativa serão descritos na Seção 3.4. O cadastro de
instruções é idêntico ao de estímulos de som (lembre-se de que tecnicamente uma instrução é um estímulo de
som) e pode ser relembrado na Seção 3.1.3.
3.3 Consequências
Assim como as instruções, consequências são como estímulos de som, porém aqui elas são tocadas após uma
resposta do aluno à tentativa. Apesar de não haver tipos específicos de consequência, elas podem ser usadas
nas tentativas como uma consequência de:
•
Acerto: “Parabéns”, “Muito bem” etc.
•
Erro: “Não, não é”, “Não, tente de novo”
Detalhes sobre o uso das consequências em uma tentativa são descritos na Seção 3.4. O cadastro de
instruções é idêntico ao de estímulos de som (veja na Seção 3.1.3).
3.4 Tentativas
Tentativas são a parte mais importante de um programa. É com elas que os alunos interagem. Combinando
estímulos, instruções e consequências, o programador pode montar uma infinidade de tentativas diferentes,
para ensino ou para avaliação de desempenho.
A tela principal das tentativas é semelhante à de estímulos, contendo botões de criação para cada tipo de
tentativa, botões para edição, campos de busca, filtragem e paginação e uma lista principal organizada por
ordem alfabética de nome. Uma visão geral pode ser vista na Figura 16.
26
Figura 16: Aba de tentativas
O GEIC suporta vários tipos de tentativas, cada uma delas mais adequada para uma determinada situação.
Por exemplo, quando você quiser testar se uma criança sabe escrever a palavra “dado”, use tentativas do tipo
resposta-construída (CR). Primeiro, alguns conceitos básicos precisam ser apresentados.
3.4.1 Conceitos básicos
Tentativas são a unidade principal de um programa, portanto alguns termos e conceitos precisam ser
definidos antes de prosseguirmos. A Figura 17 ilustra como uma tentativa é apresentada a um aluno no
Módulo de Sessões. Nela, podemos observar uma tentativa de pareamento com o modelo (Matching-toSample – MTS). Mas o que exatamente é um modelo?
27
Figura 17: Estímulos em uma tentativa
Em uma tentativa de emparelhamento, o modelo (ou referência) é o estímulo que define qual será o estímulo
de comparação correto, isto é, se a resposta de escolha de uma entre as várias comparações for o estímulo
correto, ela será registrada como correta e poderá gerar um tipo de consequência; se o aluno escolher outro
estímulo de comparação, a resposta será considerada incorreta e poderá (ou não) gerar outro tipo de
consequência.
Na tentativa mostrada na Figura 17, o estímulo modelo é a figura com a foto de um gato e os estímulos de
comparação são as três palavras impressas. Se o aluno seleciona a palavra “gato”, esta resposta pode indicar
que ele faz a correspondência entre a figura e o nome escrito do que está na figura. Entretanto, para uma
conclusão mais segura será preciso conduzir esta mesma tentativa mais vezes, intercalada com outras
tentativas em que os modelos sejam outras figuras. No GEIC, o modelo visual é apresentado na parte
superior da tela, porém várias outras combinações são possíveis no procedimento de emparelhamento com o
modelo.
Como já ficou claro na ilustração, as opções de escolha que o aluno tem para responder neste procedimento
são chamadas estímulos de comparação. No exemplo acima, as comparações poderiam ser os estímulos de
texto “dado”, “gato”e “faca”.
Em outro exemplo, o estímulo modelo pode ser o som “Abacate” e os estímulos de comparação de texto são
as sílabas “A”, “ba”, “ca” e “te” espalhadas pela tela. O aluno deve então clicar nessas sílabas na ordem
correta para formar a palavra “Abacate”, aprendendo a escrever corretamente a palavra.
No GEIC, o estímulo apresentado no centro superior da tela (que será denominado “modelo” para fins de
28
construção de uma tentativa), também pode ser usado sozinho, sem estímulos de comparação, em outros
tipos de procedimento que não o emparelhamento com o modelo. Por exemplo, o modelo pode ser uma
figura em tarefas de nomeação de figura, nas quais a resposta do aluno será dizer o nome da figura e não
escolher um entre vários estímulos de comparação. Pode ser também uma palavra ou frase escrita em tarefas
de leitura nas quais o comportamento textual será dizer o que está escrito, uma palavra ou frase falada em
tarefas de imitação vocal nas quais o aluno repete o que foi falado, ou ainda em tarefas de ditado nas quais o
aluno deve escrever a palavra ou frase.
A quantidade de oportunidades que o aluno tem para acertar uma tentativa depende do programador. No
GEIC, essas oportunidades recebem o nome de interação, pois a cada resposta o aluno deve interagir com o
teclado, mouse, pronunciando algo em voz alta etc. Uma tentativa deve ter ao menos uma interação, do
contrário não serviria para muita coisa.
Uma interação geralmente é terminada quando o aluno emite uma resposta, seja ela correta (acerto comum)
ou incorreta (erro comum). Porém, outros motivos podem ocasionar o fim de uma interação, como os
seguintes:
•
Acerto forçado: quando o tutor usa um comando especial para forçar um acerto. Isso pode ser feito
quando o aluno não interage diretamente com o sistema para dar a resposta correta mas diz a
resposta em voz alta, e o tutor a registra como um acerto.
•
Erro forçado: de forma semelhante, o tutor pode considerar que a resposta do aluno, mesmo
indireta, deva ser considerada e registrada como incorreta.
•
Tempo excedido: quando o tempo máximo para o aluno dar a resposta for excedido (ex: 15
segundos).
•
Pedido de ajuda: em alguns casos o aluno pode selecionar uma opção de pedido de ajuda (ou
consulta), como por exemplo quando ele se esquece de um texto que acabou de ler e que é necessário
para se responder uma outra tentativa. Após um pedido de ajuda, independentemente de quantas
interações a tentativa tem, ela é terminada.
•
Cancelamento: usado em casos em que o aluno não pode continuar a sessão ou quando um
imprevisto acontece (ex: o tutor precisa participar de uma reunião inadiável). Como no pedido de
ajuda, ao comando de cancelamento tanto a tentativa quanto a sessão são interrompidas
imediatamente, mesmo que haja mais interações previstas (nesse caso, a sessão será reiniciada em
outra ocasião).
3.4.2 Configurações comuns
Para se criar uma tentativa basta selecionar um dos botões da área de criação de acordo com o tipo
pretendido. Em todos os casos será apresentada uma tela com cinco abas, sendo quatro delas comuns a todos
os tipos e descritas a seguir. A quinta aba depende do tipo de tentativa a ser criada e será descrita
separadamente. Veja o exemplo a seguir na Figura 18 em que o programador está criando uma tentativa de
resposta-construída (Constructed Response – CR) com um modelo composto por uma imagem (figura de
arara) e um texto (a palavra “arara”).
29
Figura 18: Criação de uma tentativa CR
Na primeira aba é possível ver os seguintes parâmetros:
•
Nome: como sua tentativa será chamada. É obrigatório e não é mostrado ao aluno durante as sessões
•
Descrição: um breve relato sobre qual a finalidade da tentativa. Opcional e não é mostrada ao aluno.
•
Instrução de início: lembra-se das instruções? Elas podem ser associadas às tentativas para serem
tocadas no início de cada interação (ex: “Aponte a figura”). Se a tentativa possuir um modelo de
som, este será tocado após a instrução de início (ex: “Aponte a figura - gato”).
•
Instrução de repetição: é útil quando o aluno não conseguiu entender a instrução logo no início, ou
quando ele se distrai e esquece o que deve ser feito. Neste caso, a instrução de repetição (que pode
ou não ser igual à de início) é repetida a intervalos de tempo regulares, cuja duração deve ser
definida pelo programador; a repetição pode ficar em vigor até que uma resposta ocorra.
•
Intervalo entre repetições (duração do intervalo): se a instrução de repetição for por exemplo
“Aponte”, o programador pode fazer esse som se repetir a cada 3000 ms (3 segundos).
•
Modelo: neste item o programador escolhe o tipo de estímulo de modelo e o sistema já mostra
automaticamente a lista de estímulos disponíveis. Em alguns casos, estímulos como figura e texto
podem ser conectados para se tornarem um estímulo composto, assim como o do exemplo (foto de
arara com legenda “arara”). É possível ainda optar por não se usar um modelo.
A segunda aba da tela de tentativas, que pode ser vista na Figura 19, mostra os parâmetros para as
consequências de acerto.
30
Figura 19: Consequências de acerto na tentativa
Veja que são dadas duas opções:
•
Na tentativa: a consequência de acerto é apenas um som tocado na presença da mesma tela da
tentativa em que ocorreu a resposta correta. Para isso, selecione uma consequência na caixa de
seleção (onde está escrito “muito bem! - feminino” no exemplo) e clique em “+”. Para conferir o
som selecione-o na lista embaixo da caixa de seleção e clique no botão de tocar. Para tirar uma
consequência da lista, clique em “-”. Se houver várias consequências na lista, apenas uma será
sorteada logo que o aluno acertar.
•
Em tela própria: neste caso, o GEIC muda para uma nova tela logo que o aluno apresenta a
resposta correta, não reapresentando a tentativa original. Porém, além do som da consequência
(apenas um), o programador pode incluir um título para a tela (ex. “Parabéns!”), uma figura ou GIF
animado e uma mensagem de fala gravada (ex. “Você acertou! Continue assim.”). Um exemplo pode
ser conferido na Figura 20, enquanto o que o aluno verá durante a sessão está ilustrado na Figura 21.
31
Figura 20: Configuração da consequência de acerto em tela própria
Figura 21: Consequência de acerto sendo apresentada em tela própria
32
Apenas recordando, as consequências são tocadas quando o aluno apresenta uma resposta (correta ou
incorreta) como uma forma de retorno. Em alguns casos, as consequências de acerto também são chamadas
de “reforços positivos”, “reforçadores” etc (quando se sabe que têm efeito sobre a aprendizagem).
A terceira aba consiste da configuração de uma consequência de erro. Isso se dá de forma idêntica à da
consequência de acerto, exceto que, mesmo quando a opção selecionada for “Na tentativa”, só pode ser
definido um som como consequência de erro. Essa tela pode ser vista na Figura 22.
Figura 22: Consequência de erro
A quarta aba define outros parâmetros da tentativa, conforme ilustrado na Figura 23. Aqui o programador
pode definir alguns aspectos mais avançados de programação, tais como:
•
Quantidade máxima de interações: quantas vezes o aluno pode interagir com a tentativa, isto é,
quantas vezes a mesma tentativa poderá ser repetida. Se este parâmetro for definido como 3, por
exemplo, o aluno poderá interagir no máximo 3 vezes com a tentativa. Assim, se ele errar as 2
primeiras vezes, a consequência de erro (se definida) será tocada e a mesma tentativa será exibida
novamente ao aluno. Se mesmo assim ele errar a terceira vez a tentativa atual termina e a próxima
tentativa é exibida. Se o aluno acertar a tentativa na primeira vez, a quantidade máximo de interações
não será usada mesmo que tenha sido programada.
•
Limite de tempo por interação: se definido como 0, a tentativa não possui tempo limite. Do
contrário, o aluno terá um tempo máximo para responder. Se esse tempo se esgotar, a interação será
encerrada com o resultado “erro por tempo excedido”. A consequência para tempo excedido deve ser
definida separadamente e será descrita mais adiante.
•
Permitir pedido de ajuda: caso esta opção seja marcada, um botão “?” aparecerá no canto da tela,
permitindo que o aluno o selecione caso tenha alguma dúvida ou dificuldade. Neste caso, a tentativa
(não só a interação) será encerrada com o resultado de “pedido de ajuda”. Geralmente nesses casos o
programador define na sequência alguma tentativa especial que fornece o tipo de ajuda solicitada.
33
•
Ocultar modelo: define quando (e se) o estímulo modelo deve desaparecer após algum período de
tempo. Com a opção “nunca”, o modelo permanecerá na tela (se for visual) ou será repetido
periodicamente (se for auditivo), até o final da tentativa. Com “após o início”, define-se um tempo
após a tentativa começar para que o modelo seja ocultado. Com “após seleção”, o modelo será
removido da tela um determinado tempo após o aluno clicar sobre ele.
•
Exibir comparações após: define quando os estímulos de comparação devem ser apresentados na
tela. O valor padrão é “0 ms após o início”, isto é, logo quando a tentativa é iniciada. Pode-se definir
um tempo maior, ou então marcar “seleção modelo” (quando o aluno clicar no estímulo modelo) ou
“ocultação do modelo” (após o modelo ser removido da tela). Note que se a opção de ocultar o
modelo estiver marcada como “nunca” e a de exibição das comparações estiver marcada como
“ocultação modelo”, a tentativa não poderá ser executada (isto é, estes dois comandos são
incompatíveis), exceto se forem usadas as teclas de atalho de pedido de ajuda ou acerto/erro forçado .
Esta opção não está disponível para tentativas NOM.
•
Liberar comparações: define quando o aluno poderá clicar sobre as comparações. Pode ser “após
modelo”, ficando os estímulos liberados após um tempo depois da apresentação do modelo (o que
coincide com o início da tentativa) ou “imediatamente”, liberando os estímulos logo no início da
tentativa. Não disponível para tentativas NOM.
•
Consequência de tempo excedido: define o som que deve ser tocado se o aluno não conseguir
responder a tentativa a tempo.
•
Pausa após reforço: é o tempo durante o qual a tela tem que ficar “congelada” após a tentativa ser
finalizada e uma consequência (se houver) ser tocada, antes de passar para a próxima tentativa.
Figura 23: Parâmetros da tentativa
34
O conteúdo da quinta aba “comparações” é específico para cada tipo de tentativa e será discutido mais tarde.
Antes disso, é importante observar como as tentativas são complexas e como isso pode dar errado caso
algum parâmetro tenha sido esquecido. Para evitar que eventuais erros cheguem até os alunos (onde pode ser
tarde demais) é possível testar uma tentativa e ver como ela se comportará durante sua execução.
Para isso, basta clicar no botão “Testar”. Será então mostrada uma janela com alguns modificadores (Figura
24) que permitem que algumas propriedades das sessões de teste sejam manipuladas sem que a tentativa seja
alterada. Imagine isso como se fosse um ajuste temporário, durante apenas uma sessão, “só para ver como
ficaria”.
Figura 24: Modificadores de teste de tentativa
Os modificadores são:
•
Exibir pontos: uma pontuação numérica acompanha o aluno/programador ao longo da sessão
indicando em um contador quantas tentativas ele respondeu corretamente. Cada nova resposta
correta incrementa o número e toca um som. Há dois sub-modificadores para esta opção:
◦ Apenas nas primeiras ocorrências de blocos: incrementa os pontos apenas quando um
determinado bloco for apresentado pela primeira vez dentro de um passo. A montagem de passos
com seus blocos será explicada mais adiante.
◦ Apenas nas primeiras repetições de blocos: incrementa os pontos apenas quando um tipo de
bloco for repetido pela primeira vez dentro de um passo.
35
•
Exibir respostas corretas: Destaca a resposta correta de uma tentativa. Isso varia de acordo com o
tipo: em tentativas MTS e de múltipla escolha (MULT), destaca com uma cor verde quais são os
estímulos de comparação corretos. Em tentativas CR, apresenta o mesmo texto que deve ser escrito.
Em tentativas NOM e de leitura (LEIT) este modificador não tem efeito.
•
Modelos de texto em letras maiúsculas: os estímulos de modelo dos tipos texto e frase são
apresentados com todas as letras maiúsculas. Se esta opção não for marcada, todos os textos serão
apresentados em sua forma original.
•
Comparações de texto em letras maiúsculas: idêntico ao modificador anterior, mas modifica os
estímulos de comparação de tipos texto e frase.
•
Intervalo de repetições de instrução: sobrescreve a opção “Interv. repetições” da tentativa (vide
Figura 18), tocando a repetição da instrução no intervalo de tempo aqui definido se a opção estiver
marcada.
•
Pausa após reforço: sobrescreve a opção de mesmo nome da tela de parâmetros (Figura 23),
definindo o tempo em que a tela fica “congelada” antes de apresentar outra tentativa ao
aluno/programador.
•
Ocultar cursor durante a sessão: se marcado, o cursor do mouse não será mostrado durante o teste
da tentativa. Isso pode ser útil em computadores que possuem telas sensíveis a toque e que não
precisam do mouse, para evitar distrações do aluno.
•
Configurações de fonte: define as propriedades de fontes que devem ser aplicadas a todos os
estímulos de texto e frase no teste. As opções são as mesmas vistas na criação desses estímulos
(Figuras 12 e 13) e, se algumas dessas opções forem marcadas, todos os estímulos de texto e frase
serão forçados a usar essas opções, sobrescrevendo suas próprias definidas no momento da criação.
•
Tema: define algumas características da tela de teste e de sessão, como a cor de fundo e o tamanho
das imagens. Atualmente, existem apenas dois temas: “Padrão” e “Livro”. O tema Padrão apresenta
um fundo verde e um painel amarelo, como aquele mostrado na Figura 21. O tema Livro apresenta
fundo todo branco, ocupa toda a tela e os estímulos são apresentados em tamanho maior, assim como
na Figura 25. Informações adicionais durante o teste de uma tentativa, que serão mostradas a seguir,
aparecem por cima dos estímulos neste tema, portanto devem ser ocultadas.
•
Exibir informações adicionais: apresenta informações adicionais, tais como como as teclas de
atalho, qual é a interação atual, a latência (em quanto tempo a tentativa foi finalizada), a duração
total do teste (contando o tempo do início até o final da tarefa com todas as tentativas programadas e
seus componentes: instruções, latências, consequências etc.), um texto de comentário, além de
informações sobre o programa, passo, bloco e tentativa atuais. Essas informações não são mostradas
no módulo de Sessões, pois deve-se ter um foco na tentativa em si pelo aluno, mas o tutor deve se
lembrar delas para controlar a execução de um programa de ensino.
36
Figura 25: Tentativa MTS com tema de Livro
As teclas de atalho são comandos que podem ser usados pelo tutor durante a execução da sessão. Uma
descrição de suas funções é apresentada a seguir e a forma como elas aparecem em um teste de tentativa no
Windows ou no Linux pode ser vista na Figura 26. No Mac OS X as teclas são como vistas na Figura 27.
Neste caso, as teclas “Shift + Alt” devem ser substituídas pela tecla “Command” ( ⌘) e as teclas “F4”, “F5”
etc., devem ser substituídas por números simples, conforme indica cada linha dessa figura.
Figura 26: Teclas de atalho no Windows e Linux
Figura 27: Teclas de atalho no Mac
37
A lista completa de comandos é:
•
Shift + Alt + F4 (⌘ + 2) – pedido de ajuda: força uma finalização de interação tendo como motivo
o pedido de ajuda, mesmo que este não esteja disponível diretamente ao aluno.
•
Shift + Alt + F5 (⌘ + 3) – acerto comum em uma tentativa NOM: em tentativas NOM (leitura de
palavras, consoantes e vogais, nomeação de figuras e ditado manuscrito, por exemplo) não há
lugares na tela que controlem acertos ou erros do aluno, pois ele deve dizer as respostas em voz alta
ou escrevê-las usando lápis e papel. Assim, para considerar um acerto comum, o tutor deve usar este
atalho. Em outros tipos de tentativas (que não NOM) este atalho não surte efeito.
•
Shift + Alt + F6 (⌘ + 4) – erro comum em uma tentativa NOM: considera um erro comum em
uma tentativa de nomeação. Assim como o atalho anterior, este não tem efeito em tentativas que não
são do tipo NOM.
•
Shift + Alt + F7 (⌘ + 5) – acerto forçado em todos os tipos de tentativa: produz um acerto
forçado para encerrar a interação (e ficará registrado como tal, indicando a interferência do tutor).
•
Shift + Alt + F8 (⌘ + 6) – erro forçado em todos os tipos de tentativa: da mesma forma, este
atalho produz um erro forçado.
•
Shift + Alt + F9 (⌘ + 7) – exibe/oculta informações adicionais: este atalho só funciona no módulo
de Autoria para testes. Ele apresenta/oculta as informações adicionais (teclas de atalho, tempos,
informações sobre programa, passo, bloco e tentativa atuais etc.). Se as informações forem
ocultadas, o teste se assemelhará a uma tentativa no módulo de Sessões.
•
Shift + Alt + F10 (⌘ + 8) – exibe/oculta pontos: em alguns casos, é útil ir mostrando o número
acumulado de acertos do aluno em uma sessão de um programa de ensino (como uma forma de
feedback imediato, após cada resposta correta). Os pontos são mostrados em uma caixa localizada
abaixo dos estímulos de comparação e podem ser monitorados continuamente (pelo próprio aluno ou
pelo programador ao longo do teste).
•
Shift + Alt + F11 (⌘ + 9) – exibe/oculta dicas: a dica, quando apresentada, quais são as respostas
corretas de uma tentativa. Isso pode ser necessário para alguns alunos com uma dificuldade maior de
aprenderem o conteúdo de uma tentativa.
•
Shift + Alt + F12 (⌘ + 0) – força finalização do teste/sessão: caso seja necessário interromper a
sessão do aluno (ou o teste) por algum motivo, o tutor/programador pode utilizar esta tecla, que
interrompe a sessão (ou teste) imediatamente. No módulo de Sessões, dependendo das configurações
da sessão em andamento, pode ser exigido um registro de texto relatando o motivo do cancelamento.
Além desses atalhos, o tutor pode utilizar o teclado para digitar qualquer texto de comentário enquanto
o aluno estiver executando uma sessão. Esse texto não será mostrado na tela, porém será registrado no
sistema como uma informação adicional. Por exemplo, o tutor pode fazer alguma observação como “O aluno
pediu para ir ao banheiro e só completou a tentativa ao retornar”. Para excluir todo o texto digitado, basta
apertar a tecla “ESC”. Esta informação será útil na posterior análise dos dados (ex: latência); uma tentativa
com esse tipo de interrupção terá uma latência muito mais longa que todas as demais e será muito importante
contar com o registro para esclarecer o fato.
Vamos agora tratar das configurações específicas de cada tentativa, totalizando cinco tipos: Tentativas CR,
MTS, NOM, MULT e LEIT.
38
3.4.3 Tentativas CR
As tentativas de resposta construída (Constructed Response – CR) permitem que, em vez de selecionar um
estímulo inteiro, como uma unidade (por exemplo, clicar sobre a palavra PIPA), o aluno construa a palavra
ou texto, selecionando seus componentes menores (as letras de uma palavra ou as palavras de uma frase), um
a um, entre um conjunto de elementos apresentados na tela. No exemplo da palavra “PIPA”, a parte inferior
da tela pode mostrar 14 letras (B, A, P, M, E, V, I, L, P, R, O, A, D, U); o aluno pode clicar sobre cada letra
isolada; após o clique, a letra se desloca para a área de construção na parte central da tela e sucessivos
cliques resultam em uma sequencia de letras. Quando considera a tarefa terminada, o aluno pode clicar em
um botão de confirmação. Se a sequência de letras estiver correta, apertar o botão pode acionar a
consequência de acerto; se estiver errada, pode-se programar consequência de erro ou a simples mudança
para a tentativa seguinte. Vale observar que nas tentativas CR os estímulos de comparação são apenas texto
(o tamanho de cada elemento textual pode ser determinado na programação).
O aluno pode ter também a opção de mudar sua resposta antes de dar uma confirmação. Basta que ele clique
no último elemento selecionado (letra, sílaba, palavra) e o mesmo retorna para seu lugar de origem na área
inferior da tela.
Mais detalhes da tela de criação de tentativas do tipo CR podem ser vistos na Figura 28. Neste exemplo o
aluno deve compor a palavra “arara” a partir de sílabas apresentadas como estímulos de comparação.
Figura 28: Estímulos de comparação para tentativa CR
A lista de parâmetros é:
•
Texto correto: é a palavra que o aluno deve compor.
•
Comparações: a quantidade de comparações a serem apresentadas na tela.
39
•
Mínimo de seleções: em quantos estímulos o aluno deve clicar antes que o botão de confirmação
fique disponível para a resposta.
•
Feedback: indica que o sistema deve avisar ao aluno que algum estímulo selecionado está errado,
deixando-o com cor vermelha.
•
Correção: só aparece quando o estímulo de modelo for do tipo “som”. Se o aluno errar a resposta e
a tentativa tiver mais de uma interação definida nos parâmetros, o texto correto aparecerá na tela e o
som do modelo será repetido.
Na parte central da tela estão quantas comparações obrigatórias e quantas opcionais a tentativa deve
apresentar:
•
Obrigatórias: são as que sempre estarão disponíveis na tentativa, portanto não é possível definir
sua quantidade como sendo maior que o número total de comparações (definido na parte superior).
Deve ser possível formar o texto correto com as comparações obrigatórias, caso contrário o aluno
nunca conseguiria acertar a resposta!
•
Opcionais: estímulos que podem ser apresentados na tela caso a quantidade de comparações
obrigatórias seja menor que o número total de comparações. A lista pode ter qualquer quantidade de
comparações opcionais, porém o sistema selecionará (via sorteio) apenas o número necessário para
se completar o número total.
O número de comparações obrigatórias somadas às opcionais deve ser sempre maior ou igual ao número
total de comparações.
Uma tentativa com as configurações do exemplo fica com a aparência mostrada na Figura 29, que também
identifica cada elemento da tentativa.
40
Figura 29: Teste de tentativa CR
1. Estímulo modelo composto de figura + texto
2. Botão de confirmação
3. Estímulo de comparação selecionado (letra “a”)
4. Estímulo de comparação selecionado se movendo para formar a resposta (“ra” em azul)
5. Estímulos de comparação espalhados pela área de apresentação das comparações
6. Botão de ajuda
3.4.4 Tentativas MTS
São tentativas de “escolha de acordo com o modelo” ou “pareamento com o modelo” (Matching-to-Sample –
MTS), que definem o procedimento de discriminação condicional. Esses tipos de tentativas apresentam um
estímulo modelo (ou estímulo condicional) e, neste ambiente computacional, de um a três estímulos de
comparação, que são os estímulos discriminativos. A resposta do aluno consiste em selecionar uma das
alternativas de escolha (comparações) com um clique do mouse.
No GEIC, tentativas de discriminação simples simultânea também podem ser programadas como tentativas
tipo MTS; neste caso, basta omitir o modelo e definir que serão apresentados apenas dois estímulos de
comparação (um S+ e um S-).
41
Tecnicamente, uma tentativa de discriminação simples não pode ser considerada uma tentativa
MTS. Para fins de facilidade de uso, porém, ambas são criadas no mesmo tipo de tela.
Os parâmetros específicos de uma tentativa MTS podem ser vistos na Figura 30. O programador deve
primeiro definir o tipo dos estímulos, que podem ser do tipo figura, figura+texto, texto, texto+figura, GIF ou
vídeo. Ao menos um dos estímulos deve ser preenchido, enquanto os restantes podem ser definidos como
“<nenhum>”. Um ou mais estímulos devem ser marcados como corretos, de forma que, se o aluno clicar
sobre eles, sua resposta será considerada como acerto comum, enquanto que, se clicar nos outros, a resposta
será considerada como erro comum. Estímulos de texto que definem efeitos de fonte, como tamanho e cor,
aparecerão nas previsões e nas execuções com esses efeitos.
Figura 30: Criação de tentativa MTS
Um aspecto importante na programação de tentativas MTS é a variação na posição dos estímulos de
comparação na tela, para o caso de reapresentação de uma mesma tentativa ou de reaplicações de um mesmo
bloco de tentativas. Para isto o GEIC possibilita definir um embaralhamento, isto é, a posição (à direita, no
centro ou à esquerda) em que serão apresentados na tela. Se o parâmetro de embaralhamento for “Nenhum”,
os estímulos serão apresentados apenas na ordem programada. Do contrário, as opções de embaralhamento
serão apresentadas abaixo de cada estímulo. Os estímulos marcados com “Embaralhar” poderão aparecer em
posições diferentes, enquanto que os outros permanecerão na mesma posição. Se a opção “Configuração
inicial fixa” estiver marcada, os estímulos na primeira interação com a tentativa sempre estarão na posição
pré-definida, enquanto que nas demais eles podem mudar. Existem três estratégias de embaralhamento:
•
Simples: sorteia as posições, sem restrição alguma. Desta forma, pode acontecer de em algum
momento haver duas configurações repetidas seguidas, o que pode não ser interessante.
•
Repetições não-sucessivas: após o sorteio das posições, o sistema verificará se a interação anterior
42
da tentativa tinha a mesma configuração; se tiver, será realizado novo sorteio.
•
Repetições após esgotamento de possibilidades: permite uma repetição de configurações apenas se
não houver outras possibilidades diferentes.
Os exemplos das Figuras 17 e 25 são exemplos de tentativas MTS.
Pode-se também marcar a opção “resposta de consumação”. Uma resposta desse tipo é como se fosse uma
confirmação da resposta anterior, servindo para algum objetivo. Por exemplo, se o aluno apresentou uma
resposta correta na tentativa anterior, pode ser apresentada, em seguida, uma nova tentativa MTS em que o
aluno pode escolher entre dois estímulos de comparação relacionados à sua primeira resposta. Uma resposta
de consumação pode ainda ser configurada como “Consumação automática”, sendo que nesse caso o aluno
não irá interagir com a tentativa, pois será o próprio sistema que selecionará uma resposta correta e irá para a
próxima tentativa.
3.4.5 Tentativas NOM
As tentativas de “Nomeação” (NOM) tem por finalidade apresentar apenas um estímulo, que o aluno deve
nomear (dizer, oralmente ou por escrito, o que está representado em uma figura, mostrado em vídeo ou
escrito em um texto). Tentativas NOM apresentam apenas um estímulo (no local da tela destinado ao
modelo), sem comparações e com dois únicos parâmetros “texto correto” e “gravar áudio”.
Figura 31: Parâmetros de tentativa do tipo NOM
Neste tipo de tentativa, o aluno deve observar o modelo e nomeá-lo dizendo seu nome em voz alta ou
escrevendo a resposta em uma folha de papel. No caso de respostas orais ou escritas com lápis e papel, não é
feito o registro automático da resposta através de interações com a interface gráfica. Portanto, é tarefa do
tutor avaliar se a resposta foi correta ou não e interagir com o sistema para produzir a consequência
43
programada (consequência de acerto ou avanço para a próxima tentativa). Para isto, o tutor deve pressionar
as teclas de atalho Shift+Alt+F5 (⌘+3) para um acerto comum e Shift+Alt+F6 (⌘+4) para um erro
comum.
Como este tipo de tentativa não apresenta estímulos de comparação, a aba de parâmetros não apresenta os
parâmetros “Exibir comparações após” e “Liberar comparações”. Apenas o modelo é apresentado na tela,
como mostrado na Figura 31.
A quinta aba contém apenas o campo “Texto correto”, que serve unicamente para auxiliar o tutor na
avaliação da resposta do aluno, e uma caixa de seleção “Gravar áudio”; se selecionada, quando o aluno for
iniciar a interação com a tentativa, o sistema automaticamente gravará os sons capturados pelo microfone (se
houver algum conectado) e armazenará os dados quando a interação terminar, disponibilizando esse áudio
posteriormente no módulo de Projetos. Se não houver um dispositivo de gravação conectado ao computador,
o sistema ainda tentará registrar o áudio, mas o resultado será apenas uma gravação silenciosa.
A execução de uma tentativa NOM fica com a aparência da Figura 32.
Figura 32: Teste de tentativa NOM
3.4.6 Tentativas Mult
São tentativas de “Múltipla escolha” (Mult), muito semelhantes às tentativas MTS, porém contendo de um a
cinco estímulos de comparação exclusivamente do tipo frase. Elas podem ser usadas, por exemplo, para
questões de interpretação de texto como “Qual é o título do texto?”; as alternativas de escolha são frases
completas.
44
Um exemplo da aba de comparações deste tipo de tentativa pode ser visto na Figura 33, e uma execução dela
pode ser vista na Figura 34. Assim como nas tentativas MTS, é possível definir um embaralhamento para os
estímulos de comparação e um ou mais estímulos corretos, tal como descrito para aquele tipo de tentativas.
Os estímulos que definirem efeitos de fonte também aparecerão nas previsões e nas execuções com esses
efeitos (com a exceção dos efeitos de espaçamento e de cor de texto com transparência).
Figura 33: Criação de tentativa Mult
45
Figura 34: Teste de tentativa Mult
3.4.7 Tentativas Leit
Neste tipo de tentativas a resposta requerida é a de “Leitura” (Leit). Para isto, é apresentado apenas um
estímulo textual na área do modelo com até 512 caracteres. Pode-se também acrescentar uma figura de fundo
(opcional). As palavras do texto podem ser associadas a um som, de modo que se o aluno clicar sobre a
palavra impressa, o som correspondente será tocado.
Este tipo de tentativa permite criar programas de ensino de leitura com compreensão do texto. Podem-se
escrever histórias em que cada tentativa constitui uma página, por exemplo. O programador pode escolher as
palavras impressas para as quais o aluno poderá acionar também o som correspondente (consulta ou ajuda).
Para isto, a palavra é sublinhada no texto e quando se clica sobre ela, o som é apresentado.
Na aba de comparações há uma área onde o programador pode digitar o texto da tentativa, definir um tempo
mínimo após o qual o botão de confirmação aparecerá e definir, também, uma figura de fundo (Figura 35).
46
Figura 35: Criação de tentativa Leit
A tela de edição neste tipo de tentativa é diferente da tela de criação, como pode ser visto na Figura 36. Nela,
todas as palavras, espaços em branco e quebras de linha são transformados em elementos individuais
chamados termos (os retângulos envolvidos com bordas). O “X” vermelho pode ser clicado para remover
um termo do texto. Ao selecionar um dos termos, uma lista aparecerá embaixo da área de texto, onde é
possível escolher um som para ser associado. No exemplo, a palavra “OLHAVA” foi selecionada e o som
“olhava” associado a ela. Com um som associado, o retângulo da palavra fica com uma cor azul na parte
esquerda.
Ainda, nessa tela de edição, é possível clicar no botão “Novo termo” para adicionar mais frases ao texto
(Figura 37). Se houver algum elemento selecionado, os elementos dessa nova frase (palavras e espaços em
branco) serão adicionados após esse elemento; senão, serão adicionados ao fim da primeira linha.
Importante: como os termos são relacionados a estímulos de texto, todas as configurações de
fonte daquele estímulo serão propagadas para os termos, de forma que uma palavra pode,
dependendo do caso, aparecer com tamanho de fonte muito grande ou pequeno, colorida, em
itálico etc. É imprescindível, portanto, que o programador confira a tela de edição dessa tentativa e
execute testes para garantir o efeito desejado.
47
Figura 36: Edição de tentativa Leit
Figura 37: Criando novo termo para tentativa Leit
Ao fim da tentativa, basta clicar no botão de confirmação na tela para avançar. A execução do exemplo no
tema de livro pode ser vista na Figura 38. Note que as palavras associadas a sons ficam sublinhadas; ao clicar
sobre a palavra, o som relacionado será tocado.
48
Figura 38: Teste de tentativa Leit
3.5 Blocos
Um programa de ensino apresenta um conjunto de tarefas e conteúdos organizados como tentativas. Um
primeiro nível de organização é o bloco, que nada mais é do que um conjunto de tentativas. Em geral, um
bloco ensina/avalia um conteúdo específico: comparando com uma sala de aula, o bloco seria um assunto e
as tentativas os diversos exercícios sobre aquele assunto. Por sua vez, uma sessão de ensino pode agrupar
vários blocos, com conteúdos similares ou diferentes entre si. Esta organização tem por finalidade organizar
os registros e possibilitar a análise de dados, em função dos objetivos de cada bloco. Porém, para o aluno,
uma sessão é apenas uma sequência linear de tentativas. Assim, o recurso de organização em bloco serve
apenas para facilitar o trabalho do programador e deixar os programas mais organizados.
Mais tecnicamente falando, quando uma tentativa é adicionada a um bloco ela recebe o nome de ocorrência
de tentativa. O termo “ocorrência” é usado porque uma mesma tentativa pode ser apresentada (ocorrer) mais
de uma vez dentro de um mesmo bloco. Na verdade ela pode ser usada várias vezes dentro de vários blocos!
Vamos agora para a parte prática: a aba de blocos é semelhante à aba de tentativas, porém mais simples. O
botão de “Usos” mostra em que passos determinado bloco está sendo usado, enquanto a tabela não possui
coluna de tipo (ou filtro por tipo), já que não existe mais de um tipo de bloco; pelo mesmo motivo, o botão
de criação não possui a seta com a lista de tipos, sendo apenas um botão simples.
A tela de criação de bloco pode ser vista na Figura 39. Nela há os seguintes elementos:
•
Nome: como o bloco será denominado. É obrigatório e não é mostrado ao aluno durante as sessões
49
•
Descrição: um breve relato sobre qual a finalidade ou objetivo do bloco. Opcional (mas pode
facilitar muito a descrição de procedimentos) e não é mostrada ao aluno.
•
Ocorrências e transições: ou corpo, é a área onde a composição do bloco é definida, ou seja, quais
serão suas tentativas e como elas estarão relacionadas.
•
Resumo: é um apanhado geral sobre o estado do seu bloco, contendo a quantidade de ocorrências e
transições etc. Serve para deixar o programador e o analista de dados bem informados sobre o estado
do bloco.
Figura 39: Criação de bloco
Para adicionar uma tentativa, basta clicar no botão tentativa.... Uma lista parecida com a da aba de tentativas
será apresentada (Figura 40), permitindo ao programador selecionar as que deseja. Com a ajuda das teclas
Ctrl e Shift é possível selecionar e adicionar mais de uma tentativa por vez.
Figura 40: Adicionando tentativas a um bloco
50
Na tela de adição de ocorrências, seja de tentativas, blocos ou passos, você só verá itens aos quais você tem
acesso. No caso do bloco de exemplo, só apareceriam as tentativas que pertencem a você ou as que você tem
permissão para usar (por que alguém deixou).
Após adicionar algumas tentativas o corpo do bloco ficará como ilustrado na Figura 41. As cores dos
retângulos dependem do tipo da tentativa: tentativas CR ficam com a cor rosada, Mult com azul escuro, Leit
com verde, MTS com azul claro e NOM com amarelo.
Figura 41: Bloco com algumas tentativas
Os tipos de estímulo modelo também são mostrados pelas letras em negrito, sendo que F significa figura, S
significa som, FT é uma combinação de figura e texto, FR é frase etc. Reticências (…) indicam que não há
um modelo.
O número mostrado na parte superior é a identificação da tentativa, e o número na parte inferior indica a
ocorrência de uma mesma tentativa. No exemplo, a tentativa de identificação 16015 aparece duas vezes,
ficando com os números de ocorrência 1 e 2.
As ocorrências também podem ter uma função, que é uma forma de classificar uma ocorrência quanto à
utilidade dela no bloco. Ao selecionar a ocorrência, no painel inferior abaixo da opção “Inicial”, há uma
caixa de seleção com as funções disponíveis. São elas: consumação, controle de novidade, diferenças
críticas, diferenças múltiplas, discriminação, exclusão, linha de base, linha de base múltipla, pós-teste, préteste, retenção, sonda, teste e treino. Uma vez usadas, essas funções auxiliam na organização do programa e
51
podem ser úteis na posterior análise dos resultados das sessões. Não se preocupe: a menos que você seja um
pesquisador é normal não ter intimidade com estes termos, assim como também não é obrigatório usá-los.
Caso o programador deseje adicionar alguma anotação, que não faz parte da composição do bloco mas que
seja importante como lembrete, pode fazer isso clicando no botão nota (ao lado do de tentativa). Um
retângulo amarelo, semelhante a um adesivo post-it, poderá então ser anotado (Figura 42). Para remover a
nota, basta clicar no ícone de lixeira; para movê-la para outro lugar, basta clicar e segurar na área da direita e
arrastar.
Figura 42: Criação de bloco com nota
Observe que a primeira ocorrência possui uma seta apontando para ela. Isso significa que, assim que o bloco
for iniciado em uma sessão ou em um teste, essa será a primeira tentativa apresentada. Para definir outra
ocorrência como inicial, basta selecionar a desejada e uma área com opções aparecerá na parte de baixo da
tela, como na Figura 43. Então, marque a opção inicial.
Nesta tela de opções é também possível remover uma ocorrência clicando no ícone da lixeira; ainda, para
testar aquela tentativa individualmente em vez de o bloco inteiro, basta clicar no botão para tocar (o triângulo
da área de opções). Dois cliques na ocorrência permitem consultar a tentativa que ela representa, porém sem
poder editá-la.
52
Figura 43: Opções de ocorrência de tentativa
Além das ocorrências, outro recurso indispensável de um bloco são as transições. São elas que definem a
ordem em que as tentativas serão mostradas aos alunos. Para adicionar uma transição entre duas ocorrências
de tentativas, clique na ocorrência de origem para selecioná-la e então clique na ocorrência de destino com o
botão direito do mouse. Uma linha tracejada com uma seta aparecerá, conforme mostra a Figura 44.
53
Figura 44: Adicionando uma transição entre ocorrências de tentativas
Interligando todas as ocorrências na sequência, o bloco fluirá até que o aluno invariavelmente chegue a uma
ocorrência sem transições, chamada de ocorrência final. Nesse ponto considera-se que o bloco terminou.
Não deixe ocorrências soltas, do contrário elas nunca serão alcançadas pelas transições. Para evitar
que isso aconteça, deixe seu bloco sempre organizado, de forma que você tenha uma boa visão de
como a sessão irá fluir.
É possível fazer com que mais de uma transição saia da mesma ocorrência, formando assim uma
ramificação. Para ajudar o GEIC a decidir caminho tomar, é possível definir a prioridade de cada transição.
O número 0 representa a prioridade mais alta, enquanto que 1, 2, 3 etc. representam prioridades mais baixas.
Clicando na ocorrência de origem, é apresentada uma lista com as transições que saem dela, as ocorrências
de destino de cada uma e sua prioridade. É possível então selecionar um item dessa lista (a transição ficará
verde) e mudar a prioridade clicando nas setas apontando para cima e para baixo, como na Figura 45.
54
Figura 45: Lista de transições de uma ocorrência de tentativa
Apenas as prioridades podem não ser suficientes para controlar qual transição deve ser seguida. O
programador pode querer, por exemplo, que os alunos que não errarem nenhuma vez em uma tentativa sigam
um caminho específico. Para isso, podem ser usados os critérios de transição, que nada mais são que as
condições para que uma transição seja feita.
Ao se selecionar uma transição com o mouse, a linha tracejada e a seta ficarão vermelhas e as opções
aparecerão na parte inferior, contendo uma lista de critérios para aquela transição (ver Figura 46). Para uma
transição recém-criada, essa lista estará inicialmente vazia. O botão “+” permite adicionar um critério à
transição; o botão “+” com uma seta verde fica ativo quando um critério é adicionado e permite que seja
adicionado um subcritério, que será explicado mais adiante. O botão “-” remove um critério ou subcritério
da lista. Por fim, o botão com a lixeira remove a transição toda.
55
Figura 46: Opções de transição
Ao clicar para adicionar um critério, a janela da Figura 47 será apresentada, contendo um menu com os
vários tipos de critérios disponíveis, cada um para uma situação específica. Para cada item que for
selecionado, a parte inferior da janela é modificada com opções específicas para aquele menu.
Figura 47: Adicionando um critério a uma transição
Em detalhes, esses critérios são:
•
Soma de erros na tentativa executada: a transição será realizada de acordo com o número de erros
na ocorrência de tentativa anterior. Além da quantidade, há uma caixa de seleção com um operador
aritmético que pode ser igual (=), diferente (!=), menor (<), menor ou igual (<=), maior (>) ou maior
ou igual (>=). Para adicionar esse critério, confirme clicando no botão “Adicionar” da parte inferior.
56
•
Execuções totais: diz respeito ao número de vezes que a ocorrência anterior foi executada ao longo
do bloco. Isso significa que se o aluno executar aquela ocorrência uma vez, continuar ao longo do
bloco e eventualmente voltar na mesma ocorrência, serão contadas duas execuções. Os operadores
são os mesmos que os do critério anterior, e o programador pode definir o número de execuções no
campo numérico ao lado. Atenção: uma mesma tentativa pode ter várias interações mas mesmo
assim contará como uma única execução.
•
Execuções consecutivas: essa opção fica visível apenas se uma transição sair de uma ocorrência e
voltar para ela mesma (também conhecida como auto-transição). Neste caso, a transição ocorre
apenas se a mesma ocorrência for executada consecutivamente um determinado número de vezes.
•
Ocorrência anterior: esse critério ficará disponível apenas quando a ocorrência não for inicial.
Com ela, é possível ir para um determinado caminho dependendo das ocorrências anteriores
executadas. Por exemplo, suponha que há uma ocorrência de identificação 15050 e, antes dela, há
ocorrências de identificações 15048 e 15049 com transições que apontam para ela. O critério
permitirá então que o usuário escolha as ocorrências 15048 e 15049, e o aluno só seguirá aquela
transição se a ocorrência anterior houver sido a selecionada para o critério. O operador, neste
critério, contém apenas igual (=) e diferente (!=).
•
Pedido de ajuda: significa que a transição será aceita apenas se o aluno tiver pedido ajuda. A parte
inferior da janela não mostra opções neste caso, pois não há o que configurar para esse critério.
•
Estímulo selecionado: essa opção fica visível apenas se uma transição sair de uma ocorrência do
tipo MTS ou Mult. De forma semelhante ao critério “Ocorrência anterior”, as opções são os
estímulos de comparação que faziam parte da ocorrência de tentativa executada e o operador contém
apenas igual (=) e diferente (!=).
Adicionar um ou mais critérios a uma transição faz com que a linha tracejada fique sólida. Uma transição
com um ou mais critérios automaticamente passa a ter maior prioridade do que aquelas que não possuem
critérios, como pode ser visto na Figura 48. Do contrário, a transição com critérios nunca sequer seria
avaliada, já que uma transição sem critérios sempre é aprovada.
57
Figura 48: Transições na ocorrência de tentativa, uma delas com critério
Quando uma ocorrência termina, o sistema verifica sua lista de transições por ordem de prioridade. Se a
transição de maior prioridade tiver critérios e estes forem satisfeitos, o aluno a seguirá e irá para sua
ocorrência de destino. Se os critérios da transição não forem satisfeitos, o sistema verifica a próxima
transição e seus critérios. Isso continua até que os critérios de alguma transição sejam satisfeitos (ou que
alguma transição sem critérios seja encontrada). Se tudo o mais der errado e não houver para onde ir, o
sistema termina o bloco instantaneamente.
Um bloco termina quando chega a uma ocorrência de tentativa final (sem transições com origem
nela) ou não consegue passar por nenhuma transição.
Quando uma transição tiver vários critérios, basta que pelo menos um deles seja satisfeito para que ela seja
atravessada. Porém, o programador em alguns casos pode querer que a transição ocorra quando duas ou mais
condições forem verdadeiras simultaneamente, por exemplo, soma de erros maior ou igual a um e menor
que três. Para isso, é necessário usar subcritérios. No exemplo dado, a forma correta de representá-lo seria
criando um critério de soma de erros maior ou igual a um e um subcritério de soma de erros menor que
três (a ordem dos critérios e subcritérios não importa).
Lembre-se: critérios são OU (ex: leve OU barato) enquanto subcritérios são E (leve E barato). É
possível ainda fazer combinações: (leve E barato) OU (pesado E caro).
58
É possível ser muito criativo combinando transições e critérios. Por exemplo, se você quiser que um aluno
repita uma tentativa até que ele acerte de primeira, selecione a ocorrência e crie uma transição para ela
mesma. Em seguida, use o critério Soma de erros na tentativa executada > 0, como na Figura 49.
Figura 49: Ocorrência de tentativa com transição para si mesma
Um último recurso interessante: o programador pode criar uma tela de instrução, que será exibida assim que
uma transição for atravessada. Para fazer isto, basta clicar em uma transição e selecionar a aba “Tela de
instrução”. É possível colocar um som, um texto de título, uma imagem e um texto de mensagem. O som e a
imagem, porém, não são selecionados da lista de estímulos mas sim de um arquivo diretamente do seu
computador. Na Figura 50 foi criada uma a tela de instrução que orienta como o aluno deve prosseguir nas
próximas tentativas.
59
Figura 50: Criando uma tela de instrução para uma transição
Durante a sessão, o que o aluno verá em sua tela será parecido com o que está na Figura 51.
Figura 51: Tela de instrução da transição
3.6 Passos
Assim como um bloco é um conjunto de ocorrências de tentativas, um passo é um conjunto de ocorrências
de blocos. Como nos blocos, o termo “ocorrência” tem o mesmo sentido, já que um mesmo bloco pode
aparecer mais de uma vez dentro de um mesmo passo. As semelhanças com blocos não param por aqui. Ao
longo desta seção, várias explicações serão resumidas já que muitos conceitos já foram explicados.
Em geral, um passo é como se fosse uma aula completa. Cada vez que um aluno, acompanhado ou não de
um tutor, for executar uma sessão o GEIC apontará qual o passo mais adequado para começar aquela sessão.
Quando um passo é encerrado, geralmente é encerrada também a sessão, e o aluno precisa retornar depois
60
para executar o passo seguinte. Mais sobre isso no Capítulo 5.
A aba de passos é quase idêntica à de blocos, como por ser visto na Figura 52. O botão de “Usos” mostra em
quais programas o passo está sendo usado. A única diferença nesta tela é o botão “Adaptar”, entre os botões
“Duplicar” e “Remover”.
Figura 52: Aba de passos
A adaptação de um passo é uma espécie de duplicação inteligente. Você já percebeu que as coisas estão
ficando complexas? Um passo é um conjunto de ocorrências de bloco, um bloco é um conjunto de
ocorrências de tentativa, uma tentativa é uma configuração de estímulos…
Agora imagine que você deseja criar um passo semelhante a um existente, com todas as ocorrências de
blocos e tentativas tendo as mesmas funções, mesmas transições e critérios, porém com estímulos diferentes.
Criar um passo novo para isso se tornaria uma tarefa extensa e cansativa, pois no total podem existir centenas
de tentativas e estímulos dentro dele. Apenas duplicá-lo também seria tedioso, porque seria necessário
duplicar também os blocos e as tentativas (e ter muito cuidado para não errar uma vez sequer).
Para simplificar essa tarefa, basta selecionar um passo na tabela e clicar em Adaptar. Uma janela com os
estímulos presentes em todas as tentativas, de todos os blocos, e ainda por cima com separação por tipo, será
exibida como na Figura 53. Lá, basta você mudar apenas os estímulos que desejar (os que não forem
mudados permanecem como estão, inclusive sem gerar cópias desnecessárias).
Tome muito cuidado e se planeje antes de fazer uma adaptação: os estímulos serão substituídos
independentemente se forem modelo, comparação etc, em todas as tentativas daquele passo.
Adaptações mal planejadas geram uma carga computacional muito grande no sistema, então evite inclusive
adaptar passos “só para ver como fica”. Fique atento também para manter a consistência do seu passo, do
contrário você acaba com tentativas com modelos e comparações desconexos: imagine o problema que seria
se uma tentativa mal adaptada instruísse o aluno a clicar em uma árvore e a resposta correta fosse um peixe!
61
Figura 53: Janela de adaptação de passo
Veja na Figura 54 que a criação de passos também é quase idêntica à de blocos. A primeira diferença que se
pode notar é que, como blocos não têm tipo, todos são representados com a mesma cor e contendo apenas
suas identificações (número superior) e ocorrências (número inferior). Os blocos podem ter transições e
funções assim como as tentativas, e suas transições podem ter critérios, subcritérios e telas de instrução.
62
Figura 54: Criação de passo
A outra diferença significativa da criação de um passo são alguns critérios/subcritérios das transições, como
se vê na janela da Figura 55:
•
Soma de erros no bloco executado: semelhante à dos critérios de bloco vistos na Figura 47, mas
diz respeito ao bloco inteiro, e corresponde às somas dos erros de todas as suas ocorrências de
tentativas. Além disso, possui um filtro de tentativas por função (“em tentativas de...”): se a primeira
opção (vazia) estiver selecionada, consideram-se todos os tipos de tentativas; senão, é possível
considerar apenas tentativas com função de consumação, controle de novidade, pré-teste, pós-teste
etc.
•
Soma de erros na última tentativa executada: considera a última tentativa executada na ocorrência
de bloco que passou, e a quantidade de erros feitos nela.
•
Última tentativa do bloco executado: permite verificar qual foi a última ocorrência de tentativa
executada dentro da ocorrência de bloco. Pode-se assim saber se o aluno chegou a uma tentativa
final ou se o bloco terminou abruptamente, porque chegou a uma tentativa e os critérios de suas
transições não foram satisfeitos.
Os critérios de execuções totais, execuções consecutivas e ocorrência anterior são idênticos aos critérios de
bloco, e não há o critério “Estímulo selecionado”.
63
Figura 55: Critérios de transições entre ocorrências de bloco
3.7 Programas
Enquanto os passos são como dias de aula, o programa representa o equivalente a uma disciplina ou matéria,
de forma que pode-se dizer que um aluno que completa um programa de ensino aprendeu o conteúdo
proposto. Assim, pode-se dizer que um programa é um conjunto de ocorrências de passos e suas transições.
Uma visão geral da aba de programas pode ser vista na Figura 56. Novamente, tudo muito parecido com a
aba de passos, porém com algumas novidades interessantes. Uma nova coluna Status indica se o programa
ainda está em desenvolvimento (editável), se está pronto para uso (disponibilizado) ou se foi considerado
impróprio para uso (bloqueado). Da mesma forma, o segundo menu da busca realiza um filtro por tipo,
permitindo por exemplo que sejam listados apenas os programas disponibilizados.
Figura 56: Aba de programas
O botão “Adaptar” funciona de forma parecida com o equivalente para passos, só que aqui a adaptação
ocorre em um programa inteiro. É possível fazer coisas muito interessantes aqui, como por exemplo adaptar
um programa de ensino de leitura do idioma português para o inglês, em apenas alguns cliques.
Uma novidade genuína para programas é o botão “Exportar”. Clicando nele, todos os dados de um
programa (passos, blocos, tentativas etc.) serão salvos em um único arquivo, que você pode baixar para o seu
64
computador. Esse arquivo pode então ser aberto no módulo de Sessões com a opção “sessão desconectada”,
permitindo que uma sessão seja aplicada mesmo em lugares que não possuam acesso à Internet.
Os botões de “Permissões” e “Usos” são um pouco diferentes do que em passos. Como qualquer pessoa pode
usar um programa disponibilizado, a permissão que pode ser alterada na janela de permissões passa a ser
apenas de edição, como na Figura 57.
Figura 57: Permissões de um programa
Já a janela de “Usos”, que pode ser conferida na Figura 58, aqui mostra também quais projetos estão usando
o programa selecionado. Ao clicar em um projeto, uma outra lista na parte inferior é preenchida com os
alunos que estão cadastrados naquele projeto e matriculados no programa. Esse processo de associação de
um programa a um projeto e de matrículas de alunos será descrito em mais detalhes no Capítulo 4.
Figura 58: Usos de um programa
A criação de um programa em geral se assemelha à criação de passos, conforme a Figura 59. Uma novidade
é que nas transições há uma nova opção “Finalizar sessão ao se alcançar essa transição”. Se marcada, a
seta da transição passa a exibir um traço perpendicular: quando a sessão estiver sendo executada e o aluno
passar por esse tipo de transição, a sessão terminará imediatamente, como se o dia de aula tivesse acabado.
65
Figura 59: Criação de programa de ensino
Os critérios para transições são semelhantes aos utilizados na criação de passos, como pode ser visto na
Figura 60. Evidentemente, o que antes se referia a blocos agora se refere a passos.
Figura 60: Critérios de transições entre passos
De forma semelhante às telas de instrução (das transições), em um programa é possível definir uma tela de
finalização de sessão, que sempre será exibida quando uma sessão terminar. Para isso, basta clicar na aba
“Finalização de sessão” da tela de criação do programa e definir um arquivo de som, uma imagem, um texto
66
de título e uma mensagem, assim como na Figura 61.
Figura 61: Criando tela de finalização de sessão
A tela resultante aparecerá no módulo de Sessões e será como na Figura 62.
Figura 62: Tela de finalização de sessão
Assim que um programa estiver pronto e devidamente testado e o programador estiver confiante, chega a
hora de o programa ser disponibilizado, permitindo assim que alunos sejam matriculados nele. Para
disponibilizar um programa, o usuário deve obedecer a dois critérios: possuir a permissão de disponibilizar
programas, dada por um superior no módulo de Projetos, e ser dono ou poder editar o programa
selecionado. Disponibilizar um programa é simples: abra a tela de edição e clique no botão “ Disponibilizar”
(Figura 63).
67
Figura 63: Edição de um programa
Uma janela de confirmação (Figura 64) será mostrada, alertando da importância de se disponibilizar um
programa (e as consequências disso) e exigindo uma confirmação. Todo esse cerimonial é necessário porque
assim que um programa é disponibilizado para uso, tudo o que é usado dentro dele (estímulos, tentativas,
blocos etc.) fica permanentemente bloqueado. Isso porque no momento em que você cogitar editar um
programa disponibilizado ele pode estar sendo executado por um aluno (e seria um absurdo os estímulos
mudarem enquanto ele está estudando!).
Figura 64: Confirmação de disponibilização de um programa
Após um programa ser disponibilizado, a tela de edição passa a exibir um botão “Bloquear”, usado no caso
de ser encontrado algum erro no programa, ou quando ele for substituído por outro mais atualizado. Se o
68
bloqueio for confirmado (também há uma tela de confirmação para isso), o programa não ficará mais visível
nos módulos de Projetos e Sessões e, se houver algum aluno matriculado, todas as matrículas ficarão
bloqueadas. Um programa que foi bloqueado pode ser disponibilizado novamente, bastando clicar no botão
da mesma forma que antes; as matrículas assim voltam a ficar ativas e o programa visível.
69
4 Módulo de Projetos
No capítulo anterior vimos todos os detalhes sobre como criar e testar um programa de ensino. Alguns
pontos, porém, ficaram em aberto: como matricular um aluno em um projeto? Como vincular um programa a
um aluno? Como conferir os resultados de uma sessão executada? Quem são os tutores e de quais projetos
eles participam? Gerenciar esses e outros recursos são as tarefas do módulo de Projetos.
De maneira mais geral, no módulo de Projetos são gerenciados projetos, escolas, alunos e membros de
equipe, assim como as relações entre eles. Você pode pensar nele como um módulo organizacional, que
gerencia os recursos humanos de uma empresa.
Antes de qualquer coisa, é importante destacar que para ter acesso a este módulo é preciso ter uma
permissão específica, que é “Acessar módulo de Projetos”. Apenas usuários com permissões avançadas
poderão fazer isso por você, então se necessário converse com o coordenador do seu projeto.
Munido da devida permissão, a lista de módulos no site do GEIC passará a exibir o link projetos. Clique
nele, e assim como no módulo de Autoria, você será levado à janela principal do módulo, assim como pode
ser visto na Figura 65.
70
Figura 65: Janela principal do módulo de Projetos
Na parte superior da janela há quatro abas, uma para cada entidade principal dos projetos. Nas próximas
seções cada uma dessas abas será explicada em detalhes.
4.1 Membros da equipe
Os membros da equipe (ou apenas membros) são os profissionais que fazem parte da equipe do GEIC e dos
projetos. Uma visão geral dessa aba pode ser vista na Figura 66.
71
Figura 66: Aba de membros
O formato da aba é muito parecido com o que encontramos no módulo de Autoria: uma tabela, campos de
filtro, colunas de identificação, botões para criar, editar e remover etc. As diferenças aqui são a coluna de
nome de usuário (que como será explicado mais adiante é usado para se acessar os módulos) e botão de
permissões.
Usuários sem a permissão para gerenciar membros de equipe não conseguirão acessar a aba
“Membros” (ela aparecerá bloqueada).
O administrador ou um usuário com permissão de editar membros pode clicar no botão “Criar” para registrar
um novo usuário membro da equipe. Veja na tela da Figura 67 que a maioria dos campos é auto-explicativa:
nome completo, data de nascimento, sexo, e-mail e celular. Nem todos os campos são obrigatórios, então
necessariamente você não precisa fornecer uma foto, seus telefones etc, porém isso facilita muito na
organização das equipes.
72
Figura 67: Criando um membro de equipe
Dois campos desse formulário merecem destaque:
•
Nome de usuário: é com este nome que você acessará os módulos. O nome de usuário não tem, e
não precisa ter, relação alguma com o nome completo do membro. Por exemplo, um membro com
nome completo “José da Silva” poderia escolher os nomes de usuário “josedasilva”, “josesilva”,
“membroequipe2” etc. Uma restrição é que você não pode usar acentos, espaços etc, apenas letras,
números e underscore (_). A outra restrição é que um nome de usuário não pode estar sendo usado
por outra pessoa, sendo que para isso há o botão “Verificar disponibilidade”. Como você já deve ter
percebido, esse processo todo é parecido com a criação de uma conta de e-mail no Gmail ou Yahoo!.
•
Senha: escolha esse valor com cuidado, pois ele ajuda a manter o sistema como um todo mais
seguro. Misture letras, números e caracteres especiais (hífens, vírgulas etc), não use a senha do seu
banco nem sua data de nascimento etc.
Após isso, uma nova janela com as permissões do membro recém-criado será exibida, como na Figura 68. As
permissões da aba “GERAL” são bastante auto-explicativas mas valem o comentário:
•
Membro de equipe ativo: caso você não queira remover um membro mas também não queira que
ele acesse o GEIC por algum tempo, desmarque está opção. Um membro de equipe inativo tem todas
as suas permissões revogadas, ficando impedido até mesmo de acessar o site.
•
Acessar SiteAdmin: permite ao membro administrar o site do GEIC, publicando notícias, anexando
documentos, cadastrando publicações etc.
73
•
Disponibilizar programas: define se um membro pode disponibilizar os programas criados no
módulo de Autoria, como citado no final do Capítulo 3.
Figura 68: Permissões gerais de membro de equipe
Algumas permissões possuem à sua direita uma opção “transferível”. Esse recurso permite que o membro
possa repassar a permissão que ele acaba de receber para outro futuro membro. Por exemplo, se eu criar um
membro X e der a ele a permissão “Acessar SiteAdmin”, no futuro X poderá ele mesmo criar um membro Y
e dar a ele essa mesma permissão.
Como os recursos do módulo de Projetos são muitos, eles também exigem muitas permissões. Por isso, a
segunda aba “Projetos” é dedicada para as permissões desse módulo, como na Figura 69. São as permissões:
•
Acessar módulo: é o básico para que o membro possa acessar o módulo de projetos e consultar a
lista de projetos existentes. Porém, se o membro não tiver ao menos uma das próximas permissões
ele não terá muito o que fazer.
•
Editar alunos: permite ao membro criar, editar e desativar alunos.
•
Editar escolas: permite ao membro criar, editar e remover escolas.
•
Editar membros de equipe: permite ao membro gerenciar outros membros. Especialmente útil para
coordenadores de projeto, responsáveis por um grupo de tutores em uma cidade etc.
Figura 69: Permissões específicas para o módulo de Projetos
74
Após criado, é possível consultar e editar um membro de equipe. Curiosidade: na tela de edição de membros,
na segunda aba (Projetos) há uma lista dos projetos dos quais o membro faz parte, assim como seu papel
neles. Veja um exemplo na Figura 70.
Figura 70: Projetos associados a um membro
4.2 Escolas
Como o GEIC é uma plataforma voltada dentre outras coisas para ensino, é natural que a maioria dos alunos
esteja matriculada em uma escola. Portanto, é interessante manter um registro dessas escolas para se ter
estatísticas sobre onde o sistema está sendo usado, como entrar em contato com os responsáveis, quais
alunos de uma determinada escola estão usando o GEIC etc. A aba de escolas é semelhante às outras
apresentadas até agora (veja na Figura 71).
75
Figura 71: Aba de escolas
Criar e editar uma escola é trivial, bastando fornecer seu nome, cidade, estado e tipo de administração
(pública, privada ou não-governamental) e informações opcionais, como endereço, telefone, e-mail, página
da Internet e algum contato. Veja isso na Figura 72.
Figura 72: Criando uma escola
4.3 Todos os alunos
Os alunos são aqueles usuários que irão efetivamente executar os programas de ensino com o objetivo de
aprender algo, participar de uma pesquisa etc. Uma visão geral da aba de alunos pode ser vista na Figura 73.
76
Figura 73: Aba de alunos
Observe que a maioria dos alunos está associada a uma escola, contudo isso não é obrigatório. Casos em que
isso pode acontecer incluem pesquisas com adultos, provas de auto-escola etc.
Preste atenção também na coluna de cidade: se no cadastro do aluno for informada uma escola, a cidade
listada na tabela será a da escola. Se, porém, o aluno não estiver em uma escola, a cidade exibida será a do
próprio aluno. Imagine por exemplo um aluno que mora em São Carlos-SP mas que estuda na cidade
vizinha, Ibaté-SP: na tabela será listada Ibaté-SP.
A tela de cadastro e edição de aluno pode ser vista na Figura 74. Os campos aqui são bastante autoexplicativos e parecidos com os do cadastro de membro. Opcionalmente, o aluno pode ter um nome de
usuário e senha. Se preenchidos, o aluno poderá acessar o módulo de Sessões por conta própria (sem auxílio
de um tutor) e executar os programas em que estiver matriculado.
Sempre preencha campos de nomes, endereços etc. corretamente, evitando abreviações e outras
formas de simplificação. Também evite adicionar aos nomes das pessoas características como
“turma B” e “inativo”, já que há campos próprios para isso. Essas dicas podem parecer perda de
tempo no início mas quando você tiver centenas de alunos e membros de equipe elas farão toda a
diferença.
77
Figura 74: Cadastro de aluno
Novidades nesta tela incluem informações sobre os pais, que podem auxiliar muito os membros a
localizarem uma criança, entenderem o ambiente familiar de um aluno etc. É aqui também onde se deve
informar a escola, a turma e o professor do aluno.
A segunda aba desta tela possui um espaço livre para observações adicionais sobre o aluno (veja na Figura
75), o que pode ser muito útil por exemplo caso o aluno possua alguma deficiência que mereça atenção.
78
Figura 75: Observações sobre o aluno
Por fim, após o aluno ter sido criado, a tela de edição conta com uma terceira aba com os projetos aos quais o
aluno está associado (Figura 76). Ao se selecionar um projeto na lista superior, a lista inferior é preenchida
com os programas de ensino nos quais o aluno está matriculado e também com informações como data de
início da matrícula, data de fim (se ela já foi encerrada), data da última sessão executada, se a matrícula
naquele programa está bloqueada ou suspensa e a identificação daquele programa no sistema.
79
Figura 76: Informações de projetos do aluno
4.4 Projetos
Chegamos à aba principal do módulo de Projetos, que é onde a maioria dos membros passará a maior parte
do tempo fazendo seus trabalhos. Já vimos uma imagem dessa aba na Figura 65 e, a princípio, pode parecer
que não há muito o que se fazer por aqui. Porém, é partindo deste ponto que conseguiremos acompanhar os
membros e seus papéis, matrículas, resultados de sessões etc.
Afinal, o que é um projeto? Pense nele como se fosse um grupo de membros e alunos trabalhando, juntos,
por uma causa. Um projeto pode ser uma iniciativa para alfabetizar os adultos da periferia, um trabalho de
doutorado, até mesmo uma pesquisa para descobrir qual o modelo de carro preferido por mulheres jovens. As
possibilidades são infinitas!
Antes de começarmos a falar sobre a criação de um projeto, é importante saber que:
Apenas o administrador do sistema é capaz de cadastrar um projeto e não há como repassar essa
permissão para outros membros, nem para os coordenadores dos projetos.
Devido ao fato de um projeto ser algo muito importante e envolver muitas pessoas (às vezes inclusive
crianças), a criação de um projeto é rigidamente controlada. Apesar disso, vamos prosseguir com a tela de
criação, que pode ser vista na Figura 77.
80
Figura 77: Criando um projeto
Os campos desta tela são:
•
Nome: algo bem descritivo, que diferencia bem um projeto dos demais. No caso de um projeto de
doutorado, por exemplo, o nome pode ser o título da tese. Já se o projeto for uma disciplina
específica, o título poderia ser algo como “Matemática Básica – Primeiro Semestre”.
•
Descrição: algo sucinto porém descritivo, que vá além do título e dê uma visão geral sobre o projeto,
seus objetivos, contexto etc. É opcional (mas muito recomendado).
•
Tipo: pode ser ensino (como uma disciplina), pesquisa (como um projeto de doutorado) ou extensão
(por exemplo um trabalho social).
•
Coordenador: quem ficará responsável, daqui para frente, sobre tudo o que acontecer no projeto.
O coordenador é uma figura importantíssima em um projeto. Apesar de apenas o administrador do sistema
poder criar novos projetos, o coordenador é quem tem total controle sobre seu projeto, podendo vincular
programas, membros e alunos.
Depois de criado, o projeto poderá ser apenas consultado pelos outros usuários, que não poderão alterá-lo.
Veja na tela da Figura 78 as abas que são reveladas após o projeto ter sido criado.
81
Figura 78: Editando um projeto
A aba Geral nós já vimos. A única novidade aqui é que o coordenador do projeto pode passar o seu cargo
para outro membro da equipe. Evidentemente, se isso for feito ele abrirá mão de qualquer permissão (e
responsabilidade) sobre aquele projeto.
A aba Programas (Figura 79) possui os programas vinculados àquele projeto. Só poderão ser vinculados a
um projeto programas que foram devidamente criados, testados e disponibilizados no módulo de Autoria, ou
seja, não é possível aqui vincular programas não-autorizados. Vale destacar que, devido à natureza
colaborativa do GEIC, um mesmo programa pode ser vinculado a vários projetos, permitindo assim uma
economia de esforço enorme da criação e disponibilização de programas.
Figura 79: Programas vinculados ao projeto
82
Ao vincular um programa a um projeto, imediatamente será exibida uma janela com opções chamadas
modificadores, muito parecidos com os da Figura 24. Com eles, é possível modificar alguns parâmetros do
programa vinculado apenas quando ele for executado no projeto selecionado, sem afetar o programa original.
Essas opções são essenciais, por exemplo, quando você quer usar um programa muito bom mas que apenas
no seu projeto ficariam melhor com um pequeno ajuste. Uma janela de modificadores pode ser vista na
Figura 80.
Figura 80: Modificadores padrão de um programa
Quando os modificadores são definidos no vínculo do programa, todas as sessões subsequentes que forem
executadas estarão sujeitas aos mesmos modificadores. Ainda assim, quando o programa for executado no
módulo de Sessões, uma janela com modificadores também aparecerá, dando a chance de alguns ajustes de
última hora.
É possível também não modificar em nada o programa no momento do vínculo, e deixar que os
modificadores sejam escolhidos apenas no momento da sessão. Porém, quando o volume de alunos é muito
grande isso costuma se tornar cansativo.
Há ainda a situação em que o coordenador quer definir os modificadores no momento do vínculo e não quer
que os tutores possam modificá-los no momento da sessão. Para isso, basta na janela de modificadores
desmarcar a opção “Permitir que um tutor modifique estas configurações”.
83
Para não desviarmos demais do nosso assunto principal aqui, que são os projetos, falaremos mais sobre
modificadores de sessão no Capítulo 5.
Voltando aos programas vinculados ao projeto: um programa só poderá ser desvinculado do projeto se
nenhum aluno estiver matriculado nele (do contrário, o que seria dos alunos?). Nesses casos, é exibido um
aviso como o da Figura 81.
Figura 81: Janela de erro ao desvincular programa
Voltando à tela principal, as próximas abas são bem parecidas e estão todas relacionadas aos papéis dos
membros. São essas abas:
•
Gestores: um membro gestor pode vincular tutores ao projeto. Pode também fazer modificações nos
alunos vinculados, inclusive nas matrículas. Geralmente é alguém responsável por uma equipe de
tutores, como por exemplo o diretor de uma escola em um projeto envolvendo várias escolas.
•
Programadores: são os responsáveis por criar programas. Para poder acessar o módulo de Autoria,
basta que um membro seja programador de ao menos um projeto.
•
Analistas: são os membros responsáveis por fazer a análise em lote dos dados coletados durante as
sessões. Analistas (de dados) geralmente são membros interessados em aspectos gerenciais do
sistema, como o número de escolas que executaram um determinado programa. Podem ser também
pesquisadores analisando dados coletados em uma pesquisa e interessados em saber, por exemplo,
qual o desempenho médio de todos os alunos de um projeto no programa de ensino de química.
•
Tutores: aqueles membros que podem iniciar uma sessão junto aos alunos, orientando-os ao longo
da sessão. Podem também matricular alunos em programas. Para que um membro possa acessar o
módulo de Sessões basta que ele seja tutor de ao menos um projeto.
Um mesmo membro de equipe pode fazer parte de vários projetos, e em cada um deles ter papéis
diferentes.
Voltando à consulta do projeto, chegamos à aba de alunos (de longe a mais complexa). Um exemplo pode ser
visto na Figura 82, onde se encontram também o tradicional par de botões vincular / desvincular. A novidade
aqui é o botão “Matrículas”, que merece inclusive uma seção dedicada.
84
Figura 82: Alunos do projeto
4.4.1 Matrículas
Uma matrícula no GEIC é a associação de um aluno a um programa, ambos vinculados a um projeto. Essa
relação é muito parecida com o que acontece no ensino superior, onde um aluno se matricula em uma
disciplina (Cálculo, Filosofia da Ciência etc.) e ambos estão vinculados à universidade, e não tem relação
alguma com o modelo usado em escolas de ensino básico, onde um aluno se matricula em uma série.
Voltando à interface, ao clicar no botão “Matrículas” uma tela como a da Figura 83 será exibida.
Figura 83: Lista de matrículas de um aluno
Para matricular um aluno em um programa de ensino, basta clicar no botão “Matricular”. Os programas
anteriormente vinculados ao projeto serão exibidos, e após um programa ter sido escolhido a lista de
matrículas ficará como na Figura 84.
85
Figura 84: Programa na lista de matrículas
Caso o aluno ainda não tenha executado uma sessão naquele programa, ele poderá ser desmatriculado pelo
gestor caso tenha havida um engano ou outro problema. Porém, se alguma sessão já tiver sido executada,
uma mensagem como a da Figura 85 será mostrada avisando que a matrícula não poderá ser removida.
Figura 85: Erro ao remover matrícula
Caso uma matrícula precise ser interrompida, por exemplo se o aluno se mudar para outra cidade e não puder
mais acessar o GEIC, o gestor pode suspendê-la. Basta selecionar o botão “Suspender” e fornecer uma
justificativa (obrigatória). Uma suspensão pode ser revertida, bastando clicar em “Continuar”.
Todas as matrículas de um aluno também serão suspensas se o aluno for desativado. Neste caso, a
justificativa será definida automaticamente como “Aluno suspenso”.
Ainda, é possível terminar prematuramente uma matrícula. Normalmente uma matrícula é terminada de
forma automática quando o aluno chega ao final do programa de ensino por meio do módulo de Sessões.
Porém, em alguns casos o gestor pode achar necessário adiantar esse processo, e para isso ele pode clicar no
botão “Finalizar”, obrigatoriamente tendo que informar a data de encerramento ou como a data da última
sessão executada ou como a do instante em que clicar para finalizar.
Continuando com as facilidades para se gerenciar matrículas, há uma opção para alteração de passos.
Ocasionalmente o aluno poderá apresentar um desempenho acima ou abaixo do esperado no programa, de
forma que o sistema do GEIC não consiga deixá-lo na ocorrência de passo ideal para seu nível. Nesse caso, o
gestor pode selecionar “alterações de passos” e definir um novo “passo atual” para o aluno (ver Figura
86). Da próxima vez em que o aluno for executar uma sessão ele já começará a partir do novo passo.
Alterações de passo exigem uma justificativa escrita.
86
Figura 86: Alteração de passo do aluno
Na mesma tela, na aba “Histórico”, ainda é possível conferir um histórico dessas alterações, como na Figura
87. Clicando no botão “Exibir passo” é possível consultar a configuração do passo em uma tela semelhante
à do módulo de Autoria (Figura 54), evidentemente sem poder alterá-lo.
Figura 87: Histórico de alteração de passos
Voltando à tela de matrículas, é possível selecionar uma matrícula e clicar no botão “Sessões executadas”.
87
4.4.2 Sessões executadas
No GEIC, uma sessão executada ou execução de sessão é o nome que se dá ao conjunto de dados coletados
durante uma sessão. Entre esses dados estão os momentos de início e fim da sessão, quem foi o tutor (se
houve algum), quais os passos/blocos/tentativas executados etc. Uma execução de sessão é sempre
registrada por meio do módulo de Sessões no momento em que a sessão termina.
Execuções de sessão sempre são enviadas ao servidor do GEIC ao final da sessão (e nunca
durante). Assim, a execução de sessão continua sendo registrada localmente mesmo que não haja
conexão com a Internet.
Quando o aluno já tiver executado várias sessões, a tela de sessões executadas ficará como na Figura 88.
Observe que toda sessão executada possui seu próprio número identificador, se ela foi cancelada ou não etc.
Figura 88: Sessões executadas no programa
Na barra de ferramentas da janela há várias opções disponíveis. Os botões “Exportar tabela” e “Exportar
estatísticas” geram relatórios da sessão executada no formato “CSV”, que pode ser lido por programas de
planilhas como Microsoft Excel e LibreOffice Calc. Veja nas figuras 89 e 90 alguns exemplos.
Figura 89: Arquivo gerado pela opção "Exportar tabela"
88
Figura 90: Arquivo gerado pela opção "Exportar estatísticas"
O botão “importar sessão” ativa um recurso muito interessante: importar os resultados de uma sessão
executada a partir de um arquivo. Quando isso é útil? Naqueles casos onde se executou o módulo de Sessões
em locais sem acesso à Internet. A janela que será exibida na importação de sessão pode ser vista na Figura
91, porém discutiremos mais detalhes sobre isso apenas no Capítulo 6.
Figura 91: Importando uma sessão desconectada
Já o botão “Exibir programa” mostra a estrutura do programa (ocorrências de passo, transições etc), da
mesma forma como se ele estivesse sendo consultado pelo módulo de Autoria (como visto na Figura 59). Por
fim, clicando duas vezes em uma sessão ou no botão “Exibir passos” será exibida a janela da Figura 92 com
as ocorrências dos passos que o aluno executou naquela determinada sessão, assim como estatísticas como os
horários de início e fim de um passo específico, membro da equipe que monitorou o aluno, os modificadores
daquela sessão, comentários etc.
89
Figura 92: Passos executados em uma sessão
E assim sucessivamente para exibir os blocos executados (Figura 93).
Figura 93: Blocos executados em um passo
Idem para o botão “Exibir tentativas”, que por sua vez mostra a janela da Figura 94 com os resultados que
o aluno obteve em cada uma das interações de cada ocorrência de tentativa.
90
Figura 94: Tentativas em um bloco
Em alguns casos, clicar duas vezes sobre a linha da resposta faz com que sejam mostrados detalhes sobre as
seleções de estímulo em uma interação. Para tentativas CR, por exemplo, a janela de seleções tem a
aparência da Figura 95.
Figura 95: Respostas do aluno em uma ocorrência de tentativa
Todas essas informações podem parecer exagero: para que saber o que foi clicado, com tanta precisão? Em
alguns domínios da pesquisa, esses milissegundos fazem diferença! Esses detalhes serão mais úteis ainda
quando estivermos analisando centenas de estudantes simultaneamente por meio do módulo de Análise.
91
5 Módulo de Sessões
Os módulos apresentados até agora ensinaram como preparar um programa de ensino completo, a associar
um programa a um projeto, como matricular alunos a um programa, gerenciar os membros da equipe etc.
Toda essa infraestrutura de nada serviria se os alunos não pudessem fazer o principal: executar sessões.
O módulo de Sessões permite aos alunos executarem os programas tão cuidadosamente criados e testados
pelos programadores. Dá também o suporte necessário para que os tutores acompanhem os alunos no
decorrer da sessão. Ao final de cada sessão os dados são enviados de volta ao GEIC, através da Internet, e
passam a ficar disponíveis para consulta tanto por meio do módulo de Projetos quanto pelo de Análise.
A janela de autenticação do módulo é como a da Figura 96. Pelo site, essa janela é exibida apenas quando a
janela principal do módulo é fechada, para permitir que o usuário se autentique novamente ou execute uma
sessão desconectada. O botão “Carregar...” é o que permite essa sessão desconectada e será detalhado
posteriormente.
Figura 96: Janela de autenticação do módulo de Sessões
92
Os únicos tipos de usuário que podem acessar este módulo são alunos e membros de equipe com o papel de
tutor em ao menos um projeto. Na maioria dos casos, o tutor acessa o módulo de Sessões usando suas
credenciais, seleciona um dos alunos do seu projeto e inicia uma sessão. Porém, caso o aluno possua um
nome de usuário e uma senha, ele mesmo poderá iniciar uma sessão.
5.1 Acesso como tutor
No caso do usuário ser um tutor, a primeira coisa que ele precisa decidir é com qual projeto ele trabalhará
naquele momento, como na Figura 97. Lembrando: um mesmo membro pode ser tutor em vários projetos.
Um tutor só verá na lista de projetos aqueles dos quais ele faz parte. Dessa forma, não há risco
algum de interferência ou acessos indesejáveis.
Figura 97: Lista de projetos no módulo de Sessões
Aqui um tutor tem a opção de testar um projeto marcando o campo “Testar projeto” e, com isso, não é
preciso selecionar um aluno, mas apenas o programa e o passo desejado. Os resultados nesse modo são
descartados ao final da sessão. Se o teste não for marcado, clicar em “Prosseguir” fará com que o GEIC
automaticamente busque os alunos vinculados ao projeto e disponíveis para tutoria, como na Figura 98.
Figura 98: Lista de alunos vinculados ao projeto
93
Ao selecionar um aluno, basta clicar no botão “Monitorar”. Note a lista das teclas de atalho na parte inferior
da janela: elas devem ser lembradas antes da sessão, já que isso não pode (nem deve) ser exibido aos alunos.
Ao confirmar, será exibida uma lista com todos os programas nos quais o aluno está matriculado (ver Figura
99), assim como uma lista de modificadores de sessão. Caso algum modificador tenha sido definido no
módulo de Projetos, no vínculo do programa, esta tela já virá com alguns campos marcados
automaticamente. Ainda, se no módulo de Projetos o último modificador (“Permitir que um tutor
modifique estas configurações”) tiver sido desmarcado, o tutor não poderá alterar os modificadores.
Figura 99: Lista de programas em que o aluno está matriculado e seus modificadores
Em comparação com os modificadores do módulo de Autoria, aqui há quatro opções a mais. A primeira delas
é “Não exibir nome próximo passo”: por padrão, ao final da sessão, uma janela aparecerá informando o
nome do próximo passo, como na Figura 100. Isso é especialmente útil para guiar os tutores. Esse aviso só
aparecerá, contudo, se o programa em questão já não tiver uma tela de finalização (que por natureza informa
qual o próximo passo). Se a opção estiver marcada, essa janela não será exibida.
94
Figura 100: Próximo passo da sessão
Caso o programa termine (não havendo mais passos a serem executados) a janela da Figura 101 é exibida.
Figura 101: Final do programa de ensino
Outros modificadores, “Não permitir comentário ao final da sessão” e “Permitir não justificar
cancelamento de sessão”, se referem a sessões encerradas normalmente ou canceladas via tecla de atalho.
Quando a sessão termina normalmente, um campo de comentário é mostrado para que o tutor escreva (se
desejar) algumas observações sobre aquela sessão (Figura 102). O primeiro modificador faz com que a
sessão seja encerrada imediatamente, sem exibir essa janela.
Figura 102: Campo de comentário ao fim da sessão
95
Já quando a sessão é cancelada, por padrão é obrigatório que o tutor escreva um texto (com tamanho entre 5
e 256 caracteres) justificando por que precisou fazer aquilo (ver Figura 103). Se o modificador estiver
selecionado, a justificativa passa a ser opcional, não exibindo o texto em vermelho e permitindo que o
usuário pressione o botão “Salvar” imediatamente.
Figura 103: Campo de justificativa ao fim da sessão
Por fim, o modificador “Gravar áudio em tentativas NOM” faz com que todas as tentativas do tipo NOM
gravem dados de áudio quando forem executadas (se houver um microfone conectado), mesmo que em sua
criação a opção de gravação de áudio estivesse desmarcada.
Voltando às telas de escolha de projeto, aluno e programa, basta clicar em “Executar”. O GEIC procurará a
ocorrência de passo atual do aluno e a janela da Figura 104 será mostrada com algumas informações básicas
sobre o início da sessão. Se tudo estiver pronto, basta clicar no botão “Iniciar sessão”.
96
Figura 104: Tela inicial da sessão
As telas da sessão são quase idênticas às dos testes no módulo de Autoria, porém aqui aquelas informações
adicionais (teclas de atalho etc.) não podem ser mostradas, pois a sessão requer o máximo de foco do aluno.
Um exemplo de tentativa, que é como a sessão é exibida ao aluno, pode ser vista na Figura 105.
97
Figura 105: Tentativa CR sendo executada em uma sessão
Enquanto o aluno executa a sessão, várias informações vão sendo coletadas, tais como os estímulos que ele
selecionou, acertos e erros, o tempo que demorou para responder etc. Ao fim de uma sessão, mesmo que por
cancelamento, tudo isso é enviado automaticamente ao servidor do GEIC.
A exceção a essa regra é quando a opção “Testar projeto” foi selecionada: será exibida uma lista dos
programas disponíveis e será definido um aluno temporário chamado “Aluno de teste” (ver Figura 106).
Figura 106: Teste de projeto de sessão
Ao clicar no programa para testes, uma lista com suas ocorrências de passo será exibida (ver Figura 107).
Quando uma dessas ocorrências for selecionada e o tutor clicar no botão “Executar”, a sessão será
executada a partir daquela ocorrência e continuará até que o programa se encerre. Ao final os dados não
serão enviados ao servidor.
98
Figura 107: Lista de passos disponíveis para teste no programa
5.2 Acesso de aluno
O acesso de um aluno ao módulo de Sessões é muito semelhante ao de um tutor, porém mais restrito. Após
fornecer suas credenciais, o aluno poderá selecionar um dos projetos em que está cadastrado. Em seguida,
uma lista com os programas disponíveis (sem os modificadores) será exibida como na Figura 108.
99
Figura 108: Lista de programas na visão do aluno
Caso os modificadores tenham sido definidos no vínculo do programa (módulo de Projetos), eles
serão aplicados aqui sem o conhecimento do aluno e sem que eles possam ser modificados.
Na tela de início, como não há um tutor monitorando o aluno as informações dele não são exibidas (ver
Figura 109). Todo o restante da sessão é idêntico ao já apresentado e, ao fim da sessão, os resultados são
enviados ao sistema sem que o aluno perceba ou possa fazer comentários.
Figura 109: Tela inicial na visão do aluno
100
6 Módulo de Sessões (desconectado)
O GEIC foi desenvolvido desde o início para fazer uso da Internet em suas sessões de aprendizagem,
garantindo assim maior mobilidade aos tutores e alunos, tornando desnecessário o transporte de mídias para
execução da sessões e garantindo que sempre a versão mais atualizada e correta de um programa de ensino
seja disponibilizada. Porém, nem sempre é possível dispor de uma conexão com a Internet para a execução
de sessões, o que geralmente ocorre em locais de difícil acesso físico (vilarejos, zona rural, áreas de
alagamento etc) e regiões carentes.
Pensando nesse cenário, a equipe do GEIC criou uma forma de execução de sessões que dispensa uma
conexão com a Internet: o módulo Sessões - desconectado. Tudo funciona da seguinte forma...
6.1 Preparação do pendrive
Reserve um dispositivo portável, geralmente um pendrive ou um HD externo, e certifique-se de que ele
possua ao menos 200MB de espaço livre. Conecte-o ao seu computador e acesse o site do GEIC em
http://geic.ufscar.br.
Após efetuar o login, acesse a opção “Sessões - desconectado” e inicie o download (isso pode levar vários
minutos dependendo da velocidade de conexão da sua Internet). Após concluído o download, será salvo no
seu computador um arquivo chamado “sessoes_desconectado.zip”. Descompacte este arquivo para seu
dispositivo portável e você verá que foram extraídas as pastas dll, lib, programas, sessoes etc. Este processo
precisa ser feito apenas uma vez por dispositivo portável, independentemente de quantos programas de
ensino serão aplicados a partir dele.
Perceba que nessa mesma página há um grupo “Instaladores”. Caso o local onde você vá executar as sessões
desconectadas não tenha o Java ou VLC instalados, baixe os arquivos de instalação (com base na arquitetura
dos computadores que serão usados, 32 ou 64-bit) e leve junto ao seu dispositivo portátil (preferencialmente
em uma pasta instaladores).
101
Mesmo que você não vá precisar dos instaladores do Java e do VLC, baixe-os mesmo assim e
copie-os para uma pasta instaladores no seu dispositivo portátil. Você nunca sabe quando os
programas dos computadores onde você executará as sessões terão sido apagados, modificados
etc.
6.2 Download dos programas de ensino
De volta ao site, você precisará acessar o módulo de Autoria. Na aba programas, selecione o programa que
você deseja baixar para seu dispositivo portável e clique em “exportar”. Dependendo da complexidade de
um programa e da quantidade de mídias que ele possui, a exportação pode levar de poucos segundos até
vários minutos. Preferencialmente, salve os programas baixados na pasta programas do seu dispositivo.
O processo de download/exportação precisa ser feito apenas uma vez para um determinado programa de
ensino. Uma vez presente no dispositivo móvel, um programa pode ser executado várias vezes. O nome
padrão do arquivo segue a fórmula “ID DO PROGRAMA.geicp”, ou seja, para o programa de ID 178 o
nome sugerido será “178.geicp”.
Em geral, quando o software do GEIC é atualizado é preciso que os membros baixem novamente
tanto o módulo de Sessões-desconectado quando os programas exportados, do contrário não será
mais possível aplicar as sessões. Fique atento aos e-mails da lista de usuários!
6.3 Iniciando as sessões
Para que o módulo Sessões-desconectado possa ser iniciado é indispensável que o Java
(http://www.java.com) esteja instalado no computador onde você aplicará as sessões. O cenário mais comum
é que isso já esteja feito e que você possa executar as sessões normalmente. Nos casos onde o Java não está
instalado em seu computador, abra a pasta instaladores do seu dispositivo portável e execute o instalador do
Java adequado para seu sistema operacional. Se você é um usuário do Microsoft Windows, por exemplo,
execute o arquivo jre-8u66-windows-i586.exe (para sistemas 32-bit) ou jre-8u66-windows-x64.exe (64-bit) e
siga as instruções na tela. Se você estiver usando Linux, descompacte o arquivo jre-8u66-linux-i586.tar.gz ou
jre-8u66-linux-x64.tar.gz e siga as instruções.
Outra ferramenta que precisa ser instalada é o tocador de vídeos VLC (http://www.videolan.org/vlc). Você
pode encontrar os instaladores para ele na mesma pasta instaladores usada pelo Java. Se você é um usuário
do Microsoft Windows, execute o arquivo vlc-2.1.5-win32.exe (para sistemas 32-bit) ou vlc-2.1.5-win64.exe
(para sistemas 64-bit). Se você estiver usando Linux (por exemplo, Ubuntu), basta executar no console sudo
apt-get install vlc browser-plugin-vlc. Atenção: a instalação do VLC é obrigatória mesmo que sua pesquisa
não use estímulos de vídeo.
Em alguns cenários (nem tão raros), como por exemplo em algumas escolas estaduais, você inclusive não
terá permissão para instalar o VLC nos computadores que serão usados para as sessões. Há um truque para
isso também: se esses computadores possuirem o sistema Microsoft Windows, siga até seu dispositivo portátil
na pasta dll/vlc/win32 (se seu sistema for 32-bit) ou dll/vlc/win64 (se for 64-bit) e copie os arquivos libvlc.dll
e libvlccore.dll para a pasta principal (raiz), junto aos outros arquivos sessoes-windows.bat etc.
Uma vez que tudo esteja corretamente instalado, execute o sessões adequado para seu sistema operacional.
Se você estiver no Microsoft Windows, execute sessoes-windows.bat. Caso você esteja no Linux, execute
sessoes-linux.sh. Caso você deseje executar diretamente as sessões sem usar os atalhos de cada sistema
operacional, execute no console do seu sistema o comando java -jar sessoes.jar. Ainda dependendo do seu
sistema operacional, é possível iniciar sessões com um duplo-clique em sessoes.jar ou pressionando o botão
102
direito do mouse em sessoes.jar e selecionando “Executar com Java WebStart”.
6.4 Execução da sessão
Com o módulo de Sessões iniciado, selecione a opção “Carregar...”, aponte para a pasta programas do seu
dispositivo portável, escolha o programa que você deseja executar e confirme. Em seguida será exibida uma
tela com todas as ocorrências de passo presentes no programa e os parâmetros da sessão, tais como exibição
de dicas e pontos, modificadores de letra maiúscula etc (algo parecido com a Figura 107). Faça sua escolha e
clique em “Monitorar”. A sessão será iniciada imediatamente.
Perceba que a ocorrência de passo a ser executada não é selecionada automaticamente pelo sistema. Isso
ocorre porque, ao contrário do que ocorre nas sessões tradicionais / on-line, o módulo Sessões-desconectado
não possui acesso à Internet e não tem como saber em qual passo do programa um aluno se encontra.
6.5 Salvamento dos dados da sessão
Logo que a sessão chegar ao fim, um arquivo contendo todos os resultados do aluno será criado e o sistema
pedirá para você selecionar uma pasta de destino. Preferencialmente, salve as execuções de sessão na pasta
sessoes do seu dispositivo portável. O nome padrão do arquivo segue a fórmula ANO MÊS DIA_HORA
MINUTO SEGUNDO.geics, ou seja, para uma sessão iniciada em 19/08/2013 às 08:30:55h o nome sugerido
será 20130819_083055.geics. Caso você seja responsável por mais de um aluno, é uma boa prática adicionar
ao nome do arquivo o nome do aluno sendo monitorado (exemplo: josesilva_20130819_083055.geics).
Muito cuidado ao manusear arquivos de sessão! Caso você perca ou apague esses arquivos antes
de enviá-los ao servidor do GEIC, será impossível recuperar o registro das sessões!
6.6 Upload dos dados da sessão
O passo final envolve enviar o registro das sessões executadas ao servidor do GEIC, integrando assim esses
dados às fichas dos alunos. Isso geralmente será feito ao final do dia, após uma sequência de sessões
executadas com vários alunos, e sempre por um membro de equipe autenticado.
Para prosseguir, volte ao site e acesse o módulo de Projetos. Selecione o projeto associado aos seus alunos,
depois selecione o aluno para o qual você quer atribuir uma execução de sessão, abra a matrícula
correspondente, depois em “Sessões executadas”. Na próxima tela, clique no botão “Importar sessão”
(volte e veja a Figura 91), selecione a sessão desejada (geralmente gravada na pasta sessoes do seu
dispositivo portável) e confirme. Se tudo correr bem, a sessão será adicionada ao histórico do aluno.
Em casos onde mais de uma sessão foi executada no mesmo dia por um mesmo aluno (ex: às
08:30h e às 11:30h) é imprescindível importar as sessões na ordem em que elas foram gravadas.
Note que sem acesso à Internet não é possível determinar quem foi o tutor e o aluno que executaram a
sessão. O membro que enviar o arquivo com os resultados é o que será definido como tutor daquela sessão,
portanto um tutor que executará sessões desconectadas deve preferencialmente ter acesso ao módulo de
Projetos.
O horário definido para a sessão é o horário em que o arquivo foi enviado para o módulo de Projetos, e não o
do arquivo gravado em Sessões-desconectado. Isso acontece para corrigir casos em que a hora do
computador em que a sessão foi executada é diferente da hora do sistema do GEIC, o que causaria uma série
de erros e inconsistências.
103
7 Módulo de Análise
O módulo de Análise é um dos mais interessantes em toda a plataforma GEIC. Com ele é possível investigar
a fundo todas as execuções de sessão geradas por todos os alunos, desde o início do projeto em 2008. Isso
por si só não seria novidade, já que o mesmo poderia ser conseguido (com dificuldade, claro) por meio do
módulo de Projetos, aluno a aluno, sessão por sessão.
A vantagem aqui é que você pode analisar os dados em lote, informando não alunos individuais mas sim
grupos de alunos, escolas, cidades etc. Também é possível fazer pesquisas por programa, analisando o
desempenho de todos os alunos que um dia o executaram. Finalmente, o analista de dados dispõe de uma
combinação quase infinita de tabelas, gráficos, filtros e outros parâmetros que permitem que ele crie
perguntas complexas e receba a resposta em segundos.
Falando mais sobre a mecânica por trás do módulo, diariamente por volta de 4:00h (isso, de madrugada) a
base de dados do GEIC é copiada para um local específico, transformada, mapeada e reduzida. O resultado
então é colocado à disposição para análise, em um formato simplificado porém mais eficiente. Caso esse
procedimento não fosse feito, as consultas no módulo de Análise demorariam demais e logo não serviriam de
muita coisa. Um efeito colateral dessa política diária de atualização é que uma sessão executada em um dia
estará disponível para análise apenas no outro dia.
Para acessar o módulo de Análise, é preciso acessar o site e selecionar o link à esquerda. Contudo, para que
esse link esteja disponível é necessário que, no módulo de Projetos, o membro possua o papel de analista de
dados em ao menos um projeto. Se tudo correr bem, o usuário verá uma tela como na Figura 110.
104
Figura 110: Tela de autenticação do módulo de Análise
De cara você já deve ter percebido algumas diferenças. Ao contrário dos outros módulos, que ao serem
abertos exibiam a janela principal ou uma janela própria para a confirmação das credenciais, aqui a
confirmação é exibida na própria página. Além disso, a confirmação funcionará apenas se o analista possuir
um cadastro específico junto à equipe do GEIC, conseguido pelo e-mail [email protected] ou por meio do
coordenador do seu projeto.
Ao obter acesso ao módulo de Análise, você obterá também acesso irrestrito à base de dados do
GEIC, incluindo todos os alunos, escolas e projetos (e não apenas aos dados do seu projeto). Por
isso uma autorização especial é necessária.
A primeira coisa que você verá ao acessar este módulo é uma página como a da Figura 111. Mesmo para
quem tem certa familiaridade com análise de dados, alguns termos podem parecer estranhos à primeira vista,
tais como “cubo”, “dimensão” e “medida”.
Figura 111: Tela inicial do módulo de Análise
Um cubo é um conjunto de dados multidimensional, uma representação sumarizada de um determinado
assunto, composto por medidas e dimensões. No contexto do GEIC temos um cubo voltado para execuções
de sessões, mas poderíamos também ter cubos para presença dos alunos em sala de aula, distribuição de
membros de equipe por projeto etc. Para selecionar um cubo no módulo de Análise, na opção Cubos (na
porção superior esquerda da janela) selecione “sessões” (por ora nossa única opção). A janela ficará então
como na Figura 112.
105
Figura 112: Dimensões do cubo de sessões
Dimensões são as formas de se detalhar uma análise ou como ela será feita. Exemplos incluem aluno (seu
nome, sexo etc), data da sessão (dia, mês e ano) etc. Veja as opções disponíveis na figura acima, à esquerda.
Já medidas são coisas quantificáveis ou o que se deseja saber. Exemplos incluem quantidades de interações
executadas, quantidade de sessões, média de latência, tentativas executadas etc.
Trocando em miúdos, em uma consulta (ou pergunta) como “Qual a quantidade de sessões executadas por
mulheres na cidade de São Carlos?”, a medida seria “quantidade de sessões executadas” e as dimensões
seriam “alunos do sexo feminino” e “cidade de São Carlos”.
Para se fazer consultas no módulo de Análise, os componentes visuais que representam as dimensões e as
medidas precisam ser arrastados e colocados em ordem, como se você estivesse colocando peças em um
tabuleiro de palavras-cruzadas. Aqui, o equivalente ao tabuleiro são as colunas, linhas e filtros.
As dimensões e medidas colocadas nas colunas e linhas são usadas tanto para resolver uma pergunta quanto
para exibir o resultado em uma tabela. Por exemplo, se eu quisesse saber quantas sessões foram executadas
em cada cidade, bastaria colocar nas colunas a dimensão escola-cidade (que significa o item cidade dentro
da dimensão escola) e nas linhas a medida quantidade de sessões executadas. Para remover uma medida ou
dimensão da consulta, basta arrastá-la para fora da área de consulta.
Veja na parte superior da Figura 113 como esses elementos ficam dispostos. No exemplo, o usuário deseja
descobrir quantas sessões foram executadas em cada programa ao longo dos anos. Perceba um detalhe
importante: nas colunas foram colocadas uma medida e uma dimensão, o que não é algo comum, já que
estamos acostumados com tabelas com apenas um tipo de valor nas linhas e um nas colunas. Por isso um
cubo é chamado de multidimensional: você pode ter uma quantidade arbitrária de valores nas linhas e nas
colunas, gerando tabelas visualmente ricas e muito informativas. Em alguns programas de planilha como
Microsoft Excel e Libreoffice Calc, essas tabelas especiais costumam ser chamadas de pivô.
106
Figura 113: Consultando a quantidade de sessões executadas por ano e por programa
Uma consulta sempre varre todo o banco de dados e não só seus projetos, de forma que muitas vezes ela
demorará e trará resultados que não interessam. Nestes casos, é possível filtrar as dimensões: basta clicar na
pequena lupa no lado direito da dimensão e você verá uma janela como a da Figura 114. Lá haverá os nomes
de todos os membros daquela medida, como por exemplo todos os programas da dimensão programa.
Figura 114: Filtro de programas
Selecionando apenas alguns programas e fazendo a consulta, o resultado ficará mais enxuto, assim como
pode ser visto na Figura 115. Se nenhum item for selecionado, o sistema considerará válidos todos os itens.
Para selecionar apenas itens específicos, deve-se clicar em um ou mais (segurando as teclas Ctrl ou Shift) e
clicando na seta >. Para remover um membro, selecione-o na lista da direita e clicar na seta <. Para adicionar
ou remover todos os membros à outra lista, devem ser selecionadas as setas >> ou <<, respectivamente.
107
Figura 115: Consulta com filtro de programas
É também possível fazer filtros com expressões pré-definidas como “Os 10 com mais resultados”. Se for
necessário por exemplo ver os programas com mais sessões executadas (somando-se todos os anos), basta
clicar na seta ao lado de Linhas e escolher um limite conforme a Figura 116. Para remover um limite, basta
clicar na seta e procurar Limit > Clear limit.
Figura 116: Filtro por linhas
No começo do capítulo citamos linhas, colunas e filtros. Mas de que serviria um grupo filtros se já podemos
filtrar as dimensões clicando nos ícones de lupa? Os filtros são usados quando o analista deseja limitar a
consulta, porém não quer que essa limitação seja exibida na tabela. Continuando o exemplo da figura
anterior, suponha que eu quisesse saber a quantidade de sessões executadas em cada programa ao longos dos
108
anos, porém apenas para a cidade de São Carlos-SP. Para isso bastaria arrastar a dimensão escola-cidade.
Um outro exemplo pode ser visto na Figura 117. Nela foram filtrados os 10 programas com mais sessões
executadas apenas por alunos do sexo masculino. Para isso, basta adicionar nos filtros a dimensão alunosexo, clicar na lupa e, dentre as opções M e F, selecionar apenas M.
Figura 117: Consulta com dimensão de filtro
Algumas vezes é necessário colocar um filtro, porém os itens parecem ter nomes repetidos. Por exemplo, no
filtro de data de sessão por mês, há várias repetições dos meses 1, 4, 5 etc. Para resolver essa ambiguidade, é
necessário marcar a opção “Ocultar membros repetidos” (o que é um erro de tradução, já que marcá-la faz
com que os membros repetidos sejam mostrados). Assim, o filtro fica mais claro, como na Figura 118.
Figura 118: Consulta com filtro e opção de membros repetidos
Sempre que uma medida ou dimensão é adicionada à área de consulta o sistema executa essa consulta
109
imediatamente. Isso pode atrasar o trabalho do analista, pois algumas consultas podem demorar muito. Para
resolver isso, basta desmarcar o ícone “Execução automática” na parte superior (três triângulos verdes
consecutivos). Para executar uma consulta agora basta clicar em “Executar consulta” ao lado dele.
Cada ícone nas pasta das dimensões define uma hierarquia entre elas, de modo que a dimensão mais acima
tem maior nível hierárquico que a mais abaixo. Quando duas ou mais dimensões dessa pasta são usadas na
consulta, elas devem estar sempre no mesmo campo (colunas, linhas ou filtros) e a de maior hierarquia
precederá a de menor (ex: ano de sessão sempre precede o mês da sessão).
Dimensões e medidas que não possuem hierarquias entre si podem ser adicionados à consulta na ordem que
for necessária. Colocando a dimensão de uf (estado da escola dos alunos que executaram o programa) depois
da de programa no campo linha, a consulta fica como na Figura 119.
Figura 119: Consulta com “programa” antes de “uf” nas linhas
Colocando o “uf” antes do “programa”, a consulta fica como na Figura 120.
110
Figura 120: Consulta com “uf” antes de “programa” nas linhas
Outro detalhe interessante: as dimensões e medidas na consulta possuem duas setas em sua extremidade
direita, uma apontando para cima e uma para baixo. Elas servem para ordenar os resultados da consulta de
acordo com aquele elemento, e possuem três estados: ascendente, descendente e livre. Se os estados
ascendente ou descendente estiverem selecionados, os resultados serão organizados dando prioridade à
dimensão/medida e à ordem que foi definida; se o estado for livre, o sistema escolhe uma ordem.
Ao lado da tabela de resultados é possível adicionar alguns gráficos para acompanhar as mudanças em
relação às colunas: são eles o “Spark Bar” (barra - Figura 121) e o “Spark Line” (linha - Figura 122).
Figura 121: Resultados com gráfico de barra
111
Figura 122: Resultados com gráfico de linha
Já o botão “sigma” (Σ) apresenta estatísticas sobre a tabela de resultados, mostrando os valores como
mínimo, máximo, soma, média e desvio padrão, organizados de acordo com as colunas da consulta. Veja um
exemplo na Figura 123.
Figura 123: Estatísticas sobre os resultados
As tabelas de resultados podem ser exportadas para os formatos XLSX e CSV, que podem ser abertos em um
programa de planilhas como o Microsoft Excel ou o LibreOffice Calc, e também para o formato PDF. Para
isso, basta clicar em um dos ícones na parte superior mostrados na Figura 124. Isso é especialmente útil
quando o pesquisador deseja usar o dado bruto (tabular) para realizar análises mais refinadas ou com uma
apresentação mais personalizada.
Figura 124: Ícones para exportar as tabelas de resultados
Além do modo de tabela, é possível mostrar os resultados na forma de gráficos de barra, torta, linha etc.,
como visto na Figura 125. Esses gráficos podem ser exportados para os formatos PNG, JPG, PDF e SVG e
salvos no computador do usuário, para serem usados em relatórios, artigos etc.
112
Figura 125: Resultados na forma de gráficos
Por fim, uma consulta pode ser salva no próprio site. Para isso, clique no ícone do disquete na parte superior,
dê um nome ao arquivo e clique em “Save”. Para abrir uma consulta guardada, basta clicar no ícone da pasta
ao lado do disquete e procurar o arquivo na página que se abrir.
113
8 Administrando o Site
A administração diz respeito ao gerenciamento das notícias, documentos e publicações exibidos aos usuários
no momento em que eles acessam o site oficial do GEIC em http://geic.ufscar.br/. Para acessar essa área, o
usuário precisa da permissão “Acessar SiteAdmin” dada a partir do módulo de Projetos. Após isso, basta
clicar no link SiteAdmin na área de módulos do site.
8.1 Notícias
A primeira página exibida ao membro após clicar no módulo será a de gerenciamento de notícias, como a da
Figura 126.
Figura 126: Área de notícias do site
No link “Criar”, uma página com os campos Título e Conteúdo estarão disponíveis para que o usuário crie
uma notícia (Figura 127).
114
Figura 127: Criação de uma notícia
Essa notícia ficará então disponível na página inicial na área de notícias, conforme a Figura 128:
Figura 128: Página inicial do site
Qualquer usuário poderá então consultar a notícia, que será exibida como na Figura 129.
Figura 129: Consulta de uma notícia
8.2 Documentos
A área de documentos é muito semelhante à de notícias, como pode ser visto na Figura 130. Os documentos
são arquivos importantes relacionados à plataforma GEIC, tais como manuais.
115
Figura 130: Área de documentos
No link “Criar”, assim como para as notícias, estão disponíveis alguns campos para o novo documento, tais
como título, autores, descrição, referência (como o documento poderá ser referenciado por outras
publicações) e arquivo (uma cópia do documento original para download, como um PDF ou DOC). Um
exemplo da criação de um documento pode ser visto na Figura 131.
Figura 131: Criação de documento
A edição e remoção de um documento são idênticas ao caso de uma notícia, sendo possível alterar os campos
da mesma forma. O arquivo que for selecionado na tela de edição substituirá o original nesse caso. O
documento pode ser consultado por qualquer usuário através do link “Documentação” na parte superior do
site, e aparece como na Figura 132:
Figura 132: Consulta de um documento
116
8.3 Publicações
Também semelhante à de notícias e documentos, a área de publicações pode ser vista na Figura 133. Esse é o
local onde são cadastradas as publicações acadêmicas relacionadas ao Projeto GEIC, tais como dissertações
de mestrado, teses de doutorado, artigos científicos etc.
Figura 133: Área de publicações
A criação de uma publicação se dá da mesma forma que a de um documento: a tela de cadastro possui os
campos de título, autores, tipo (resumo, painel, pôster, artigo curto, artigo completo, artigo em revista,
capítulo em livro, livro, dissertação ou tese), resumo em português, resumo em inglês, referências e um
arquivo correspondente à publicação. A consulta de uma publicação aparece como na Figura 134.
Figura 134: Consulta de uma publicação
A tela de criação pode ser vista na Figura 135.
117
Figura 135: Criação de uma nova publicação
118
9 Notificações e mensagens
Enquanto que a área administração do site é restrita a usuários que possuam a permissão necessária, existem
dois recursos disponíveis a todos os membros de equipe: as notificações e mensagens.
Apesar de alunos também poderem acessar o site utilizando suas credenciais (nome de usuário e
senha), eles não possuem acesso a esses recursos, que são restritos apenas aos membros.
9.1 Notificações
Há casos em que um membro de equipe está vinculado a muitos projetos e deseja acompanhar as diversas
atividades que acontecem neles. Para isso, seria necessário que o membro possuísse permissão para acessar o
módulo de Projetos e abrisse os projetos um a um, verificando todos os alunos e matrículas vinculados a ele
e procurando novidades nas sessões executadas. Fica óbvio que isso seria um enorme inconveniente e
dificultaria o trabalho de todos.
Como alternativa para ajudar nesse acompanhamento, o site do GEIC possui o sistema de notificações, que
são avisos gerados sempre que algum desses eventos de interesse acontece; esses eventos incluem, por
exemplo, um novo programa vinculado a um projeto, um aluno matriculado em um programa, as sessões que
são executadas naquele projeto etc.
O acesso à área de notificações pode ser feito clicando no ícone do globo no cabeçalho do site, tal como na
Figura 136. Note o número com fundo vermelho no canto do ícone: ele indica que há notificações que o
usuário ainda não viu, muito semelhante ao que acontece em redes sociais.
Figura 136: Ícone de notificações com aviso
Ao clicar nesse ícone, é exibida uma lista de notificações em ordem decrescente de data, isto é, as mais
recentes aparecem primeiro, como pode ser visto na Figura 137. As mensagens que ainda não haviam sido
vistas aparecem primeiro nessa lista e em negrito; assim que o usuário entra nessa página, todas as
notificações ficam marcadas como lidas, e se voltar à tela de listagem nenhuma delas estará em negrito.
Figura 137: Listagem de notificações
Essa lista, porém, não terá nenhuma notificação sem antes o usuário informar quais tipos de notificação
deseja receber. Para isso, deve-se clicar no link “Preferências”. Será exibida uma listagem de todos os
projetos aos quais o usuário está autenticado e várias caixas de seleção com os tipos de notificação existentes
(Figura 138). Clicar em “todas” faz com que todos os tipos sejam marcados ou desmarcados. Quando as
119
configurações estiverem terminadas, basta clicar em “Salvar” e o usuário passará a receber notificações dos
tipos que marcou nos projetos selecionados.
Figura 138: Preferências de notificações
O sistema exclui automaticamente as notificações cuja data de criação foi há mais de 1 mês; além disso, só é
permitido haver até 999 notificações por usuário. Se houver mais, o sistema também excluirá as mais antigas
automaticamente, mesmo que elas não tenham sido lidas. Portanto, mantenha-se atualizado sobre as
notificações de seu interesse!
9.2 Mensagens
A comunicação entre integrantes de um projeto é essencial, principalmente em projetos grandes e com
muitos membros de equipe envolvidos. Existem diversas formas com as quais os membros podem se
comunicar, como e-mails, programas de mensagens instantâneas, redes sociais etc. Porém, nem todos os
usuários possuem esses recursos e o GEIC é o único contato dessas pessoas com a Internet. Esse é o caso
principalmente com professores mais antigos, de regiões mais humildes etc., fora que isso criaria a
necessidade de gerenciar, conferir e instalar esses recursos para cada usuário.
Para remover mais esse entrave da comunicação interna da equipe, o GEIC possui um sistema de mensagens
semelhante que é integrado diretamente ao site. Voltando ao cabeçalho (Figura 136), note o ícone de
envelope ao lado do ícone de notificações. Esse ícone leva à tela de listagem das mensagens, que é separada
em 3 abas: não lidas, lidas e enviadas (Figura 139). Assim como nas notificações, um número com fundo
vermelho é exibido quando há mensagens novas, mas, ao contrário das notificações, acessar a página de
listagem não faz com que as mensagens sejam marcadas como lidas.
Figura 139: Listagem de mensagens
Nessa tela de listagem é possível selecionar uma ou mais mensagens clicando nas caixas de seleção do lado
esquerdo e excluí-las clicando no botão “Excluir”. Para selecionar todas de uma determinada aba, basta
clicar na caixa de seleção no cabeçalho da lista (isto é, na parte roxa). Ainda, o link “Criar” permite escrever
uma mensagem nova e enviá-la a um membro de equipe.
A página de criação é bem simples, contendo um campo com os projetos dos quais o usuário faz parte, um
campo para selecionar o usuário destinatário, outro campo para o assunto da mensagem e outro para seu
120
conteúdo, conforme a Figura 140.
A primeira coisa a se fazer nesta página é selecionar um projeto; fazendo isso, o campo “Para:” fica
preenchido com os usuários daquele projeto, de onde é possível selecionar um deles para enviar a mensagem.
Ainda, esse campo possui valores “Todos”, “Gestores”, “Programadores”, “Analistas” e “Tutores”, que
podem ser selecionados para enviar cópias da mensagem para todos os membros desses grupos. Note que é
possível enviar uma mensagem para si mesmo, assim como acontece em e-mails; isso pode ser útil caso o
usuário deseje se lembrar de algo do projeto no futuro, por exemplo. Basta então preencher um assunto com
até 128 caracteres e um texto de até 2048 caracteres e clicar no botão “Enviar”.
Figura 140: Criação de mensagem
Voltando à tela de listagem, para consultar uma mensagem, basta clicar no conteúdo de uma delas, que é o
texto verde na coluna “Mensagem”. Será mostrada então a tela da Figura 141, contendo a data da mensagem,
informações de remetente e destinatários, o assunto e seu conteúdo.
Figura 141: Consulta de uma mensagem
Ainda na tela de consulta, é possível excluir a mensagem e respondê-la. Responder uma mensagem funciona
de forma idêntica a criar uma, com alguns detalhes a mais: se nenhum projeto estiver selecionado, o campo
“Para:” fica pré-preenchido com o autor da mensagem original e o assunto e o conteúdo contêm textos
relacionados à mensagem original, como pode ser visto na Figura 142.
121
Figura 142: Resposta a uma mensagem
Por fim, a lista de mensagens “Enviadas” possui uma particularidade, que é a coluna “Lida”. Quando o
destinatário lê ou exclui uma mensagem que recebeu, esta coluna possuirá um ícone de confirmação verde,
de onde o usuário que enviou a mensagem pode ter a certeza de que ela foi recebida ( Figura 143). Se a
mensagem foi enviada a mais de um destinatário, esse ícone aparecerá quando todos tiverem lido ou excluído
a mensagem.
Figura 143: Listagem de mensagens enviadas
122
10Agradecimentos
As seguintes pessoas fizeram (ou ainda fazem) parte da equipe responsável pelo GEIC. As contribuições não
poderiam ser mais diversas: coordenação, concepção, financiamento, análise de requisitos, desenvolvimento
de software, testes, documentação, divulgação etc.
Resultados em ordem alfabética. Caso seu nome não tenha sido incluído, entre em contato com a equipe do
GEIC pelo e-mail [email protected].
Camila Domeniconi
Jussara Pascualon Araújo
Carolina Coury Silveira
Lídia Maria Marson Postalli
Dhayana Inthamoussu Veiga
Mainá Santana
Drausio Capobianco
Marcelo Silveira
Edson Huziwara
Marcia Regina Minto
Felipe Ribeiro Saruhashi
Maria Clara de Freitas
Graziela de Oliveira
Priscila Crespilho Grisante
Guilherme Yuki Hatano
Rodrigo Estevan Bela
Isabela Zaine
Solange Calcagno
Julia Roca
Vera Aparecida Dorsa Periotto
123