Embed Size (px)
Citation preview
Pontifícia Universidade Católica de Minas Gerais
Mestrado em Informática
Um Ambiente Virtual de Aprendizagem Colaborativo
para o Ensino de Algoritmos
Uirá Endy Ribeiro
Belo Horizonte
2008
Livros Grátis
http://www.livrosgratis.com.br
Milhares de livros grátis para download.
Uirá Endy Ribeiro
Um Ambiente Virtual de Aprendizagem Colaborativo para o Ensino de
Algoritmos
Dissertação de Mestrado submetida à Pontifícia Universidade Católica de Minas Gerais como requisito parcial para obtenção do título de Mestre em Informática, com linha de pesquisa em sistemas de informação.
Orientadora: Doutora Lucila Ishitani
Belo Horizonte
2008
FICHA CATALOGRÁFICA Elaborada pela Biblioteca da Pontifícia Universidade Católica de Minas Gerais
Ribeiro, Uirá Endy R484a Um ambiente virtual de aprendizagem colaborativo para o ensino de algoritmos / Uirá Endy Ribeiro. – Belo Horizonte, 2008. 101 f. : il. Orientadora: Profa. Dra. Lucila Ishitani. Dissertação (mestrado) – Pontifícia Universidade Católica de Minas Gerais, Programa de Pós-graduação em Informática. Bibliografia.
1.Algoritmos. 2. Ensino auxiliado por computador. 3. Programação de computadores I. Ishitani, Lucila. II. Pontifícia Universidade Católica de Minas Gerais. III. Título
CDU: 681.3:37
Bibliotecário: Fernando A. Dias – CRB6/1084
À Deus,
por sempre ser um Pai de amor e bondade infinitos ;
Ao meu filho Arthur,
por sempre me receber com seu sorriso generoso e olhar doce;
À alma gêmea de minh'alma, flor de luz da minha vida, Carla,
por tecer-me a felicidade e encher meu coração;
OFEREÇO
Aos meus pais, meus amigos da Fundação Caminho, Verdade e Vida e meus mestres;
DEDICO
AGRADECIMENTOS
O paradoxo dos agradecimentos é quase impossível de ser completo e aceitavelmente breve. Agradeço à minha eterna companheira Carla Cruz, pelo carinho, amor, incentivo, amizade e muita paciência. Ela sabe que não existem palavras para a minha gratidão. Hei de esperar-te, entre as flores da claridade dos céus. Aos meus pais, que souberam tão graciosamente transmitir seus valores e ideais para que eu pudesse crescer feliz. Ao meu filho especial agradecimento por seu sorriso e por seus pequenos mimos que fazem da vida algo ímpar e precioso. Aos amigos de todas as horas, minha gratidão eterna, pois não é possível construir nada sozinho. À minha orientadora Lucila Ishitani, que suportou minhas faltas e meus textos por três anos e soube conseguir o melhor de mim. Sem suas orientações este texto não seria produzido. Aos professores do mestrado, que souberam transformar as pedras em algo melhor. À professora Caroline Hoffmann que gentilmente leu a versão final do texto e colaborou imensamente com sua revisão. Aos professores da Universo que abraçaram a proposta e souberam executá-la com dedicação. Aos alunos que gentilmente cederam seu tempo e esforços para a realização desta pesquisa. Ao divino mestre de Nazaré, muito obrigado pela ventura de poder atender ao Seu chamado e honra em servi-Lo.
“Já se disse que duas asas conduzirão o espírito humano à presença de Deus.
Uma chama-se Amor, a outra, Sabedoria.
Através do amor valorizamo-nos para a vida. Através da sabedoria somos pela vida valorizados.”
Emmanuel, Pensamento e Vida.
RESUMO
As disciplinas de programação de computadores e algoritmos são consideradas por muitos alunos de cursos tecnológicos um obstáculo difícil de ser vencido. É comum o relato de um estado de apatia nos alunos que geralmente leva à desistência ou a um grande número de reprovações nas instituições de ensino. Na tentativa de sanar este problema no aprendizado vêm se utilizando Ambientes Virtuais de Aprendizagem (AVA) no auxílio do ensino em sala de aula para os cursos de computação. Além do uso de um AVA específico para facilitar e assistir o professor no ensino de algoritmos, é importante salientar que o uso de técnicas pedagógicas baseadas na colaboração, construtivismo, conectivismo, inteligência colaborativa promete aumentar a eficácia do aprendizado. Desta forma, este trabalho desenvolveu um ambiente virtual colaborativo, com uma abordagem conectivista e construtivista, seguindo as tendências da Web 2.0, com o objetivo de aumentar a eficiência no aprendizado. Para avaliar o seu uso, realizou-se um estudo de caso no ensino de algoritmos. Utilizou-se o AVA com um glossário colaborativo para apoiar os estudantes na construção dos conhecimentos prévios e servir como fonte de conteúdo didático sintético. E para fomentar a proficiência em programação foi feira uma avaliação dos algoritmos dos alunos através de um verificador de qualidade de software do AVA para medir o grau de assertividade e evolução do aprendizado. A metodologia ainda possibilitou a permuta de experiências entre os alunos com a troca de algoritmos e formulação de uma nova solução aprimorada. Como resultado, metade dos alunos considera que foram capazes de entender os conceitos de colaboração e construtivismo e metade dos alunos foi capaz de auxiliar e pedir ajuda aos colegas sem maiores problemas. A grande maioria dos alunos percebeu que o algoritmo colaborativo criado pelo grupo foi melhor que seu código individual. Esta vivência, em conjunto com o glossário colaborativo, permitiu que os discentes se sentissem melhor preparados e acreditam que aprenderam mais depois do experimento. Os professores também corroboraram essa percepção.
Palavras-Chave: Algoritmos; Ambiente Virtual de Aprendizagem; Construtivismo; Conectivismo; Web 2.0.
ABSTRACT
The disciplines of computer programming and algorithms are considered among many students in technology courses an obstacle difficult to be won. The reporting of a state of apathy in students is common, which usually leads to withdrawal or a large number of disapprovals in the educational institutions. In an attempt to solve this learning problem, it has been used Virtual Learning Environments (VLE) to help the teaching process in the classroom of computer courses. Besides the use of a specific VLE to facilitate and assist the teacher in teaching algorithm, it is important to highlight that the use of pedagogical techniques based on collaboration, constructivism, connectivism, collaborative intelligence, promises an increase on the effectiveness of learning. Thus, this work has made a case study in teaching algorithms with the goal of improving efficiency in learning using a virtual collaborative environment in Web 2.0 combined with a constructivist and connectivist approach. It has used the VLE with a collaborative glossary to support students in the construction of previous knowledge and to be a synthetic source of didactic content. And to raise the proficiency in programming the VLE evaluated the algorithms of students through a quality-checker software that measures the degree of assertiveness and learning evolution. The methodology also enabled the exchange of experiences between students with the trade of algorithms and formulation of an improved new solution. As a result, half part of students considered that they could understand the concepts of collaboration and constructivism and half of the students was able to help and ask their colleagues for help without major problems. And most of the students realized that the collaborative algorithm created by the group was better than their individual code. This collective experience with the collaborative glossary allowed the students to feel better prepared and they believe they have learned more after the experiment. The professors also corroborate this perception.
Keywords: Algorithms; Virtual Learning Environment, Construtivism; Connectivism; Web 2.0.
LISTA DE FIGURAS
FIGURA 1 - Fases da proposta ............................................................................................................... 39 FIGURA 2 - Glossário colaborativo ....................................................................................................... 41 FIGURA 3 - Quadro de avisos ............................................................................................................... 42 FIGURA 4 - Chat................................................................................................................................... 42 FIGURA 5 - Fórum de mensagens ......................................................................................................... 43 FIGURA 6 - Construção do código ........................................................................................................ 45 FIGURA 7 - Escala de valores ............................................................................................................... 49 FIGURA 8 - Análise do metrificador de um código fonte ....................................................................... 51 FIGURA 9 - Construção do código em Wiki .......................................................................................... 53 FIGURA 10 - Camadas da Web 2.0 ....................................................................................................... 55 FIGURA 11 - Diagrama de funcionamento do AVA .............................................................................. 56 FIGURA 12 - Ilustração da definição dos parâmetros do metrificador .................................................... 65
LISTA DE GRÁFICOS
GRÁFICO 1 - Distribuição de pontuação de Teoria da Computação ....................................................... 66 GRÁFICO 2 - Distribuição de pontuação de Linguagem de Programação I ............................................ 67 GRÁFICO 3 - Resultado dos aspectos gerais da disciplina Teoria da Computação .................................. 80 GRÁFICO 4 - Resultado dos aspectos colaborativos e construtivistas da disciplina Teoria da Computação .............................................................................................................................................................. 81 GRÁFICO 5 - Resultado dos aspectos relativos ao AVA da disciplina Teoria da Computação ................ 82 GRÁFICO 6 - Resultado dos aspectos gerais da disciplina Linguagem de Programação I ....................... 84 GRÁFICO 7 - Resultado dos aspectos colaborativos e construtivistas da disciplina Linguagem de Programação I ........................................................................................................................................ 85 GRÁFICO 8 - Resultado dos Aspectos relativos ao AVA da disciplina Linguagem de Programação I .... 86
LISTA DE TABELAS
TABELA 1 - Pontos positivos e negativos dos trabalhos relacionados .................................................... 34 TABELA 2 - Relação entre as métricas avaliadas pelos softwares metrificadores ................................... 46 TABELA 3 - Ocorrências buscadas pelo metrificador ............................................................................ 48 TABELA 4 - Comparativo entre as características da Web 2.0 e o AVA................................................. 54 TABELA 5 - Resultado do aproveitamento da disciplina de Teoria da Computação em semestres anteriores ao experimento ...................................................................................................................... 58 TABELA 6 - Resultado do aproveitamento da disciplina de Linguagem de Programação I em semestres anteriores ao experimento ...................................................................................................................... 59 TABELA 7 - Cronograma das atividades ............................................................................................... 59 TABELA 8 - Participação dos alunos nas sessões de chat de cada disciplina .......................................... 60 TABELA 9 - Resultados da disciplina Teoria da Computação ................................................................ 69 TABELA 10 - Resultados da disciplina Linguagem de Programação I .................................................... 70 TABELA 11 - Resultado do questionário da disciplina Teoria da Computação. ...................................... 79 TABELA 12 - Resultado do questionário da disciplina Linguagem Programação I ................................. 82 TABELA 13 - Aproveitamento da disciplina Teoria da Computação ...................................................... 89 TABELA 14 - Aproveitamento da disciplina Linguagem de Programação I ............................................ 89
LISTA DE SIGLAS
AJAX Asynchronous Javascript And XML
API Application Programming Interface
ASTRAL Animation of Data Structures and Algorithms
AVA Ambiente Virtual de Aprendizagem
CCCC C and C++ Code Counter
CSS Cascading Style Sheets
DOM Document Object Model
EDDL Estruturas de Dados Dinâmicas Lineares
HTML HyperText Markup Language
HTTP HyperText Transfer Protocol
RDF Resource Description Framework
RSS Rich Site Summary
SBC Sociedade Brasileira de Computação
SBIE Simpósio Brasileiro de Informática na Educação
TED Tutorial de Estruturas de Dados
TBC-AED Treinamento Baseado em Computador para Algoritmos e Estruturas de Dados
ULBRA Universidade Luterana do Brasil ULBRA
UNERJ Centro Universitário de Jaraguá do Sul
UNIVERSO Universidade Salgado de Oliveira
VDSP Verificador de Diferenças Significativas entre Programas
ZPD Zona Proximal de Desenvolvimento
XML eXtensible Markup Language
WEI Workshop sobre Educação em Computação
WIE Workshop sobre Informática na Escola
SUMÁRIO
1 INTRODUÇÃO .................................................................................................................................. 15
2 REVISÃO DE LITERATURA ............................................................................................................ 19
2.1 Metodologia Construtivista Colaborativa .......................................................................................... 19
2.2 Trabalhos Relacionados.................................................................................................................... 27
3 METODOLOGIA ............................................................................................................................... 36
4 PROPOSTA – OBJETIVOS E DESCRIÇÃO DO AVA ...................................................................... 37
4.1 Fase 1 - Construção Colaborativa do Conhecimento ......................................................................... 40
4.2 Fase 2 - Análise de Problema ........................................................................................................... 43
4.3 Fase 3 - Construção do Código ......................................................................................................... 44
4.4 Fase 4 - Metrificação do Código ....................................................................................................... 45
4.5 Fase 5 - Formação de Grupos para Construção de Novo Código ....................................................... 51
4.6 Características do AVA .................................................................................................................... 53
5 RESULTADOS – APRESENTAÇÃO E ANÁLISE ............................................................................ 57
5.1 Contexto .......................................................................................................................................... 57
5.2 Descrição do Processo ...................................................................................................................... 60
5.3 Resultados Obtidos........................................................................................................................... 68
5.4 Avaliação do Processo pelos Participantes ........................................................................................ 78
6 CONCLUSÕES E TRABALHOS FUTUROS ..................................................................................... 91
REFERÊNCIAS .................................................................................................................................... 94
APÊNDICE 1 - RELAÇÃO DE NOTAS DOS ALUNOS DA UNIVERSIDADE SALGADO DE
OLIVEIRA NAS DISCIPLINAS INTRODUTÓRIAS DE ALGORITMOS ........................................... 98
APÊNDICE 2 - QUESTIONÁRIO DE AVALIAÇÃO DO AVA PELO ALUNO ................................ 100
APÊNDICE 3 - QUESTIONÁRIO DE AVALIAÇÃO DO AVA PELO PROFESSOR ........................ 101
15
1 INTRODUÇÃO
O aprendizado de programação e algoritmos é considerado um desafio por muitos
professores e principalmente pelos alunos iniciantes de cursos da área de Tecnologia da
Informação. A pouca motivação e falta de maturidade dos alunos, aliada aos altos índices de
abstração e lógica matemática são fatores que contribuem muito para um estado de apatia que
geralmente leva à desistência da disciplina ou a um grande número de reprovações, fenômeno
este estudado por Tobar et al. (2001) e Proulx (2000).
Dados do curso de Análise de Sistemas da Universidade Salgado de Oliveira [APÊNDICE
1] nas disciplinas de Teoria da Computação e Linguagem de Programação I, no período de 2004
a 2007, revelam que de 15% a 30% dos alunos entrantes desistem das disciplinas, e daqueles que
continuam, 30% a 50% são reprovados. Este problema é recorrente nos cursos de tecnologia cujo
currículo inicia com estudos de programação. Diversos estudos nacionais e internacionais
também apontam que existem sérias dificuldades de aprendizado de algoritmos que geram
reprovações e desistências (RODRIGES, 2004; PIMENTEL et al., 2003; MENDES, 2001).
Tobar et al. (2001) apontam que os prováveis fatores que geram os altos índices de
desistências e reprovações são o excesso de preocupação com detalhes sintáticos e semânticos,
falta de visão do problema, incapacidade de derivar as soluções em um modelo lógico,
incapacidade de idealizar este modelo em uma linguagem específica, a complexidade crescente
dos paradigmas de programação, o desconhecimento de padrões de raciocínio lógico na resolução
de problemas e a falta de domínio da língua inglesa.
Tratar esses problemas levantados por Tobar et al. (2001) tem sido foco nos últimos
congressos e workshops da área de computação e educação, de forma que grande parte dos
trabalhos apresentados caminha para a adoção de Tecnologias de Informação e Comunicação, e
especialmente, na construção de Ambientes Virtuais de Aprendizagem (AVA) com o objetivo de
auxiliar no ensino de algoritmos em sala de aula.
16
Faria, Vilela & Adán Coello (2004) sugerem como estratégia para a resolução do baixo
rendimento no ensino de algoritmos o uso de um AVA em conjunto com metodologias de ensino-
aprendizagem, apresentadas na Seção 2.1 deste trabalho, que são as metodologias construtivista e
colaborativa. Tobar et al. (2001) também sugerem a colaboração como uma boa metodologia para
sanar, ou pelo menos amenizar, este problema.
Além do uso de um AVA específico para facilitar e catalisar o ensino de algoritmos, o
crescente número de artigos científicos sugerindo o uso de técnicas pedagógicas baseadas na
colaboração, construtivismo, conectivismo e inteligência colaborativa prometem aumentar a
eficácia do aprendizado (FRANTZ, 2001; SIEMENS, 2006; VOIGT, 2007; MACHADO &
TIJIBOY, 2005; MARCELINO & ROSATELLI, 2008).
Da evolução do construtivismo e colaboração aliada à Internet, Siemens (2006) criou o
conceito de Conectivismo, teoria pedagógica que afirma que quantidades enormes de
conhecimento de todas as formas podem ser criadas através de relações entre as pessoas
utilizando a Web como meio de interação. Um exemplo típico da aplicação da teoria do
conectivismo e colaboração em forma de software social é a Wikipedia (wikipedia.com),
enciclopédia livre em que todos podem criar e editar verbetes.
Siemens (2006) remodelou o Construtivismo idealizado por Piaget (1990) observando a
evolução das redes sociais através do uso intensivo de tecnologia como meio para alcançar a
troca de experiências, conceitos e informações entre as pessoas em massa. O uso intensivo das
redes sociais na Internet idealizado por Siemens pode ser visto através do fenômeno crescente na
internet: a Web 2.0.
O conceito de Web 2.0 foi criado por O’Reilly (2005). No seu entendimento a Web 2.0 é
caracterizada pela intensificação da participação e do efeito-rede. Trata-se mais de como os
usuários estão fazendo uso dos sites, de forma mais ativa, criando, alterando e construindo
conteúdos de forma colaborativa, do que uma nova tecnologia. Como efeito deste
direcionamento, diversos sites internacionalmente conhecidos foram criados utilizando as
características da Web 2.0, tais como: blogs (blogger.com), notícias (digg.com), recomendações
17
(pandora.com), comunidades (orkut.com), podcasting (folcast.com), video-blogs (youtube.com),
documentos (wikipedia.com), marcadores sociais (del.icio.us), blogs de fotos (flickr.com), dentre
outros.
Segundo Voigt (2007), grande parte dos AVAs de uso geral já fazem uso da Internet
como meio de interação entre aluno e professor. Mas constatou-se através do estudo de trabalhos
relacionados que existem poucos AVAs para ensino de programação e algoritmos em ambiente
de Internet, e bem poucos fazem uso da Web 2.0.
Desta forma, com o objetivo de aumentar a eficiência no aprendizado de algoritmos em
cursos tecnológicos, foi proposto o desenvolvimento e a avaliação do uso de um ambiente virtual
colaborativo para a Web 2.0, aliado à uma abordagem conectivista e construtivista. A
metodologia utilizada foi: a avaliação dos pontos positivos e negativos de diversas propostas
científicas já existentes, a proposta de melhorias, o desenvolvimento e teste de um protótipo do
AVA com alunos do curso de Análise de Sistemas da Universidade Salgado de Oliveira. Para
avaliar os resultados, os alunos responderam a um questionário [APÊNDICE 2] e suas notas
foram comparadas com as notas de outros períodos que não tiveram acesso ao projeto. Os
professores também responderam a um questionário [APÊNDICE 3].
O trabalho de pesquisa realizado teve como objetivos específicos:
a) Investigar técnicas cognitivas que estimulem a aprendizagem de algoritmos
b) Propor uma ferramenta computacional para a formalização de conceitos
importantes no ensino de algoritmos e que dinamize o processo de ensino-
aprendizagem tornando-o mais atrativo e eficiente
c) Verificar a aplicabilidade do modelo proposto
Este texto está estruturado da seguinte forma:
No Capítulo 2 é feita uma revisão de literatura, destacando-se pontos positivos e negativos
de diversos trabalhos anteriores.
18
No Capítulo 3 é descrita a metodologia utilizada durante o trabalho.
No Capítulo 4 é apresentada a proposta do AVA com seus objetivos e descrição do
funcionamento. As atividades da avaliação realizadas pelos alunos e professor durante o
experimento também estão descritas neste capítulo.
No Capítulo 5 são apresentados os resultados obtidos nos experimentos realizados com os
professores e alunos das disciplinas de linguagem e programação com o questionário de avaliação
da experiência. Esses resultados são acompanhados de uma análise que inclui a quantificação da
eficiência da metodologia avaliando o percentual de alunos que evadiram e que foram reprovados
nas disciplinas, bem como as discrepâncias nas notas obtidas nas avaliações em comparação aos
semestres anteriores.
No Capítulo 6 são tecidas as conclusões finais do trabalho e apresentadas sugestões de
trabalhos futuros.
19
2 REVISÃO DE LITERATURA
Neste capítulo serão abordadas as metodologias construtivistas e colaborativas aplicadas
ao ensino de algoritmos e uma avaliação dos trabalhos relacionados.
2.1 Metodologia Construtivista Colaborativa
O ensino de algoritmos e linguagens de programação de computadores é um dos pilares
dos cursos voltados para a área de tecnologia. No entanto, ensinar algoritmos é visto como um
grande desafio para os professores da área, pois exige do estudante um domínio prévio de
habilidades matemáticas e raciocínio lógico que nem sempre são encontrados nos ingressantes
dos cursos superiores (RAPKIEWICZ, 2004).
O conteúdo da disciplina de algoritmos, de maneira geral, envolve o ensino de linguagens
de programação, bem como dos conceitos, dos princípios, dos métodos e dos modelos de
programação, como também o estudo de estruturas de dados, de algoritmos de classificação e
ordenação e de métodos eficazes de pesquisa de dados. Isto significa ir além do estudo de uma
linguagem específica, sua sintaxe, métodos e propriedades, mas desenvolver uma capacidade de
modelar problemas do mundo real para que possam ser resolvidos pelos computadores. Esta
habilidade abstrata envolve a solução de problemas, que por sua vez envolve uma grande
variedade de atividades como especificação, projeto, validação, modelagem e estruturação de
programas e dados. E, no fim, a linguagem de programação será apenas uma ferramenta.
Wirth (1989) entendia que o ensino de algoritmos tratava de uma arte de organizar e
dominar a complexidade. Enquanto arte, o estudo de algoritmos envolvia capacidades pessoais e
bagagem cognitiva que tornariam um individuo bem sucedido ou, na falta delas, um fracasso na
área. Em seu entendimento, não existia uma metodologia ou um processo formal que permitisse o
desenvolvimento de pessoal de forma eficaz. O programador para ele era um artesão de software.
20
Este cenário mudou com o fomento das agências governamentais de segurança norte
americanas que contribuíram muito para o desenvolvimento de algoritmos como ciência em vista
da sua crescente necessidade de construção de softwares confiáveis. O estudo sistemático e
crescimento científico na área trouxeram novos princípios, técnicas, fórmulas, métricas e
procedimentos que visam o desenvolvimento profissional de softwares. Portanto, o estudo de
algoritmos e de programação se inicia com o estudo dos paradigmas de programação como a
programação imperativa, a funcional, a baseada em lógica e a orientada a objetos. O
desenvolvimento da disciplina também envolve o estudo dos conceitos de associação, avaliação,
atribuição, chamada de procedimento, envio de mensagens, passagem de parâmetros, herança,
polimorfismo e encapsulamento. E na sua conclusão, o estudo de algoritmos propõe a
concretização da solução de um problema em um programa de computador capaz de resolvê-lo,
criando um produto de software (SANTOS & COSTA, 2006).
O desenvolvimento das linguagens de programação de alto nível e a utilização de
frameworks facilitou o estudo de algoritmos de forma que o professor pode dar ênfase aos
aspectos funcionais e estruturais, em detrimento aos detalhes de sintaxe. A linguagem de
programação deixou de ser o objeto principal de estudo para dar lugar aos conceitos principais
comuns presentes na maioria das linguagens, como o significado de associação, avaliação,
atribuição, chamada de procedimento, envio de mensagens, passagem de parâmetros, herança,
polimorfismo e encapsulamento (SANTOS & COSTA, 2006).
Santos & Costa (2006) entendem que ensinar programação de computadores vai muito
além de simplesmente ensinar uma linguagem de programação. A disciplina envolve entender os
problemas, ser capaz de elaborar soluções computacionalmente viáveis, e só então codificar em
uma linguagem de programação que atenda aos requisitos do projeto.
Um problema comum no aprendizado de algoritmos foi estudado por Pimentel & Omar
(2008) que afirmam que as lacunas de aprendizagem causadas por ausência de pré-requisitos bem
definidos contribuem para ampliar as dificuldades de aprendizagem e levam ao insucesso escolar
de muitos alunos. Na percepção deles, uma metodologia de ensino-aprendizagem deveria dar
21
condições ao aluno e professor para identificação destas lacunas para, num segundo momento, se
preocupar em suprir esta necessidade.
Pimentel & Omar (2008) basearam seu trabalho na idéia de que o fator isolado mais
importante influenciando a aprendizagem é aquilo que o aprendiz já sabe. Para eles a
aprendizagem ocorre quando a nova informação ancora-se em conceitos relevantes preexistentes
na estrutura cognitiva de quem aprende. Para os autores é importante formatar o conteúdo de
maneira que os conceitos gerais devam ser apresentados como organizadores prévios.
Com base nas idéias de Pimentel & Omar (2008), um glossário colaborativo pode apoiar
os estudantes na construção dos conhecimentos prévios e preencher as lacunas existentes ao se
iniciar o processo de aprendizagem de algoritmos.
Uma vez preenchidas as lacunas, o próximo passo é entender e especificar os problemas
computacionais. Para isto, é necessário que o aluno desenvolva uma capacidade de abstração e
um pensamento lógico para uma correta descrição dos requisitos, parâmetros e destino das
informações (RAPKIEWICZ, 2004).
Entretanto, a busca pela solução de um problema computacional é uma tarefa difícil, pois
exige que o estudante domine um universo de terminologias, elementos, aspectos e habilidades
que podem ou não fazer parte da solução. E em um primeiro momento o aluno pode não
visualizar os meios necessários para solucionar o problema.
Desta forma, faz-se necessário que uma metodologia “dividir para conquistar” seja
utilizada, dividindo o problema em problemas menores sucessivamente até que se consiga um
nível para o qual seja possível encontrar uma solução clara e viável.
Para que esta metodologia tenha sucesso a capacidade de abstração é de grande
importância, pois refina o problema original em novos pequenos contextos, determinando
pequenos módulos que podem ser executados pelo aprendiz.
22
A capacidade de abstração para a resolução de algoritmos é dada principalmente pelo
pensamento proponente, que é formado através da combinação de conceitos aprendidos, com o
objetivo de determinar proposições formadas por um sujeito e um predicado que por sua vez,
pode ser um estado, um atributo ou uma atividade (ATKINSON, 1995). Portanto, a combinação
de proposições é o primeiro passo para pensamentos lógicos e complexos, e conseqüentemente,
para o raciocínio.
Acompanhar e entender este processo de combinação de proposições e de conceitos que
formam o raciocínio dos alunos é uma das maiores dificuldades no processo de ensino e
aprendizagem de algoritmos. Isto exige habilidades e competências específicas do professor desta
disciplina.
Além da dificuldade natural que os alunos têm com o conteúdo, a disciplina é
essencialmente tecnológica, e nesta área, na maioria das vezes, o professor não tem qualquer
formação pedagógica ou em licenciatura, dificultando ainda mais o processo de aprendizado dos
alunos.
Portanto, para que o processo de aprendizagem de algoritmos tenha maior chance de
sucesso, é necessário que o professor desenvolva algumas habilidades pedagógicas.
A primeira habilidade, a didática, deve ser utilizada pelo professor para apresentar o
conteúdo introdutório da disciplina, pois os alunos, normalmente, têm dificuldade em entender os
diversos e novos conceitos referentes à execução de tarefas pelo computador (RODRIGUES,
2004).
Uma boa estratégia didática sugerida por Hoc (2000) é a ascendente. Ela determina que os
itens de um conteúdo devam ser abordados passo a passo, iniciando pelos itens mais simples e
caminhando lentamente para os itens complexos. Desta forma, a cada passo, representações
internas são criadas, processos de pensamento proponente são gerados e uma combinação de
conceitos são agregados a partir do momento que novos itens são trabalhados.
23
Rodrigues (2004) afirma que o professor deve utilizar sua criatividade para demonstrar a
resolução de problemas com situações cotidianas desenvolvendo no aluno a capacidade de
raciocínio lógico e ordem de pensamento.
Outro problema relacionado à motivação é o preconceito existente em relação à
disciplina. Os alunos acreditam previamente que ela será um obstáculo difícil que exigirá muito
deles. Infelizmente alguns professores reforçam esta percepção negativa. É preciso na verdade
que o aluno tenha a sensação de que terá ajuda e que um pouco de esforço extra é necessário. A
motivação é imprescindível para que o aluno participe intensamente das aulas, faça perguntas e
resolva os exercícios (RODRIGUES, 2004).
Além da motivação, o professor precisa desenvolver a habilidade de elaborar avaliações
inteligentes que realmente privilegiem avaliar as competências necessárias ao egresso dos cursos
de tecnologia.
É comum os cursos tecnológicos serem pautados por poucas provas e de resolução
extensa. Essa abordagem segundo Rodrigues (2004) é prejudicial especialmente neste tipo de
disciplina. Para ele a avaliação deve ser constante e diária, de forma a garantir o desempenho,
possibilitar o acompanhamento e criar uma taxa de sucesso nos alunos. Além disso, Rodrigues
(2004) enfatiza que isto facilita o tratamento especial de dificuldades que possam surgir e
sustentar um bom desempenho.
Assim, sugere-se que o professor busque novas formas de avaliação, que possam ser
diluídas durante o curso. O resultado dessas avaliações nutre o professor com informações que
podem ser usadas para propor mudanças e adaptações durante o processo que possibilitem um
melhor desempenho dos alunos. Essa estratégia também pode aliviar o estresse que os alunos
sofrem durante uma prova extensa em que eles ainda podem estar sujeitos a não conseguir
expressar todo o conhecimento adquirido.
24
O material didático também precisa estar constantemente em processo de adaptação e
melhoria a partir dos retornos recebidos pelos alunos. Um conhecimento prévio para o
entendimento de algo pode se fazer necessário à maioria dos alunos, de forma que pode ser
incluído no material como fonte de consulta. Infelizmente, na visão da maioria dos alunos, os
livros sobre algoritmos que estão disponíveis em língua portuguesa têm leitura complexa e difícil
exigindo que o professor na maioria das vezes elabore seu próprio material (RODRIGUES,
2004).
Outra estratégia muito importante para o sucesso do processo de aprendizagem dos alunos
é reforçar a colaboração e a cooperação através de técnicas pedagógicas construtivistas para
assimilação dos conceitos.
Outra característica importante que a colaboração proporciona é a modelagem baseada em
restrições. Esta modelagem coloca que os estudantes que não detêm o conhecimento necessário
não são capazes de diagnosticar os próprios erros com clareza. Assim, o estudante precisa ser
confrontado com diversas soluções possíveis para poder analisar todas as restrições que cada uma
possui para delinear uma solução apropriada. A colaboração permite que os estudantes façam o
diagnóstico de seus pares e no processo sejam capazes de identificar seus próprios erros.
Rodrigues (2004) relata que a intensidade da colaboração é proporcional à qualidade dos
algoritmos desenvolvidos pelos alunos. Em seu experimento os grupos de alunos que
colaboraram intensamente foram capazes de desenvolver algoritmos elegantes e com qualidade
maior. Já aqueles grupos em que houve pouca colaboração, ou que somente um integrante
trabalhou, não conseguiram chegar a uma solução viável ou elegante.
Resumidamente, Menezes & Nobre (2002) apontam as principais dificuldades enfrentadas
pelos professores no ato de ensinar algoritmos:
a) Reconhecer as habilidades inatas de seus alunos
b) Apresentar técnicas para soluções de problemas
c) Trabalhar a capacidade de abstração do aluno, tanto na busca das possíveis
soluções como na escolha da estrutura de dados a ser utilizada
25
d) Promover a cooperação e a colaboração entre os alunos
Reconhecer as habilidades inatas dos alunos é algo que pode exigir certo tempo e
habilidade do professor. Felizmente a diversidade dos alunos nos cursos da área de tecnologia
permite que a interação natural entre eles facilite o trabalho do professor.
Para trabalhar a capacidade de abstração dos alunos Pimentel (2003) sugere que o
professor escolha preferencialmente problemas inseridos no contexto da realidade cotidiana dos
alunos. Pimentel (2003) também afirma que outro problema grave no ensino de algoritmos é o
acompanhamento deficitário que o professor dispõe para cada aluno, em face do grande número
de alunos nas turmas. Ele ainda aponta que uma saída para este problema é o uso de ferramentas
computacionais e sistemas inteligentes.
Ainda na ótica de habilidades necessárias ao professor Setubal (2000) define algumas
recomendações importantes ao ensino das disciplinas de algoritmos e programação:
a) Expressar claramente as idéias, conceitos e técnicas
b) Destacar a importância dos resultados teóricos e mostrar rigor formal toda vez que
isto se fizer necessário
c) Procurar valorizar o uso de técnicas na resolução de problemas
d) Dar ênfase ao pensamento crítico em face de pouca maturidade matemática dos
alunos
e) Usar como recurso didático um grande número de exemplos cotidianos
Para que o estudante possa então ter sucesso na disciplina, ele precisa entender os
problemas propostos, descrever formas de sua resolução utilizando lógica e matemática,
transcrevê-lo em uma sintaxe apropriada e testá-lo no computador para convalidar os conceitos
aprendidos e a sua lógica, conforme descreve Setubal (2000).
Através de observações feitas durante o aprendizado de algoritmos, percebeu-se que
utilizar ferramentas computacionais que estimulassem o exercício prático e que também
pudessem fornecer um ambiente capaz de simular os conceitos abstratos que envolvem a lógica
26
de programação promoveu uma fixação melhor do conteúdo e desenvolvimento do raciocínio
lógico-matemático (SOARES, 2004). Ao mesmo tempo em que este ambiente precisa fornecer
características que facilitem o estudo dos algoritmos e simular seu funcionamento, ele precisa
despertar no aluno seu espírito de pesquisa e a busca de informações de forma construtivista.
Desta forma o aluno será forçado a buscar o conhecimento que necessita e a testá-lo de forma
científica. Isto desenvolve sua capacidade de aprender a aprender que será utilizada ao longo do
curso e durante sua vida profissional.
Buzin (2001) fez as seguintes observações quando não é utilizado nenhum método
pedagógico colaborativo e nenhum uso de ferramentas que auxiliem no estudo de algoritmos:
a) Percepção de falta de motivação do aluno criada pelo despreparo e bagagem
cognitiva insuficiente
b) Tensão do aluno durante o processo tradicional de avaliação (prova em papel)
c) Relacionamento empobrecido entre professor e aluno
Considerando então o uso de algum apoio computacional para o ensino de algoritmos,
Rapkiewicz (2004) aponta que há três vertentes utilizadas por professores:
a) Uso exclusivo de ferramentas computacionais que facilitam o processo de ensino e
aprendizagem, como AVAs, compiladores, depuradores e ferramentas gráficas
b) Uso de estratégias e metodologias de ensino como o construtivismo e técnicas de
avaliação
c) Uso de estratégias em conjunto com ferramentas que apóiem a metodologia
proposta
Trabalhando nessas três vertentes, vários trabalhos nacionais foram apresentados em
congressos e seminários como Workshop sobre Educação em Computação (WEI), Workshop
sobre Informática na Escola (WIE) e Simpósio Brasileiro de Informática na Educação (SBIE)
com o objetivo de resolver alguns problemas no ensino de algoritmos.
Neste novo contexto, Siemens (2006) propôs princípios de aprendizado conectivistas,
dentre eles:
27
a) O aprendizado é um processo de formação de redes
b) O aprendizado nasce da diversidade de opiniões, culturas, etc
c) O conteúdo é o produto do conhecimento, e não o ponto de partida
d) As conexões são o ponto de partida para o conteúdo
e) O aprendizado pode nascer de conexão de coisas e não apenas de
interação entre humanos
f) O conhecimento já existente está na rede. Basta conectá-lo
g) O estudante é o centro do processo
h) Professores e estudantes são pares no ambiente social em rede
i) A Web não é apenas a mídia, mas a plataforma do aprendizado
O referencial teórico das metodologias de ensino-aprendizagem mencionadas sugere o
desenvolvimento de um AVA para auxiliar no ensino de algoritmos e programação
fundamentado nas técnicas colaborativas conectivistas.
2.2 Trabalhos Relacionados
Faria & Adán Coello (2004) propuseram uma abordagem de aprendizagem baseada na
colaboração partindo do princípio de que o conflito sócio-cognitivo entre os aprendizes pode
melhorar o seu aprendizado. Foi construído um software avaliador de programas em C, chamado
Verificador de Diferenças Significativas entre Programas (VDSP) para metrificar e pontuar os
programas desenvolvidos pelos alunos. Os estudantes são então agrupados de acordo com os
pontos obtidos e depois de trocar experiências e pontos de vista devem propor mudanças no
software melhorando ou reconstruindo o código construído individualmente para atingir um
programa mais coerente e eficaz.
A pesquisa de Faria & Adán Coello (2004) teve como base os alunos do curso de
Sistemas de Informação da PUC Minas Arcos, especificamente, alunos da disciplina Algoritmos
e Estruturas de Dados. Eles obtiveram resultados positivos em relação ao trabalho individual que
era realizado pelos alunos.
28
Alguns aspectos positivos do seu trabalho merecem destaque, tais como: eles usam uma
metrificação do software para avaliar o código-fonte desenvolvido de forma individual pelos
alunos para que o professor possa avaliar os alunos dentro de parâmetros estabelecidos. Com base
na métrica fornecida por seu programa VDSP, eles agrupam os alunos em equipes com diferentes
níveis de resultados (alto, médio, baixo, misto) para que eles possam trocar experiências. A troca
de experiências proporcionou o desenvolvimento de um código-fonte com maior qualidade pelos
grupos formados, sanando os problemas de implementação e proporcionando melhorias extras.
Com esta metodologia de trabalho, eles conseguiram que os alunos trocassem experiências e
diferentes formas de equacionar a abstração do problema em um modelo computacional.
No entanto, o VDSP não pode ser utilizado via Web, limitando seu uso aos laboratórios
da instituição de ensino e requer uma atuação significativa do professor como moderador para
que o trabalho possa ser realizado.
Faria, Vilela & Adán Coello (2004) buscaram sanar as lacunas de seu projeto anterior em
outro trabalho e propuseram um sistema em Web para o aprendizado colaborativo de
programação chamado “Learn in Group”. A principal característica do novo sistema são os
agentes inteligentes mediadores para a constituição de grupos de trabalho colaborativo e para
acompanhar e estimular a participação dos membros dos grupos. Nenhuma abordagem
construtivista de construção de textos em torno dos conteúdos e conceitos da disciplina foi
trabalhada neste projeto.
Outro trabalho apresentado por Raabe & Silva (2004) baseia seu estudo no princípio de
que o aprendizado de algoritmos é considerado desafiador pelos estudantes de cursos
tecnológicos devido ao alto nível de abstração do conteúdo e a dificuldade dos docentes em
detectar e atender as dificuldades de aprendizagem dos alunos na disciplina de Algoritmos.
Ele propõe um ambiente que auxilia na resolução deste problema utilizando o paradigma
de Assistentes Inteligentes de Ensino. Estes assistentes assessoram o professor em sua tarefa de
monitorar, assistir e analisar os alunos. Os resultados da utilização do ambiente apontam para a
29
viabilização da tarefa de acompanhamento individualizado dos alunos e uma maior eficiência na
identificação e atendimento às dificuldades de aprendizagem.
O AVA de Raabe & Silva (2004) permite que o professor faça uso da Web para publicar
conteúdo da disciplina, o que permite uma maior disponibilidade do conteúdo. Ele também faz
uso de questionários inteligentes para aferir o conhecimento dos alunos e avisar o professor sobre
possíveis deficiências no aprendizado.
No entanto, a metodologia proposta por Raabe & Silva (2004) pode sobrecarregar o
professor com informações detalhadas sobre desenvolvimento dos alunos. Isto pode ser
apropriado para a abordagem clássica de Piaget (1990), que pressupõe turmas reduzidas, mas de
difícil execução em turmas com muitos alunos. Ele também explora pouco o uso da colaboração
e do construtivismo, pois em sua proposta o professor ainda é o principal gerador de conteúdo e a
comunicação é quase exclusiva em direção do professor para aluno.
Borges (2005) aponta que grupos de estudo têm surgido como uma alternativa para
complementar os conteúdos vistos em sala de aula e desenvolver/aprimorar habilidades. Ele
relata a experiência com o grupo de estudos de Java da Universidade Luterana do Brasil
(ULBRA). Ele observou que uma forte interação entre os componentes do grupo e o prazer em
dividir o conhecimento adquirido possibilitou um maior sucesso na aprendizagem de algoritmos.
Em sua proposta ele criou uma comunidade de pessoas com um objetivo comum de
estudar Java. Esta comunidade colaborativa utiliza a Web para criar conteúdo fomentado pelos
professores das disciplinas de Java. Desta forma, permitiu que documentos comuns fossem
criados a partir da contribuição dos membros da comunidade com apoio computacional de lista
de discussão, fórum e repositório de informações.
Borges (2005) demonstrou que as comunidades colaborativas de estudo específico
apoiadas por ferramentas computacionais podem ter a taxa de sucesso no aprendizado de seus
membros aumentada. Entretanto, este trabalho não trata nenhum processo formal de avaliação e
acompanhamento do aprendizado.
30
Na mesma linha pedagógica construtivista e colaborativa para o ensino de algoritmos,
Delgado et al. (2005) apontam uma proposta que vai ao encontro das metas para desenvolver
experiências relativas ao ensino de programação no nível médio criada pelo Grupo de Trabalho
de Licenciatura em Computação (GT-3) da Sociedade Brasileira de Computação (SBC) realizada
pela Universidade Estadual do Norte Fluminense (UENF) em uma escola pública de Cardoso
Moreira - RJ através de uma oficina que permitiu identificar pontos de dificuldade no processo e
a necessidade de trabalhar mais a informática de modo interdisciplinar. A oficina permitiu
comprovar que alunos do ensino médio são capazes de aprender algoritmos e programação sem
necessariamente estarem inseridos em um curso técnico, capacitando 16 alunos que cumpriram
diversas exigências no estudo de algoritmos.
Em seu estudo Delgado et al. (2005) fizeram um levantamento de problemas comuns no
ensino de algoritmos na literatura e puderam constatá-los. O estudo indicou que as dificuldades
apontadas pelos alunos do ensino médio não diferiram daquelas apontadas na literatura pelos
alunos do 3º grau especializado na área tecnológica. Com uma carga-horária pequena de 36
horas, ele fez uso intensivo de técnicas construtivistas, com diversas reuniões entre os envolvidos
e discussão das abordagens desenvolvidas para resolver os trabalhos propostos. No entanto, ele
não fez uso de nenhum AVA para auxiliar no processo, mas pôde constatar os benefícios de uma
metodologia construtivista.
Procurando sanar a dificuldade de trabalhar com a sintaxe de uma linguagem de
programação em língua inglesa e desenvolver a capacidade de lógica de programação nos alunos,
Ferrandin & Stephani (2006) desenvolveram uma ferramenta para o ensino de programação
através da Web, o WEB-UNERJOL. Esta ferramenta tem como principal objetivo ser utilizada
como ferramenta de apoio aos professores no ensino de técnicas de programação usando a
linguagem Portugol como base. Neste sistema o aluno é capaz de compilar, depurar e executar
programas em Portugol através de um compilador web com auxílio e acompanhamento do
professor. Como resultado, obteve-se uma maior interatividade entre professor e aluno, o que
diminui a carência na carga horária disponibilizada pelas disciplinas de ensino de programação.
31
Infelizmente o AVA não fez uso dos conceitos de colaboração e construtivismo e também não fez
uso de um repositório de informações ou biblioteca que pudesse ser consultada pelos alunos.
Outro trabalho, apresentado por Soares et al. (2004), buscou sanar o problema de falta de
capacidade de abstração dos alunos através de uma ferramenta computacional para ensino de
algoritmos de grafos que utiliza ambiente gráfico em Web. Para eles é de suma importância que a
ferramenta tenha animação gráfica para simular o processamento e auxilie na abstração de
conceitos. Além disso, para os autores a ferramenta é uma continuidade da aula, com transmissão
de conceitos e o teste de comandos pelo aluno.
Infelizmente, por ser muito específica, o AVA de Soares et al. (2004) não permitia que o
aluno possa alterar os algoritmos envolvidos na disciplina de grafos, bem como não trata de
outros temas.
Santos & Costa (2005) ampliaram a ferramenta criada por Soares et al. (2004) para o
estudo de estrutura de dados e algoritmos básicos, como: busca em vetor (busca binária), métodos
de ordenação (Select Sort, Insert Sort, Bubble Sort, Merge Sort e Quick Sort), estruturas de
alocação estática e dinâmica de memória (Lista, Fila e Pilha) e árvores (Árvore Binária de
Busca).
Santo & Costa (2005) propõem ainda que a ferramenta contenha material didático virtual,
evitando explanações cansativas em sala de aula. Eles ainda propõem que a possibilidade de
ampliação da literatura das aulas virtuais estimula o processo educacional. Seu ambiente utiliza
gráficos para demonstrar a execução dos algoritmos em tempo real e permite que os usuários
interajam com o ambiente, de forma que eles possam montar sua própria estrutura (listas, pilhas,
filas e árvores) e ver a execução do algoritmo escolhido. Assim como a proposta de Soares et al.
(2004), o novo AVA contém um repositório com o conteúdo da disciplina de algoritmos, mas
também não permite que o aluno possa alterar o algoritmo, nem testar variações do código.
Flávio (2005) percebeu que o trabalho de Santos & Costa (2005) poderia ser melhorado se
permitisse a colaboração dos alunos e propôs um Tutorial de Estruturas de Dados – TED –
32
através de um sistema informatizado que permite que o aluno possa ter acesso aos conteúdos,
com demonstrações de implementação de diversos algoritmos em exemplos visuais com todos os
passos da execução.
O AVA de Flávio (2005) permite que o aluno contribua com os conceitos estudados,
ampliando o conteúdo dos temas abordados. No entanto, assim como nas propostas de Soares et
al. (2004) e Santos & Costa (2005), seu ambiente não permite que o usuário interaja com o
sistema, de forma que ele possa montar sua própria estrutura (listas, pilhas, filas e árvores) e ver a
execução do algoritmo escolhido.
Hostings e Raabe (2007) ampliaram a ferramenta de Ferrandin & Stephani (2006) e
construíram um ambiente em Web que auxilia na construção da lógica de programação através da
linguagem Portugol (WEBPORTUGOL). A versão de Hostings & Raabe (2007) conta com um
interessante recurso de verificação de algoritmos que executa o programa com entradas pré-
definidas e compara as saídas com valores também pré-estabelecidos. Este recurso possibilitou
aos estudantes identificar a conformidade de suas soluções e iniciar processos de depuração de
código com mais facilidade. Os autores puderam constatar que isto ampliou o grau de autonomia
dos alunos durante o desenvolvimento dos algoritmos, pois permitia que algum teste com valores
pré-definidos fosse realizado, a exemplo do que muitas vezes faz o professor em sala de aula. No
entanto, eles entendem que esta funcionalidade “não é suficiente para detectar e orientar todos os
tipos de erros que os alunos cometem, mas certamente fornece alguma referência para
identificação da conformidade da solução”.
Trabalhando com uma abordagem conectivista, Xexéo, Kalinowski & Rapkiewicz (2007)
fizeram um experimento com o objetivo de desenvolver competências sociais e técnicas em
ingressantes de cursos de computação através da constituição de comunidades virtuais com
suporte em Ambiente Virtual de Aprendizagem. Eles escolheram o AVA de código aberto
TELEDUC. O experimento foi feito com a disciplina Seminários I com 57 alunos do primeiro
período do curso de computação no modelo sem aulas presenciais. A cada semana um conjunto
de atividades a distância foi proposto de forma que os alunos experimentassem o uso de
diferentes ferramentas do AVA. Inicialmente os alunos apresentaram carência de conhecimento
33
de regras e postura comuns na Internet, foram prolixos e usaram linguagem escrita com formas
de expressões típicas de comunicação oral. Os autores perceberam que o objetivo de
desenvolvimento de competências sociais foi parcialmente alcançado. Primeiramente porque os
alunos se ressentiram muito da falta do contato com o professor. Isto foi parcialmente sanado
com uma participação muito ativa do docente para dar retorno no fórum e por e-mail aos 57
estudantes de forma rápida, exigindo muito trabalho. Apesar da atuação do docente como
elemento motivador, a maioria dos alunos fizeram aquilo que foi estritamente pedido, não
explorando espontaneamente o ambiente. Os autores perceberam que os alunos estranharam
também a sensação de autonomia, provavelmente por ser uma novidade para eles no ambiente
acadêmico. Mesmo assim, as dificuldades tornaram-se gradualmente mais amenas no decorrer da
disciplina indicando um possível desenvolvimento das competências sociais desejadas.
Marcelino & Rosatelli (2008) desenvolveram um Ambiente Virtual de Aprendizagem
para o ensino de algoritmos de forma colaborativa, cujo principal diferencial foi o uso de um
agente pedagógico. O objetivo foi motivar o estudante para que ele desenvolva esses exercícios,
individualmente ou em grupo. O AVA apresenta dois ambientes: um cooperativo e outro
competitivo.
No ambiente cooperativo os alunos estudam em grupos gerenciados pelo professor. Os
estudantes podem discutir e trocar informações em uma área de chat. O agente pedagógico
monitora os grupos e avisa os integrantes sobre o atraso demasiado de algum dos membros
durante o processo de aprendizagem. No ambiente competitivo os alunos respondem perguntas
em forma de jogo para verificar qual ou quais estudantes conseguiram assimilar melhor os
conceitos apresentados.
No estudo feito por Marcelino & Rosatelli (2008) 73% dos estudantes manifestaram a
preferência pelo ambiente competitivo, mas quando foi perguntado em qual ambiente eles
acreditaram aprender melhor, 75% indicaram o ambiente cooperativo. Os estudantes avaliaram
que o estudo colaborativo os ajudou a entender melhor os tópicos e o processo de ajudar os
colegas com mais dificuldade foi considerado benéfico para todos os envolvidos.
34
A Tabela 1 sumariza estes trabalhos, evidenciando os pontos positivos e pontos negativos
de cada trabalho relacionado:
TABELA 1 - Pontos positivos e negativos dos trabalhos relacionados
Trabalhos Relacionados Contribuição Pontos Negativos
FARIA & ADÁN COELLO (2004)
Faz uso da colaboração em conjunto com software
metrificador
Não faz uso da Web e precisa de mediador ativo
FARIA; VILELA & ADÁN COELLO
(2004)
Faz uso da colaboração em conjunto com software metrificador em Web
Faz uso de poucas técnicas construtivistas
SOARES et at. (2004) Propõe ensino de algoritmos de
grafos utilizando ambiente gráfico em Web
Não permite que o aluno possa alterar os algoritmos
RAABE & SILVA (2004)
Faz uso de Assistentes Inteligentes de Ensino em Web
Sobrecarrega o professor com informações detalhadas, com pouco uso de colaboração e
construtivismo
SANTOS & COSTA (2005)
Faz uso de um AVA para ensino de estrutura de dados e algoritmos
básicos
Não permite que o aluno possa alterar os algoritmos
BORGES (2005) Propõe uma comunidade de estudos de Java com apoio
tecnológico em Web
Não trata nenhum processo formal de avaliação e de
acompanhamento do aprendizado.
DELGADO et al. (2005)
Propõe ensinar programação no nível médio com técnicas
construtivistas Não faz uso de AVA
FLÁVIO (2005) Propôs um Tutorial de Estruturas de Dados (TED)
Não permite que o aluno possa alterar os algoritmos
FERRANDIN & STEPHANI (2006)
Propõe um compilador de programas em Portugol em Web
Não faz uso dos conceitos de colaboração e construtivismo
HOSTINGS & RAABE (2007)
Propõe um compilador de programas em Portugol em Web com um verificador de entradas e
saídas
Não é suficiente para detectar e orientar os tipos mais comuns de
erros que os alunos cometem
XEXÉO; KALINOWSKI &
RAPKIEWICZ (2007)
Propõe o desenvolvimento de competências sociais nos alunos
com o uso de comunidades virtuais em um AVA
Estranhamento por parte dos alunos com a autonomia
proporcionada
35
MARCELINO & ROSATELLI (2008)
Propõe um AVA com processo colaborativo e competitivo para
aprendizagem
Não faz avaliação automática dos algoritmos dos estudantes
36
3 METODOLOGIA
A metodologia utilizada na elaboração do trabalho foi a seguinte:
Foram pesquisados Ambientes e Ferramentas Virtuais de Aprendizagem voltados para o
ensino de algoritmos. Os pontos positivos e negativos dos trabalhos relacionados e dos
Ambientes Virtuais de Aprendizagem foram verificados em conjunto com as sugestões de
trabalhos futuros com o objetivo de elaborar uma nova proposta. Também foi feita uma pesquisa
na literatura por metodologias pedagógicas que fossem adequadas ao ensino de algoritmos.
Uma nova proposta foi elaborada e um novo Ambiente Virtual de Aprendizagem para
estudo de algoritmos foi desenvolvido para atender os requisitos levantados. Este novo ambiente
foi formulado através do estudo de ambientes virtuais já existentes e alguns recursos foram
construídos utilizando frameworks especializados (fórum, chat e nuvem de tags) disponíveis na
Internet.
O novo AVA foi avaliado em um estudo de caso com professores e alunos da
Universidade Salgado de Oliveira do curso de Análise de Sistemas, nas disciplinas de Teoria da
Computação (alunos do 1º semestre do curso) e Linguagem de Programação I (alunos do 2º
semestre do curso) pois são disciplinas que tratam de conceitos relacionados a algoritmos.
A aplicação do AVA e da metodologia construtivista colaborativa foi avaliada através de
um questionário para os professores e alunos, como também da comparação entre as notas
obtidas pelos alunos que participaram do experimento e as notas dos alunos dos semestres
anteriores.
37
4 PROPOSTA – OBJETIVOS E DESCRIÇÃO DO AVA
Neste capítulo são destacadas as fases que foram aplicadas durante o experimento com o
detalhamento do funcionamento do Ambiente Virtual de Aprendizagem.
Com base na análise dos trabalhos relacionados é possível destacar características
consideradas essenciais para o sucesso de qualquer ferramenta computacional para o auxílio da
aprendizagem de algoritmos:
a) Fazer uso de técnicas de colaboração através do conflito sócio-cognitivo (FARIA,
VILELA & ADÁN COELLO, 2004) com grupos de alunos para estudo e resolução de
problemas específicos (BORGES, 2005; XEXÉO, KALINOWSKI & RAPKIEWICZ,
2007 e MARCELINO & ROSATELLI, 2008)
b) Medir os esforços dos alunos através de um verificador de qualidade de software
(FARIA & ADÁN COELLO, 2004)
c) Utilizar assistentes computacionais que monitoram o desenvolvimento dos estudantes
(RAABE & SILVA, 2004)
d) Permitir o compartilhamento de código colaborativo (FERRANDIN & STEPHANI,
2006)
e) Disponibilizar conteúdo didático sintético (SANTOS & COSTA, 2005)
Lévy (1999) afirma que a colaboração parte do princípio de que dois ou mais indivíduos,
trabalhando conjuntamente, podem chegar a uma situação de equilíbrio, por meio de troca de
idéias, distribuídas entre os participantes do grupo, gerando assim, novas idéias, novos
conhecimentos, educação, frutos deste trabalho coletivo. Este “conflito sócio-cognitivo” segundo
Piaget (1990) é fundamental para a construção de conhecimento.
Para que o AVA proposto consiga atingir seus objetivos de aumentar a eficiência do
aprendizado de algoritmos é necessário que ele esteja adequado à uma metodologia pedagógica
construtivista que prime pelo desenvolvimento de habilidades e colaboração entre os indivíduos
como forma de crescimento.
38
O AVA precisa trabalhar as lacunas de aprendizado através do uso de um glossário
colaborativo para apoiar os estudantes na construção dos conhecimentos prévios como apontam
Pimentel & Omar (2008). Este glossário também servirá como fonte de conteúdo didático
sintético conforme sugerem Santos & Costa (2005).
É preciso que o AVA faça uso de técnicas de colaboração com grupos de alunos para o
estudo e resolução de problemas específicos. As soluções dos grupos de alunos precisam ser
confrontadas e discutidas de forma colaborativa. Esta interação permitirá a troca de experiências
e o crescimento cognitivo dos alunos conforme sugerem Faria, Vilela & Adán Coello (2004),
Borges (2005), Xexéo, Kalinowski & Rapkiewicz (2007) e Marcelino & Rosatelli (2008).
O AVA deve permitir que a produção de algoritmos pelos alunos seja avaliada de forma
automática pela ferramenta com parâmetros fornecidos pelo professor para medir o grau de
assertividade e evolução do aprendizado, através de um verificador de qualidade de software
(FARIA & ADÁN COELLO, 2004). O código-fonte dos alunos deve ser compartilhado para que
a troca de experiências resulte em um código melhorado conforme sugerem Ferrandin & Stephani
(2006).
O AVA deve também auxiliar o professor através do uso de assistentes computacionais
inteligentes que monitoram o desenvolvimento dos estudantes (RAABE & SILVA, 2004).
Neste trabalho propõe-se uma metodologia composta de fases, elaboradas a partir da
observação dos conceitos de colaboração construtivista e conectivismo, bem como dos pontos
fortes apontados em trabalhos relacionados.
Delgado et al. (2004) sugerem três fases para a construção do conhecimento aplicado a
resolução de programas computacionais em algoritmos de forma construtivista:
1. A primeira trabalha a resolução dos problemas, valorizando a autonomia cognitiva
(Fase 1 - Construção Colaborativa do Conhecimento)
39
2. Na segunda fase o professor conduz o aluno pela experiência da formalização,
valorizando a concisão e o entendimento do problema computacional proposto
(Fase 2 - Análise de Problema)
3. Na terceira fase o objetivo passa a ser então a construção de algoritmos (Fase 3 -
Construção do Código)
Adicionalmente à proposta de Delgado et al. (2004), propõem-se neste trabalho duas
novas fases que são: a Fase 4 de “Metrificação do Código” e a Fase 5 de “Formação de Grupos
para Construção de Novo Código” e nova metrificação conforme sugerido por Faria & Adán
Coello (2004).
Desta forma, o detalhamento do funcionamento do AVA proposto está dividido em cinco
fases: 1) Construção Colaborativa do Conhecimento; 2) Análise de Problema; 3) Construção do
Código; 4) Metrificação do Código; 5) Formação de Grupos para Construção de Novo Código.
A Figura 1 apresenta de forma sucinta as fases da metodologia apresentada.
FIGURA 1 - Fases da proposta
40
4.1 Fase 1 - Construção Colaborativa do Conhecimento
O objetivo da primeira fase é desenvolver a autonomia na busca de soluções próprias para
os problemas apresentados privilegiando a percepção e interpretação. Seu propósito final é a
auto-afirmação do aluno para ponderar e validar suas próprias soluções.
Desta forma será solicitado ao aluno que desenvolva os textos do conteúdo da disciplina
de forma colaborativa, em conjunto com seus colegas, sob supervisão do professor.
Nesta fase o aluno será levado a:
a) Compreender procedimentos expressos em modelos computacionais
b) Dominar o funcionamento das estruturas simbólicas formais para o
estabelecimento de procedimentos computacionais
c) Formular um conceito de programa contextualizado no universo de uso doméstico
do PC e nos modelos computacionais vigentes
d) Avaliar o grau de similaridade entre suas formulações e as novas experiências
e) Compreender a importância histórica e funcional de modelos computacionais
abstratos para a interação homem-computador
f) Escrever e exemplificar as estruturas formais de linguagem de programação
g) Descrever e exemplificar o processo de compilação e execução de programas
Essas atividades deverão ser desenvolvidas principalmente através da criação de um
glossário colaborativo. A interação entre os indivíduos para criar um texto colaborativo com o
conteúdo da disciplina de forma construtivista favorece o amadurecimento e solidificação de
conceitos (BORGES, 2005).
Outros instrumentos também estão disponíveis para fomentar a colaboração entre os
alunos: Quadro de Avisos, Chat para troca de informações síncronas entre os participantes e o
Fórum para a troca de informações assíncronas. Estas ferramentas foram escolhidas por sua
ampla utilização na Internet e por sua presença na maioria dos Ambientes Virtuais de
41
Aprendizagem. Stewart & Williamns (2005) apontam que estas ferramentas, apesar de simples,
estão sendo utilizadas para ampliar a colaboração de comunidades virtuais.
No glossário foi disponibilizada uma nuvem de tags, que se trata de uma lista
hierarquizada visualmente de um conjunto de palavras. Na nuvem, o número de alterações de
cada termo é representado pelo tamanho da fonte utilizada. Desta forma, os verbetes com mais
alterações foram destacados visualmente. O uso deste recurso foi muito difundido por sites de
bookmarks (www.del.icio.us) e de fotos (www.flickr.com) e representa uma nova forma
taxonômica emergente na Internet. Seu uso tornou o glossário mais atrativo e dinâmico para os
alunos.
A Figura 2 ilustra o glossário colaborativo com a nuvem de tags.
FIGURA 2 - Glossário colaborativo
A Figura 3 ilustra o quadro de avisos criado para que as pessoas possam postar
informações gerais.
42
FIGURA 3 - Quadro de avisos
A Figura 4 ilustra o chat para troca de informações síncronas entre os participantes.
FIGURA 4 - Chat
A Figura 5 ilustra o fórum de mensagens para a troca de informações assíncronas.
43
FIGURA 5 - Fórum de mensagens
4.2 Fase 2 - Análise de Problema
Na segunda fase o aluno deverá desenvolver sua habilidade de compreender o problema e
dividí-lo em problemas menores e construir um modelo computacional adequado que seja
factível de solução utilizando algoritmos. Nesta fase o aluno será levado a:
a) Identificar e estabelecer os objetivos
b) Identificar informações e procedimentos
c) Classificar a transformação de informações
d) Fazer a derivação do modelo
e) Formalizar a proposta de solução do problema
Essencialmente esta fase é desenvolvida em sala de aula com a discussão de possíveis
soluções do problema. Os alunos se organizam em grupos de três ou quatro pessoas de forma
autônoma e contam com a orientação do docente, conforme sugerem Delgado et al. (2004).
44
4.3 Fase 3 - Construção do Código
Na terceira fase o aluno deverá construir o código a partir da solução e do entendimento
proposto na segunda fase e utilizando os conceitos aprendidos e construídos na Fase 1.
Apesar dos autores Ferrandin & Stephani (2006) e Hostings & Raabe (2007) sugerirem o
Portugol como linguagem adequada para a iniciação com algoritmos, a Universidade Salgado de
Oliveira adota desde o primeiro período do curso a linguagem C++, por sua robustez e facilidade
em se encontrar vastas referências bibliográficas.
Desta forma, o código deverá ser compilado utilizando o compilador C++ padrão ANSI.
Nesta fase o aluno será levado a:
a) Escrever um código com corretude
b) Escrever um código com eficiência
c) Adequar-se a um estilo de escrita apropriado
d) Adequar-se ao nível de complexidade que o problema exige
e) Identificar casos e subcasos do problema
f) Fazer a modelagem das condições de decisão
g) Identificar blocos que se repetem
h) Construir condições de parada
i) Compreender as técnicas de compilação e depuração
A Figura 6 ilustra a fase de construção individual do código.
45
FIGURA 6 - Construção do código
4.4 Fase 4 - Metrificação do Código
Na quarta fase, o código escrito pelo aluno deverá ser submetido a um software de
metrificação de código para que possa ser avaliado e uma nota possa ser atribuída ao seu
programa.
Sommerville (2003) aponta que os programas têm uma série de atributos associados que
refletem sua qualidade e que nem sempre estão diretamente associados ao que o programa faz.
A estrutura, organização do código fonte e documentação associada refletem o
comportamento do programa quando em funcionamento, principalmente em programas
complexos.
Berry & Meekings (1985) e Hung; Kwork & Chang (1993), demonstraram que é possível
construir avaliadores automatizados de programas baseados em algumas métricas levantadas por
eles. Baseado neste estudo, Jackson (2000) descreve uma abordagem semi-automatizada para
46
avaliação on-line, levantando métricas de qualidade que devem ser consideradas para avaliação
de programas. Os critérios apontados por ele são:
a) Corretude: produção e estrutura do programa conforme as exigências desejadas
b) Estilo de escrita: comprimento de módulo, comprimento de identificador, linhas de
comentário, endentação, linhas em branco, uso de constantes e outros aspectos
relacionados ao estilo de construção do programa
c) Eficiência: tempo de CPU usado pelo programa do estudante comparado ao
programa do professor
Para fazer a metrificação do código foram avaliados os programas VDSP criado por Faria
& Adán Coello (2004) e o CCCC (C and C++ Code Counter) criado por Littlefair (2001).
A Tabela 2 faz uma relação das métricas avaliadas pelo VDSP e CCCC:
TABELA 2 - Relação entre as métricas avaliadas pelos softwares metrificadores
Métricas VDSP CCCC
Número de Linhas de Código SIM SIM
Número de Módulos SIM SIM
Complexidade Ciclomática de McCabe
NÃO SIM
Número de Comentários SIM SIM
Relação entre número de linhas de código por comentário
SIM SIM
Relação entre a Complexidade Ciclomática de McCabe por comentário
NÃO SIM
Número de chamadas de métodos
NÃO SIM
Tamanho dos Identificadores SIM NÃO
Número de Constantes SIM NÃO
47
Littlefair (2001) utilizou no CCCC a metrificação criada por Thomas McCabe para medir
a complexidade de um programa (Complexidade Ciclomática de McCabe ) contando o número de
caminhos lineares independentes de execução de um código-fonte. Se um programa não contiver
nenhuma instrução IF ou FOR, ele será classificado com complexidade 0, uma vez que o código
será executado sem nenhum desvio ou loop. Se o programa contiver uma instrução IF, o
processamento poderá ser desviado para a execução condicional ou não. Desta forma, a
complexidade será 1.
Analisando a relação das métricas avaliadas por ambos os softwares, o CCCC é capaz de
analisar mais aspectos do que o VDSP. Portanto, o software CCCC - C and C++ Code Counter
foi analisado detalhadamente para que um software similar fosse construído com capacidade para
atender aos requisitos da proposta. O CCCC não foi utilizado por funcionar em ambiente
Unix/Linux com execução em linha de comando em shell, dificultando sua utilização em um
ambiente Web.
Desta forma, o software de metrificação do AVA criado a partir do estudo do CCCC trata-
se de um avaliador automatizado de programas em linguagem C capaz de medir a qualidade de
um programa a partir das métricas propostas por Littlefair (2001):
a) Contar o número de linhas de código preenchidas (excluindo os comentários) do
programa como um todo
b) Contar o número de comentários do programa como um todo
c) Medir a complexidade ciclomática de McCabe
d) Contar a quantidade de laços de repetição
e) Contar a quantidade de estruturas de dados (Structs)
f) Contar o número de métodos por classe a partir do número de funções acessíveis
por outros módulos no código-fonte
g) Contar o número de Classes
h) Contar o número de chamadas de métodos
48
Para que o metrificador funcione, as atividades propostas pelo professor precisam ser
previamente cadastradas definindo-se um conjunto mestre de valores máximos e mínimos
aceitáveis e valores máximos e mínimos ideais para cada métrica.
A tarefa do metrificador será avaliar o código-fonte do programa segundo as métricas
propostas e procurar em qual faixa de valores o programa submetido se encontra. Desta forma o
código avaliado receberá um valor correspondente a um índice que procura medir a qualidade do
estilo de programação usado em sua construção.
O programa metrificador fará uma busca no código-fonte postado pelos alunos
procurando por seqüências específicas de texto que fazem parte da sintaxe da linguagem C/C++ e
fará a contabilidade das ocorrências.
A Tabela 3 exemplifica quais são as ocorrências procuradas:
TABELA 3 - Ocorrências buscadas pelo metrificador
Métrica Ocorrência
Complexidade ciclomática de McCabe if ( condição ) Complexidade ciclomática de McCabe switch (condição) Número de Laços de Repetição for ( expressão ) Número de Laços de Repetição while ( expressão ) Contar o número de comentários /* até */ ou // Número de métodos por classe tipo função ( ) Número de classes class
Número de chamadas Objeto -> Método Número de Structs struct { dados }
A métrica obtida pelo metrificador será utilizada para auxiliar na montagem de grupos
colaborativos para o aprendizado de programação.
Cada código-fonte analisado pelo metrificador ganhará um índice proporcional para cada
métrica analisada de acordo com os valores mínimos e máximos aceitáveis e valores mínimos e
máximos ideais.
49
Para cada uma das métricas avaliadas pelo software o professor deverá indicar os valores:
a) Mínimo aceitável (MIMA)
b) Mínimo ideal (MIMI)
c) Máximo ideal (MAXI)
d) Máximo aceitável (MAXA)
A Figura 7 ilustra as faixas de valores Mínimo Aceitável, Ideal e Máximo Aceitável
fornecidas pelo professor:
FIGURA 7 - Escala de valores
A proposta adota o modelo de Faria e Adán Coello (2004) para aferir um índice para as
métricas, a seguir:
Quando o valor encontrado pelo metrificador estiver fora de qualquer Faixa, o índice da
métrica deverá ser 0.
Quando o valor encontrado pelo metrificador estiver na Faixa Aceitável Mínima, a
seguinte fórmula de cálculo será utilizada para gerar o índice da métrica:
ÍNDICE =
50
Quando o valor encontrado pelo metrificador estiver na Faixa Aceitável Máxima, a
seguinte fórmula de cálculo será utilizada para gerar o índice da métrica:
ÍNDICE =
Estas fórmulas irão fornecer um índice proporcional ao quanto o valor encontrado está
próximo ou não dos valores ideais.
Quando o valor encontrado pelo metrificador estiver na Faixa Ideal, o índice deverá ser
100.
Por exemplo, se o professor definiu os seguintes valores para a métrica de Número de
Métodos por Classe:
a) Mínimo Aceitável (MIMA) = 2
b) Mínimo Ideal (MIMI) = 6
c) Máximo Ideal (MAXI) = 8
d) Máximo Aceitável (MAXA) = 10
Se o metrificador encontrar no código-fonte do Aluno1 sete métodos por classe, o
algoritmo obterá a métrica 100. Se o código do Aluno2 contiver apenas três métodos por classe,
sua métrica será o resultado da fórmula = = 25.
A ferramenta ainda irá fornecer um índice global do código-fonte que consistem no
somatório dos índices das métricas individuais.
ÍNDICE GLOBAL=
O programa metrificador analisa oito métricas conforme descrito na página 48, portanto, o valor
máximo do Índice Global são 800 pontos.
A Figura 8 ilusta o resultado de uma métrica feita de um código-fonte:
51
FIGURA 8 - Análise do metrificador de um código fonte
4.5 Fase 5 - Formação de Grupos para Construção de Novo Código
Para a construção do conhecimento apontada por Lévy (1999) e Piaget (1990) através do
conflito sócio-cognitivo aplicado ao contexto do aprendizado de programação, faz-se necessário
levar o aluno a identificar diferenças significativas nos programas desenvolvidos pelos seus
colegas de forma a encorajá-los à discussão para que os envolvidos tenham um ganho de
conhecimento advindo do próprio conflito. Os alunos foram divididos em grupos para que fosse
provocado um conflito sócio-cognitivo.
Faria & Adán Coello (2004) também dividiram os alunos em grupos possibilitando um
ganho de resultado advindo da colaboração. Eles criaram grupos homogêneos e heterogêneos
com a finalidade de criar diferentes formas de conflito sócio-cognitivo.
Assim a ferramenta utilizará das notas obtidas pelo metrificador para dividir os alunos na
seguinte formação:
52
• Um ou mais grupos heterogêneos: alunos que obtiveram notas díspares no
metrificador
• Um grupo homogêneo alto: alunos que obtiveram notas altas no metrificador
• Um grupo homogêneo baixo: alunos que obtiveram notas baixas no metrificador
Constantino-González & Suthers (2001) fizeram uma análise a respeito do
comportamento de grupos de estudo. Eles constataram que em grupos heterogêneos os alunos
mais fortes obtêm ganho de conhecimento através da atividade de ensinar e que os alunos com
baixo rendimento também tiveram sua eficiência de aprendizado aumentada nas tarefas
subseqüentes. Os autores também apontam que no grupo homogêneo baixo houve crescimento
dos alunos nas tarefas subseqüentes. Quanto ao grupo homogêneo alto, não foi constatado no
estudo o aumento significativo da nota, provavelmente porque a preocupação dos alunos não se
atem somente aos problemas estilísticos, mas também aos problemas de corretude e eficiência
dos programas desenvolvidos.
Os alunos serão levados a trocar e discutir os algoritmos dos colegas para encontrar
anomalias e apontar melhorias. Para aplicar a metodologia construtivista proposta por
Rapkiewicz (2004) e a colaboração proposta por Siemens (2006), nesta etapa é importante a
elaboração de um documento colaborativo com as principais diferenças e aspectos importantes
destacados pelos integrantes.
Uma vez formalizado este documento, o grupo será solicitado a escolher um líder que
conduzirá à construção de um novo programa colaborativamente com as correções e melhorias
sugeridas.
A Figura 9 ilustra a construção colaborativa do novo código-fonte.
53
FIGURA 9 - Construção do código em Wiki
O novo código produzido deverá ser analisado novamente pelo metrificador para que seja
aferida melhora do algoritmo pelo sistema. A avaliação final das melhorias e correções deve ser
feita pelo professor.
4.6 Características do AVA
O AVA foi escrito dentro dos padrões Web 2.0 uma vez que a metodologia pedagógica
utilizada foi a colaborativa e conectivista.
A Tabela 4 faz um comparativo entre as funcionalidades da Web 2.0 enumeradas por
O´Reilly (2005) e o AVA:
54
TABELA 4 - Comparativo entre as características da Web 2.0 e o AVA
Web 2.0 AVA
Interfaces ricas e fáceis de usar Interface simples, com uso de nuvem de tags
Sucesso da ferramenta depende do número de utilizadores, pois os mesmos podem ajudar a tornar o sistema melhor
Utilizada por duas classes de alunos do curso de Análise de Sistemas da UNIVERSO. Os alunos contribuíram para a melhoria do sistema
Gratuidade na maioria dos sistemas disponibilizados
Gratuito para os alunos
Vários utilizadores podem acessar mesma página e editar as informações
Sistema Wiki para criação do Glossário Colaborativo e programação
Os softwares da web 2.0 geralmente criam comunidades de pessoas interessadas em um determinado assunto
Comunidade de alunos das disciplinas de Teoria da Computação e Linguagem e Programação I
A atualização da informação é feita colaborativamente e tende a tornar-se mais confiável com o crescente número de utilizadores
Glossário Wiki e Programação Wiki
Com a utilização de “tags” em quase todos
os aplicativos, ocorre um dos primeiros passos para a web semântica e a indexação correta dos conteúdos disponibilizados
Glossário Wiki
O´Reilly (2005) também aponta quatro camadas que caracterizam a Web 2.0: Tecnologia,
Distribuição, Modelo e Filosofia. A Figura 10 sintetiza essas quatro camadas.
55
FIGURA 10 - Camadas da Web 2.0
Fonte: O´Reilly (2005)
Na camada de tecnologia o AVA utiliza o HTML, CSS, JavaScript e HTTP e na camada
de distribuição utiliza o AJAX e o Wiki. A linguagem de programação escolhida foi o ASP.Net por
sua rapidez de desenvolvimento em ambiente Web e o Banco de Dados MySQL, por ser robusto
e gratuito.
O AVA é executado em um servidor Windows Server 2008 rodando Internet Information
Services (IIS) 7.0 com framework .Net 3.5.
O AVA foi construído com páginas Asp.Net. Estas páginas são processadas pelo IIS que
executa o código compilado e faz acessos ao banco de dados MySql. O resultado do
processamento é enviado em HTML e Javascript para interpretação no navegador.
O Javascript (AJAX) nas páginas é então interpretado pelo navegador e o resultado é
apresentado na tela. O AJAX foi utilizado para evitar que muitas requisições de dados sejam feitas
ao servidor, principalmente no Glossário Wiki.
Para implementar a nuvem de tags foi utilizado o componente criado por Vavilala (2006)
chamado Cloud Control for ASP.NET por ser simples de utilizar.
56
A Figura 11 ilustra o diagrama de funcionamento do AVA:
FIGURA 11 - Diagrama de funcionamento do AVA
Utilizando o AVA, o aluno pode:
a) Construir colaborativamente um glossário de termos Wiki
b) Construir os algoritmos
c) Submeter o código fonte para avaliação do algoritmo no metrificador
d) Discutir e debater novas soluções em fórum e chat
e) Construir um novo algoritmo baseado na solução proposta pelo grupo em
modalidade colaborativa Wiki
O AVA fornece as seguintes funcionalidades para o professor:
a) Acompanhar os trabalhos dos alunos
b) Configurar as métricas do metrificador
c) Construir automaticamente os grupos homogêneos e heterogêneos de alunos a
partir das notas obtidas pelos alunos no metrificador
57
5 RESULTADOS – APRESENTAÇÃO E ANÁLISE
Neste capítulo é feita uma descrição cronológica da aplicação do estudo de caso, com
apresentação e análise dos resultados obtidos.
5.1 Contexto
O experimento do uso do AVA e a metodologia construtivista colaborativa para o
aprendizado de algoritmos foi feito com os alunos da Universidade Salgado de Oliveira
(UNIVERSO), nas disciplinas de Teoria da Computação e Linguagem de Programação I.
Os alunos foram convidados a participar do experimento voluntariamente. Aqueles que
optassem por participar teriam metade da nota da última avaliação da disciplina transformada em
pontos referentes ao trabalho.
Optou-se por pontuar os alunos voluntários como forma de estímulo para que
participassem ativamente. O professor pontuou apenas os alunos que participaram de todas as
fases.
A Universidade adota a seguinte metodologia de pontuação de avaliações: existem duas
avaliações escritas em forma de prova individual sem consulta com valor de 10 pontos cada. Uma
é realizada na metade do semestre (V1) e outra ao término (V2). Ainda existe uma avaliação em
forma de trabalho individual ou em grupo (VT) que tem seu término no final do semestre com
atividade à critério do professor com valor de 10 pontos. É feita a média simples das notas de V1,
V2 e VT. O aluno é aprovado com nota superior a sete. Se a nota for inferior a sete e superior a
quatro o aluno tem direito a uma prova suplementar (VS).
58
A turma da disciplina de Teoria da Computação submetida ao experimento era composta
de 17 alunos, sendo 13 homens e quatro mulheres. Quinze alunos têm entre 18 e 25 anos de idade
e dois alunos com mais de 40 anos. A disciplina ocorre no primeiro período do curso de
bacharelado em Análise de Sistemas, com carga-horária de 60 horas-aula. O programa da
disciplina é composto por:
“Definição e distinção entre programas e algoritmos. Técnicas de construção de algoritmos, utilizando-se de estruturas de seqüência, seleção e repetição. Tipos de instruções, dados, operadores, estruturas de dados homogêneas e heterogêneas. Modularização.” (UNIVERSO, 2004).
O resultado do aproveitamento dessa disciplina nos dois últimos semestres anteriores ao
experimento está na Tabela 5.
TABELA 5 - Resultado do aproveitamento da disciplina de Teoria da Computação em semestres anteriores ao experimento
Semestre Total Alunos Desistência Reprovações % Aprovados
1⁰ / 2007 36 6 14 44,40%
2⁰ / 2007 15 1 9 33,3%
A turma da disciplina de Linguagem de Programação I submetida ao experimento era
composta por 14 alunos, sendo 13 homens e apenas uma mulher. Todos os alunos estão entre 18 e
24 anos de idade. A disciplina ocorre no segundo período do curso de bacharelado em Análise de
Sistemas e a base de seu programa reside no conteúdo da disciplina de Teoria da Computação.
A disciplina Linguagem de Programação I tem uma carga-horária de 60 horas-aula e o
programa da disciplina é composto por:
“Estudo da sintaxe e semântica da linguagem C++. Introdução à estrutura de dados. Tipos de dados. Vetores e Matrizes. Registros. Arquivos. Tipos de processamento. Passagem de parâmetros. Procedimentos. Funções.” (UNIVERSO, 2004).
59
O resultado do aproveitamento dessa disciplina nos dois últimos semestres anteriores ao
experimento está na Tabela 6.
TABELA 6 - Resultado do aproveitamento da disciplina de Linguagem de Programação I em semestres anteriores ao experimento
Semestre Total Alunos Desistência Reprovações % Aprovados
1⁰ / 2007 25 0 14 44,0%
2⁰ / 2007 21 1 14 28,5%
Os percentuais de aproveitamento descritos nas Tabelas 5 e 6 apontam que o
aproveitamento dessas disciplinas são inferiores a 50%. Isto justifica o esforço em utilizar uma
metodologia construtivista e colaborativa em conjunto com um AVA para melhorar este número.
As atividades foram executadas em cinco fases conforme detalhado no Capítulo 4 e com
início e duração descritos no cronograma da Tabela 7.
TABELA 7 - Cronograma das atividades
Fase 1 Fase 2 Fase 3 Fase 4 Fase 5
Construção Colaborativa do Conhecimento
Análise de Problema
Construção do Código
Metrificação do Código
Formação de Grupos para
Construção de Novo Código
1ª Semana Abril/08 4 semanas
1ª Semana Maio/08 2 semanas
3ª Semana Maio/08 3 semanas
2ª Semana Junho/08 1 dia 3 semanas
60
5.2 Descrição do Processo
Durante a aplicação da ferramenta e metodologia de trabalho nas disciplinas de Teoria da
Computação e Linguagem de Programação I, observou-se que pelo menos dois alunos por turma
exteriorizaram verbalmente e voluntariamente suas apreensões relativas ao conceito construtivista
e colaborativo proposto.
O experimento contou com três sessões de chat previamente marcadas pelos professores
de cada disciplina separadamente. Cada sessão durou pelo menos 20 minutos. A primeira sessão
foi no início da Fase 1, a segunda sessão foi no meio da Fase 3 e a terceira sessão, no início da
Fase 5.
A Tabela 8 lista o número de alunos participantes das sessões de Chat.
TABELA 8 - Participação dos alunos nas sessões de chat de cada disciplina
Disciplina Chat 1 Chat 2 Chat 3
Teoria da Computação 8 9 8
Linguagem de Programação I 6 8 9
A Fase 1 - Construção Colaborativa do Conhecimento iniciou com a descrição do
experimento, seus objetivos e descrição das tarefas que os alunos iriam executar. Os professores
descreveram os princípios colaborativos e construtivistas para que os alunos entendessem a
metodologia pedagógica que seria utilizada.
A primeira atividade consistia em fazer um glossário colaborativo em Wiki com os termos
mais utilizados, descrições de conceitos, técnicas e comandos que fazem parte do programa
pedagógico das disciplinas. Os alunos puderam pesquisar livremente os termos e postar no
sistema. Apenas alguns termos iniciais foram sugeridos pelos professores para que os alunos
pudessem iniciar a atividade.
61
Após a aula de apresentação do experimento, o chat foi utilizado para resolução de
dúvidas iniciais e instigar os alunos a conhecerem o AVA.
Na primeira sessão de chat das disciplinas as principais dúvidas foram a respeito da
metodologia colaborativa construtivista. Algumas perguntas que os alunos fizeram demonstram
como eles estranharam a atividade colaborativa, tais como “Professor, eu posso escrever no que o
colega escreveu?”, “De onde eu pego as palavras?”, “Como vou saber se está certo?”, “Posso
corrigir o que alguém digitou?”.
Foi preciso que o professor de Teoria da Computação instigasse os alunos com perguntas
de exercícios de fixação propostos em sala para que eles fossem capazes de elaborar os primeiros
termos do glossário. O professor também relatou que na aula após o chat dois alunos trouxeram
voluntariamente os termos que colocaram no glossário para que ele corrigisse alguma possível
irregularidade.
Na disciplina de Teoria da Computação foram criados 48 termos e na disciplina de
Linguagem de Programação I foram criados 37 termos.
Notou-se que, em ambas as disciplinas, 70% dos termos sofreram correções por seu
próprio autor pelo menos uma vez. Na disciplina de Teoria da Computação apenas cinco termos
sofreram alterações por autores diferentes e na disciplina de Linguagem de Programação I apenas
8 termos. Termos mais complexos como “Alocação Dinâmica”, “Arranjo de Dados”,
“Encapsulamento”, “Funções” e “Vetores” foram aqueles editados por mais de um aluno.
Como poucos termos foram editados por mais de um aluno, supõe-se que houve certo
respeito entre os pares em editar os textos de outros colegas ou falta de hábito em fazer este tipo
de atividade colaborativa construtivista.
62
Naqueles termos editados por mais de um aluno observou-se que houve uma evolução no
conceito, como no exemplo:
“FUNÇÃO: São blocos de instruções, que serão chamados em outra parte do programa. Ela pode retornar apenas um ou nenhum valor, nela está dito como é que se vai calcular ou fazer alguma coisa.” (ALUNO 11).
“FUNÇÃO: Uma função em C++ é parecida com um programa principal. Podem-
se declarar variáveis dentro da função. As variáveis declaradas dentro da função (além dos parâmetros) somente existem enquanto a função estiver sendo executada. Ao término da execução da função, as variáveis declaradas deixam de existir, liberando espaço na memória do computador. Toda e qualquer função deve ser declarada logo após as variáveis globais (variáveis que são utilizadas em todo o programa principal). O resultado de uma função é atribuído a uma variável e seu uso pode ser isolado ou acompanhado de uma expressão. A declaração da função é composta pelo tipo da função (tipo de valor que será retornado pela função), do nome da função e dos parâmetros que podemos passar a esta função.” (ALUNO 13).
Observou-se que cinco alunos predominaram na criação dos termos na disciplina de
Teoria da Computação, responsáveis por 48% dos termos. Na disciplina de Linguagem de
Programação I três alunos foram responsáveis por 53% dos termos.
Ao término da fase, os professores postaram para os alunos pequenas correções em termos
que apresentaram incoerências e algumas observações foram feitas em sala de aula.
A Fase 2 - Análise de Problema iniciou com a apresentação em sala do problema
computacional que seria resolvido através da construção de um algoritmo.
Os professores formularam os problemas computacionais de maneira independente para
que os algoritmos fossem condizentes com aquilo que estava sendo desenvolvido em sala de aula
e com os programas das disciplinas.
63
O professor da disciplina de Teoria da Computação apresentou o seguinte problema
computacional:
“A Universo deseja saber quanto está gastando de energia
elétrica no campus de Belo Horizonte e fazer a estimativa do custo de energia por aluno, por turno e por turma. O programa deve calcular a energia que não é gasta em sala de aula (exemplo: corredores e outros setores da Universidade.
Faça um programa que receba o total de energia gasta no campus em quilowatts/mês, o consumo médio das lâmpadas em sala de aula e o consumo médio dos aparelhos de ar condicionado das salas. O programa deve receber o número de alunos por turno (matutino, vespertino e noturno) e o número de salas de aula utilizadas por turno.”
O professor da disciplina de Linguagem de Programação I apresentou o seguinte
problema computacional:
“Um pequeno estabelecimento (ex. Loja de Roupas) deseja manter o cadastro de seus clientes. Para isto, os seguintes dados de clientes deverão ser armazenados: CPF, Nome, email e Valor médio de suas compra.
Projete e implemente um algoritmo em C++ que permita armazenar estes dados em memória primária. Caso julgue necessário, estabeleça um limite máximo de clientes a serem cadastrados (Ex. #define MAX_CLIENTES 50). Ao inicializar a execução do algoritmo, o usuário terá a opção de cadastrar clientes. Ao final do cadastro dos clientes, o usuário poderá optar por visualizar os dados cadastrados.
A solução computacional para este problema deve envolver os seguintes conceitos: função ou procedimento, arranjo de dados (vetor ou matriz), estruturas, ponteiros e alocação dinâmica de memória.
Requisito não-funcionais: Embora não seja obrigatório, deseja-se que o aplicativo desenvolvido tenha um grau de interatividade interessante, como por exemplo, o uso de um menu iterativo com possibilidade de execução das funções "Cadastrar Cliente", "Listar Clientes cadastrados" e "Sair do Sistema".
Deseja-se ainda, que o sistema não permita cadastrar clientes com CPF já cadastrado.”
64
Os alunos de cada disciplina se reuniram em grupo de três ou quatro integrantes, com
organização própria, buscando identificar e formalizar uma possível solução para os problemas
apresentados, conforme solicitado no Capítulo 4.2. Algumas perguntas foram feitas para que os
alunos pudessem identificar com maior clareza os objetivos da Fase.
a) Identificar e estabelecer os objetivos: quais os requisitos funcionais e não
funcionais?
b) Identificar informações e procedimentos: quais são as entradas e saídas do
programa?
c) Classificar a transformação de informações: como calcular ou construir a lógica
para que o programa funcione?
d) Fazer a derivação do modelo: quais estruturas de dados devem ser utilizadas?
Existem restrições? Qual a seqüência de eventos sem erros? Quais os valores de
entradas e saídas esperados?
e) Formalizar a proposta de solução do problema.
O entendimento do problema mostrou-se importante para que a Fase de Construção do
Código pudesse ter sucesso.
Na Fase 3 - Construção do Código os alunos foram levados para os laboratórios de
informática da universidade para codificação das soluções de forma individual. Os alunos tiveram
duas aulas com o professor para orientação e puderam desenvolver o código em casa.
Os programas foram desenvolvidos em Bloodshed Dev-C++ distribuído nos termos da
GNU - General Public License, instalados nos laboratórios e disponível para download no site da
universidade.
Os programas foram desenvolvidos para execução em console, por sua simplicidade de
implementação e interface.
65
Os professores também fizeram seus algoritmos para que fossem metrificados pelo AVA.
Isso permitiu que eles obtivessem o resultado da métrica de seus códigos para definir os
parâmetros Mínimo Aceitável (MIMA), Mínimo Ideal (MIMI), Máximo Ideal (MAXI) e Máximo
Aceitável (MAXA) de cada métrica do metrificador.
Os parâmetros Mínimo Ideal e Máximo Ideal foram definidos como 20% menor e 20%
maior, respectivamente, do valor encontrado nos códigos dos professores pelo metrificador. E, os
parâmetros Mínimo Aceitável como sendo 20% menor, e Máximo Aceitável como 20% maior
que os valores ideais. A Figura 12 ilustra a definição dos parâmetros do metrificador.
FIGURA 12 - Ilustração da definição dos parâmetros do metrificador
Na sessão de Chat ocorrida no meio desta fase os alunos aproveitaram para tirar dúvidas
com os professores, principalmente na parte de depuração do código.
Como pré-requisito para iniciar a próxima fase, os algoritmos desenvolvidos precisavam
atender aos requisitos da formulação do problema e gerar os resultados esperados. Nenhum
código incompleto pôde ser postado. A verificação dessas condições ficou a cargo dos
professores nos laboratórios de informática.
66
A Fase 4 - Metrificação do Código iniciou com a postagem dos algoritmos dos alunos no
AVA para que fossem metrificados pelo sistema e uma nota fosse atribuída.
O Gráfico 1 demonstra a distribuição de pontuação do índice global da métrica dos
algoritmos da disciplina Teoria da Computação.
GRÁFICO 1 - Distribuição de pontuação de Teoria da Computação
Observa-se que um aluno apresentou grandes dificuldades na elaboração do algoritmo
com pontuação inferior a 200 pontos, três alunos com pontuação baixa entre 300 e 400 pontos,
quatro alunos com pontuação mediana entre 400 e 500 pontos, seis alunos com pontuação boa
entre 500 e 600 pontos e apenas um aluno com pontuação acima de 600 pontos.
O Gráfico 2 demonstra a distribuição de pontuação da métrica dos algoritmos da
disciplina Linguagem de Programação I.
6%
20%
27%
40%
7%
Abaixo 200
300-400
400-500
500-600
Acima 600
67
GRÁFICO 2 - Distribuição de pontuação de Linguagem de Programação I
Pode-se notar nos resultados que 25% dos alunos com pontuação baixa, 50% com
pontuação mediana e 25% com pontuação superior, atingindo a maioria dos valores ideais
definidos pelo professor.
Nenhum aluno conseguiu superar 700 pontos (valor máximo 800 pontos).
Os alunos não tiveram acesso aos parâmetros fornecidos ao metrificador, nem como as
métricas eram contadas pelo software. O receio era que estas informações pudessem influenciar
as implementações dos algoritmos.
Ao término desta fase os professores relataram que pelo menos três alunos de cada turma
emitiram pareceres verbais voluntários a respeito da sensação de justiça que a metrificação
proporcionou, uma vez que as regras e o método de avaliação são únicos para todos.
Na Fase 5 - Formação de Grupos para Construção de Novo Código, o software organizou
os alunos em grupos de forma automática de acordo com as regras mencionada no Capítulo 4.5.
25%
25%25%
25%
300-400
400-500
500-600
600-700
68
Assim, na disciplina Teoria da Computação, os seguintes grupos foram criados:
a) Um grupo homogêneo baixo (GA1) com três alunos
b) Dois grupos homogêneos altos (GA2 e GA6) com três e dois alunos,
respectivamente
c) Três grupos heterogêneos (GA3, GA4 e GA5) com três alunos cada
E na disciplina Linguagem de Programação I os alunos foram organizados da seguinte
forma:
a) Um grupo homogêneo baixo (GB1) com três alunos
b) Um grupo homogêneo alto (GB5) com três alunos
c) Três grupos heterogêneos (GB2 e GB3) com dois alunos e um (GB4) com três
alunos
Com base nesta organização os alunos foram orientados a trocarem seus algoritmos pelo
AVA e fazer críticas e sugestões nos códigos dos colegas.
Os alunos contaram com dois momentos presenciais nos laboratórios de informática para
implementarem um código com as melhorias sugeridas.
5.3 Resultados Obtidos
A Tabela 9 contém os resultados do experimento da disciplina Teoria da Computação.
69
TABELA 9 - Resultados da disciplina Teoria da Computação
Disciplina Teoria da Computação
Aluno Posts Wiki Pontuação Individual Grupo Pontuação em Grupo Diferença
A1 9 367
GA1 452
18,8%
A2 7 397 12,2%
A3 8 379 16,2%
A4 13 520
GA2 617
15,7%
A5 6 584 5,3%
A6 9 527 14,6%
A7 6 527
GA3 713
26,1%
A8 22 616 13,6%
A9 12 475 33,4%
A10 4 486
GA4 689
29,5%
A11 14 599 13,1%
A12 9 473 31,3%
A13 3 192
GA5 664
71,1%
A14 8 514 22,6%
A15 5 441 33,6%
A16 4 525 GA6 598
12,2%
A17 11 563 5,9%
O grupo GA1 qualificado como homogêneo baixo obteve um ganho na pontuação médio
de 15% em relação ao ganho individual de seus integrantes. Isto demonstrou que os alunos com
baixo desempenho se beneficiaram com a troca de experiências.
Os grupos homogêneos altos (GA2 e GA6) tiveram um ganho de desempenho menor se
comparado aos outros grupos: 11,9% e 9,0%, respectivamente. Este resultado já era esperado, e é
coerente com o trabalho de Constantino-González & Suthers (2001). As melhorias desses grupos
são menos sentidas pelo metrificador, pois são fruto de algoritmos mais elaborados.
Os grupos heterogêneos (GA3, GA4 e GA5) apresentaram os maiores ganhos entre a
pontuação individual do código e a metrificação do algoritmo em grupo. Os grupos GA3 e GA4
tiveram um ganho aproximado de 24,5%, enquanto o grupo GA5 teve um ganho de 42,4%. Para
70
os alunos de desempenho baixo destes grupos o ganho médio foi de 30%. Os alunos de alto
desempenho tiveram também um ganho apurado de pelo menos 13%.
A Tabela 10 apresenta os resultados da disciplina Linguagem de Programação I.
TABELA 10 - Resultados da disciplina Linguagem de Programação I
Disciplina de Linguagem I
Aluno Posts Wiki Pontuação Individual Grupo Pontuação em Grupo Diferença
B1 11 415
GB1 616
32,6%
B2 0 350 43,2%
B3 4 365 40,7%
B4 2 670 GB2 592
-13,2%
B5 11 370 37,5%
B6 0 620 GB3 622
0,3%
B7 3 435 30,1%
B8 2 510
GB4 685
25,5%
B9 6 600 12,4%
B10 5 470 31,4%
B11 10 585 GB5 638
8,3%
B12 6 550 13,8%
O grupo homogêneo baixo (GB1) da disciplina de Linguagem de Programação I
apresentou o maior ganho atingindo na média, uma diferença de 38,9%.
O grupo homogêneo alto (GB5) apresentou a menor diferença média entre os grupos, com
apenas 11,1% de diferença.
O aluno B4 do grupo heterogêneo GB2 obteve uma nota menor no código em grupo do
que no código elaborado individualmente. Trata-se de um caso atípico, justificado pelo uso
exagerado de comentários: um comentário para cada linha de código. Já o ganho para o aluno B5
71
foi de 37,5%. Não foi possível apurar a efetiva participação desse aluno na construção do código
colaborativo.
Quase a mesma situação ocorreu no grupo GB3, uma vez que o aluno B6 obteve um
ganho muito pequeno. Averiguando os algoritmos individuais e em grupo, observou-se que o
algoritmo do grupo também foi basicamente o do aluno B6 com poucas modificações.
Já o grupo GB4 apresentou um algoritmo colaborativo diverso dos códigos individuais
dos alunos B8, B9 e B10.
As seqüências de programa a seguir ilustram a diferença entre os códigos individuais e o
código colaborativo do grupo GB4:
Código do aluno B8: #include <cstdlib> #include <iostream> #define tam 50 #define tamChar 100 using namespace std; //Criando uma estrutura de dados. struct Cliente { float cpf; char nome[tamChar]; char email[tamChar]; float media; } ; //Funcao para receber a quantidade dos produtos e o valor para depois calcular a media. int Media_prod (int num, int valor) { float media; for (int cont=0; cont < tam; cont++) { cout << "Digite quantos produtos foram comprados pelo cliente: " << endl; cin >> num; cout << "Digite o valor total da compra feita pelo cliente: " << endl; cin >> valor; media = valor / num; cout << "O valor medio das compras feita pelo cliente e: " << media << endl << endl;
72
return media; } } int main(int argc, char *argv[]) { Cliente vet[tam]; float med_prod, num, valor; //Recolhendo os dados dos clientes e armazenando em um vetor. for (int i = 0; i < tam; i++) { cout << "Digite o cpf do " << i + 1 << " cliente:" << endl; cin >> vet[i].cpf; cout << "Digite o nome do " << i + 1 << " cliente:" <<endl; cin >> vet[i].nome[tamChar]; cout << "Digite o email do " << i + 1 << " cliente:" << endl; cin >> vet[i].email[tamChar]; med_prod = Media_prod (num, valor); }
O algoritmo do aluno B8 apresenta poucos comentários, ausência de estrutura de
apresentação e duas funções simples (main e média).
Código do aluno B9: #include <cstdlib> #include <iostream> #include <conio.h> #define MAX_CLIENTES 100 using namespace std; //Estrutura de dados "Cliente" struct Clientes { char nome[100]; char e_mail[100]; Clientes * clientes; char cpf[100]; float valor_medio; }; //Procedimento para cadastrar os dados de um cliente void cadastrar(Clientes * c) { c->clientes = new Clientes(); cout<<"Informe o nome do cliente: "<<endl; cin>>c->nome;
73
cout<<"Informe o e-mail : "<<endl; cin>>c->e_mail; cout<<"Informe o CPF: "<<endl; cin>>c->cpf; cout<<"Informe o valor medio das compras desse cliente: "<<endl; cin>>c->valor_medio; } //Procedimento para listar os dados dos clientes cadastrados void mostrardados(Clientes * clientes[], int dados) { cout<<"Listando os clientes cadastrados..."<<endl<<endl; for(int i=0;i<dados; i++) { cout<<"Nome: " << clientes[i]->nome<< endl; cout<<"E-mail: " << clientes[i]->e_mail << endl; cout<<"CPF: " << clientes[i]->cpf << endl; cout<<"Valor medio de compras: " << clientes[i]->valor_medio << endl; cout<<endl; } } int main(int argc, char *argv[]) { int dados = 0; //Vetor que armazena a estrutura clientes Clientes * clientes[MAX_CLIENTES]; cout<<"************************** Seja bem-vindo ao Sistema **************************" <<endl; char continuar; do { cout<<endl; //Cria novo cliente para armazenar os dados informados pelo usuario Clientes * novo = new Clientes(); //Chamada do procedimento que vai cadastrar os dados dos Clientes cadastrar(novo); //Armazenamento do cliente no vetor clientes[dados] = novo; cout<<endl<<"Voce deseja continuar inserindo dados? (s/n): "; cin>>continuar; dados++; } //Cria um loop de repetição, com a condição de continuar enquanto o usuario não digita n // e não ultrapasse a capacidade do vetor while ((continuar == "s" || continuar == "S") && dados <= MAX_CLIENTES); cout<<endl<<"Foram cadastrado(s) " << dados << " cliente(s)"<<endl; cout<<"Pressione uma tecla para visualizar os clientes cadastrados..."<<endl; //Aguarda o usuário digitar qualquer tecla getch(); //Comando usado para limpar a tela, e aparecer somente os clientes listados // com seus devidos dados preenchidos system("CLS"); //Chamada do procedimento vai mostrar os clientes que foram cadastrados mostrardados(clientes, dados);
74
system("PAUSE"); return EXIT_SUCCESS; } system("PAUSE"); return EXIT_SUCCESS; }
O algoritmo do aluno B9 já apresenta mais comentários, três funções (cadastrar,
mostrardados e main). Algumas estruturas de apresentação também já se fazem presentes.
Código do aluno B10:
#include <cstdlib> #include <iostream> #include <conio.h> #define tam 50 using namespace std; struct cadastro { char nome [50]; int cpf; float valormedio; char email; }; void cadastrar(cadastro * v) { cout<<"Informe o nome do cliente: "; cin>>v->nome; cout<<"Informe o CPF: "; cin>>v->cpf; cout<<"Informe o valor medio de comprade desse cliente: "; cin>>v->valormedio; cout<<"Informe o E-mail do cliente: "; cin>>v->email; } void listarClientes(cadastro * cadastro[], int nclientes) { cout<<"Listando os clientes"<<endl; for(int i=0;i<nclientes; i++) { cout<<"Nome: " << cadastro[i]->nome << endl; cout<<"CPF: " << cadastro[i]->cpf << endl; cout<<"Valor meido de compra: " << cadastro[i]->valormedio << endl; cout<<"E-mail: " << cadastro[i]->email << endl; cout<<endl; } } int main(int argc, char *argv[]){ int nclientes = 0; cadastro * cadastro[tam]; cout<<"Bem vindo ao Sistema" <<endl; char continuar;
75
do { cout<<endl; cadastro * novo = new cadastro(); cadastrar(novo); cadastro[tam] = novo; cout<<endl<<"Deseja continuar inserindo dados? (s/n): "; cin>>continuar; nclientes++; } while ((continuar == “s” || continuar == “S”) && nclientes <= tam); cout<<endl<<"Foram cadastrado(s) " << nclientes << " clientes(s)"<<endl; cout<<"Pressione uma tecla para lista de clientes cadastrados"<<endl; listarClientes(clientes, nclientes); system("PAUSE"); return EXIT_SUCCESS; }
O algoritmo do aluno B10 tem ausência de comentários e três funções: cadastrar,
listarclientes e main. Algumas estruturas de apresentação também já se fazem presentes.
Código colaborativo: #include <cstdlib> #include <iostream> #include <conio.h> #define TAM 50 using namespace std; //Estrutura de dados com o nome Cadastro. struct Cadastro { //Criado um vetor do tipo char chamado cadastro. char cadastro [50]; }; //Criado uma estrutura de dados chamado Cliente struct Cliente { //Declaraçao de um ponteiro chamado cliente para a estrutura Cadastro. Cadastro * cliente; //Declaração de uma variavel chamada cpf do tipo float (real). float cpf; //Declaração de um vetor chamado email, cuja capacidade é de 50 caracteres. char email[50]; //Declaraçao de uma variavel chamada valor_medio do tipo float (real). float valor_medio; }; //Criado um procedimento, que não retorna valor, com o nome fazerCadastro, que //nela foi criado um ponteiro c que vao receber os dados por parametro. //E nele vai se cadastrar os clientes.
76
void fazerCadastro (Cliente *c) { //Variavel ponteiro que aponta para a estrutura Cliente que recebe um novo cadastro. c -> cliente = new Cadastro(); cout << "Digite o nome do cliente: " << endl; //Armazena na variavel cliente da estrutura Cliente os caracteres do nome do cliente, //que aponta para Cadastro, onde foi criado um vetor cadastro[] do tipo caracter //para recebe-los. cin >> c-> cliente -> cadastro; cout << "Digite o CPF do cliente: "<< endl; //Armazena na variavel cpf do tipo float da estrutura Cliente os numeros do cpf do cliente. cin >> c-> cpf; cout << "Digite o e-mail do cliente: " << endl; //Armazena no vetor email[] do tipo char da estrutura Cliente o email dos cliente. cin >> c-> email; cout << "Digite o valor medio das compras"<<endl; //Armazena na memoria os numeros, no qual c aponta para a estrutura Cliente e //para a variavel valor_medio. cin >> c-> valor_medio; } //Criado procedimento para se listar os clientes cadastrados, onde foi criado //um ponteiro vetor chamado cadast[] para receber os valores digitados atraves //da estrutura Cliente. Tambem criou-se uma variavel do tipo inteiro chamada numero. void lista_de_Clientes (Cliente * cadast[], int numero) { cout << "Relatando os clientes..." << endl << endl; //Condiçao onde sera impresso quando nao houver cadastro. if (numero == 0) { cout << "Nao ha clientes cadastrados." << endl; } //Comando for criado para definir a listagem dos cadastros dos clientes. for (int cont=0; cont < numero; cont++) { //Imprimindo o nome do cliente, onde o vetor cadast[] aponta o que está //na memoria que foi digitado na variavel ponteiro cliente que aponta para //cadastro na estrutura Cadastro. cout << "Nome do cliente: " << cadast[cont] -> cliente -> cadastro << endl; //Imprimindo o cpf do cliente, onde o vetor cadast[] aponta o que está //na memoria que foi digitado na variavel cpf da estrutura Cliente. cout << "CPF do cliente: " << cadast[cont] -> cpf << endl; //Imprimindo o email do cliente, onde o vetor cadast[] aponta o que está //na memoria que foi digitado na variavel vetor email[50] da estrutura Cliente. cout<<"E-mail do cliente: "<<cadast[cont]->email<<endl; //Imprimindo o valor medio do cliente, onde o vetor cadast[] aponta o que está //na memoria que foi digitado na variavel valor_medio da estrutura Cliente. cout<<"Media das compras do cliente: " << cadast[cont] -> valor_medio << endl << endl; } } int main(int argc, char *argv[]) { //Criado uma variavel do tipo inteiro com o nome numero.
77
int numero = 0; //Criando um vetor cad[] como ponteiro da estrutura Cliente. Cliente * cad[TAM]; //Imprime na tela o inicio do sistema. cout << "SEJA BEM-VINDO AO SISTEMA DE CADASTRAMENTO." << endl << endl; //Criado uma variavel do tipo char (caracter). char prosseguir; //Imprime na tela as opçoes do inicio do sistema. cout << "Para cadastrar clientes, digite S: " << endl; cout << "Caso nao, digite N para SAIR." << endl; cin >> prosseguir; //Testa condiçao, caso verdadeira irá executar o bloco de comandos. while (prosseguir == "s" || prosseguir == "S") { //Criado comando do para executar o bloco. do { cout << endl; //Criado um ponteiro chamado novo que irá receber um novo cliente. Cliente * novo = new Cliente(); //Chamando o procedimento fazerCadastro para que o usuario comece ou refaça //outro cadastro. fazerCadastro(novo); //Vetor cad[] da estrutura Cliente recebe o novo cadastro. cad[numero] = novo; cout << endl << "Deseja continuar cadastrando? (s/n): "; cin >> prosseguir; //Incrementa o numero para fazer a contagem de quantos cadastros foram feitos. numero++; } //Criado outro comando para testar a condiçao depois de executado o bloco //de comando. while ((prosseguir == "s" || prosseguir == "S") && numero <= TAM); } //Imprime na tela quantos cadastros foram feitos. cout << endl << "Foram cadastrado(s) " << numero << " cliente(s)" << endl; //Dá opçao ao usuario para caso ele queira listar os clientes ja cadastrados. cout << endl << "Para listar os cadastrados dos clientes, digite s." << endl; //Criado outra opçao para caso o usuario nao queira listar os cadastros. cout << "Caso nao, digite uma letra qualquer para SAIR." << endl; cin >> prosseguir; //Testa condiçao, caso verdadeira irá executar o bloco de comandos. if (prosseguir == "s" || prosseguir == "S") { //Chamando o procedimento lista_de_clientes, que irá mostrar todos os dados. lista_de_Clientes(cad, numero); } //Caso a condiçao seja falsa, irá executar o bloco de comando else. else { //Sai do sistema. return 0;
78
} //Comando para limpar a tela do sistema. getch(); system("CLS"); system("PAUSE"); return EXIT_SUCCESS; }
O código colaborativo do grupo GB4 é mais elaborado, apresentando duas structs, três
funções, uso de estruturas de decisão, estrutura de apresentação e uso adequado de comentários.
Analisando os resultados das Tabelas 9 e 10 e o código-fonte individual dos alunos e o
código-fonte colaborativo de seus grupos, constatou-se que:
a) Os alunos com baixo desempenho nos códigos individuais escreveram algoritmos
simples, fazendo estritamente aquilo que foi solicitado e por vezes deixando de
fazer um ou dois requisitos que não foram percebidos pelo professor
b) Em quase todos os grupos heterogêneos percebe-se que o algoritmo do aluno com
maior pontuação dominou a estrutura do código colaborativo
c) Excetuando-se o caso do aluno B4, todos os alunos tiveram um ganho na
pontuação do código colaborativo
d) O pouco ganho aferido pelo metrificador nos grupos homogêneos alto foi
principalmente devido à falta de sensibilidade do software às melhorias de
apresentação e de estilo efetuados pelos alunos
e) Nos grupos cuja colaboração dos integrantes foi intensa, houve uma melhora
significativa no algoritmo colaborativo
5.4 Avaliação do Processo pelos Participantes
Para aferir os resultados qualitativos foi aplicado o Questionário [APÊNDICE 2] para
todos os alunos participantes das disciplinas. A coleta de dados desse questionário estão nas
Tabelas 11 e 12.
79
Solicitou-se aos alunos que fornecessem uma nota de 1 até 7 para cada pergunta, sendo 1
para extremamente ruim e 7 para excelente. Esta faixa de valores foi escolhida porque os alunos
já a utilizam para pontuar outras pesquisas da universidade.
TABELA 11 - Resultado do questionário da disciplina Teoria da Computação.
Dados do Questionário dos alunos da
Disciplina Teoria da Computação
1 - Como você avalia a qualidade geral da disciplina de programação?
4 5 5 3 5 2 1 4 5 6 4 3 1 6 6 5
2 - Pensando no curso como um todo, avalie o valor que você obteve em relação a seus gastos (tempo, esforço, dinheiro etc.)
3 7 4 6 4 6 1 3 5 5 5 3 2 7 5 5
3 - A minha aprendizagem é focalizada em assuntos que me interessam
4 6 1 5 4 6 5 2 6 4 5 6 6 7 6 6
4 - Eu aprendo como fazer para melhorar o meu desempenho profissional
5 5 1 6 6 5 6 5 5 4 3 4 5 6 5 3
5 – Eu compreendi os conceitos de construtivismo e colaboração
6 5 2 7 5 5 6 6 6 5 4 6 5 6 2 5
6 - Eu me auto-avalio como sendo um aluno ... 7 6 6 7 6 6 6 7 6 6 6 5 7 6 6 7
7 - Eu explico as minhas idéias aos outros participantes
6 2 5 6 5 3 3 2 6 5 4 4 6 2 5 6
8 - Peço aos outros alunos explicações sobre as idéias deles
4 5 2 5 6 2 5 1 5 4 6 4 6 7 5 5
9 - Os outros participantes me pedem explicações sobre as minhas idéias
7 1 4 7 6 6 7 6 6 6 7 5 6 4 6 1
10 - Os outros participantes reagem às minhas idéias 7 1 5 6 2 5 6 5 3 3 2 5 5 4 6 5
11 - O professor me ajuda a melhorar a qualidade do que é pedido
6 1 3 6 7 5 5 6 6 3 2 3 6 5 4 1
12 - Eu entendi o conceito de metrificar o software 5 5 3 5 2 1 4 5 6 4 4 3 1 5 4 6
13 - Eu gostei de fazer contribuições no grupo para melhoria do software
7 4 6 4 6 1 3 5 5 2 1 4 3 4 2 4
14 - O aprendizado colaborativo contribuiu para meu crescimento
6 1 5 4 6 5 2 6 4 2 5 3 6 6 7 6
15 - O fórum e o chat foram meios complementares de me ajudar a solucionar problemas e resolver dúvidas
3 7 6 5 4 1 3 4 3 2 6 4 5 5 2 1
16 - O software criado em grupo de forma construtivista foi melhor do que eu criei sozinho
7 5 1 5 4 6 1 7 5 1 7 7 6 4 2 5
17 - Eu consegui aprender muito com meus colegas ao criar o software em grupo
5 6 3 4 2 4 1 6 5 1 6 6 4 3 2 6
80
18 - Fui capaz de ajudar meus colegas com mais dúvidas que eu
6 7 6 6 7 6 6 6 7 3 7 6 6 6 6 7
19 - O ambiente virtual de aprendizagem é simples de usar
7 6 2 5 6 5 3 3 2 2 3 7 5 3 3 2
20 - Eu contribuí muito no ambiente para a evolução da disciplina
6 6 5 6 5 1 7 5 6 3 6 6 6 2 5 1
21 - Percebi a contribuição dos meus colegas no ambiente para a evolução da disciplina
7 5 5 6 5 1 6 6 5 6 6 5 5 6 6 7
22 - Eu senti mais bem preparado depois de utilizar a metodologia e o ambiente virtual
5 2 6 5 4 3 7 5 5 6 5 5 3 4 5 6
23 - Eu senti que aprendi mais depois de utilizar a metodologia e o ambiente virtual
6 1 5 5 5 2 3 5 5 6 6 5 1 5 6 2
O Gráfico 3 ilustra os resultados dos questionários quanto aos aspectos gerais da
disciplina Teoria da Computação.
GRÁFICO 3 - Resultado dos aspectos gerais da disciplina Teoria da Computação
81
O Gráfico 4 ilustra os resultados dos questionários quanto aos aspectos colaborativos e
construtivistas da disciplina de Teoria da Computação.
GRÁFICO 4 - Resultado dos aspectos colaborativos e construtivistas da disciplina Teoria da Computação
O Gráfico 5 ilustra os resultados dos questionários quanto aos aspectos relativos ao AVA
da disciplina de Teoria da Computação.
82
GRÁFICO 5 - Resultado dos aspectos relativos ao AVA da disciplina Teoria da Computação
TABELA 12 - Resultado do questionário da disciplina Linguagem Programação I
Dados do Questionário dos alunos da
Disciplina de Linguagem I
1 - Como você avalia a qualidade geral da disciplina de programação?
4 1 3 5 3 3 2 4 5 6 4 3
2 - Pensando no curso como um todo, avalie o valor que você obteve em relação a seus gastos (tempo, esforço, dinheiro etc.)
3 5 2 6 2 5 1 5 3 4 5 3
3 - A minha aprendizagem é focalizada em assuntos que me interessam
4 6 7 7 5 6 3 6 7 6 5 6
4 - Eu aprendo como fazer para melhorar o meu desempenho profissional
5 5 4 6 2 2 4 5 5 4 3 4
5 – Eu compreendi os conceitos de construtivismo e colaboração
6 5 3 6 5 3 6 6 6 5 4 6
6 - Eu me auto-avalio como sendo um aluno ... 7 6 7 5 5 4 7 7 6 6 6 5
83
7 - Eu explico as minhas idéias aos outros participantes 6 2 7 7 2 4 5 5 6 5 4 4
8 - Peço aos outros alunos explicações sobre as idéias deles
4 5 7 6 5 3 5 6 5 4 6 4
9 - Os outros participantes me pedem explicações sobre as minhas idéias
7 1 5 6 3 5 3 3 4 2 4 5
10 - Os outros participantes reagem às minhas idéias 7 1 5 6 3 2 3 3 2 4 2 5
11 - O professor me ajuda a melhorar a qualidade do que é pedido
6 1 3 6 4 4 3 4 3 6 4 4
12 - Eu entendi o conceito de metrificar o software 5 5 3 5 2 1 4 5 5 6 5 4
13 - Eu gostei de fazer contribuições no grupo para melhoria do software
7 4 6 4 6 1 3 5 4 6 6 5
14 - O aprendizado colaborativo contribuiu para meu crescimento
6 1 5 4 6 5 2 6 5 7 5 4
15 - O fórum e o chat foram meios complementares de me ajudar a solucionar problemas e resolver dúvidas
3 3 4 4 4 1 3 4 5 5 4 4
16 - O software criado em grupo de forma construtivista foi melhor do que eu criei sozinho
7 5 7 5 7 7 1 7 7 7 6 7
17 - Eu consegui aprender muito com meus colegas ao criar o software em grupo
4 1 6 4 6 1 1 6 6 5 6 6
18 - Fui capaz de ajudar meus colegas com mais dúvidas que eu
7 2 5 5 4 2 2 7 5 5 6 6
19 - O ambiente virtual de aprendizagem é simples de usar
7 5 5 7 6 6 6 7 6 6 6 7
20 - Eu contribuí muito no ambiente para a evolução da disciplina
7 4 5 6 5 1 5 6 5 6 6 6
21 - Percebi a contribuição dos meus colegas no ambiente para a evolução da disciplina
7 4 6 7 5 1 2 5 4 6 6 5
22 - Eu senti mais bem preparado depois de utilizar a metodologia e o ambiente virtual
5 1 5 5 4 3 4 5 6 5 5 5
23 - Eu senti que aprendi mais depois de utilizar a metodologia e o ambiente virtual
5 1 5 5 5 2 3 5 5 6 6 5
Quanto aos aspectos gerais da disciplina, o Gráfico 6 ilustra os resultados dos
questionários de Linguagem de Programação 1.
84
GRÁFICO 6 - Resultado dos aspectos gerais da disciplina Linguagem de Programação I
Quanto aos aspectos colaborativos e construtivistas, o Gráfico 7 ilustra os resultados dos
questionários da disciplina de Linguagem de Programação 1.
85
GRÁFICO 7 - Resultado dos aspectos colaborativos e construtivistas da disciplina Linguagem de Programação I
Quanto aos aspectos relativos ao AVA, o Gráfico 8 ilustra os resultados dos questionários
da disciplina de Linguagem de Programação 1.
86
GRÁFICO 8 - Resultado dos Aspectos relativos ao AVA da disciplina Linguagem de Programação I
A leitura dos Gráficos 3 ao 8 indicam os seguintes resultados:
a) 85,7% dos alunos atribuíram notas abaixo de 4 avaliando a disciplina como sendo
muito ruim ou razoável. Esse resultado reforça a idéia trazida por outros autores de
que, em geral, os alunos não apreciam disciplinas que tratam do ensino de
algoritmos (Seção 2.1)
b) 70% dos alunos atribuíram notas entre 3 e 5 avaliando que o retorno do
investimento de tempo e financeiro é médio e bom
c) 60,7% dos alunos responderam entre 4 e 6 expressando que de alguma forma
aquilo que aprendem traz um retorno no trabalho. Esse resultado, conjugado ao
87
apresentado na letra c), demonstra a importância de se trabalhar exemplos
práticos, de aplicabilidade no cotidiano dos alunos, para sua melhor motivação e
interesse na aprendizagem de algoritmos
d) 46,4% dos alunos responderam que entenderam bem o conceito de colaboração e
construtivismo. Isso é explicado pela falta de atividades colaborativas e
construtivistas corriqueiras no curso
e) 42,9% dos alunos acreditam que foram capazes de explicar de maneira satisfatória
suas idéias aos colegas e 25% responderam que apresentaram dificuldade. Isso
demonstra a importância da realização de atividades colaborativas para o
aprendizado, pois para explicar bem, é necessário anteriormente organizar seus
conhecimentos. De forma que a comunicação entre colegas força o aluno a
exercitar a organização de suas idéias
f) 57,1% dos alunos responderam que foram capazes de pedir explicações aos
colegas de forma satisfatória (notas entre 4 e 6) e apenas 14,3% responderam
abaixo de 3, indicando que apresentaram dificuldade
g) 35,7% dos alunos responderam que sentiram o professor afastado e ausente
durante o experimento (notas abaixo de 3). 32,1% responderam que a atuação do
docente foi mediana (notas 4 ou 5) e 32,1% responderam que o professor foi ativo
e contribuiu muito no processo (acima de 6).
h) 71,4% dos alunos entenderam o conceito de metrificar, embora tenham pouca
habilidade no assunto. Eles não tiveram acesso ao cálculo das métricas para evitar
que a metrificação fosse burlada
i) 28,6% dos alunos gostaram bastante de colaborar com o grupo e 42,9% acharam a
experiência boa
j) 78,6% dos alunos responderam que acreditam que a metodologia colaborativa
contribuiu positivamente para o aprendizado das disciplinas
k) 60,7% dos alunos responderam que o Fórum e Chat foram ferramentas úteis para
resolver dúvidas
88
l) 82,1% dos alunos perceberam que o algoritmo colaborativo foi melhor que seu
código individual
m) 67,9% dos alunos responderam que o Ambiente Virtual de Aprendizagem foi
simples de usar;
n) 50% dos alunos responderam que contribuíram ativamente no AVA e 32,1%
responderam que contribuíram de forma razoável
o) Apenas 17,9% dos alunos responderam que ainda não se sentem bem preparados
depois do experimento
p) 71,4% dos alunos responderam que acreditam que aprenderam mais depois do
experimento. Esse resultado reforça os apresentados anteriormente, nas letras o),
q) e r)
Já os professores responderam o Questionário ao Professor [APÊNDICE 3] para avaliar
suas percepções quanto ao experimento.
Ambos os professores responderam ao questionário com avaliação superior a cinco para
todos os itens perguntados. As respostas dos docentes indicam que:
a) Consideram que os alunos foram capazes de entender os conceitos de
construtivismo e colaboração
b) Eles conseguiram terminar o programa da disciplina dentro do planejado, sem
precisar de horas extras, mas apontam que a metodologia proposta e a utilização
do AVA os fez gastar mais tempo com a gestão da disciplina do que sem este
processo
c) Apontam que o conteúdo do glossário colaborativo construído pelos alunos foi
satisfatório, com possibilidade de melhora
d) Consideram que os alunos foram capazes de contribuir com os colegas para o
crescimento do grupo
89
e) Consideram que efetivamente os algoritmos colaborativos foram bem superiores
aos algoritmos elaborados individualmente
f) Consideram que os alunos foram capazes de se beneficiar com o aprendizado
colaborativo
g) Consideram que os alunos estão bem preparados e que aprenderam mais após o
experimento
A Tabela 13 demonstra o aproveitamento da disciplina Teoria da Computação após o
experimento.
TABELA 13 - Aproveitamento da disciplina Teoria da Computação
Semestre Total
Alunos Desistência Reprovações %
Aprovados
1⁰ / 2007 36 6 14 44,40%
2⁰ / 2007 15 1 9 33,30%
1⁰ / 2008 23 5 3 65,22%
Observa-se que em relação ao 1º semestre de 2007 houve uma melhora sensível no
aproveitamento. Já em relação ao 2º semestre de 2007, o aproveitamento praticamente dobrou.
No entanto, não é possível afirmar que esta melhora se deve a aplicação do experimento, sendo
necessário repeti-lo mais vezes.
A Tabela 14 demonstra o aproveitamento da disciplina Linguagem de Programação I após
o experimento.
TABELA 14 - Aproveitamento da disciplina Linguagem de Programação I
Semestre Total
Alunos Desistência Reprovações %
Aprovados
1⁰ / 2007 25 0 14 44,00%
90
2⁰ / 2007 21 1 14 28,5%
1⁰ / 2008 14 2 8 17,39%
É necessário observar que a aparente piora no aproveitamento no 1º semestre de 2008 se
deve principalmente ao fato de que nove alunos que cursaram a disciplina Linguagem de
Programação foram reprovados na disciplina de Teoria da Computação no semestre anterior e
que seu conteúdo é a base para o conteúdo da disciplina de Linguagem de Programação I, mas
não é pré-requisito. Sete alunos que foram reprovados em Linguagem de Programação I no 1º
semestre de 2008 também foram reprovados em Teoria da Computação no 2º semestre de 2007.
Em termos práticos, esses alunos chegaram à disciplina de Linguagem de Programação I sem o
conhecimento básico de lógica de programação, como declaração de variáveis e estruturas de
decisão. Eles até foram capazes de elaborar algoritmos no experimento e em trabalhos em sala
com o auxílio dos colegas e sem a limitação de tempo. Mas não conseguiram responder
corretamente às questões individuais nas avaliações.
Isto evidencia que a falta de requisito obrigatório entre as duas disciplinas impedindo que
um aluno reprovado em Teoria da Computação se matricule em Linguagem de Programação I
prejudica o aproveitamento dos alunos e pode ter gerado uma redução na eficiência da
metodologia proposta neste experimento.
Os resultados dos experimentos realizados com o glossário construtivista colaborativo e a
implementação de algoritmos colaborativos evidenciaram que a metodologia pedagógica
colaborativa e construtivista resultou na elaboração de códigos mais elegantes, bem elaborados e
corretos. E também houve a percepção das pessoas envolvidas que houve melhora no
aprendizado. No entanto, esta melhora não pode ser mensurada em relação às notas obtidas pelos
alunos.
91
6 CONCLUSÕES E TRABALHOS FUTUROS
A dificuldade enfrentada por estudantes de cursos da área de tecnologia nas disciplinas de
algoritmos e programação de computadores é grande. Os resultados em diversas instituições de
ensino são o alto índice de reprovação, evasão e apatia. A bagagem cognitiva necessária para o
aprendizado de programação de computadores exige boa capacidade de abstração e de lógica
matemática. Além disso, a disciplina exige muita prática, pois não se aprende programação
somente com contemplação do conteúdo, conforme indicam Proulx (2000), Tobar et al. (2001),
Mendes (2001), Pimentel (2003), Rodrigues (2004), Faria & Adán Coello (2004), Rapkiewicz
(2004), Santos & Costa (2006), Voigt (2007), Pimentel & Omar (2008) e Marcelino & Rosatelli
(2008).
Portanto, esta proposta teve como seu principal objetivo aumentar a eficiência do
aprendizado de algoritmos através de um Ambiente Virtual de Aprendizagem aliado à uma
metodologia pedagógica construtivista colaborativa.
Esta metodologia utilizou-se de um AVA que contou com um glossário colaborativo para
apoiar os estudantes na construção dos conhecimentos prévios e serviu como fonte de conteúdo
didático sintético.
Para fomentar a proficiência em programação o AVA fez a avaliação dos algoritmos dos
alunos através de um verificador de qualidade de software que permitiu medir o grau de
assertividade e evolução do aprendizado. A metodologia ainda possibilitou a permuta de
experiências entre os alunos através da troca de algoritmos e formulação de uma nova solução
aprimorada.
Os conflitos sócio-cognitivos foram enfatizados no processo de construção do
conhecimento, de maneira que a aprendizagem colaborativa ocorreu como resultado do
92
compartilhamento do conhecimento entre múltiplos participantes. Para tanto, o AVA proposto foi
capaz de apoiar e organizar as situações, gerar o conflito sócio-cognitivo e medir os resultados.
Como resultado, 46,4% dos alunos consideram que foram capazes de entender os
conceitos de colaboração e construtivismo e metade dos alunos foi capaz de auxiliar e pedir ajuda
aos colegas sem maiores problemas. A falta de hábito em atividades claramente colaborativas
contribuiu negativamente neste aspecto. Mesmo com esta dificuldade inicial, 82,1% dos alunos
perceberam que o algoritmo colaborativo criado pelo grupo foi melhor que seu código individual.
Esta vivência, em conjunto com o glossário colaborativo, permitiu que 82,1% dos discentes se
sentissem melhor preparados e 71,4% responderam que acreditam que aprenderam mais depois
do experimento.
Os professores também corroboram a percepção de que o construtivismo aliado à
colaboração auxiliada por um AVA foi capaz de gerar uma melhora sensível nos algoritmos dos
alunos. A percepção de que os alunos se sentiram melhor preparados e que o aprendizado foi
mais efetivo também foi compartilhada pelos docentes.
Infelizmente, o experimento não traduziu diretamente na melhora das notas dos alunos
apesar da melhora perceptível nos índices de reprovação e desistência. Na disciplina de Teoria da
Programação, a reprovação caiu pela metade depois do experimento em relação ao 2º semestre de
2007, mas igualou ao índice do 1º semestre de 2007. Já na disciplina de Linguagem de
Programação I o índice de reprovação dobrou, mas isso pode ser justificado pelo fato de que 87%
dos alunos reprovados também foram reprovados na disciplina Teoria da Computação no
semestre anterior, demonstrando possuir uma bagagem cognitiva deficiente.
Para confirmar os resultados e realmente aferir que a metodologia pedagógica
construtivista e colaborativa aliada ao AVA é capaz de auxiliar no processo de aprendizagem de
algoritmos e, diretamente gerar um índice de aproveitamento melhor, é necessário que novos
experimentos nos semestres seguintes sejam realizados.
93
As perspectivas futuras deste trabalho incluem a instalação de um compilador C++ no
ambiente Web do software metrificador para verificar a validade do código. O metrificador
também poderá ser aprimorado para receber parâmetros de entrada e saída de dados para testar
alguns requisitos funcionais dos algoritmos. Isto iria permitir um refinamento da avaliação dos
softwares produzidos pelos alunos.
Sugere-se também para melhoria do AVA a incorporação dos recursos de mensagens
instantâneas para a troca de informações entre os alunos conectados e a possibilidade de
construção colaborativa de mapas conceituais em ambiente Web. Conectados ao glossário
colaborativo, os mapas conceituais permitiriam uma visualização gráfica dos conceitos estudados
e as relações existentes entre os conteúdos.
Estudar os processos de aprendizagem que levam ao sucesso no ensino de algoritmos
oferece vasto campo para pesquisas futuras. Entender os mecanismos cognitivos que fazem parte
do processo educacional é tarefa multidisciplinar complexa e em franca evolução. Portanto, para
compreender as diversas variáveis que compõem este processo, isolar e relacionar os resultados
faz-se necessário aprofundar o estudo, com as várias alternativas que envolvem Ambientes
Virtuais de Aprendizagem e as técnicas de ensino-aprendizagem.
Na percepção dos alunos e professores esta experiência promoveu uma melhora do
processo de aprendizagem de algoritmos. Portanto, a Universidade Salgado de Oliveira decidiu
manter o experimento para que se possam aferir os resultados futuros com novas turmas de
alunos. Essa experiência possibilitará encontrar novos recursos e características que podem ser
incorporados ao ambiente, para obtenção de melhores resultados.
94
REFERÊNCIAS
ANDERSON, J. R. Cognitive Psychology and its Aplications. New York: Freeman, 1990.
ATKINSON, Rita A. et al. Introdução à Psicologia. Porto Alegre: Artes Médicas, 1995.
BERRY, R.E.; MEEKINGS, B.A.E. A Style Analysis of C Programs. Communications of the ACM, Volume 28, Issue 1, January 1985, pp. 80 – 88.
BORGES, K. S. A Importância dos Grupos de Estudos na Formação Acadêmica. ANAIS DO XIII WORKSHOP DE EDUCAÇÃO EM COMPUTAÇÃO (WEI’2005). São Leopoldo, RS, Brasil, 2005.
BUZIN, P. F. W. K. A epistemologia da Ciência da Computação: Desafio do Ensino dessa Ciência. Revista de Educação, Ciência e Cultura, v. 6, nº 2. Centro Universitário La Salle. Canoas, RS, Brasil, 2001.
CONSTANTINO-GONZÁLEZ, M.A.; SUTHERS, D.D. Coaching Collaboration by Comparing Solutions and Tracking Participation, P. Dillenbourg, A. Eurelings, K. Hakkarainen (Eds.). European Perspectives on Computer-Supported Collaborative Learnin, Proceedings of the First European Conference on Computer, 2001.
DAZZI, R. L. S.; MIRANDA, E. M.; SOUZA, E. M. S. SAEL. Sistema de apoio ao ensino de lógica de programação. ANAIS DO WORKSHOP DE INFORMÁTICA APLICADA À EDUCAÇÃO. Araraquara, 2000.
DELGADO, C.; XEXÉO, J. A. M.; SOUZA, I. F.; CAMPOS, M.; RAPKIEWICZ, C. E. Uma Abordagem Pedagógica para a Iniciação ao Estudo de Algoritmos. XII WORKSHOP DE EDUCAÇÃO EM COMPUTAÇÃO (WEI'2004). Salvador, BA, Brasil, 2004
EYSENCK, M.; KEANE, M.. Psicologia Cognitiva: Um Manual Introdutório. Porto Alegre , Artmed, 1994.
FARIA, E. S. J.; ADÁN COELLO, J. M.. Detectando diferenças significativas entre programas como auxílio ao aprendizado colaborativo de programação. WORKSHOP DE AMBIENTES DE APRENDIZADO BASEADOS EM AGENTES, Simpósio Brasileiro de Informática na Educação. Manaus, AM, 2004.
FERRANDIN, Mauri; STEPHANI, Simone. Ferramenta para o ensino de programação via Internet. Rio de Janeiro: UNERJ, 2006.
FLÁVIO, D. TED - Tutorial de Estruturas de Dados, desenvolvido durante estágio supervisionado na Universidade do Vale do Itajaí – 2004. Disponível em http://www.tutorialdeestruturadedados.8m.com. Acesso em: 20/jan/2008.
FRANTZ, Walter. Educação e Cooperação: Práticas Que se Relacionam. Sociologias, pp. 242-264. Porto Alegre. Ano 3, número 6, jul/dez, 2001.
HOC, J.M. Psychologie Cognitive de la planification Grenoble.Traduzido por Maria Suzana M. Amoretti. Porto Alegre – Brasil, 2000.
95
HOSTINGS, Higor. RAABE, André Luis Alice. Auxiliando a Aprendizagem de Algoritmos com a Ferramenta WEBPORTUGOL. ANAIS DO XXVII CONGRESSO DA SBC. Rio de Janeiro, 2007.
HUNG, S.; KWORK, L.; CHAN, R. Automatic Program Assessment, Computers and Education, volume 20, issue 2, p. 183-190,1993.
JACKSON, David. A Software System for Grading Student Computer Programs, Computers and Education, vol. 27, ed.314, p. 171–180, 1996.
KOSLOSKY, M. A. N. Aprendizagem baseada em casos um ambiente para ensino de lógica de programação. Dissertação apresentada a Universidade Federal de Santa Catarina para obtenção do grau de Mestre em Engenharia de Produção. 1999.
LÉVY, Pierre. A Inteligência Coletiva. 2.ed. São Paulo: Loyola, 1999.
LITTLEFAIR, Tim. An investigation into the use of software code metrics in the industrial software development environment. p.h.D thesis. Faculty of Communications, Health and Science, Edith Cowan University, Mount Lawley Campus, 2001.
MACHADO, Joicemegue Ribeiro; TIJIBOY, Ana Vilma. Redes Sociais Virtuais: um espaço para efetivação da aprendizagem corporativa. 2005. Disponível em: <http://www.cinted.ufrgs.br/renote/maio2005/artigos/a37_redessociaisvirtuais.pdf>. Acesso em 04/jan/2008.
MARCELINO, Eduardo Rosalém; ROSATELLI, Marta Costa. Ensino de Programação em um Ambiente Colaborativo. ANAIS DO XXVIII CONGRESSO DA SBC. Belém do Pará, 2008.
MENDES, A. J. N. Software educativo para apoio à aprendizagem de programação, In: Taller International de Software Educativo, Santiago, Disponível em <http://www.c5.cl/ieinvestiga/actas/tise01/pags/charlas/charla_mendes.htm>. Acesso em 21/jan/2008
MENEZES, C.; NOBRE, I. Suporte à Cooperação em um Ambiente de Aprendizagem para Programação (SambA). ANAIS DO XIII SIMPÓSIO BRASILEIRO DE INFORMÁTICA NA EDUCAÇÃO (SBIE’2002). São Leopoldo, RS, Brasil, 2002.
O´REILLY, Tim. What is web 2.0: Design Patterns and Business Models for the Next Generation of Software. Disponível em: <http://www.oreillynet.com/pub/a/oreilly/tim/news/2005/09/30/what-is-web-20.html>. Acessado em 03/02/2008.
PIAGET, Jean. Epistemologia Genética. Martins Fontes, 1990.
PIMENTEL, E. P. ; FRANCA, V. F. ; NORONHA, R. V. ; OMAR, N. Avaliação Contínua da Aprendizagem, das Competências e Habilidades em Programação de Computadores. ANAIS DO XXIII CONGRESSO DA SOCIEDADE BRASILEIRA DE COMPUTAÇÃO. Campinas: UNICAMP, 2003.
PIMENTEL, Edson Pinheiro; OMAR, Nizam. Ensino de Algoritmos baseado na Aprendizagem Significativa utilizando o Ambiente de Avaliação NetEdu. ANAIS DO XXVIII CONGRESSO DA SOCIEDADE BRASILEIRA DE COMPUTAÇÃO. Belém do Pará, 2008.
PROULX, V.K. Programming Patterns and Design Patterns in the Introductory Computer Science Course in Proceedings of the 31st SIGCSE. Austin, TX, USA, 2000.
96
RAABE, André Luís Alice; SILVA, Júlia Marques Carvalho da. Um Ambiente para Atendimento as Dificuldades de Aprendizagem de Algoritmos. ANAIS DO XXV CONGRESSO DA SOCIEDADE BRASILEIRA DE COMPUTAÇÃO. São Leopoldo: Unisinos, 2004.
RAPKIEWICS, C. E. O Processo de Ensino e Aprendizagem de Algoritmos e Programação: Uma Visão Crítica da Literatura. ANAIS DO III WORKSHOP DE EDUCAÇÃO EM COMPUTAÇÃO E INFORMÁTICA DO ESTADO DE MINAS GERAIS (WEIMIG’ 2004). Belo Horizonte, MG, Brasil, 2004.
RODRIGUES, M. C. Experiências Positivas para o Ensino de Algoritmos, Escola Regional de Computação Bahia-Sergipe, 2.ed. Feira de Santana. Anais... Feira de Santana: UEFS, 2004.
SANTOS, R. P.; COSTA, H. A. X. TBC-AED: Um Software Gráfico para Apresentação de Algoritmos e Estruturas de Dados aos Iniciantes em Computação e Informática. ANAIS DO I CONGRESSO DE COMPUTAÇÃO DO SUL DO MATO GROSSO (COMPSULMT). Rondonópolis, MT, Brasil, 2005.
SANTOS, R. P.; COSTA, H. A. X. Análise de Metodologias e Ambientes de Ensino para Algoritmos, Estruturas de Dados e Programação aos iniciantes em Computação e Informática. INFOCOMP Journal of Computer Science. UFLA – Universidade Federal de Lavras, 2006.
SETUBAL, J. C. Uma proposta de Plano Pedagógico para a Matéria de Computação e Algoritmos. ANAIS DO II CURSO DE QUALIDADE DE CURSOS DE GRADUAÇÃO DA ÁREA DE COMPUTAÇÃO E INFORMÁTICA (WEI). Editora Universitária Champagnat, 2000.
SIEMENS, George. Knowing the knowledge. Disponível em: <http://www.knowingknowledge.com/>. Acesso em: 03/jun/2007. 2006.
SOARES, T. C. A. P.; CORDEIRO, E. S.; STEFANI, Í. G. A.; TIRELO, F. Uma Proposta Metodológica para o Aprendizado de Algoritmos em Grafos Via Animação Não-Intrusiva de Algoritmos. III WORKSHOP DE EDUCAÇÃO EM COMPUTAÇÃO E INFORMÁTICA DO ESTADO DE MINAS GERAIS (WEIMIG). Belo Horizonte, MG, Brasil, 2004.
SOMMERVILLE, Ian. Engenharia de Software. 6.ed., Addison Wesley, 2003.
STEWART, K.; WILIAMS, M. Researching online populations the use of online focus groups for social research. Qualitative Research, vol. 5, n. 4, p. 395 – 416, 2005.
STRASSBURG, U.; MOREIRA, D. A. Avaliação de desempenho de professores pelo aluno: uma experiência desenvolvida junto a um curso superior de contabilidade. Revista Ciências Sociais em Perspectiva, vol 1, nº 1, 2002.
TOBAR, Carlos Miguel; GARCIA ROSA, João Luís; ADÁN COELLO, Juan Manuel; PANNAIN, Ricardo. Uma Arquitetura de Ambiente Colaborativo para o Aprendizado de Programação. ANAIS DO XII SBIE. Vitória/ES, novembro, 2001.
VOIGT, Emilio. Web 2.0, E-Learning 2.0, EAD 2.0: para onde caminha a educação a distância. Congresso Internacional de Educação a Distância: ABED, 2007.
UNIVERSO. Manual Informativo do Aluno. São Gonçalo: Universidade Salgado de Oliveira, 2008.
UNIVERSO. Projeto Pedagógico do Curso de Graduação em Análise de Sistemas – Habilitação em Sistemas de Informação. São Gonçalo: Universidade Salgado de Oliveira, 2004.
97
VAVILALA, Rama Krishna. Cloud Control for ASP.NET. Disponível em <
http://www.codeproject.com/KB/aspnet/cloud.aspx> . Acessado em 05/01/2008.
XEXÉO, José A. M.; KALINOWSKI, Marcos; RAPKIEWICZ, Clevi. Construindo Comunidades Virtuais de Aprendizagem: uma experiência prática em Curso de Ciência da Computação. ANAIS DO XXVII CONGRESSO SOCIEDADE BRASILEIRA DE COMPUTAÇÃO. Rio de Janeiro, 2007.
WIRTH, N. Algoritmos e Estruturas de Dados. LTC Informática-Programação, 1989.
98
APÊNDICE 1 - RELAÇÃO DE NOTAS DOS ALUNOS DA UNIVERSIDADE SALGADO DE OLIVEIRA NAS DISCIPLINAS INTRODUTÓRIAS DE ALGORITMOS
RELAÇÃO DE NOTAS DA DISCIPLINA TEORIA DA COMPUTAÇÃO (1º /2007)
ALUNO V1 V2 VT VS Final Faltas Situação
Aluno 1 7,3 2,43 22 MATRICULA
Aluno 2 3,8 8,9 2,8 5,5 5,34 1 APROVADO
Aluno 3 6,5 9,5 4,4 6,3 6,55 3 APROVADO
Aluno 4 4,4 9,2 1,7 4,6 4,85 6 REPROVADO
Aluno 5 1,8 0,6 22 MATRICULA
Aluno 6 2,5 9,9 2 2,9 3,85 0 REPROVADO
Aluno 7 3 9,3 1,6 0 2,32 7 REPROVADO
Aluno 8 6,2 9,9 3,2 5 5,72 1 APROVADO
Aluno 9 3,9 8,7 3,6 5,5 5,45 4 APROVADO
Aluno 10 8,1 9,2 4,1 7,13 7 APROVADO
Aluno 11 0 39 MATRICULA
Aluno 12 1,8 0,6 18 MATRICULA
Aluno 13 0 0 43 REPR.FREQ.
Aluno 14 9,4 9,9 6,4 8,57 0 APROVADO
Aluno 15 1 7,7 2,9 7 REPROVADO
Aluno 16 2,6 7,7 0,7 3,67 6 REPROVADO
Aluno 17 0 0 54 REPR.FREQ.
Aluno 18 9,5 9,9 5,4 8,27 0 APROVADO
Aluno 19 4,6 9,9 6,4 7,2 7,09 3 APROVADO
Aluno 20 0 0 51 REPR.FREQ.
Aluno 21 3,2 8,5 2,8 5,2 5,02 4 APROVADO
Aluno 22 6,1 9,5 8,6 8,07 10 APROVADO
Aluno 23 5,3 8,5 3,5 3,7 4,74 4 REPROVADO
Aluno 24 5 7,5 4,8 5,1 5,44 10 APROVADO
Aluno 25 0 27 MATRICULA
Aluno 26 9,7 9,9 6 8,53 5 APROVADO
Aluno 27 0 43 MATRICULA
Aluno 28 10 9,9 8,5 9,47 2 APROVADO
Aluno 29 5,4 8,9 3,3 3,9 4,89 6 REPROVADO
Aluno 30 5,7 9,9 4,7 8,6 7,69 5 APROVADO
Aluno 31 5,1 6,3 4,4 3,9 4,59 17 REPROVADO
Aluno 32 0 0 35 REPR.FREQ.
Aluno 33 0,7 5,5 2,07 10 REPROVADO
Aluno 34 5,1 8,5 4,5 7,2 6,62 1 APROVADO
Aluno 35 3,3 1,1 36 REPR.FREQ.
99
Aluno 36 7,3 9,5 5,7 7,5 6 APROVADO
Aprovados:
16 Reprovado por Nota:
9
Reprovado por Freq.:
5 Desistentes:
5
RELAÇÃO DE NOTAS DA DISCIPLINA DE LINGUAGEM DE PROGRAMAÇÃO I (1º /2007)
ALUNO V1 V2 VT VS Final Faltas Situação
Aluno 1 4,25 5,1 2,65 6 5 2 APROVADO
Aluno 2 5,75 1 2,25 35 REPR.FREQ.
Aluno 3 0,85 0,28 40 MATRICULA
Aluno 4 0,65 7,2 1,75 3,2 2 REPROVADO
Aluno 5 4 4,2 2,73 6 REPROVADO
Aluno 6 4 9,5 9,75 7,75 16 APROVADO
Aluno 7 0,2 0,07 23 REPR.FREQ.
Aluno 8 0,2 0,07 16 REPROVADO
Aluno 9 7,15 10 7 8,05 3 APROVADO
Aluno 10 0 0,2 0,07 19 REPR.FREQ.
Aluno 11 8,75 7,2 6,5 7,48 8 APROVADO
Aluno 12 3 4,3 2 3,1 11 REPROVADO
Aluno 13 1,85 0 0,62 46 REPR.FREQ.
Aluno 14 1,85 1,8 3,5 2,38 7 REPROVADO
Aluno 15 1,7 1,4 1 1,37 14 REPROVADO
Aluno 16 7,8 6,8 2 7,5 6,52 7 APROVADO
Aluno 17 9,75 10 9,75 9,83 6 APROVADO
Aluno 18 0,5 1,2 0,57 24 REPR.FREQ.
Aluno 19 5,05 2,4 3,75 3,73 10 REPROVADO
Aluno 20 0,4 0,13 19 REPR.FREQ.
Aluno 21 2,5 5,5 2,25 3,42 10 REPROVADO
Aprovados:
6 Reprovado por Nota:
8
Reprovado por Freq.:
6 Desistentes:
1
100
APÊNDICE 2 - QUESTIONÁRIO DE AVALIAÇÃO DO AVA PELO ALUNO
Responda as perguntas a seguir avaliando com uma nota de 1 a 7, sendo 1 para extremamente ruim e 7
para excelente.
1) Como você avalia a qualidade geral da disciplina de programação? ____
2) Pensando no curso como um todo, avalie o valor que você obteve em relação a seus gastos
(tempo, esforço, dinheiro etc.) ____
3) A minha aprendizagem é focalizada em assuntos que me interessam. ____
4) Eu aprendo como fazer para melhorar o meu desempenho profissional. ____
5) Eu compreendi os conceitos de construtivismo e colaboração: ____
6) Eu me auto-avalio como sendo um aluno: ____
7) Eu explico as minhas idéias aos outros participantes: ____
8) Peço aos outros alunos explicações sobre as idéias deles: ____
9) Os outros participantes me pedem explicações sobre as minhas idéias. ____
10) Os outros participantes reagem às minhas idéias: ____
11) O professor me ajuda a melhorar a qualidade do que é pedido: ____
12) Eu entendi o conceito de metrificar o software: ____
13) Eu gostei de fazer contribuições no grupo para melhoria do software: ____
14) O aprendizado colaborativo contribuiu para meu crescimento: ____
15) O fórum e o chat foram meios complementares de me ajudar a solucionar problemas e resolver
dúvidas: ____
16) O software criado em grupo de forma construtivista foi melhor do que eu criei sozinho: ____
17) Eu consegui aprender muito com meus colegas ao criar o software em grupo: ____
18) Eu fui capaz de ajudar meus colegas com mais dúvidas que eu: ____
19) O ambiente virtual de aprendizagem é simples de usar: ____
20) Eu contribuí muito no ambiente para a evolução da disciplina: ____
21) Percebi a contribuição dos meus colegas no ambiente para a evolução da disciplina: ____
22) Eu senti mais bem preparado depois de utilizar a metodologia e o ambiente virtual: ____
23) Eu senti que aprendi mais depois de utilizar a metodologia e o ambiente virtual: ____
SUGESTÕES: ________________________________________________________________________
101
APÊNDICE 3 - QUESTIONÁRIO DE AVALIAÇÃO DO AVA PELO PROFESSOR
Responda as perguntas a seguir avaliando com uma nota de 1 a 7, sendo 1 para extremamente ruim e 7
para excelente.
1) Como você avalia a qualidade geral da disciplina de programação? ____
2) Você acha que os alunos compreenderam o que é o construtivismo e a colaboração? ____
3) A metodologia e o ambiente virtual melhorou a administração do meu tempo para a disciplina:
____
4) Eu consegui ministrar todo o conteúdo da ementa: ____
5) Eu percebi uma melhora nos exercícios dos alunos: ____
6) Os alunos foram capazes de gerar um conteúdo colaborativo inteligente: ____
7) Os alunos gostaram da metrificação do software: ____
8) Os alunos foram capazes de contribuir com os colegas: ____
9) Houve uma melhora no software em grupo em relação ao software individual: ____
10) Consegui individualizar os atendimentos aos alunos: ____
11) A colaboração dos alunos no conteúdo auxiliou o aprendizado: ____
12) O fórum e o chat foram meios complementares de me ajudar a solucionar problemas e resolver
dúvidas dos alunos: ____
13) Percebi que os alunos aprenderam muito com a colaboração feita entre eles: ____
14) Percebi a contribuição dos alunos no ambiente para a evolução da disciplina: ____
15) Eu senti os alunos mais bem preparado depois de utilizar a metodologia e o ambiente virtual:
____
16) Eu senti que os alunos aprenderam mais depois de utilizar a metodologia e o ambiente virtual:
____
SUGESTÕES: __________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
_____________________________________________________________________________________
Livros Grátis( http://www.livrosgratis.com.br )
Milhares de Livros para Download: Baixar livros de AdministraçãoBaixar livros de AgronomiaBaixar livros de ArquiteturaBaixar livros de ArtesBaixar livros de AstronomiaBaixar livros de Biologia GeralBaixar livros de Ciência da ComputaçãoBaixar livros de Ciência da InformaçãoBaixar livros de Ciência PolíticaBaixar livros de Ciências da SaúdeBaixar livros de ComunicaçãoBaixar livros do Conselho Nacional de Educação - CNEBaixar livros de Defesa civilBaixar livros de DireitoBaixar livros de Direitos humanosBaixar livros de EconomiaBaixar livros de Economia DomésticaBaixar livros de EducaçãoBaixar livros de Educação - TrânsitoBaixar livros de Educação FísicaBaixar livros de Engenharia AeroespacialBaixar livros de FarmáciaBaixar livros de FilosofiaBaixar livros de FísicaBaixar livros de GeociênciasBaixar livros de GeografiaBaixar livros de HistóriaBaixar livros de Línguas
Baixar livros de LiteraturaBaixar livros de Literatura de CordelBaixar livros de Literatura InfantilBaixar livros de MatemáticaBaixar livros de MedicinaBaixar livros de Medicina VeterináriaBaixar livros de Meio AmbienteBaixar livros de MeteorologiaBaixar Monografias e TCCBaixar livros MultidisciplinarBaixar livros de MúsicaBaixar livros de PsicologiaBaixar livros de QuímicaBaixar livros de Saúde ColetivaBaixar livros de Serviço SocialBaixar livros de SociologiaBaixar livros de TeologiaBaixar livros de TrabalhoBaixar livros de Turismo
![[HAD2012] 13 - construtivismo](https://img.document.onl/doc/110x75/540746ca8d7f72d8088b4a49/had2012-13-construtivismo.jpg)
