Maria Elisabete de Sousa Cunha

UMinho|2015
Maria Elisabete de Sousa Cunha Aulas interativas com recurso à exposição: Uma metodologia para o ensino da linguagem de programação Python
Universidade do Minho
Instituto de Educação
Maria Elisabete de Sousa Cunha
Aulas interativas com recurso à exposição: Uma
metodologia para o ensino da linguagem de
programação Python
abril de 2015
Universidade do Minho
Instituto de Educação
Maria Elisabete de Sousa Cunha
Aulas interativas com recurso à exposição: Uma
metodologia para o ensino da linguagem de
programação Python
Relatório de Estágio
Mestrado em Ensino de Informática
Trabalho realizado sob a orientação da
Professora Doutora Altina Ramos
abril de 2015
DECLARAÇÃO
Nome: Maria Elisabete de Sousa Cunha
Endereço eletrónico: [email protected]
Telemóvel: 965732023
Número do cartão de cidadão: 9513806
Título do Relatório: Aulas interativas com recurso à exposição: Uma metodologia para
o ensino da linguagem de programação Python
Supervisora: Professora Doutora Altina Ramos
Ano de conclusão: 2015
Designação do Mestrado: Mestrado em Ensino de Informática
É AUTORIZADA A REPRODUÇÃO INTEGRAL DESTE RELATÓRIO APENAS
PARA EFEITOS DE INVESTIGAÇÃO, MEDIANTE DECLARAÇÃO ESCRITA DO
INTERESSADO, QUE A TAL SE COMPROMETE.
Universidade do Minho, ____/ ____/ _______
Assinatura: _____________________________________________
AGRADECIMENTOS
À professora Altina pela paciência e dedicação que despendeu para que este projeto chegasse a
bom porto.
À minha mãe pela paciência e compreensão pelos momentos que deixei de lhe dar a atenção
que considero seria importante.
Ao colega do curso Jorge Coutinho pela força que me deu para que eu levasse este projeto até
ao fim e ajuda em alguns momentos do curso.
À Escola Secundária Alberto Sampaio por me ter recebido com sua estagiária.
iii
iv
RESUMO
Aulas interativas com recurso à exposição: Uma metodologia para o ensino da
linguagem de programação Python
A metodologia utilizada durante a minha intervenção pedagógica teve recurso à exposição
para apresentar alguns conceitos da linguagem de programação Python, sendo este o assunto
lecionado, fazendo alternância com a interação e complementando com a resolução de
problemas desenvolvendo programas utilizando esta linguagem.
Este trabalho foi realizado num turno de 10 alunos de uma turma com 21 alunos do curso
profissional Técnico de Gestão e Programação de Sistemas Informáticos do 12º ano. A disciplina
era designada de Programação e Sistemas de Informação. Teve a duração de 16 aulas
contínuas de 90 minutos.
Os objetivos que se pretendiam com a aposta em interação era tornar estes alunos mais
colaborativos e motivados. Mas essencialmente verificar que as suas aprendizagens foram
consolidadas e que eles adquiriram novas competências.
Foram aplicados três questionários online, um inicial para apurar os conhecimentos
prévios, entre outos assuntos e dois finais, onde num deles pretendi apurar as aprendizagens
realizadas e o outro para eles avaliarem as aulas lecionadas por mim.
As limitações sentidas neste processo foram o facto de a turma ser bastante turbulenta,
podendo ter atitudes imprevisíveis; também a intervenção ser no mês de janeiro de forma
contínua e próximo do final do semestre e por a matéria que me foi apresentada ser-me
desconhecida inicialmente.
Feito um apanhado geral das aulas e da avaliação final feita pelos alunos das minhas
aulas, posso aferir que o resultado foi positivo. A aposta em interação criou mais motivação para
os assuntos lecionados e de uma forma geral colaboraram quando interpelados. Houve alunos
que evoluíram positivamente ao longo das aulas demonstrando que estavam a aprender. Apenas
os trabalhos em grupo não foram suficientes para tornar os alunos mais colaborativos.
v
vi
ABSTRACT
Interactive lessons using exhibition: A methodology to the teaching Python
programming language
The methodology used during my pedagogical intervention resorted to the exhibition in
order to present some concepts of the Python programming language, which is the learning
subject, alternating with the interaction and complementing with problem solving in development
programs using this language.
This work was performed in a 10 students group from a 21 student’s class taking the
vocational course Técnico de Gestão e Programação de Sistemas Informáticos, in the 12th year.
The discipline was designated as Programação e Sistemas de Informação. It lasted for 16
continuous lessons of 90 minutes.
The aims pursued to bet on interaction were to make these students more collaborative
and motivated. However, essentially verify that their learning was consolidated and that they have
acquired new skills.
We applied 3 online questionnaires, an initial were applied to establish the existing
knowledge among other subjects and two at the end, where one of them intended to ascertain
the learning achieved and the other to assess the lessons taught by me.
The limitations felt in this process was the fact that the class was quite turbulent and had
unpredictable attitudes; as well as the fact that the intervention was carried out in January in a
continuous way and near the end of the semester and also the subject to teach was unknown to
me.
As an overview of the classes and the final evaluation made by the students, I can verify
that the result was positive. The investment in the interaction created more motivation for the
subjects taught and in general the students collaborated when asked. There were students who
developed positively during the lessons demonstrating that they were learning. Only the group
work were not enough to make more collaborative students.
vii
viii
ÍNDICE GERAL
Introdução .............................................................................................................................. 13
Capítulo I – Enquadramento teórico ........................................................................................ 15
1.1
Abordagem teórica .................................................................................................. 15
1.1.1
Exposição de conteúdos: uma necessidade?..................................................... 15
1.1.2
A exposição e a interação nas aulas de programação ....................................... 16
1.1.3
Interação ......................................................................................................... 17
1.1.3.1 Interação do aluno com o computador ......................................................... 17
1.1.3.2 Interação dos alunos entre si e com o professor ........................................... 17
1.1.4
A importância da programação para o desenvolvimento do pensamento
computacional ................................................................................................................ 19
1.1.5
A linguagem de programação Python ............................................................... 20
Capítulo II – Contexto e plano geral de intervenção ................................................................. 23
2.1
Contexto da intervenção .......................................................................................... 23
2.1.1
Caraterização da escola ................................................................................... 23
2.1.2
Caraterização da turma ................................................................................... 24
2.1.3
Caraterização da disciplina .............................................................................. 25
2.2
Plano geral da intervenção....................................................................................... 26
2.2.1
Objetivos ......................................................................................................... 26
2.2.2
Técnicas e instrumentos de recolha de dados .................................................. 26
2.2.3
Estratégias de intervenção ............................................................................... 27
Capítulo III - Desenvolvimento e avaliação da intervenção ........................................................ 28
3.1
Ferramentas educativas .......................................................................................... 28
3.1.1
Google Drive .................................................................................................... 28
3.1.2
Microsoft PowerPoint ....................................................................................... 29
3.1.3
Interpretador do Python ................................................................................... 30
3.2
Aulas observadas .................................................................................................... 31
3.3
Levantamento de requisitos ..................................................................................... 33
3.4
Implementação e avaliação da ação ........................................................................ 35
3.4.1
Calendarização das atividades realizadas ......................................................... 35
3.4.2
Recursos utilizados e elementos de avaliação ................................................... 38
ix
3.4.3
Da aula 1 até à aula 12 e aula 14 – Aulas não assistidas ................................. 39
3.4.4
Aula 13, aula 15 e aula 16 - Aulas assistidas ................................................... 61
3.4.5
Reflexão final ................................................................................................... 71
3.5
Análise da intervenção ............................................................................................. 72
Capítulo IV – Considerações finais .......................................................................................... 77
4.1
Conclusões ............................................................................................................. 77
4.2
Limitações .............................................................................................................. 78
4.3
Reflexão sobre o projeto e aprendizagens ................................................................ 79
Referências bibliográficas........................................................................................................ 81
Anexos ................................................................................................................................... 83
Anexo 1: Planificação do módulo 17 E ................................................................................ 83
Anexo 2: Grelha de observação dos alunos .......................................................................... 85
Anexo 3: Planos de aula das aulas observadas pelos supervisores ....................................... 86
Anexo 4: Questionário inicial sobre levantamento de requisitos ............................................ 92
Anexo 5: Questionário sobre as aprendizagens realizadas pelos alunos ................................ 95
Anexo 6: Questionário sobre a avaliação final feita pelos alunos das minhas aulas ............... 96
Anexo 7: Código do programa sobre o problema “Jornada de futebol” ................................. 98
x
ÍNDICE DE FIGURAS
Figura 1 - Escola Secundária Alberto Sampaio ......................................................................... 23
Figura 2 - Ícone do Google Drive na barra de tarefas ............................................................... 28
Figura 3 - Google Drive - Partilha de material com os alunos .................................................... 29
Figura 4 - Google Drive - Partilha de pastas individuais para colocar TPC's ............................... 29
Figura 5 - Programa e interpretador interativo do Python ......................................................... 31
Figura 6 - Enunciado do problema "Serviço de restaurante" .................................................... 41
Figura 7 - Compilação do programa sobre o problema "Serviço de restaurante" ...................... 42
Figura 8 - Sintaxe geral da sequência de comandos if/elif/else................................................ 43
Figura 9 - Enunciado do problema "Média das notas de um aluno" ......................................... 44
Figura 10 - compilação do programa sobre o problema "Média das notas de um aluno" .......... 44
Figura 11 - Compilação do programa sobre o problema "Promoções no cinema" .................... 48
Figura 12 - Compilação do programa sobre o problema "Soma e média de um conjunto de
números" ............................................................................................................................... 49
Figura 13 - Enunciado do problema "Exame da turma" ........................................................... 50
Figura 14 - Compilação do programa sobre o problema "Exame da turma" ............................. 52
Figura 15 - Compilação do programa sobre o problema "Tabuada sem formatação"................ 53
Figura 16 - Compilação do programa sobre o problema "Tabuada com formatação" com dois
dígitos .................................................................................................................................... 54
Figura 17 - compilação do programa sobre o problema "Tabuada com formatação" com três
dígitos .................................................................................................................................... 54
Figura 18 - Compilação do programa sobre o problema "Contador de carateres" ..................... 56
Figura 19 - Exemplo de indexação em strings .......................................................................... 56
Figura 20 - Exemplos de utilização de slicing sobre strings ...................................................... 57
Figura 21 - Compilação do programa sobre o problema "Nome em escada"............................ 58
Figura 22 - Compilação do programa sobre o problema "Teste de palíndromo" ....................... 60
Figura 23 - Compilação do programa sobre o problema "Inteiro para romano" ........................ 60
Figura 24 - Compilação do programa sobre o problema "Conta e imprime consoantes" ........... 62
Figura 25 - Compilação do programa sobre o problema "Soma quadrados" ............................ 63
Figura 26 - Enunciado do problema "Investigação do crime" ................................................... 65
Figura 27 - Compilação do programa sobre o problema "Investigação do crime" ..................... 65
xi
Figura 28 - Compilação do programa sobre o problema "Jornada de futebol" .......................... 69
ÍNDICE DE TABELAS
Tabela 1 - Comparação de código da linguagem de programação C com a linguagem de
programação Python............................................................................................................... 21
Tabela 2 - Apresentações no ensino da linguagem de programação Python ............................. 30
Tabela 3 - Calendarização das atividades realizadas ................................................................ 35
Tabela 4 - Problema “Promoções no cinema” ......................................................................... 47
ÍNDICE DE GRÁFICOS
Gráfico 1 - Resposta à questão "Realizei as tarefas que me foram indicadas?" ......................... 73
Gráfico 2 - Resposta à questão "Gostei da forma como as aulas foram lecionadas?" ................ 74
Gráfico 3 - Resposta à questão "Gostei das atividades que me foram propostas?" .................... 74
Gráfico 4 - Resposta à questão "A professora tirou as minhas dúvidas?" .................................. 75
Gráfico 5 - Resposta à questão "A professora criou um ambiente de interatividade?" ............... 75
Gráfico 6 - Resposta á questão "Fiquei motivado para programar em Python?" ........................ 76
Gráfico 7 - Resposta à questão "Aumentei a minha autonomia no desenvolvimento de programas
em Python?" ........................................................................................................................... 76
xii
INTRODUÇÃO
Este trabalho foi realizado no âmbito da Unidade Curricular Estágio profissional, do
Mestrado em Ensino da Informática do Instituto da Educação da Universidade do Minho.
A minha intervenção pedagógica baseou-se no ensino da linguagem de programação
Python. Ao mesmo tempo que ia expondo alguns conceitos utilizei a interatividade para promover
a discussão de pontos de vista no desenvolvimento das tarefas e troca de ideias entre os colegas
para a resolução de um dado problema. A realização de trabalhos de grupo teve como finalidade
a colaboração para um mesmo objetivo.
A linguagem de programação Python é uma linguagem de alto nível e uma linguagem
orientada a objetos como a linguagem de programação Java. É fácil de utilizar e por isso
também é fácil de aprender em comparação com outras linguagens como é o caso da
linguagem C. Segundo Papert (1980) “Uma linguagem de programação é como uma língua
natural humana, que favorece determinadas metáforas, imagens e formas de pensar.” (p. 34)
O meu projeto de intervenção foi colocado em prática na Escola Secundária Alberto
Sampaio, uma escola do centro da cidade de Braga. Era uma escola bem equipada com
computadores, tendo uma média de uma computador por aluno.
Realizei a minha intervenção num turno de 10 alunos que pertenciam a uma turma de 21
alunos, estando esta dividida em dois turnos. Era uma turma reconhecida pelo seu mau
comportamento, segundo informações recolhidas. Lecionei uma parte de um módulo da
disciplina Programação e Sistemas de Informação do curso profissional Técnico de Gestão e
Programação de Sistemas Informáticos do 12º ano, desde o dia 8 de janeiro de 2014 a 29 de
janeiro de 2014, com cinco blocos/aulas semanais de 90 minutos, num total de 16 blocos.
As principais limitações deste projeto foram: 1) o facto de ter sido colocado em prática
próximo do final do semestre, criando dificuldades no acompanhamento de outras Unidades
Curriculares do curso; 2) ser uma turma difícil em termos de comportamento, dificultando a
lecionação das matérias; e 3) a falta de tempo para me preparar para lecionar um conteúdo
novo.
Este relatório está organizado em quatro capítulos.
No primeiro capítulo encontra-se o enquadramento teórico, onde é demostrada a base
para a escolha dos métodos utilizados na lecionação das minhas aulas. É também apresentada
a importância da aprendizagem de uma linguagem de programação, sendo um meio para
13
desenvolver o pensamento computacional. Por fim são apresentadas as caraterísticas da
linguagem de programação Python.
No segundo capítulo é descrito o contexto de intervenção, a escola, a turma e a disciplina
onde vou intervir. Também são apresentados os objetivos pretendidos, as técnicas utilizadas
para a recolha da informação e as estratégias aplicadas.
No terceiro capítulo é desenvolvida e avaliada a intervenção pedagógica. São referidas as
ferramentas utilizadas durante as aulas e é apresentada a informação recolhida antes da
intervenção. É também realizada uma descrição aula a aula abordando os respetivos resultados
e reflexões, concluindo com uma reflexão final. Por fim, é feita a análise da intervenção com a
apresentação dos resultados dos questionários aplicados à turma.
Finalmente no quarto capítulo são apresentadas as considerações finais, onde são
relatadas as limitações/dificuldades encontradas, as conclusões e a reflexão sobre o projeto e as
aprendizagens adquiridas ao longo do processo.
14
CAPÍTULO I – ENQUADRAMENTO TEÓRICO
1.1 Abordagem teórica
Neste ponto vou desenvolver os princípios teóricos que segui e que considerei adequados
para o ensino de uma linguagem de programação, dado o contexto disciplinar onde iria colocar
em prática essas intenções.
Seymour Papert defende a importância da interação do aluno com o computador já que
promove o seu desenvolvimento cognitivo, neste caso ao programar com a linguagem de
programação LOGO. Nesta mesma lógica, programar na linguagem de programação Python vai
ao encontro dos mesmos objetivos.
Recorri ao método expositivo nas minhas aulas por considerar que nos casos em que há a
tendência para a distração seria uma estratégia para centrar a atenção dos alunos. Ribeiro
(2012) e Crato (2006) confirmam esta perspetiva. A exposição foi intercalada com interação de
modo a envolver os alunos para os assuntos da aula. Esta estratégia foi utilizada para obrigar os
alunos a pensar e ao mesmo tempo verificar se estavam atentos. Apostei ainda na interação
entre eles nas tarefas em grupo para incentivar a partilha de conhecimentos e a ajuda entre os
que têm mais e os que têm menos capacidades de aprender.
Por fim abordo a linguagem de programação Python, que foi o tema das minhas aulas.
Apresento alguns conceitos, caraterísticas, vantagens na utilização e exemplos de aplicação.
1.1.1 Exposição de conteúdos: uma necessidade?
Considero que utilizar unicamente métodos ativos de aprendizagem nem sempre acaba
por dar os melhores resultados, por exemplo quando se estiver a aplicar a alunos que estão
desmotivados pela escola e pela educação. Os métodos de ensino construtivistas, como refere
Jonassen (2007), são eficazes quando os alunos têm objetivos.
Os alunos com quem trabalhei esperam o apoio do(a) professor(a) para ganharem alguma
motivação para a realização de tarefas. Nestes casos, acredito que se lhes tivesse pedido para
fazerem a procura da informação utilizando apenas métodos ativos, resultaria em atitudes de
desinteresse como observei em algumas aulas. Portanto, na minha intervenção pedagógica,
dada a turma em questão e dado o tipo de matéria, optei por métodos que considerei mais
adequados para captar maior interesse por parte dos alunos pelos assuntos a serem lecionados
15
com o objetivo de trabalhar a informação da melhor forma. Ou seja, adequei o método ao
contexto.
Com o objetivo de ter alunos mais atentos aos assuntos da aula, Ribeiro (2012) refere que
as suas aulas “têm sido (quase) sempre expositivas. (…) Evitam-se atitudes de crianças e
adolescentes exibicionistas, mestres no bloqueio do discurso dos docentes.” (p. 69) E ainda
acrescenta que “o método expositivo torna também a gestão de conteúdos bem mais objetiva e
linear. Poupa tempo. Torna mais raro o álibi da falta de tempo para cumprir programas.” (p. 72)
A utilização do método expositivo é útil para a “introdução de um tema tendo em vista
despertar interesse para um assunto ou fornecer diretrizes para a realização de tarefas
orientadas pelos métodos ativos.” (Pinheiro & Ramos, 2005, p. 30), Ou seja, neste caso
particular pretendi introduzir conceitos da linguagem de programação para que os alunos
tivessem as noções necessárias para posteriormente poderem desenvolver os programas
propostos.
O Ministério da Educação elaborou um programa em 2005 para ensino de linguagens de
programação e em relação à metodologia a adotar é referido que “A metodologia a seguir nesta
disciplina será intercalar exposições teóricas com a resolução de exercícios práticos em
microcomputador.” (p. 6) Assim constatei que a metodologia que adotei não estaria
desadequada, uma vez que lecionei uma linguagem de programação.
1.1.2 A exposição e a interação nas aulas de programação
Considero demasiado cansativo o ensino baseado essencialmente em exposição, em que
se dá poucas oportunidades de intervenção dos alunos. Como o tema a lecionar era uma
linguagem de programação, considerei que seria adequado expor alguns conceitos teóricos, no
caso a sintaxe da linguagem e exemplos em que diversas vezes comparava com uma linguagem
de programação que eles já conheciam, alternando com questões que lhes ia colocando, desse
modo interagindo com eles com o objetivo de os fazer pensar. Segundo Arends (1995) “o uso
adequado do modelo da exposição é situacional, ou seja, o seu uso depende do objectivo que o
professor pretende atingir e dos alunos com quem está a trabalhar.” (p. 269)
Na minha opinião, o que torna o ensino mais motivador é a alternância de um conjunto de
métodos, uma vez que “não se pode memorizar tudo, tal como não se deve esquecer a
memorização. Deve-se desenvolver o raciocínio e o gosto pela compreensão dos conceitos
complexos, tal como se deve desenvolver a memória e a automatização de alguns
16
procedimentos. Ou seja, devem-se usar técnicas variadas e apontar objetivos variados, ao
contrário do que defendem os teóricos do construtivismo dogmático.” (Crato, 2006, p.13).
Embora algumas opiniões façam acreditar que o método expositivo é algo negativo para
se utilizar no ensino e que os métodos ativos são basicamente aqueles que se deve seguir,
Arends afirma que “os efeitos na instrução do modelo baseado na exposição são claros e
diretos, nomeadamente para ajudar os alunos a adquirir, a assimilar e a reter a informação.”
(1995, p. 280).
1.1.3 Interação
Na última aula a que assisti, antes da minha intervenção pedagógica, apliquei um
questionário aos alunos onde solicitava, entre outros aspetos, para sugerirem uma estratégia
que os motivasse para a programação. De entre as respostas dadas, a que considerei mais
relevante foi a de um aluno que referiu que o motivavam aulas interativas. Assim, optei por usar
também esse método para conseguir captar o interesse dos alunos para os assuntos da aula,
uma vez que estes facilmente se distraíam e se deixavam levar por assuntos que saíam fora do
âmbito da aula.
1.1.3.1
Interação do aluno com o computador
De acordo com Silva (2006) “a “sociedade interativa” é aquela que se relaciona com a
comunicação “sob as condições da tecnologia interativa com base em computador” (p. 58).
O que se pretendia era ensinar uma linguagem de programação, neste caso a linguagem
de programação Python, onde era proporcionada interação com o computador onde Papert
(1980) refere que os computadores podem acelerar o processo de desenvolvimento cognitivo,
alterando a fronteira entre o concreto e o formal e permitindo que as crianças façam a transição
para o pensamento formal numa idade bem anterior ao que se pensava. Ou seja, a interação
com o computador apresenta-se como um ambiente potenciador de aprendizagem.
1.1.3.2
Interação dos alunos entre si e com o professor
Segundo Silva (2006) “a escola não se encontra em sintonia com a emergência da
interatividade. Encontra-se alheia ao espírito do tempo e mantém-se fechada em si mesma, em
seus rituais de transmissão, quando o seu entorno modifica-se fundamentalmente em nova
dimensão comunicacional.” (p. 68).
17
Uma vez que o método expositivo limita-se a transmitir a informação, é importante utilizar
a interação de forma alternada, de modo a ativar o pensamento dos alunos sobre os conteúdos,
ou seja, “a comunicação interativa é, portanto, o que enfatizo como desafio para a educação
centrada no paradigma da transmissão.” (Silva, 2006, p.69)
Quando o professor coloca questões aos alunos, está a interagir com eles, ou seja a criar
um ambiente de discurso na sala de aula, assim definido por Arends (1995):
O termo discurso será utilizado para fornecer uma perspetiva geral
sobre a comunicação na sala de aula. (…) [e] (…) pode ser visto como uma
exteriorização do pensamento, isto é, uma revelação dos nossos
pensamentos invisíveis. Assim, através do discurso público, os professores
obtêm uma janela parcial para observarem os processos de pensamento dos
seus alunos e um contexto para corrigirem e darem feedback quando
observarem raciocínios errados ou incompletos. (p. 416)
Dessa forma é possível detetar e resolver a não compreensão dos conteúdos por parte
dos alunos, deixando claro aquilo que possivelmente não tinham compreendido, antes de serem
questionados. Assim, “os alunos têm aí configurado um espaço de diálogo, participação e
aprendizagem. O professor não distribui o conhecimento. Ele disponibiliza elos probabilísticos e
móveis que pressupõem o trabalho de finalização dos alunos ou campos de possibilidades que
motivam as intervenções dos alunos.” (Silva, 2006, pp. 185-186)
Os alunos interagem entre eles quando, por exemplo, realizam trabalhos em grupo.
Têm a possibilidade de aprender e melhorar os relacionamentos sociais. De acordo com
Arends (1995) “um dos aspectos importantes da aprendizagem cooperativa é o de que,
ao ajudar a promover o comportamento cooperativo e ao desenvolver melhores relações
grupais entre os alunos, está simultaneamente a ajudar os alunos na aprendizagem
escolar.” (p. 369).
O aluno consegue aprender melhor em interação com colegas com mais
capacidades do que sozinho. A este propósito, Vygotsky (1978) refere que “aquilo que a
criança consegue fazer com a ajuda dos outros poderia ser de alguma maneira, muito
18
mais indicativo do seu desenvolvimento mental do que aquilo que consegue fazer
sozinha.” (p. 85)
Mais importante do que a interação com o computador será a interação entre as
pessoas presentes na sala de aula como fator proporcionador de motivação e
aprendizagem, desta forma Arends (1995) refere que “ (…) a interação social na sala de
aula é um resultado de pessoas individualmente motivadas respondendo umas às outras
num contexto social (…) e produz determinados comportamentos dos alunos para a
aprendizagem social e escolar.” (p.111)
1.1.4 A importância da programação para o desenvolvimento do
pensamento computacional
Na programação a aprendizagem não é adquirida de forma mecânica, não se transmite
informação que seja memorizada de forma automática, em cada problema é necessário ajustar
os conhecimentos anteriores à nova situação.
O pensamento computacional é uma caraterística que é desenvolvida no aluno com o
apoio do computador, sendo definido por Wing (2006) como “uma maneira de pensar humana e
não dos computadores. O Pensamento computacional é uma forma humana de resolver
problemas e não uma forma de tentar que os seres humanos pensem como computadores.” (p.
35).
Ainda em relação ao conceito “pensamento computacional” Ramos (2013) acrescenta
características como
(…) formular problemas numa forma que permita utilizar o
computador e outras ferramentas para resolver, organizar e analisar dados
de forma lógica, são aspetos que estão envolvidos no pensamento
computacional. Representar dados através de abstrações como por exemplo
modelos e simulações. Automatizar soluções através do pensamento
algorítmico. Identificar, analisar e implementar soluções possíveis.
Generalizar e transferir estes processos para resolver uma grande variedade
de situações.
19
Para desenvolver o pensamento computacional pode-se utilizar um conjunto de aplicações
ou programas, sendo que com estas ferramentas o aluno tem capacidade de se tornar mais
autónomo, mais criativo e ir assim adquirindo uma atitude mais crítica em relação ao que o
rodeia.
Ramos (2013) também considera que “essas capacidades servem para descrever e
explicar situações complexas, é mais uma linguagem que podemos usar para compreender o
universo, os seus fenómenos e os seus processos complexos, mas também para compreender e
usar no universo humano e social na resolução dos problemas que enfrentamos.” (s/p), Ou seja,
o “pensamento computacional” permite para compreender o ser humano, os problemas sociais,
os fenómenos do universo e sua complexidade e, assim, ajuda a resolver os problemas a eles
associados.
À semelhança de outras aplicações referidas por Jonassen (2007) como micromundos,
onde se podem representar simulações de fenómenos do mundo real, ao utilizar uma linguagem
de programação “os alunos aprendem fazendo, em vez de apenas observarem ou ouvirem uma
descrição de como algo funciona. Por esta razão, os micromundos tendem a ser intrinsecamente
mais motivantes do que as descrições tradicionais de atividades” (p. 179)
Portanto, ao utilizar uma linguagem de programação, o aluno desenvolve a capacidade de
pensar ou raciocinar ao construir programas, uma vez que conhecendo os conceitos da
linguagem pode construir o programa dando um cunho pessoal, exibindo a sua criatividade.
Sendo uma linguagem de programação uma forma de desenvolver o pensamento
computacional, esta pode ser considerada uma ferramenta cognitiva, uma vez que desenvolve as
capacidades cognitivas do aluno, e assim “aprender com as ferramentas cognitivas exige que os
alunos pensem com mais empenho sobre a matéria que está a ser estudada do que pensariam
se as não usassem.” (Jonassen, 2007, p. 22)
1.1.5 A linguagem de programação Python
Morais e Pires explicam assim a origem desta linguagem: “Python é uma linguagem de
programação criada por Guido Van Rossum no início da década de 90 (…) ” e o nome vem do
facto do seu criador ser fã série britânica Monty Python. (, 2002, p. 1)
O motivo de ter sido criada foi porque “Guido sentiu falta de uma linguagem de mais alto
nível que o C (…), mas que fosse mais poderosa do que as linguagens de shell scripting (…).
Para preencher essa lacuna, resolveu criar o Python.” (idem)
20
Algumas das caraterísticas desta linguagem são: é fácil de utilizar; incentiva à utilização de
metodologias de programação corretas, tornando os programas muito legíveis e fáceis de
compreender. É orientada a objetos, assim como a linguagem de programação Java. É uma
linguagem multiplataforma, ou seja, é possível executar em vários sistemas operativos, como
Windows, Linux, Macintosh, etc. (Morais & Pires, 2002).
Esta é uma linguagem que oferece mais vantagens do que desvantagens, uma vez que é
uma das melhores escolhas para programadores que procuram robustez e produtividade, é fácil
de aprender, tem disponíveis na sua biblioteca módulos prontos para tarefas como conexão a
sistemas de herança, webservices, tratamento de imagem, integração com aplicativos de
produtividade e com todo tipo de aplicações que se possa imaginar. É útil na criação de páginas
web e no acesso a bases de dados. Por exemplo, a linguagem Perl está ao mesmo nível do
1
Python, no entanto à medida que um programa em Perl cresce torna-se cada vez mais difícil de
ler e compreender (Morais & Pires, 2002).
Os alunos com que trabalhei já tinham experimentado anteriormente a linguagem C e
puderam fazer a comparação com um código simples que dá como resultado a impressão de
uma frase no ecrã. Na linguagem C, são precisas algumas linhas de código, enquanto que em
Python basta uma linha de código, como se pode observar na tabela seguinte.
Tabela 1 - Comparação de código da linguagem de programação C com a linguagem de programação Python
Impressão da frase “Olá Mundo!”
Linguagem de programação C
Linguagem de programação Python
include <stdio.h>
print “Olá Mundo!”
int main() {
printf(“Olá Mundo!\n”)
return 0;
}
Esta linguagem é utilizada nos sites do Google, do Youtube, nos programas da NASA, no
programa Gimp. Foi utilizada para a criação de um conjunto de jogos, como por exemplo Word
of Tanks. Também foi utilizada para a criação dos efeitos especiais do filme Star Wars.
1
http://www.python.org
2
http://powerpython.wordpress.com/2012/03/16/programas-e-jogos-feitos-em-python/
21
2
22
CAPÍTULO II – CONTEXTO E PLANO GERAL DE INTERVENÇÃO
2.1 Contexto da intervenção
2.1.1 Caraterização da escola
O meu estágio realizou-se na Escola Secundária Alberto Sampaio, situada na Rua Álvaro
Carneiro, freguesia de S. Lázaro no conselho de Braga.
Figura 1 - Escola Secundária Alberto Sampaio
Entre 2009 e 2010 as instalações da escola foram objeto de requalificação, com o
objetivo de reunir as condições essenciais ao desenvolvimento da ação educativa. (IGEC, 2011,
p. 2)
Ainda segundo IGEC (2011) “Para responder à heterogeneidade da comunidade educativa
que serve, a Escola apresenta na sua oferta formativa todas as modalidades de formação de
nível secundário: cursos científico-humanísticos; cursos profissionais; cursos de educação e
formação de adultos; formações modulares; reconhecimento, validação e certificação de
competências; e português para todos, orientado para estrangeiros.” (p. 2), Ou seja, a Escola
Secundária Alberto Sampaio tem uma vasta oferta formativa, incluindo Oficinas de Teatro,
Oficinas de Artes, Oficinas de Música entre outras.
De acordo com IGEC (2011), “a população escolar, em 2011-2012, é constituída por
1622 alunos. Destes, 1206 (47 turmas) frequentam os cursos científicos-humanísticos
regulares, 299 (25 turmas) os cursos profissionais e 117 (nove turmas) os cursos de educação e
formação de adultos. […] A equipa docente é constituída por 197 professores. […] O pessoal não
docente é constituído por 42 trabalhadores.” (p. 2)
Segundo IGEC (2011), no ano letivo 2010-2011, a idade média dos alunos encontra-se
abaixo da média nacional, constatando-se uma baixa incidência de retenções no percurso
escolar dos alunos que frequentam a escola. (p. 2)
23
O tipo de público que a Escola Secundária Alberto Sampaio recebe é de variados extratos
sociais conforme é referido em ESAS (2011):
A ESAS capta uma população estudantil muito diversificada, servindo,
fundamentalmente, a zona centro e sul da cidade. Contudo, nos últimos
anos, tem-se acentuado a tendência para uma maior diversificação,
integrando a escola alunos provenientes de todas as freguesias da cidade. Do
ponto de vista sociológico, esta escola integra alunos oriundos de famílias de
nível social médio-alto e alto, mas também, numa parcela significativa,
alunos oriundos de famílias de nível social médio-baixo e baixo, portadores de
níveis de instrução muito baixos. Na proximidade da escola, na zona oeste e
sul, situam-se alguns dos bairros mais degradados da cidade e com maiores
problemas em matéria de segurança pública. (p. 14)
Em termos de equipamento informático, verifiquei que esta Escola está bem
equipada, servindo convenientemente os alunos em termos informáticos, tendo em média
um computador para cada aluno.
2.1.2 Caraterização da turma
Esta turma frequenta o 12º ano do curso de Técnico de Gestão e Programação de
Sistemas Informáticos, é constituída por 21 alunos, dos quais 20 são rapazes e uma é
rapariga. A disciplina onde realizei o meu estágio é designada por Programação e
Sistemas de Informação. Esta disciplina está dividida em dois turnos, um com 11 alunos e
outro com 10 alunos, sendo este último aquele onde realizei o meu estágio. Estes 10
alunos eram todos do sexo masculino.
Relativamente às caraterísticas da turma, de acordo com a informação fornecida
pelo Diretor de Turma, seis dos alunos são os próprios Encarregados de Educação.
Apenas dois Encarregados de Educação estão desempregados, sendo que a maior parte
deles estão contratados e apenas sete estão efetivos. As suas profissões variam muito,
sendo que a de serralheiro e assistente operacional são as mais representadas. Verificase, pois, uma baixa escolaridade dos Encarregados de Educação.
24
Em relação aos alunos, a maior parte tem dezassete anos, no entanto, existem
alguns alunos já fora da escolaridade obrigatória. A sua média de idades é 18,1 anos,
sendo a mesma média de idades no turno onde estagiei, informação que obtive a partir
dos dados do questionário que apliquei ao turno.
No que diz respeito à vida escolar, sete destes alunos já repetiram pelo menos um
ano letivo. No entanto, nenhum deles é repetente no 12º ano e todos estes alunos
andaram nesta Escola no ano anterior.
De referir também, que apenas um aluno afirma que estuda todos os dias. As suas
disciplinas preferidas são Educação Física e Programação e Sistemas de Informação,
enquanto que as disciplinas em que os alunos sentem mais dificuldade são Inglês e
Programação e Sistemas de Informação.
Questionado o turno onde estagiei, verifiquei que em relação à ocupação dos
tempos livres, quase todos os alunos utilizam a Internet, gostam de ver filmes na televisão
e ouvir música. Todos referiram que possuem computador e internet em casa.
Quanto ao comportamento durante as aulas, e segundo Ata do Conselho de Turma
(2013), do terceiro período, é declarado a nível de comportamento que os alunos são mal
comportados, perturbando o bom funcionamento das aulas. Verifiquei este facto nas aulas
que observei e durante a minha intervenção pedagógica; havia falta de respeito pela
autoridade do professor, eram bastante barulhentos e manifestavam pouco interesse na
realização das tarefas.
2.1.3 Caraterização da disciplina
Conforme DGFV (2005), “A disciplina de Programação e Sistemas de Informação,
vulgarmente designada por PSI, integra a componente de formação técnica dos cursos
profissionais, de forma a garantir aos jovens a aprendizagem de técnicas de programação
e desenvolvimento de sistemas informáticos, indispensáveis ao sucesso pessoal e
profissional nesta área.” (p. 2)
Esta disciplina é composta por vários módulos ao longo dos três anos do curso,
sendo que no 12º ano é constituída por quatro módulos. A minha intervenção sucede no
3º módulo, módulo opcional da lista dos módulos opcionais definidos no programa da
disciplina, designado por Ferramentas de desenvolvimento de páginas web. A planificação
deste módulo encontra-se em anexo.
25
Quanto às competências desenvolvidas neste módulo, e segundo DGFV, (2005)
“este módulo destina-se a dotar os alunos de conhecimentos de nível mais avançado na
utilização da ferramenta de desenvolvimento de páginas web, para que desenvolvam sites
profissionais mais completos, com ligações a bases de dados, permitindo evoluir de um
site estático para um site dinâmico. Pretende-se também interligar a ferramenta de
desenvolvimento com outras aplicações.” (p. 51). A ferramenta definida para
desenvolvimento de páginas web é a linguagem de programação Python.
2.2 Plano geral da intervenção
2.2.1 Objetivos
O que pretendia como resultado era verificar no final se estes alunos se tornaram
autónomos na construção de programas, seja na linguagem de programação Python ou
em outras linguagens de programação, uma vez que cada problema é sempre diferente
do anterior, exigindo que alie um conhecimento prévio ao novo conhecimento. Ao utilizar
interação durante as aulas, pretendi verificar no final se estes alunos se tornaram mais
colaborativos na realização de tarefas.
Foi também minha intenção verificar se ficaram mais motivados para a linguagem
de programação Python bem como apurar se as aprendizagens dos alunos foram
consolidadas e eles adquiriram novas competências.
2.2.2 Técnicas e instrumentos de recolha de dados
Os instrumentos utilizados para a recolha de dados foram três questionários online
construídos na ferramenta Google Drive. Os alunos tinham acesso através de um link para
esse questionário criado no final da construção do mesmo e as respostas eram enviadas
para um ficheiro do tipo folha de cálculo e colocadas na minha conta do Google Drive.
O primeiro questionário foi aplicado à turma antes de iniciar a minha intervenção
pedagógica, com o objetivo de analisar os seus conhecimentos prévios, dificuldades na
área da informática, gosto por programação, as suas aspirações em termos de futuro
profissional, entres outras questões.
No final da minha intervenção pedagógica apliquei dois questionários. Um deles
apliquei-o no último dia da minha intervenção pedagógica e com isso pretendi analisar as
aprendizagens que eles realizaram, isto é, saber se tiverem dificuldades com as matérias
26
que lecionei e se a resposta fosse positiva pedia-lhes que referissem qual a dificuldade. O
último questionário tinha como objetivo verificar a forma como os alunos avaliaram as
minhas aulas, onde questionava se realizaram as tarefas propostas, se gostaram da forma
como foram lecionadas, se lhes foram tiradas as dúvidas, se ficaram motivados para a
linguagem de programação Python, entre outras.
2.2.3 Estratégias de intervenção
Depois de aplicar o questionário anteriormente à minha intervenção pedagógica, fiz
uma análise, onde verifiquei os conhecimentos prévios dos alunos, neste caso
conhecimentos sobre linguagens de programação. Dessa análise foi possível também
fazer comparações de algumas situações com uma linguagem que eles tiveram e que
também era conhecida para mim, de modo a que a aprendizagem pudesse ser
concretizada e assim incorporar um novo conhecimento no anterior.
Através da questão em que pedi para sugerir uma estratégia que motivasse para
aprender programação, de entre as poucas respostas aquela que considerei relevante
para adotar na minha intervenção pedagógica foi a que referia a interação como algo
que cria motivação para aprender programação. Assim, resolvi apostar na interação nas
minhas aulas. Para além de haver interação com o computador na construção dos
programas, houve interação professora/aluno ao longo das apresentações de exemplos,
demonstrações e construção de programas de forma interativa, onde se questionam os
alunos com o objetivo de os fazer pensar. No que diz respeito à interação Silva (2001)
refere que “ o essencial não é a tecnologia, mas um novo estilo de pedagogia sustentado
por uma modalidade comunicacional que supõe interatividade, isto é, participação,
cooperação, bidirecionalidade e multiplicidade de conexões entre informações e atores
envolvidos.” (p. 15)
27
CAPÍTULO III - DESENVOLVIMENTO E AVALIAÇÃO DA INTERVENÇÃO
3.1 Ferramentas educativas
Esta secção apresenta uma breve caraterização das ferramentas utilizadas para
apoio à minha intervenção pedagógica.
3.1.1 Google Drive
O Google Drive é um serviço de armazenamento na nuvem, disponibilizado pela
Google em abril de 2012, considerado um concorrente à Dropbox. Permite aos
utilizadores armazenar, partilhar, editar e visualizar diferentes tipos de ficheiros e
sincronizá-los usando vários dispositivos a partir de múltiplos pontos de acesso com
terminais fixos ou móveis.
É OpenSource, ou seja é um serviço gratuito que oferece 15 GB de capacidade de
armazenamento, basta fazer o download e instalar, possibilitando o acesso aos ficheiros
através do ícone
que se encontra na barra de tarefas como se pode observar na
figura seguinte:
Figura 2 - Ícone do Google Drive na barra de tarefas
Ao instalar fica integrado com o Google Docs. Da mesma forma pode-se criar
documentos e trabalhar em grupo no mesmo documento e as alterações aparecem em
tempo real. Também determina-se quem pode ter acesso a determinados documentos
com as opções de partilha. A particularidade do Google Drive é a de poder manter os
vestígios das sucessivas versões dos documentos modificados. É também possível
reverter as alterações feitas durante os últimos 30 dias.3
Nas minhas aulas utilizei o Google Drive para disponibilizar aos alunos o programa
Python que os alunos deveriam instalar, um manual da linguagem para quem quisesse
aprender algo mais sobre a linguagem em horário não letivo, apresentações utilizadas nas
aulas e alguns programas desenvolvidos, como se pode observar a seguir (Fig. 3):
3
http://en.kioskea.net/faq/26485-discovering-and-using-google-drive, acedido em 8 de Janeiro de 2015
28
Figura 3 - Google Drive - Partilha de material com os alunos
Também utilizei esta ferramenta para criar pastas individuais partilhadas com cada
aluno, onde me depositariam programas/exercícios que resolviam como T.P.C. (Trabalho
Para Casa), como se pode observar na imagem seguinte (Fig. 4). No entanto, esta
intenção não produziu resultados, como se explica na secção 3.3.
Figura 4 - Google Drive - Partilha de pastas individuais para colocar TPC's
3.1.2 Microsoft PowerPoint
O Microsoft PowerPoint está incorporado no Microsoft Office. É um software que
permite a criação de materiais que podem ser apresentados por meio de um projetor. O
29
uso desses materiais serve para anunciar um relatório ou uma proposta sendo designado
de apresentação. Transitam de uma tela para a outra, como uma apresentação de slides.
Pode-se animar o texto e as ilustrações na tela, usando o recurso de animação, podendo
também adicionar-se efeitos de som e narração. Este software incorpora imagens, sons,
vídeos, textos e gráficos para criar uma apresentação interativa. Interage também com
outros produtos do Microsoft Office, como o Microsoft Word e Microsoft Excel.4
Utilizei esta ferramenta nas minhas aulas com o objetivo de apresentar alguns
conceitos teóricos, sintaxe e exemplos da linguagem Python, como se pode observar na
tabela seguinte que inclui slides onde é mostrada essa utilização:
Tabela 2 - Apresentações no ensino da linguagem de programação Python
Conceitos
Sintaxe
Exemplo
3.1.3 Interpretador do Python
Um interpretador é um programa que executa outros programas.
O interpretador do Python lê o código Python e executa as instruções que ele
contém. É um interpretador interativo sendo uma característica diferencial da linguagem,
porque há a possibilidade de testar e modificar funções antes de incluí-las nos programas.
Isso permite um grau de aprendizagem relativamente alto em relação às outras
linguagens.5
Como exemplo apresento um programa construído durante as aulas, em que sendo
dado um número inteiro entre 1 e 3999 se pretende obter como resultado o
4
http://www.businessdictionary.com/definition/Microsoft-PowerPoint.html
5
https://www.python.org/
30
correspondente em numeração romana. O código e o interpretador na forma interativa são
apresentados como se observa a seguir (Fig. 5):
Figura 5 - Programa e interpretador interativo do Python
3.2 Aulas observadas
A minha primeira visita à escola foi no dia 1 de novembro de 2013, passando a assistir às
aulas do professor cooperante a partir daí.
No total assisti a seis aulas lecionadas pelo professor cooperante, uma delas na turma
onde o colega de estágio Ricardo Carvalho realizou a sua intervenção pedagógica e cinco aulas
onde realizei a minha intervenção pedagógica.
A 5 de novembro de 2013 acompanhei o colega de estágio Ricardo Carvalho à primeira
aula que assistimos em conjunto, com professor cooperante a lecionar na turma onde o colega
realizou a sua intervenção pedagógica. Nessa aula os alunos estavam a apresentar trabalhos
sobre redes com projeção no computador do professor.
Na turma onde realizei a minha intervenção pedagógica concretizei as observações às
quintas-feiras desde 7 de novembro de 2013 até 12 de dezembro de 2013, exceto a quinta-feira
dia 28 de novembro.
A primeira aula que assisti, na turma onde tive a minha intervenção pedagógica foi a 7 de
novembro de 2013, com a presença do colega de estágio. Nessa aula os alunos estavam a
31
trabalhar com UML (Unified Modeling Language). O aluno J. F. foi ao quadro desenhar uma
tabela, ao mesmo tempo que manifestava ao professor cooperante desagrado pela tarefa.
Nestas aulas observadas estavam a ter o módulo 17C de opção, com a designação de
Metodologia de análise e desenvolvimento de sistemas, sendo o conteúdo sobre UML. Esta é
uma linguagem que se define como linguagem de modelagem que permite representar um
sistema de forma padronizada. O UML permite que os programadores visualizem o produto do
seu trabalho sobre a forma de diagramas padronizados. Os objetivos do UML são: especificação,
documentação, estruturação para sub-visualização e maior visualização lógica do
desenvolvimento completo de um sistema de informação.6
Comportamento observado
Em algumas situações gerava-se bastante confusão com barulho e gargalhadas fazendo
com que o professor cooperante acabasse por mandar algum deles para a rua.
Numa dada situação um aluno comentou algo que estava a observar pela janela, levando
outros colegas a vir do outro lado da sala juntar-se a eles para observar. O professor cooperante
mandou irem para os seus lugares, no entanto davam pouca importância à ordem do professor,
desobedecendo. Em algumas situações distraíam-se com jogos de computador, utilização do
telemóvel, entre outras coisas que não faziam parte do conteúdo sumariado.
Alguns entravam às vezes a cantar na sala de aula, numa atitude clara de desrespeito.
Num outro momento observavam fotos de alguém, onde comentavam ser uma pessoa da
escola. Numa aula o professor cooperante tirou o telemóvel de um aluno, e o aluno exaltou-se
com ele por esse facto, reclamando o telemóvel. Em geral chegavam atrasados, embora fosse
hora do almoço, chegavam depois do limite da tolerância.
“Por indisciplina entende-se a transgressão das normas escolares, prejudicando as
condições de aprendizagem, o ambiente de ensino ou o relacionamento das pessoas na escola.”
(Veiga, 2007, p. 15)
6
www.uml.org
32
O professor cooperante chegou a mandar fazerem o relatório para a PAP (Prova de
Aptidão Profissional), dois deles abriram o relatório, no entanto logo a seguir voltaram a fechar,
continuando com os jogos. Apenas um deles continuou a trabalhar no relatório.
Na penúltima aula que assisti, os alunos em geral, não fizeram trabalho útil, apenas o
aluno T. B. esteve a fazer um levantamento dos problemas dos computadores da sala de aula,
para depois serem resolvidos, por sugestão do professor cooperante.
Na última aula que assisti, dia 12 de dezembro de 2013 apliquei um inquérito à turma,
para daí perceber alguns conhecimentos prévios, ambições para o futuro, entre outros assuntos.
Aproveitei essas informações para aplicar na construção do projeto de intervenção. Os resultados
desse questionário são apresentados a seguir na secção 3.3.
3.3 Levantamento de requisitos
Na última aula observada, antes de iniciar a minha intervenção pedagógica, apliquei
um questionário online à turma/turno com o objetivo de me informar dos seus
conhecimentos prévios, a possibilidade de utilizar computador em casa, onde encontram
dificuldades, as pretensões para o final do curso, entre outros assuntos. Este questionário
encontra-se em anexo.
Conjunto de questões aplicadas:

Que idade tens?

Possuis computador em casa?

Possuis internet?

Quais as matérias na área da informática que tens mais dificuldades?

Quais as matérias que dominas melhor na área da informática?

Gostas de programar?

Tens alguma dificuldade em programação?

Se respondeste “sim” à questão anterior, explica de género é a tua
dificuldade.

Sugere uma estratégia que te motive para a programação.

O que ambicionas que este curso profissional te traga profissionalmente?

Pretendes atingir o ensino superior?

O que ambicionas para o futuro?
A este questionário responderam os 10 alunos da turma.
33
Quanto à resposta à primeira questão resultou uma média de idades de 18,1 anos
de idade, como também foi referido no capítulo II.
À segunda e à terceira questão, todos referiram que possuem computador e
internet em casa.
As cinco questões seguintes testam os conhecimentos prévios e como referem Coll
et al. (2001) “O fator mais importante que influi na aprendizagem, é aquilo que o aluno já
sabe. Isto deve ser averiguado e o ensino deve depender desses dados” (p. 66)
Quanto à questão “Quais as matérias na área da informática que tens mais
dificuldades?”, dois não responderam, outros dois afirmaram que tinham dificuldades em
quase tudo, um deles referiu que não tinha nenhuma dificuldade e os restantes cinco
referiram AJAX, Casos de uso, Redes, Redes de comunicação e Programação como as
suas dificuldades.
Em relação à questão “Quais as matérias que dominas melhor na área da
informática?”, um dos alunos não respondeu, dois afirmaram que não dominam nenhuma
matéria na área da informática, dois referiram “programação” como a matéria que
dominam melhor, um aluno referiu que domina melhor C# e outro além de C# também
referiu Redes. Um deles afirmou que domina melhor HTML (HyperText Markup Language),
outro aluno referiu “programação web” e o último afirmou que domina melhor PHP
(Personal Home Page), HTML e JavaScript.
Quanto à questão “Gostas de programar?”, oito dos alunos responderam “sim” e
dois responderam “não”.
Em relação à questão “Se respondeste “sim” à questão anterior, explica de género
é a tua dificuldade.”, apenas três responderam a esta questão, onde um deles mencionou
“um pouco de tudo”, outro aluno referiu “Lembrar os códigos” e o último acrescentou que
tem dificuldade em “Sintaxe, comandos e funções complexas”.
A questão “Sugere uma estratégia que te motive para a programação.” foi aquela
que pretendia que me orientasse para a minha estratégia de intervenção. Três dos alunos
não responderam, um deles afirmou “não sei”, outro aluno referiu “programação web” e
outro acrescentou como uma estratégia que o motivasse como “criação de programas
uteis”. Dois deles referiram que gostariam de ouvir música enquanto trabalham e o outro
34
aluno referiu que o motiva “Aulas interativas”. Assim, depois de analisar as respostas
considerei esta a mais relevante e que estaria adequada para colocar em prática.
Quanto à questão “O que ambicionas que este curso profissional te traga
profissionalmente?”, dois dos alunos não responderam e as oito respostas obtidas foram
“trabalhar em empresas, categoria”, “programação web”, “Capacidade de trabalho
independente de terceiros.”, “Dinheirinho”, “€”, “Pergunta que não possui resposta”,
“Preparação para o mundo do trabalho” e “Trabalho”.
Em relação à questão “Pretendes atingir o ensino superior?”, cinco dos alunos
responderam “não” e cinco responderam “sim”.
Finalmente na questão “O que ambicionas para o futuro?” dois dos alunos não
responderam e as respostas obtidas foram “Ser empresário de sucesso”, “trabalhar”,
“Dinheiro e mulheres”, ” Trabalhar”, “trabalho”, “Não sei”, ” Um trabalho estável e
desafiador.” e “Trabalhar”.
3.4 Implementação e avaliação da ação
3.4.1 Calendarização das atividades realizadas
Estratégias gerais:

Diálogo com os alunos;

Ensino de Conceitos;

Exposição dos conteúdos de forma interativa, alternado com questões aos alunos
e promovendo a discussão na sala de aula;

Utilização do programa Python para experimentar exemplos;

Interrogar os alunos ao desenvolver programas de modo a desenvolver o seu
raciocínio.
Tabela 3 - Calendarização das atividades realizadas
Aula
Duração
Data

1
90
minutos
Conteúdo
Conceitos teóricos da
linguagem Python;
8-01-2014

Instalação do programa
Python 2.7.6.
35

Atividades/Estratégias
Estratégias gerais.

Conceitos básicos da
linguagem;

2
3
4
5
90
minutos
aritméticos;
8-01-2014
90
minutos
9-01-2014
90
minutos
13-01-2014
90
minutos
13-01-2014

Variáveis – atribuição;

Tipos de dados.

Comando print;

Estratégias gerais;

Comando input;

Resolução de problemas

Criar um ficheiro .py;
utilizando os comandos print e

Abrir um ficheiro .py.
input.

90
minutos
Comandos if/elif/else.

Estratégias gerais;

Resolução de problemas
utilizando os comandos
if/elif/else.

6
Operadores lógicos e
15-01-2014
Conclusão da matéria

Estratégias gerais;
com utilização dos

Resolução de problemas
comandos if/elif/else.
utilizando os comandos
if/elif/else;

7
90
minutos
8
9
90
minutos
16-01-2014
20-01-2014

Resolução de problemas
utilizando o comando while.
while.
15-01-2014

90
minutos
Introdução do comando
Introdução ao tipo de

Estratégias gerais;
dados sequenciais –

Resolução de problemas
strings;
utilizando strings com o

Operadores + e *;
comando raw_input e utilizando

Comando raw_input.
os operadores + e *.

Tipos de dados
36

Estratégias gerais;
sequenciais – strings:

Interpolação.
10
90
minutos
Construção do programa da aula
anterior em conjunto com a
turma;
20-01-2014

Resolução de problemas
utilizando interpolação em
strings.

Indexação em strings;

Estratégias gerais;

Método len;

Resolução de um problema com

Códigos ASCII dos
carateres da tabela
11
90
minutos
22-01-2014


base na tabela ASCII;

Resolução de problemas
ASCII;
utilizando indexação, os métodos
Métodos mais utilizados
existentes e também utilizando
da classe String;
slicing.
Pesquisa dos métodos
da classe String.
12
13
90
minutos
90
minutos
22-01-2014

Fatiar/slicing strings.

Introdução ao tipo de

Estratégias gerais;
dados sequenciais –

Resolução de problemas fazendo
listas;
a alteração e inserção de valores

Operadores + e *;
em listas de tamanho definido.

Caraterísticas das
listas;
23-01-2014

Alterar (inserir,
remover, atualizar)
valores em listas de
tamanho definido.

14
90
minutos
27-01-2014

Tipos de dados

Estratégias gerais;
sequenciais – strings;

Resolução de problemas
Tipos de dados
37
utilizando strings;
sequenciais – Listas de

90
minutos
27-01-2014

Resolução de problemas
tamanho definido.
utilizando listas de tamanho
Tipos de dados
definido;
sequenciais – listas:
15


Resolução de problemas
listas de tamanho
utilizando listas de tamanho
indefinido;
indefinido e os métodos len, del
Métodos len, del e
e append.
append.

Fatiar/slicing listas;

Estratégias gerais;

Inserção utilizando

Resolução de um problema

16
90
minutos
29-01-2014

slicing;
utilizando slicing, os métodos da
Métodos mais utilizados
classe list e o método randint da
da classe list;
classe random.
Pesquisa dos métodos
da classe list;

Método randint da
classe random.
3.4.2 Recursos utilizados e elementos de avaliação
Recursos:

Quadro

Videoprojector

Computador

Windows

Python 2.7.6
Avaliação:

Grelha de Observação (encontrando-se esta em anexo)

Pontualidade

Assiduidade
38

Comportamento

Participação
3.4.3 Da aula 1 até à aula 12 e aula 14 – Aulas não assistidas
Aula 1 e aula 2
Este foi o primeiro dia de aulas da minha intervenção pedagógica e coincidiu com o início
do segundo período. Este dia era composto por dois blocos de 90 minutos.
Faltou apenas um aluno por estar doente.
Dei início a um novo módulo da disciplina de Programação e Sistemas de Informação
(PSI), com a linguagem de programação Python.
Os objetivos que se pretendiam com estas duas aulas eram:

Entender os conceitos da linguagem;

Saber trabalhar com os operadores lógicos e aritméticos da linguagem;

Saber definir uma variável e atribuir-lhe valores.
No primeiro bloco
Os alunos receberam-me de forma agradável e participaram quando questionados.
Comecei por questionar as respostas dadas ao questionário aplicado à turma no dia 12 de
dezembro de 2013, dia da última aula a que tinha assistido. Também os questionei sobre as
linguagens de programação que tinham estudado anteriormente, para poder comparar com
aquelas que conhecia e também perceber se tinham algum conhecimento sobre a linguagem de
programação Python. Apenas o aluno T. B. referiu que esteve a pesquisar algumas noções e a
experimentar alguns comandos desta linguagem. “A programação em contexto adequado
oferece condições particularmente favoráveis, condições que melhoram quanto mais jovem for o
programador” (Papert, 1995, p.186), sendo neste caso, alunos relativamente jovens.
De seguida passei à introdução da linguagem Python, passando pela apresentação de
conceitos teóricos, assim como a sua origem, as características, as vantagens da sua utilização,
exemplos de aplicação desta linguagem desde sites e jogos, etc., questionando os
conhecimentos dos alunos de forma interativa.
O aluno T. B. interrompeu para perguntar sobre a construção de jogos; referi que não
estava previsto para aquele módulo da disciplina.
39
Procederam à instalação do programa nos seus computadores.
Como os alunos já tinham estudado a linguagem C, e uma vez que tenho conhecimento
dessa linguagem, resolvi fazer uma comparação com essa linguagem. Apresentei um programa
construído em linguagem C que imprime uma frase comparando com o mesmo programa
construído em Python. Este programa em Python tem apenas uma linha de código e em C o
mesmo programa é composto por cinco linhas de código, podendo-se verificar, como demonstrei
aos alunos, que é mais prático trabalhar com a linguagem Python.
No segundo bloco
Mostrei os operadores aritméticos, os operadores lógicos, as expressões booleanas, qual a
forma de comentar o código Python, tudo isto seguido de exemplos. Apresentei as regras para se
criarem variáveis e expliquei como funcionavam as atribuições às variáveis e quais os tipos de
dados desta linguagem. Referi que todos os tipos de dados no Python são objetos, apresentando
o exemplo de que os números inteiros também são reconhecidos como objetos, isto para
demonstrar que esta é uma linguagem por objetos.
Resultados destas duas primeiras aulas
De uma forma geral, os alunos, portaram bastante bem, para aquilo que era habitual.
Participaram de modo satisfatório quando questionados.
Pela forma como participou, o aluno P. M. deixou-me expectativas de que viria a ser um
aluno interessado.
Reflexão da aula 1 e da aula 2
Foi minha intenção verificar os conhecimentos prévios dos alunos. No final destas aulas
fiquei com boa impressão dos alunos pela forma como se mostraram interessados pelos
assuntos tratados, uma vez que parti com poucas expetativas depois do que tinha observado em
aulas anteriores.
Aula 3
Neste dia de aulas a disciplina de PSI era composta por 1 bloco de 90 minutos.
Não faltou nenhum aluno.
40
Os objetivos que se pretendiam com esta aula eram:

Entender os conceitos da linguagem;

Saber trabalhar com o comando print;

Saber trabalhar com o comando input;

Saber criar ficheiros em Python com exemplos simples;

Saber abrir os ficheiros criados anteriormente.
No início desta aula o professor cooperante começou a discutir um assunto com o aluno
J. F. que não se referia diretamente aos assuntos tratados nas aulas, enquanto eu estava a
tentar começar a aula, até que o aluno T. B. ao ver-me a insistir em dar início à aula, intervém
dizendo “Deixe a professora começar a aula!”
Depois de o professor cooperante concluir a discussão com o aluno J. F., iniciei a aula
onde passei a apresentar a sintaxe do comando print e input e alguns exemplos de utilização
destes comandos. O comando print serve para imprimir mensagens no ecrã e o comando input
serve para receber valores do tipo inteiros ou decimais introduzidos pelo utilizador para serem
utilizados no programa.
Em vez de fazer correr o código diretamente na linha de comandos e com o objetivo de
tornar o código mais claro, facilitar a compilação e ter sempre acesso ao programa,
exemplifiquei como se criava um ficheiro com a extensão .py, como se guardava e como se abria
esse ficheiro.
De seguida resolveram alguns exercícios propostos onde iriam aplicar todos os conceitos
aprendidos até ao momento.
Um dos resultados de compilação do seguinte problema do serviço de restaurante:
Figura 6 - Enunciado do problema "Serviço de restaurante"
seria da seguinte forma:
41
Figura 7 - Compilação do programa sobre o problema "Serviço de restaurante"
Resultados desta aula
Nesta aula, de uma forma geral, os alunos tiveram um comportamento razoável e
mostraram interesse em resolver os exercícios.
Ao resolverem o exercício referido em cima, observando um a um, verifiquei que o aluno
R. B. estava a resolver de forma interessada, organizando o código de forma legível, separando
as contas. O aluno P. F. resolvia também de forma interessada, demonstrando ser um aluno
empenhado.
O aluno J. F. e o aluno T. B. experimentavam código no programa Python que iam buscar
à internet, código este que ainda não tinha sido lecionado. Assim, não estavam atentos aos
assuntos que estavam a ser lecionados e que eram importantes, por exemplo pormenores de
sintaxe, acabando estes alunos por questionar os erros que obtinham com esse código retirado
da internet. Quem mais interrompia com questões era o aluno T. B. Acabei por informar o T. B.
e o J. F. que tinha disponibilizado um manual de Python na pasta partilhada com a turma no
Google Drive, para que em vez de perguntarem assuntos que não eram referentes à aula,
consultassem o manual.
Os alunos P. M. e J. R. estiveram conversadores, usavam o computador, não para
trabalhar, mas para outros fins. Nesta aula não foi possível captar o interesse destes alunos.
Reflexão da aula 3
Nesta aula, onde começaram por desenvolver trabalho pela primeira vez, marcaram pela
positiva os alunos R. B. e P. F. pelo empenho, criando-me expetativas para aulas futuras.
Em relação aos alunos J. F. e T. B., preocupava-me a forma como trabalhavam, uma vez
que tinham bastantes capacidades, talvez estavam acima da média da turma. Em termos de
autonomia tinham uma atitude positiva, mas o facto de não estarem atentos quando eram
42
apresentados os conceitos básicos levava a que acabassem por ter dificuldades quando
desenvolviam os programas.
Para tentar que os alunos P. M. e J. R. criassem motivação para o Python, poderia ter de
os acompanhar mais e dar apoio para as dificuldades que pudessem ter.
Aula 4 e aula 5
Neste dia de aulas a disciplina de PSI era composta por dois blocos de 90 minutos.
O conteúdo destas duas aulas foi o ensino dos comandos if/elif/else, seguido da
resolução de exercícios utilizando a combinação destes comandos.
A primeira aula começou com um atraso de cerca de 20 minutos por motivos que me
foram alheios.
Os objetivos que se pretendiam com estas duas aulas eram:

Entender os conceitos da linguagem;

Saber trabalhar com os comandos if/elif/else.
Comecei por lecionar os comandos if/elif/else e de seguida dei alguns exercícios para
resolverem em que utilizavam estes comandos.
Estes são designados comandos de controlo de fluxo, onde conjuntos de instruções são
executados de forma condicional permitindo validar a entrada de dados. A sintaxe geral de um
bloco de código é da seguinte forma:
Figura 8 - Sintaxe geral da sequência de comandos if/elif/else
43
Pode haver casos onde só seja necessário utilizar a instrução if ou outros onde não seja
necessário utilizar a instrução elif ou a instrução else.
Neste problema resolvido durante a aula sobre cálculo da média das notas de um aluno
não foi necessário utilizar a instrução else, uma vez que os intervalos de valores eram
específicos.
Figura 9 - Enunciado do problema "Média das notas de um aluno"
As três possibilidades de resultado de um exemplo da compilação de um programa que
resolve este problema, poderia ser da seguinte forma:
Figura 10 - compilação do programa sobre o problema "Média das notas de um aluno"
Começaram a construir os programas pedidos no final do primeiro bloco, continuando
depois esse trabalho no segundo bloco. Uma vez que estes problemas eram mais simples e
exigiam menos raciocínio, apenas acompanhei os alunos um a um orientando na construção dos
programas.
Resultados destas duas aulas
44
O aluno J. N. dificilmente trabalhava, só depois de muita insistência acabava por fazer
alguma coisa, preferia usar o computador para outros fins. Os alunos J. R. e P. M. não
trabalhavam e afirmavam que não iam trabalhar. P. M. referiu que não gostava de Python.
Os alunos mais aplicados foram o P. F. e R. B. O aluno J. L. também trabalhou alternando
com conversa.
O J. F. e o T. B. continuavam a experimentar código no programa Python que não lhes era
pedido. Para que eles resolvessem os exercícios pedidos informei-os que o facto de os resolver
contava para a avaliação. Logo se puseram a resolver esses exercícios. Estes dois alunos
estavam a trabalhar razoavelmente, no entanto também estavam bastante faladores.
Durante a resolução de um exercício, ao passar pelo lugar do aluno R. B., este referiu-me
que o programa estava a dar um erro e não sabia porquê, então perguntei-lhe se não faltava
nada numa certa linha de código, onde ele percebeu que faltava “:” no final dessa linha, sendo
uma caraterística da sintaxe desta linguagem.
Pedi ao aluno P. F. que fosse ao computador do professor para construir o programa
sobre a média de notas dos alunos para que os seus colegas observassem a sua construção,
uma vez que tinha resolvido no computador dele de forma correta. No entanto, ele estava pouco
à vontade para se expor perante a turma. O seu colega T. B. incentivou-o dizendo-lhe para não
ser tímido, levando-o a realizar a tarefa sob minha orientação e esclarecimento.
Em termos de comportamento, à exceção de P. F., R. B. e J. L., os alunos portaram-se
bastante mal nestas duas aulas, fazendo muito barulho.
Já muito próximo do final do segundo bloco, os alunos estavam bastante desatentos e
barulhentos. Para que eles acalmassem informei-os de que ia enviar-lhes por email três
problemas para T.P.C., que seguiam o modelo dos anteriores. Pedi que me enviassem o
trabalho para o meu email. Para atingir esse objetivo pedi que cada um dos alunos me enviasse
email para criar pastas individuais no Google Drive partilhando com cada um deles, onde
colocariam os exercícios resolvidos. Essas pastas partilhadas foram criadas nesse dia depois da
aula.
Reflexão sobre a aula4 e a aula 5
No final destas aulas o que mais me preocupou foi a atitude inflexível que os alunos P. M
e J. R. tiveram em relação ao desinteresse pelas matérias que eram lecionadas. Questionei-me
se existe alguma forma de motivar estes alunos.
45
O aluno P.F. demonstrou interesse e teve bom comportamento. Se não fosse um aluno
tímido, se estivesse à vontade quando era necessário ser participativo, seria um aluno exemplar.
J. F e T. B. demonstraram bastante autonomia, o que é positivo, quando pesquisavam
informação, no entanto faziam-no quando deviam estar atentos a pormenores importantes da
linguagem, perdendo essa informação.
Aula 6 e aula 7
Neste dia de aulas a disciplina de PSI era composta por dois blocos de 90 minutos.
No primeiro bloco estiveram presentes cinco alunos e no segundo bloco estiveram na
mesma cinco alunos. Três dos alunos que tiveram falta, foi por terem sido mandados para a rua,
sendo referido a seguir o motivo nos resultados do primeiro bloco.
Os objetivos que se pretendiam com estas duas aulas eram:

Entender os conceitos da linguagem;

Saber trabalhar com os comandos if/elif/else;

Saber trabalhar com o comando while.
No início do primeiro bloco, chamei a atenção do aluno T. B. porque estava
constantemente a interromper para colocar questões sobre assuntos da linguagem Python que
viriam a ser lecionados mais à frente. Uma vez que isso atrapalhava o acompanhamento de
quem tinha mais dificuldades, ele aceitou e compreendeu a chamada de atenção.
Interpelei a turma pelo facto de não me terem enviado os exercícios resolvidos que lhes
forneci para resolverem em casa. O aluno P. F., que era um dos alunos mais aplicados na aula,
respondeu que não fazia T.P.C.’s.
No primeiro bloco
Os alunos estiveram a resolver um exercício que exigia raciocínio, referente à matéria da
aula anterior, utilizando os comandos if/elif/else. Consistia em calcular o valor que uma pessoa
deveria pagar por um bilhete de cinema, analisando a idade do cliente e ao mesmo tempo o dia
da semana, fazendo o desconto de uma dada percentagem conforme o caso, como se pode
verificar na tabela seguinte:
46
Tabela 4 - Problema “Promoções no cinema”
De
Segunda
(2,3,4 e 5)
Acima de 65 ou abaixo de
12 anos
Entre 12 e 65 anos
a
Quinta Sexta, Sábado e Domingo
(6,7 e 1)
60%
40%
35%
5%
Expliquei a mecânica do problema no quadro, para entenderem, e depois acompanhei
pelos lugares. Como tiveram algumas dificuldades, passei a resolver no computador do professor
projetando e questionando. T. B., J. F. e J. L. foram dizendo instruções de código conforme se ia
construindo o programa e segundo Arends (1995) “O discurso é uma via para os alunos
praticarem os seus processos de pensamento e assua competências de raciocínio.” (p. 416)
Quatro dos resultados da compilação de um programa que resolve este problema seriam
os seguintes:
47
Figura 11 - Compilação do programa sobre o problema "Promoções no cinema"
Resultados do primeiro bloco
No final do primeiro bloco gerou-se confusão com bastantes risadas, por mau
comportamento, assim sendo o professor cooperante resolveu mandar três alunos para a rua,
autores dessa confusão. A partir daí no resto desta primeira aula e na segunda aula ficaram
mais tranquilas. Quatro dos cinco alunos foram resolvendo o problema enquanto eu os
acompanhava ajudando a perceber algum erro de compilação, exceto J. N. que foi quem
trabalhou menos. Este aluno trabalhava depois de eu lhe exercer bastante pressão e insistir com
ele.
No segundo bloco
No segundo bloco comecei por introduzir matéria relativa ao ciclo While, apresentando a
sintaxe e exemplos de utilização. Por ser um ciclo define-se como sendo uma instrução de
48
repetição, que repete uma sequência de comandos enquanto uma expressão booleana (uma
expressão que testa uma condição) é avaliada como verdadeira.
Resultados do segundo bloco
Ao apresentar um exemplo de um programa utilizando o ciclo while, questionei a turma
sobre qual seria o resultado, logo o aluno T. B. responde prontamente de forma acertada. De
seguida passaram a resolver exercícios. Os dois primeiros por terem um baixo grau de
dificuldade, foram resolvidos com pouca ajuda. Pedi ao aluno T. B. para ir ao computador do
professor resolver o exercício que soma N (valor introduzido pelo utilizador) números (estes
também introduzidos pelo utilizador) e calcula a sua média. Pedi que explicasse ao mesmo
tempo, então ele explicou com uma atitude de imitação de um professor.
Um resultado da compilação de um programa que resolve este problema pode ser:
Figura 12 - Compilação do programa sobre o problema "Soma e média de um conjunto de números"
Os três últimos exercícios referentes à matéria do ciclo while enviei por email para o email
dos alunos (uma vez que existiam um email da turma) para que colocassem nas pastas
partilhadas que criei no dia anterior. No final da aula o professor cooperante disse que não valia
a pena enviar exercícios para T.P.C., uma vez que eles não faziam trabalhos de casa.
Reflexão da aula 6 e da aula 7
Não estando presentes na aula os alunos que fazem mais confusão, os restantes
trabalharam melhor e criou-se um ambiente mais tranquilo, ou seja houve mais rendimento.
Esses alunos acabavam por levar os outros a distrações.
Considero preocupante que estes alunos não tenham criado hábitos de levar trabalhos
para casa, resolvendo-os. Nesta fase seria difícil pensar em mudar os seus hábitos, talvez com
mais tempo de intervenção pedagógica isso tivesse sido possível.
49
Aula 8
Neste dia de aulas a disciplina de PSI era composta por 1 bloco de 90 minutos.
Apenas estiveram presentes os alunos P.F., T.B., J.N., J. L. e R.S.
Esta aula foi assistida pelo colega estagiário Ricardo Carvalho.
Os objetivos que se pretendiam com esta aula eram:

Entender os conceitos da linguagem;

Saber trabalhar com strings;

Saber utilizar os operadores + e *;

Saber utilizar o comando raw_input.
Nesta aula iniciei a matéria relativa às strings. Estas são sequências de carateres
imutáveis, ou seja, não é possível adicionar, remover ou modificar carateres.
Depois de apresentar a definição, alguns exemplos de utilização e o comando raw_input,
o aluno T. B. pediu que lhe explicasse a diferença da utilização deste comando e do comando
input. Expliquei no quadro exemplificando que o comando input retorna números inteiros e
números de vírgula flutuante e o comando raw_input retorna Strings. Para que este comando
possa retornar números, deve-se colocar antes deste comando, o comando int ou o comando
float, ou seja o comando raw_input serve para retornar os três tipos de dados e o comando input
só retorna números.
A seguir apresentei o exercício que deveriam resolver, onde se pretendia que
construíssem um programa para dar como resultado informações sobre a turma deles, tendo o
seguinte enunciado:
Figura 13 - Enunciado do problema "Exame da turma"
50
Estava pensado para ser resolvido em grupo, uma vez que era um problema mais
complexo, envolvendo vários parâmetros; no entanto estavam cinco alunos na sala, assim sendo
considerei que não seria adequado, passando a ser resolvido individualmente.
Resultados desta aula
O aluno P. F. foi o aluno que trabalhou mais e com algum apoio resolveu o exercício
apresentado na íntegra. Acabou por me surpreender, quando ao construir o programa, ao
inicializar as variáveis, o fez da forma mais otimizada (ou seja, mais comprimida). Verificou-se
que é um aluno atento, uma vez que este foi um assunto lecionado na primeira aula. O aluno T.
B. esteve também aplicado, mas menos que o aluno P. F., uma vez que alterna trabalho com
conversa. O professor cooperante esteve a construir o programa com ele, com alguma
controvérsia porque o aluno T. B. queria resolver de forma diferente e não aceitava a forma
como o professor cooperante estava a fazer. Eu intervim dizendo que um programa pode ser
feito de várias formas diferentes, cada um tem a sua maneira de resolver. Relativamente a esta
ideia Jonassen (2007) refere que o professor “Deve tornar-se mais recetivo na aceitação de
diferentes perspetivas e interpretações do mundo e, talvez, permitir aos alunos que desafiem as
suas perspetivas enquanto defendem as deles.” (p. 303).
O aluno J. N. foi o que trabalhou menos. Sempre demonstrou pouco interesse em
trabalhar, mesmo tendo-o eu acompanhado no lugar tentando que fizesse algo. Mesmo assim,
sempre acabava por fazer pouco.
Os alunos J. L. e R. S. trabalharam alternando com distrações.
Reflexão sobre a aula 8
Depois do acompanhamento aos alunos, conclui que os que demonstraram maior
interesse e trabalharam mais, foram os que aprenderam mais. Verifiquei que não é fácil colocar
a trabalhar alunos que não estão interessados em aprender, como é o caso de J. N., que só
trabalha depois de ser pressionado.
Uma vez que o problema apresentado era mais complexo do que aqueles que foram
apresentados até ao momento, considero então que deveria ter sido realizado em grupo e assim
podendo haver mais produtividade em termos de trabalho e aprendizagem.
Aula 9 e aula 10
51
Neste dia de aulas a disciplina de PSI era composta por dois blocos de 90 minutos.
No primeiro bloco estiveram presentes 7 alunos.
No segundo bloco estiveram seis alunos.
Os objetivos que se pretendiam com estas duas aulas eram:

Entender os conceitos da linguagem;

Saber fazer interpolação com strings.
Retomou-se o exercício/programa da aula anterior, sobre alunos de uma turma utilizando
Strings, mas de um modo mais elaborado e com varias etapas. Pretendia-se saber a
percentagem de rapazes, a percentagem de raparigas, a média das notas das raparigas, a
média das notas dos rapazes, quem foi a rapariga que tirou melhor nota e o rapaz que tirou
melhor nota. Como a maioria dos alunos não conseguiu completar, comecei a aula a resolver
este exercício no computador de forma interativa, projetando para os alunos poderem
acompanhar, questionando-os sobre o código a colocar.
Um dos resultados de compilação poderia ser o seguinte, para uma turma de três alunos.
Figura 14 - Compilação do programa sobre o problema "Exame da turma"
52
Resultados do primeiro bloco
Apenas o P. F. tinha completado esse exercício na aula anterior. O J. R. costumava ser um
aluno que sempre se recusava a trabalhar e que falava muito para o lado; no entanto, ao
questioná-lo no preenchimento do código, ele respondia de forma razoavelmente acertada. O T.
B. tinha construído o programa na aula anterior com o professor cooperante ao lado dele,
ajudando-o a fazer o exercício, mas sempre insistindo em fazer à sua maneira. Portanto o que
aconteceu nesta aula foi que o T. B. resolveu não tomar atenção e usar a internet para outros
fins, uma vez que já não lhe interessava este exercício. Tenho consciência que nesta aula
poderia ter agido de forma diferente com este aluno. Com efeito, por ser um aluno que de uma
forma geral tinha bastante rendimento, entendi que deveria preparar para esse aluno exercícios
extra para que ele resolvesse e não se distraísse com outros assuntos. No final da aula falei com
ele e disse-lhe que faria tudo o possível para que não voltasse a acontecer esta situação. Levarlhe-ia exercícios extra de modo a mantê-lo ocupado. Depois de concluído o programa, alguns
alunos foram ao computador do professor experimentar a execução do programa, entre eles o
aluno J. R., que introduziu a informação com correção e humor. Todos mostraram gostar da
experiência.
No segundo bloco mostrei como funcionava a interpolação nas strings. Por exemplo
quando se pretende apresentar a tabuada de um número como resultado, sem esta técnica de
formatação ficaria da forma que se pode observar no exemplo a seguir:
Figura 15 - Compilação do programa sobre o problema "Tabuada sem formatação"
Com esta técnica de formatação ficaria desta forma:
53
Figura 16 - Compilação do programa sobre o problema "Tabuada com formatação" com dois dígitos
É uma técnica que permite imprimir um resultado com um aspeto formatado, ou seja,
encosta à esquerda o número de dígitos máximo que pode atingir o resultado, de forma que os
carateres estejam todos alinhados (neste exemplo, observa-se o carater ‘=’). O máximo que pode
dar o resultado da tabuada é o valor 100, tendo três dígitos, como se pode observar a seguir:
Figura 17 - compilação do programa sobre o problema "Tabuada com formatação" com três dígitos
Resultados do segundo bloco
Os alunos resolveram dois exercícios, o primeiro foi mais simples, apenas os acompanhei
pelos lugares conseguindo todos resolver o exercício exceto T. B. O segundo programa devia
imprimir a tabuada de um número usando interpolação, exercício que estava previsto na matéria
do ciclo while acabando por não ser resolvido nessa aula. Este exercício resolvi-o no computador
de forma interativa questionando os alunos, o aluno J. L. foi o que mais participou nas
respostas. J. A. também respondeu, mas demonstrou mais dificuldades. P. F. percebeu bem a
mecânica e resolveu os problemas com pouca ajuda, no entanto não participou, tendo
dificuldades nesse sentido.
54
O J. L. é um aluno que sempre foi razoável, de um ponto de vista geral, portanto vinha a
melhorar o interesse pelas matérias e notou-se que estava a melhorar a aprendizagem da
linguagem Python.
Reflexão sobre a aula 9 e a aula 10
O facto de interagir com os alunos, questionando-os, resulta com alguns deles,
principalmente os que menos trabalham, fazendo com que estejam mais ativos e interessados
pelos assuntos da aula, como é o caso de um deles que desta forma se mantém mais atento. Já
outro aluno, tímido, que costuma estar atento quando são apresentados os conteúdos e sempre
interessado em resolver os exercícios, não se mostra interessado quando envolve interação.
Como os alunos são diferentes na sua forma de estar, a solução é ir ao encontro de cada
situação e tentar proporcionar uma aprendizagem adequada a cada caso.
Como referi em cima, o aluno T.B. nesta aula não esteve bem, logo resolvi que nas aulas
seguintes iria atuar de forma diferente.
Aula 11 e aula 12
Neste dia de aulas a disciplina de PSI era composta por dois blocos de 90 minutos.
No primeiro bloco estiveram todos os alunos presentes. No segundo bloco faltou R. S.
Os objetivos que se pretendiam com estas duas aulas eram:

Entender os conceitos da linguagem;

Saber indexar utilizando strings;

Saber qual a ordem dos carateres na tabela ASCII;

Saber utilizar os métodos existentes na biblioteca do Python na resolução de
exercícios;

Saber fatiar/slicing strings.
No primeiro bloco
Gerou-se bastante confusão, de modo que o professor cooperante decidiu mandar para
rua três alunos, P. M., J. F. e J. R..
O tema da aula foi a continuação do tipo de dados strings. Expliquei a indexação nas
strings exemplificando, como era utilizado o método len e dando exemplos de utilização.
55
Apresentei as características da tabela ASCII, verificaram os códigos de cada carater utilizando a
internet, onde cada carater tem um valor associado, por exemplo nos carateres do alfabeto de
“a” para “z” o valor vai aumentando.
De seguida resolveram o exercício utilizando o conceito de ordem da tabela ASCII. O que
se pretendia era que, dada uma frase fossem contadas as letras maiúsculas, as minúsculas e os
algarismos. Para ajudar a perceber o problema fiz um esboço do problema no quadro. Um dos
resultados da compilação de um programa que resolva este problema pode ser o que se observa
a seguir:
Figura 18 - Compilação do programa sobre o problema "Contador de carateres"
Também apresentei os métodos mais utilizados da classe String, que estão definidos
nessa biblioteca facilitando quando for necessário trabalhar com strings. Fiz demonstrações,
onde sugeri que me acompanhassem para perceberem melhor o funcionamento e mostrei como
pesquisar outros métodos dessa classe.
No segundo bloco
Apresentei slicing sobre strings com algumas demonstrações, questionando quais seriam
os resultados. O slicing utiliza a indexação das strings, sabendo que o índice do primeiro carater
começa em zero e termina em comprimento da string menos um, isto do início para o fim. Se
percorrer a string do fim para o início, o último carater tem valor -1, até ao primeiro que tem o
valor do comprimento da string, mas negativo. Pode-se observar um exemplo na imagem
seguinte:
Figura 19 - Exemplo de indexação em strings
56
O slicing consiste em fatiar a string, em que podem ser definidos como parcelas, da forma
[inicio : fim + 1 : intervalo]. Se não for definido o início, será considerado como zero. Se não for
definido o fim + 1, será considerado o tamanho do objeto. O intervalo (entre os caracteres), se
não for definido, será 1. Os exemplos seguintes, utilizando a string “Python”, mostram algumas
situações diferentes de como se pode aplicar.
Figura 20 - Exemplos de utilização de slicing sobre strings
De seguida, os alunos estiveram a resolver exercícios utilizando slicing e métodos da
classe String. Acompanhei aluno a aluno, para ver se estavam a conseguir resolver.
Um dos problemas que foi resolvido, em que o programa pedia o nome do utilizador,
dando como resultado o nome em maiúsculas e em formato de escada, como se pode verificar
pelo resultado da compilação desse programa:
57
Figura 21 - Compilação do programa sobre o problema "Nome em escada"
Resultados destas duas aulas
O aluno P. F. demonstrou mais empenho em resolver o exercício referente à tabela ASCII.
Em relação aos problemas que utilizavam slicing, este aluno teve mais dificuldade, assim sendo
tive que dar algum apoio.
J. R. não acompanhou e estava falador como era costume. T. B. resolveu fotografar o slide
dos exemplos do slicing, no entanto referi que iria ceder as apresentações.
J. F. e J. L. estavam a tentar resolver com alguma dificuldade, acabei por lhes dar
algumas indicações para os ajudar na resolução.
O aluno P. M. voltou para a aula e o professor cooperante sentou-se ao lado dele tentando
ajudá-lo a construir um destes programas utilizando slicing, no entanto, a resolução sugerida
pelo professor cooperante não estava a ser compreendida pelo aluno. Por isso, apresentei a
minha solução mais simplificada no computador do professor. Todos os alunos verificaram o
resultado e ao mesmo tempo corrigiram os seus programas.
R. B. nas primeiras aulas ia trabalhando alternando com alguma distração, nesta aula
trabalhou menos e quando fez correr o programa anterior, utilizou uma frase com conteúdo
desadequado, para fazer piada.
Os alunos J. R. e J. N. não trabalharam absolutamente nada. Mais ainda, J. R. foi um dos
alunos que sempre se recusou a trabalhar e quase sempre esteve distraído e a falar com o
colega do lado.
Reflexão sobre a aula 11 e a aula 12
Embora estes alunos tivessem conhecimentos de programação, o tema slicing era algo
novo para eles, uma vez que nunca tinham utilizado noutras linguagens e por esse motivo
58
existiram algumas dificuldades por parte dos alunos que estavam a tentar construir o programa.
Dos que nem tentaram, não é possível falar em dificuldades.
O aluno R. B. até ao momento era um aluno que trabalhava, embora falasse às vezes para
os colegas do lado, tinha um comportamento razoável de acordo com o que era habitual nesta
turma, neste dia surpreendeu pela negativa.
O aluno J. R. no dia de aulas anterior foi participativo quando questionado, por isso neste
dia acreditava que estivesse mais motivado para desenvolver os programas. No entanto,
continuava a manter a atitude inflexível em relação ao trabalho.
Aula 14
Neste dia de aulas a disciplina de PSI era composta por dois blocos de 90 minutos.
O que diz respeito ao primeiro bloco é descrito a seguir.
Faltou apenas o aluno P.F.
Os objetivos que se pretendiam com esta aula eram:

Entender os conceitos da linguagem;

Saber trabalhar com listas de tamanho indefinido, utilizando os métodos len, del e
append.
Neste bloco
Os alunos estiveram a construir programas sobre Strings e sobre listas de tamanho
definido, que não foram resolvidos anteriormente e que envolviam noções importantes que
considerei necessário experimentar e perceber.
Fiz esboços no quadro para entenderem e resolvi-os no computador do professor
projetando-os de forma interativa e ao mesmo tempo questionando qual o código a colocar.
Num dos problemas utilizando strings, era pretendido que se construísse um programa
que recebia uma sequência de carateres do utilizador, inclusive frases, e se testasse se essa
sequência era um palíndromo, ou seja, a sequência era igual da esquerda para a direita e da
direita para a esquerda, ignorando os carateres de pontuação e espaços.
Estes podem ser resultados da compilação de um programa que resolve esse problema:
59
Figura 22 - Compilação do programa sobre o problema "Teste de palíndromo"
Noutro problema que foi resolvido, utilizando listas de tamanho definido, pretendia-se
converter um número inteiro entre 1 e 3999 em numeração romana. Sendo listas de tamanho
definido, uma lista continha um conjunto de valores possíveis em numeração romana (atómicos
e os que tem carater de menor valor à esquerda) e a outra continha os números inteiros
associados.
Um dos resultados da compilação de um programa que resolve este problema:
Figura 23 - Compilação do programa sobre o problema "Inteiro para romano"
Resultados deste bloco
Voltei a questionar o aluno J. R., que habitualmente não desenvolve os programas no
computador dele. Desta vez, ao fazer-lhe as perguntas, ele respondeu e demonstrou capacidade
de aprendizagem.
T. B. e J. F deram algumas ideias para a construção dos programas; já era habitual serem
participativos, e quase sempre de forma acertada. R. B. também acrescentou um pormenor no
código do programa que utilizava strings.
Reflexão sobre a aula 14
Cheguei à conclusão que o aluno J. R. apenas se envolve nos assuntos da aula quando
questionado, quanto a trabalho desenvolvido continuava a recusar-se. O aluno R. B. também
60
passou a ser mais interessado pelos assuntos da aula desta forma interativa, passando a ser
mais preguiçoso no momento de desenvolver trabalho.
3.4.4 Aula 13, aula 15 e aula 16 - Aulas assistidas
Aula 13
Neste dia de aulas a disciplina de PSI era composta por 1 bloco de 90 minutos.
Não faltou nenhum aluno.
Esta aula foi a primeira aula assistida pelos supervisores, a professora Altina Ramos e o
professor Bento Silva. Esteve presente o colega Ricardo Carvalho, também estagiário do
professor cooperante numa outra turma.
Estava bastante nervosa por ser a primeira aula assistida por dois supervisores e também
porque era o primeiro contacto com a professora Altina.
Os objetivos que se pretendiam com esta aula eram:

Entender os conceitos da linguagem;

Saber trabalhar com listas;

Saber utilizar os operadores + e *;

Saber fazer alteração e inserção de valores numa lista de tamanho definido.
Nesta aula dei início à matéria sobre listas, que se definem como sendo sequências de
objetos que podem ser de qualquer tipo, inclusive outras listas e também podem conter
diferentes tipos de dados (int, float, string, lista) em simultâneo, sendo esta uma caraterística do
Python. São mutáveis, ou seja, é possível fazer alterações, ao contrário das strings.
Apresentei também as suas caraterísticas, a sintaxe, exemplificando e ao mesmo tempo
interagindo com os alunos, questionando-os acerca do resultado dos programas exemplificados.
O aluno T.B. ia respondendo. Apresentei exercícios para resolverem e comecei por resolver o
primeiro no computador do professor com projeção, para ajudar a entender, questionando os
alunos acerca do código que deveria colocar. Na construção do programa, o professor
cooperante deu uma sugestão para otimizar o código, de forma que o programa fizesse a
impressão dos resultados omitindo elementos desnecessários.
61
O que se pretendia com este programa era que ao receber 10 carateres, introduzidos pelo
utilizador, deviam ser colocadas as consoantes numa lista, assim dar como resultado a sua
quantidade e imprimi-las.
Questionei o J. A. sobre um assunto de sintaxe e ele respondeu acertadamente. O aluno
T. B. participou na construção do programa e questionou o porquê de certo código, então eu
expliquei.
O resultado da compilação de um programa que resolve este problema pode ser da
seguinte forma:
Figura 24 - Compilação do programa sobre o problema "Conta e imprime consoantes"
A seguir pedi que resolvessem outro problema, idêntico ao anterior, que recebe do
utilizador 10 números inteiros e os coloca numa lista, imprimindo a soma dos quadrados desses
números. Fui acompanhando pelos lugares e observando como estavam a resolver, ao mesmo
tempo questionava os seus códigos para que tivessem a noção se iam no caminho certo.
Observa-se a seguir um resultado possível de um programa que resolve este problema:
62
Figura 25 - Compilação do programa sobre o problema "Soma quadrados"
Resultados desta aula
O aluno P. F. que tinha sido até ao momento um aluno que estava acima da média da
turma, sempre sossegado e que mostrava sempre mais empenho em trabalhar, nesta aula não
estava a trabalhar. Falei com ele orientando-o para a forma de resolver o problema, no entanto
ele recusou-se a trabalhar.
Decidi pedir ao aluno J. F., sendo este um aluno pouco inibido e que tem boas
capacidades de compreensão, para que fosse ao computador do professor resolver este
programa, projetando para os outros alunos acompanharem. Ele não aceitou, demonstrando
alguma inibição nesta aula. Depois, pedi ao aluno J. N. que fosse ele, informei-o que ajudava na
construção do programa, então ele aceitou. O professor cooperante, os alunos T. B. e J. F.
davam sugestões de código.
Os alunos que não trabalharam absolutamente nada foram o P. M., J. R. e R. S. O aluno
R. S. normalmente ia trabalhando alguma coisa durante as outras aulas, nesta deixou-se levar
pelas distrações dos alunos P. M. e J. R.
Os alunos que estiveram mais empenhados foram T. B. e J. F., pela forma como
acompanharam e resolveram os problemas, não alternando com conversa como era habitual.
Reflexão sobre a aula 13
Questiono o porquê de o aluno P. F. não trabalhar nesta aula, seria por ter receio de ser
convidado a participar ou a ir ao computador do professor resolver o exercício, isto por estarem
pessoas a assistir?
63
O aluno J. N. esteve muito bem ao ir ao computador do professor construir o programa,
demonstrou segurança e dedicação. Apenas lamento que ele não desenvolva trabalho no
computador dele.
Aula 15
Esta foi a segunda aula/segundo bloco do dia 27 de janeiro de 2014, sendo a segunda
aula assistida pelos supervisores Altina Ramos e Bento Silva.
Estiveram presentes cinco alunos, J. F., J. A., J. N., J. L. e R. S.
Os objetivos que se pretendiam com esta aula eram:

Entender os conceitos da linguagem;

Saber trabalhar com listas de tamanho indefinido, utilizando os métodos len, del e
append.
Neste bloco
O tema da aula do segundo bloco foi listas de tamanho indefinido. Neste caso a lista vai
sendo construída ao longo da execução, partindo da lista vazia, utilizando para isso métodos
existentes na classe list.. Mostrei como funcionavam, apresentei os métodos mais utilizados para
construir essas listas e dei exemplos de utilização, onde questionava os resultados do código no
interpretador do Python, e também apresentei outros exemplos de código onde questionei os
resultados.
De seguida passou-se à resolução de problemas. O primeiro foi mais simples, pretendia-se
que fosse construída uma lista de nomes e ao imprimir devia ser colocado ao lado do nome o
número de letras de cada nome. Eles resolveram nos seus computadores, enquanto eu
acompanhava e dava apoio.
O problema seguinte foi sobre a investigação de um crime, tema que considerei
interessante para os motivar.
O enunciado do problema era o seguinte:
64
Figura 26 - Enunciado do problema "Investigação do crime"
Dois dos resultados da compilação do programa podem ser da seguinte forma:
Figura 27 - Compilação do programa sobre o problema "Investigação do crime"
Num dado momento reparei que o aluno J. F. estava a visualizar esta apresentação que
eu ainda não tinha disponibilizado aos alunos, fiquei surpreendida, então o professor cooperante
referiu que tinha colocado na pasta partilhada com os alunos.
65
A seguir pedi a este aluno para ir ao computador do professor construir o programa do
crime, ele aceitou e explicou o código, ao mesmo tempo que era projetado para o resto dos
alunos.
Resultados deste bloco
Quando questionado, o aluno J. F. respondia de forma acertada.
No primeiro programa desenvolvido, o aluno R. S., que sempre teve dificuldades, e
também o aluno J. A. conseguiram resolver com alguma orientação.
Em relação ao segundo programa, os alunos J. A. e J. L. resolveram com empenho. O
aluno R. S. tentava fazer, no entanto ia copiando algum código pelo colega J. L. No momento
que chegava junto ao aluno J. N., ele fazia alguma coisa, quando me afastava já não fazia mais
nada. Disse-lhe que tinha bastantes capacidades, considerando lamentável não as colocar em
prática. O aluno J. F. também conseguiu resolver, fazendo alguns erros, no entanto conseguiu
completar depois de ser esclarecido.
No final desta aula foram feitos alguns comentários pelos supervisores, onde referiram
que as minhas aulas tinham sido muito expositivas. Declarei que alternava com interação,
questionando os alunos e fazendo experimentar algum código. O professor Bento criticou por
haver falta de história para cativar no exercício sobre o crime. Considerei que por ser um
exercício onde havia a investigação de um crime, por si só já ajuda a motivar.
Reflexão sobre a aula 15
Nesta fase verifiquei que o aluno J. A. estava a melhorar em termos de empenho de forma
progressiva ao longo das aulas, com isto notou-se que ele estava a aprender.
O aluno J. N. tem dificuldades em aprender por ser bastante preguiçoso, tenta resolver os
problemas à custa de muita pressão, e não consegui que desenvolvesse mais as suas
capacidades.
Aula 16
Neste dia de aulas a disciplina de PSI era composta por dois blocos de 90 minutos, no
entanto só houve a aula do primeiro bloco.
Faltaram três alunos, J. F., J. R. e P. M.
66
Esta foi a terceira e última aula assistida pelos supervisores Altina Ramos e Bento Silva.
Também esteve presente o colega estagiário Ricardo Carvalho.
Os objetivos que se pretendiam com esta aula eram:

Entender os conceitos da linguagem;

Saber trabalhar com slicing em listas;

Saber utilizar os métodos da classe list;

Saber pesquisar métodos na classe list;

Saber utilizar o método randint da classe random.
Os alunos que vieram à aula chegaram bastante atrasados, no entanto o professor
cooperante comentou que era normal por ser hora de almoço e também iam ter visita de estudo
a seguir a esta aula.
Depois da crítica à utilização de exposição por parte dos supervisores, nesta aula resolvi
fazer alterações no método de ensino que estava a utilizar, abdicando da apresentação
PowerPoint. Mantive o conteúdo que estava programado, contudo utilizando o interpretador do
Python para fazer demonstrações de exemplos.
Comecei por exemplificar o slicing sobre listas. Foi criada uma lista com nomes de
animais do Jardim Zoológico, onde pedi aos alunos para dizerem nomes para inserir na lista.
Chegaram a sugerir nomes invulgares, como “Suricata”, sugestão do aluno R. B. Fui
questionando os resultados dos testes de slicing na linha de comandos.
De seguida passei a mostrar alguns métodos dos mais utilizados da classe list, também
mostrei alguns exemplos de utilização e a pesquisa de outros métodos que possam interessar
para programas que estejam a desenvolver. Assim, os alunos ficaram a saber como podem
procurar aquilo que pretendem da classe list.
Também demonstrei como se trabalha com aleatoriedade, uma vez que seria útil para o
programa que iam desenvolver a seguir.
Depois de observar os alunos nas aulas a que assisti, verifiquei que estavam bastantes
vezes a jogar jogos de futebol no computador. Para motivar resolvi planear e construir um
programa que tinha como tema jogos de futebol, com o objetivo de criar jornadas de futebol.
Este programa envolve várias etapas na sua construção, que estão enumeradas pela seguinte
ordem:
67
1º O utilizador insere um número par de equipas;
2º O utilizador insere as equipas;
3º Aleatoriamente com essas equipas cria-se pares de equipas para jogar;
4º O utilizador insere o número de remates para cada equipa e para cada remate é
gerado um valor aleatório entre zero e um (zero significa que não foi golo e um significa que foi
golo);
5º São apresentados os golos de cada equipa;
6º No final, o programa apresenta a equipa que venceu, ou então se tiveram o mesmo
número de golos diz que as equipas empataram.
O código deste programa encontra-se em anexo.
68
Um dos resultados da compilação de um programa que resolve este problema:
Figura 28 - Compilação do programa sobre o problema "Jornada de futebol"
Passei a explicar no quadro a ideia para o início o programa. Os alunos foram colocados
em grupo, formou-se um grupo de três alunos e dois grupos de dois alunos. Acompanhei pelos
lugares um a um e observava a forma como estavam a desenvolver.
Resultados desta aula
69
Ao questionar os testes de slicing na linha de comandos, verificou-se que os alunos foram
bastante participativos entre eles o aluno R. B. que em aulas anteriores não estava interessado
em dar atenção aos assuntos da aula.
Verifiquei que estavam com bastantes dificuldades. O aluno J. N. estava no grupo de três,
mas não estava empenhado em ajudar os colegas. Os alunos T. B. e R. S. estavam a avançar na
resolução, graças ao aluno T. B. que tinha menos dificuldades. O aluno J. L. estava empenhado
mas com bastantes dificuldades e o aluno R. B. estava ao seu lado, mas não se esforçava para
ajudar na construção do programa.
Resolvi pedir ao aluno R. S. para ir ao computador do professor construir o programa e
mostrar para os seus colegas. Ele recusou-se a ir, mas o professor cooperante exigiu que ele
fosse. Então foi e começou a construir o programa com algumas orientações, entretanto deu o
toque de saída e não foi possível completar. Ficou o professor cooperante de o completar na
aula seguinte.
No final da aula foram-me apresentadas críticas pelos supervisores. A professora Altina
referiu que tinha escrito de forma errada a palavra “Orangotango”. O professor Bento voltou a
referir que faltou uma história para cativar, antes de iniciar a construção do programa e também
que fiz uma má gestão do tempo. Acrescentaram que fiz bem em alterar a forma de dar a aula,
mas que mesmo assim ainda tinha sido expositiva.
Para justificar a falta de uma história, referi que tenho pouca cultura de futebol, para estar
à-vontade em contar histórias referentes a esse tema.
Entendo que esta aula foi pouco expositiva, foi mais interativa e demonstrativa e também
considero que a exposição ajuda a entender melhor alguns conceitos.
Reflexão sobre a aula 16
Dos alunos presentes na aula, aqueles que mostraram interesse nas matérias e estavam a
aprender, foram os alunos P. F., J. A., J. L. e T. B, pela forma como se empenharam em
trabalhar.
O aluno R. B. esteve bem no momento em que foram convidados a participar, uma vez
que foi mais participativo.
70
Considero que o problema que apresentei era de um grau de dificuldade bastante
elevado, daí os alunos apresentarem dificuldades em construir este programa. Com efeito, penso
que deveria ser construído ao longo de mais de uma aula.
Considero ainda que não foi fácil gerir o tempo da aula, uma vez que os alunos entraram
bastante atrasados.
As planificações destas três aulas assistidas encontram-se em anexo.
3.4.5 Reflexão final
O aluno R. B. era um aluno que nas primeiras aulas interessava-se em trabalhar, depois
de faltar algumas vezes, nas aulas seguintes tornou-se mais desinteressado e não adiantava
aproximar para tentar ajudar, que ele não estando interessado, ateimava em não trabalhar,
chegando a responder de forma arrogante ao professor cooperante.
O aluno R. S. nunca foi muito autónomo no seu trabalho precisando constantemente de
apoio pois tinha bastantes dificuldades.
Os alunos P. M. e J. R. nunca estiveram interessados em trabalhar, apesar das várias
tentativas, sempre se recusaram, preferiam a diversão e a conversa. Em relação a estes casos
Ausubel (1980) refere que “Alunos que têm pouca necessidade de saber e compreender
naturalmente exercem relativamente pequeno esforço para aprender.” (p. 335)
O aluno J. F. e o aluno T. B eram conversadores, no entanto iam trabalhando,
conseguindo perceber facilmente como resolver os problemas.
O aluno J. N. nunca esteve interessado em aprender, apenas trabalhava alguma coisa
depois de eu exercer bastante pressão.
O aluno P. F. foi sempre um aluno empenhado em trabalhar, exceto na primeira aula
assistida, situação para a qual não encontrei explicação. Mantinha-se discreto na sua secretária
e geralmente não se deixava levar por distrações. Destoava da média da turma em termos de
comportamento e dedicação ao trabalho, uma vez que esta turma era visada pelo seu mau
comportamento.
Em relação ao aluno J. L., este manteve-se um aluno linear em termos de comportamento
e aproveitamento, ia desenvolvendo trabalho alternando com algumas distrações e conversa,
contudo não era um aluno que perturbasse o ritmo da aula.
71
Finalmente, no que se refere ao aluno J. A., este era um aluno que se distraia bastante,
tanto com jogos de computador como com conversa, desde as aulas observadas. Embora
envolvendo-se em algumas distrações ocasionalmente foi evoluindo ao longo das aulas,
passando a desenvolver cada vez mais trabalho e tornando-se mais interessado pelas matérias.
3.5 Análise da intervenção
Uma vez que terminei a minha intervenção aproximadamente a meio do módulo não tive
oportunidade de aplicar avaliação aos alunos, isto porque esta apenas é realizada no final de
cada módulo. Com efeito, apliquei um questionário online no final da minha intervenção para
verificar as aprendizagens concretizadas até aquele momento. Este questionário encontra-se em
anexo. As questões foram as que se apresentam a seguir:

Qual o teu nome e apelido?

Tiveste alguma dificuldade na linguagem Python?

Se respondeste “sim” à questão anterior enumera a (s) tua (s) dificuldade (s):
o Operadores (aritméticos/lógicos)
o Variáveis
o Ciclo while
o Strings
o Listas

Explica de que género é (são) a (s) tua (s) dificuldade (s).
Foram seis os alunos que responderam a este questionário, uma vez que eram os alunos
presentes.
A primeira questão teve como objetivo saber quem era o aluno que tinha a dificuldade
para esta ser transmitida ao professor cooperante para que o problema fosse resolvido.
Em relação à segunda questão “Tiveste alguma dificuldade na linguagem Python?”, cinco
alunos referiram que não tinham dificuldades e um aluno referiu que tinha dificuldades.
Quanto à questão “Se respondeste “sim” à questão anterior enumera a (s) tua (s)
dificuldade (s) ”, o aluno selecionou “Listas” como a sua dificuldade.
Finalmente à questão “Explica de que género é (são) a (s) tua (s) dificuldade (s).” não
houve respostas.
72
Depois de ter realizado a minha intervenção pedagógica apliquei outro questionário online,
interrompendo uma aula que estavam a ter. Neste questionário os alunos tiveram a
oportunidade de avaliar as aulas que lecionei. Pode-se encontrar este questionário em anexo.
As questões aplicadas foram:
1. Realizei a tarefas que me foram indicadas?
2. Gostei da forma como as aulas foram lecionadas?
3. Gostei das atividades que me foram propostas?
4. A professora tirou as minhas dúvidas?
5. A professora criou um ambiente de interatividade?
6. Fiquei motivado para programar em Python?
7. Aumentei a minha autonomia no desenvolvimento de programas em Python?
Para cada questão tinha como opção de resposta a possibilidade de seleção de um dos
valores de 1 a 5 conforme a classificação que achavam adequada para essa questão.
Considerando 1-medíocre, 2-insuficiente, 3-satisfaz, 4-bom e 5-muito bom.
Responderam sete alunos a este questionário, uma vez que eram os alunos presentes no
momento.
Em relação à questão “Realizei as tarefas que me foram indicadas?”, dois alunos deram
como resposta o valor 5, quatro alunos deram resposta o valor 4 e um aluno deu resposta o
valor 3.
Resposta dos alunos à questão 1
0%
0%
Valor
14%
29%
1
2
3
57%
4
5
Gráfico 1 - Resposta à questão "Realizei as tarefas que me foram indicadas?"
73
Quanto à questão “Gostei da forma como as aulas foram lecionadas?”, cinco alunos
deram resposta cinco, um aluno deu a resposta 4 e um aluno deu resposta 3.
Resposta dos alunos à questão 2
0%
0%
Valor
14%
14%
1
2
3
72%
4
5
Gráfico 2 - Resposta à questão "Gostei da forma como as aulas foram lecionadas?"
A questão “Gostei das atividades que me foram propostas?” teve uma resposta com valor
5, quatro respostas com valor 4 e duas com valor 3.
Respostas dos alunos à questão 3
0% 0%
14%
29%
Valor
1
2
3
4
57%
5
Gráfico 3 - Resposta à questão "Gostei das atividades que me foram propostas?"
Quanto à questão “A professora tirou as minhas dúvidas?”, seis alunos deram como
resposta o valor 5 e um aluno deu como resposta o valor 4.
74
Resposta dos alunos à questão 4
0%
0% 0%
Valor
14%
1
2
3
4
86%
5
Gráfico 4 - Resposta à questão "A professora tirou as minhas dúvidas?"
Em relação à questão “A professora criou um ambiente de interatividade?”, quatro alunos
deram como resposta o valor 5 e três alunos deram como resposta o valor 4.
Respostas dos alunos à questão 5
0%
0%
0%
Valor
43%
1
2
57%
3
4
5
Gráfico 5 - Resposta à questão "A professora criou um ambiente de interatividade?"
A questão “Fiquei motivado para programar em Python?” teve três respostas com valor 5,
duas respostas com valor 4, uma com valor 3 e uma com valor 2.
75
Respostas dos alunos à questão 6
0%
14%
Valor
43%
1
14%
2
3
4
29%
5
Gráfico 6 - Resposta á questão "Fiquei motivado para programar em Python?"
Finalmente a última questão “Aumentei a minha autonomia no desenvolvimento de
programas em Python?” teve quatro respostas com valor 5, duas com valor 4 e uma com valor
2.
Respostas dos alunos à questão 7
0%
14%
0%
Valor
1
29%
57%
2
3
4
5
Gráfico 7 - Resposta à questão "Aumentei a minha autonomia no desenvolvimento de programas em Python?"
Avaliação no final do módulo
76
Foi-me fornecido o resultado da avaliação dos alunos no final do módulo, onde pude
constatar que todos os alunos da turma/turno foram aprovados, obtendo notas que variaram
entre 10 valores e 13 valores, resultando uma média de 11,1 valores.
CAPÍTULO IV – CONSIDERAÇÕES FINAIS
4.1 Conclusões
Chegando ao final deste processo, resta fazer uma análise dos resultados obtidos da
aplicação do projeto de intervenção e verificar se os objetivos previstos foram realmente
concretizados.
No que diz respeito à escolha da interatividade, fazendo um apanhado geral, entendo que dado o
género de turma em questão, por ser uma turma com problemas de comportamento e falta de
empenho na realização de tarefas, a utilização da interação foi dos melhores meios de captar a
atenção da turma para os assuntos que estavam a ser lecionados. De realçar o caso de um
aluno que se recusava a trabalhar, no entanto interagindo com ele consegui-o cativar para os
assuntos da aula. “Em sala de aula essa aprendizagem é interativa porque ocorre mediante
participação, bidirecionalidade e multiplicidade de conexões.” (Marco Silva, 2006, p. 74) Outra
forma de trabalho interativo foi serem convidados a desenvolver programas no computador do
professor com projeção para os colegas, acompanhar e ao mesmo tempo dar ideias acerca
construção do programa. Desta forma demonstravam empenho na realização da tarefa, ou seja,
notou-se que havia mais motivação e colaboração.
Quanto ao desenvolvimento de tarefas nos seus computadores, um dos alunos foi sempre
muito empenhado, no entanto não era muito recetivo à interação. Dois deles tinham bastantes
capacidades cognitivas, desenvolviam os programas, no entanto alternavam com conversa.
Houve o caso de dois alunos que evoluíram positivamente, tornando-se cada vez mais aplicados.
Dois deles trabalhavam pouco, acabando por realizar as tarefas com bastante apoio. Um deles
era um aluno que realizava as tarefas, no entanto depois de faltar três aulas, voltou com pouco
empenho em trabalhar, mas respondia quando questionado. Houve dois alunos que se
recusaram a trabalhar, mesmo insistindo e tentado dar apoio para a resolução do problema.
Quanto à realização de T.P.C. considero lamentável que os alunos se recusassem a fazer
estas tarefas, impossibilitando-me a realização deste plano.
77
Analisando as respostas ao questionário da avaliação das aulas, verifico que os alunos
consideraram que as aulas responderam aos objetivos propostos.
Considerando os resultados das respostas dadas às questões “Gostei da forma como as
aulas foram lecionadas?”, “Gostei das atividades que me foram propostas?”, “A professora tirou
as minhas dúvidas?”, “A professora criou um ambiente de interatividade?”, “Fiquei motivado
para programar em Python?” e “Aumentei a minha autonomia no desenvolvimento de
programas em Python?”, concluo que foram bastante satisfatórios, pelas percentagens de alunos
que deram valor 4 e 5 a estas respostas.
Quanto à realização de trabalhos em grupo, houve dois problemas com maior grau de
complexidade, em duas aulas distintas, que estavam planeados para serem desenvolvidos em
grupo, no entanto verificando o escasso número de alunos dentro da sala, optei por não colocar
em prática esse plano. Depois de realizada a intervenção conclui que não foi uma boa opção,
podendo mesmo assim criar grupos, nem que fosse apenas um grupo. Reconheço que foi uma
aprendizagem para mim e se vier a ter outra oportunidade não voltarei a repetir esta situação.
Com efeito, os trabalhos em grupo não foram suficientes para tornar os alunos mais
colaborativos.
Fazendo uma análise global, considero que o resultado foi positivo.
4.2 Limitações
Para que a minha intervenção pedagógica se realizasse foi necessário bastante esforço
para ultrapassar algumas dificuldades.
De entre as dificuldades, uma delas foi o facto de ser uma turma de alunos mal
comportados e com pouca vontade de trabalhar, conforme pude constatar pelas observações
realizadas e por informações recolhidas em atas do ano anterior. Foi uma turma onde tive
bastantes dificuldades em trabalhar os conteúdos, ainda assim consegui que realizassem algum
trabalho alternando com momentos de distração, perturbação de aula com bastante barulho,
trabalhando uns mais do que outros. Dois dos alunos recusaram-se sempre a trabalhar, não
tendo eu conseguindo alterar essa atitude deles.
Outra das limitações com que me deparei foi o facto de a matéria que estava combinada
com o professor cooperante para lecionar, decorreria durante o mês de janeiro, uma vez que
fazia parte de um módulo do 12º ano para assim os alunos irem para estágio no início do mês
de março. Isso dificultou ou impossibilitou a presença em algumas aulas do meu curso e
78
dificultou a preparação para os trabalhos finais das Unidades Curriculares do primeiro semestre
do segundo ano do curso.
Finalmente a última dificuldade teve a ver com o conteúdo que lecionei, sendo uma
matéria que não tive oportunidade de aprender antes. Mesmo tendo experiência em linguagens
de programação, obtida na formação anterior que tive, esta era uma linguagem nova para mim,
daí ter que dispor de tempo, que neste caso era escasso, para estudar a sintaxe e requisitos
desta linguagem de programação.
4.3 Reflexão sobre o projeto e aprendizagens
Tendo chegado ao fim a minha intervenção pedagógica, resta fazer uma análise do projeto
realizado e daquilo que aprendi ao longo deste processo.
Cada nova escola com que nos deparamos envolve sempre novas situações quer seja
com experiências positivas quer com experiências negativas. Essas experiências são sempre
uma aprendizagem. Se estas resultarem em algo positivo, em outras experiências futuras irei
procurar repetir, caso contrário, estarei mais atenta e tentarei evitar que se voltem a repetir
essas situações.
Apesar de ter pouco tempo para a preparação das aulas que tinha de lecionar, consegui
elaborar materiais didáticos para as minhas aulas, o que aumentou o meu sentimento de
autonomia e capacidade de resolução de problemas.
Tive a oportunidade de aprender uma nova linguagem de programação. Embora tenha no
meu currículo experiência com outras linguagens de programação, cada linguagem é diferente.
Podem existir alguns elementos em comum, no entanto as suas diferenças exigem novas
aprendizagens, portanto esta foi uma experiência que considerei enriquecedora para o meu
currículo.
Na minha pouca experiência de ensino, já estive em contacto com turmas complicadas
em termos de comportamento; neste projeto voltei a estar em contacto com uma turma com
essas características e por isso desenvolvi novas competências de como gerir uma turma deste
género.
Durante a temporada passada na escola, tive a oportunidade de conviver com professores
de outras áreas, funcionários com os quais tive uma relação de cordialidade. Os alunos em
ambiente externo às aulas sempre mantiveram uma atitude de simpatia em relação a mim.
79
Todas estas experiências, com colegas, alunos, orientadores e professores tornaram-me,
acredito, melhor profissional e fizeram-me evoluir como pessoa.
80
REFERÊNCIAS BIBLIOGRÁFICAS
Arends, R. (1995). Aprender a ensinar. Lisboa: Editora McGraw-Hill.
Ausubel, D. (1980). Psicologia educacional. 1ª Edição. Rio de Janeiro: Editora Interamericana.
Coll, C., Martín, E., Mauri, T., Miras, M., Onrubia, J., Solé, I., & Zabala, A. (2001). O
construtivismo na sala de aula. São Paulo: Editora Ática.
Crato, N. (2006). O «Eduquês» em discurso direto: uma crítica da pedagogia romântica e
construtivista.
Acedido
em:
18
de
dezembro
de
2014,
em:
www.filedu.com/ncratoeduques.pdf.
DGFV. (2005). Programa - Componente da Formação Técnica da Disciplina de Programação e
Sistemas
de
Informação.
Acedido
em:
30
de
novembro
de
2013,
em:
http://www.anqep.gov.pt.
DGFV. (2005). Programa da disciplina de Linguagens de programação. Acedido em: 2 de
fevereiro de 2014, em: http://www.anqep.gov.pt.
ESAS. (2011). Escola Secundária Alberto de Sampaio - Projeto Educativo. Acedido em: 11 de
novembro de 2013, em: http://www.esas.pt.
IGEC. (2011). Avaliação Externa das Escolas - Relatório Escola Secundária de Alberto Sampaio.
Acedido em: 28 de outubro de 2013, em: http://www.ige.min-edu.pt.
Jonassen, D. (2007). Computadores, ferramentas cognitivas: para desenvolver o pensamento
crítico nas escolas. Porto: Porto Editora.
Morais, P. & Pires, J. (2002). Python: Curso completo. Lisboa: FCA.
81
Papert, S. (1980). Mindstorms - Children, Computers and Powerful Ideas. Second edition. New
York: Basic Books.
Papert, S. (1995). La máquina de los niños. 1ª Edición. Barcelona: Editorial Paidós.
Pinheiro, J. & Ramos, L. (2005). Métodos Pedagógicos. Lisboa, Instituto do Emprego e
Formação Profissional. Acedido em: 18 de dezembro de 2014, em: opac.iefp.pt.
Ramos, J. L. (2013). Pensamento computacional na escola, no currículo e na aprendizagem.
[Vídeo]. DGE
– Webinars. Disponível em
30
de Janeiro de 2013, em
http://webinar.dge.mec.pt/2013/01/30/pensamento-computacional-na-escola-nocurriculo-e-na-aprendizagem/.
Ribeiro, G. (2012). O Ensino da História. Lisboa: Fundação Francisco Manuel dos Santos.
Silva, M. (2001). Sala de aula interativa. A educação presencial e à distância em sintonia com a
era digital e com a cidadania. Acedido em: 3 de janeiro de 2014, em:
www.unesp.br/proex/opiniao/np8silva3.pdf.‎
Silva, M. (2006). Sala de aula interativa. 4ª Edição. Rio de Janeiro: Editora Quartet.
Veiga, H. (2007). Indisciplina e violência na escola: práticas comunicacionais para professores e
pais. Coimbra: Almedina.
Vygotsky L. (1978). Mind in society: The development of higher psycological processes. MA:
Harvard University Press. Cambridge.
Wing, J. M. (2006). Computational Thinking. Communications of the ACM March 2006/Vol. 49,
No. 3
82
ANEXOS
Anexo 1: Planificação do módulo 17 E
MÓDULO N.º 17E (OP5) - FERRAMENTAS DE DESENVOLVIMENTO DE PÁGINAS WEB
Objectivos de ensino/ Conteúdos
1. Modelos (Templates)
2. Folhas de Estilos
2.1. Painel css;
2.2. Estilos css personalizáveis
2.3. Folha de estilos externa
3. Integração com outras aplicações (ex. Javascript)
4. Requisitos para a criação de um site dinâmico
4.1. Linguagem script PHP
5. Ligação a Base de dados
5.1. Construção de Base de dados
5.2. Ligação à base de dados
6. Criação de fontes de conteúdo dinâmico
7. Inserção de conteúdos dinâmicos
8. Trabalhar com páginas dinâmicas
8.1. Mostrar registos da base de dados
8.2. Criação de página principal/detalhes de registo
8.3. Criar páginas de pesquisa a bases de dados
8.4. Restrição de acesso ao site
9. Trabalhar com páginas dinâmicas
9.1. Mostrar registos da base de dados
9.2. Criação de página principal/detalhes de registo
9.3. Criar páginas de pesquisa a bases de dados
9.4. Restrição de acesso ao site
Objectivos de
Aprendizagem/Competências
1. Utilizar Modelos (Templates).
2. Interagir com outras Aplicações.
Estratégias/Sugestões Metodológicas



3. Utilizar um servidor virtual num
computador pessoal
4. Criar e Configurar Bases de Dados


5. Ligar Bases de dados com a
aplicação criada
83
Apresentar os conceitos fomentando
sempre que possível o debate com os
alunos.
Envolver o aluno na sua própria
aprendizagem, de modo a permitir-lhe
desenvolver a autonomia e iniciativa.
Observação
directa
do
trabalho
desenvolvido pelo aluno durante as aulas,
tendo em atenção a qualidade do trabalho
realizado e a forma como o aluno o gere,
organiza e autoavalia.
Resolver de exercícios, sempre que
possível utilizando casos reais.
Desenvolver trabalho de grupo e/ou
individual.
Duração
(Blocos de 90 min.)
25
10. Extensões
Recursos: Computadores c/ acesso à Internet; Quadro; Videoprojector; Aplicações informáticas: WampServer (Apache, PHP,MySQL) ou Xampp
84
Anexo 2: Grelha de observação dos alunos
Grelha de Observação
Ano/Turma: 12º/3P
Nome
11
12
13
14
15
16
17
18
19
20
LEGENDA:
85
Assiduidade:
X Faltou
Positivo: +
Pontualidade:
Y Não
pontual
Negativo: -
Demonstração de
autonomia e
iniciativa própria
Participação e
Empenho
Capacidades e atitudes
Comportamento
Pontualidade
N.º do
aluno
Competências transversais
Assiduidade
Data:
Anexo 3: Planos de aula das aulas observadas pelos supervisores
Aula Nº: 13
Ano: 12º - Período: 2º
Início: 13h35
Data: 23/01/2014
Sala: C 2.3
Fim: 15h05
Supervisores: Altina Ramos e Bento Silva
Orientador cooperante: Hélio Vilas
Estagiária: Elisabete Cunha
Disciplina: Programação e Sistemas de Informação
Módulo: 17E – Ferramentas de desenvolvimento de Páginas Web
Duração da aula: 90 minutos
Sumário: Tipos de dados sequenciais - Listas;
Resolução de problemas.
Conteúdos
Objetivos
Atividades/Estratégias
-------------------------------
-------------------------------
Efetuar a chamada;
-------------------------------
-------------------------------
Registar o sumário;
-------------------------------
-------------------------------
Indução à prontidão;
Recursos
Avaliação
Quadro
Grelha de Observação
Videoprojector
Pontualidade
Computador
86
Windows
1min
1min
Assiduidade
Comportamento
Apresentar os objetivos da aula;
Tempo
2min
Conteúdos
Objetivos
Atividades/Estratégias
Recursos
Python 2.7.6
Introdução ao tipo de
dados sequenciais –
listas;
Entender os
linguagem;
conceitos
da
Avaliação
Tempo
Participação
80min
Diálogo com os alunos;
Ensino de Conceitos;
Saber trabalhar com listas;
Operadores + e *;
Saber utilizar os operadores + e *;
Caraterísticas das
listas;
Alterar (inserir,
remover, atualizar)
valores em listas de
tamanho definido.
Saber fazer alteração e inserção
de valores numa lista de tamanho
definido.
Exposição dos conteúdos de forma
interativa, alternado com questões aos
alunos e promovendo a discussão na sala
de aula;
Utilização do programa Python para
experimentar exemplos;
Interrogar os alunos ao desenvolver
programas de modo a desenvolver o seu
raciocínio;
Resolução de problemas fazendo a
alteração e inserção de valores em listas
de tamanho definido.
-------------------------------
-------------------------------
------------------------------
------------------------------
Resumo da Aula;
5min
Antevisão da próxima aula.
1min
Plano da Aula nº 13 - Módulo 17E
87
Aula Nº: 15
Ano: 12º - Período: 2º
Início: 17h00
Data: 27/01/2014
Sala: C 2.7
Fim: 18h30
Supervisores: Altina Ramos e Bento Silva
Orientador cooperante: Hélio Vilas
Estagiária: Elisabete Cunha
Disciplina: Programação e Sistemas de Informação
Módulo: 17E – Ferramentas de desenvolvimento de Páginas Web
Duração da aula: 90 minutos
Sumário: Listas de tamanho indefinido;
Resolução de problemas;
Conteúdos
Objetivos
Atividades/Estratégias
Recursos
Avaliação
Tempo
-------------------------------
-------------------------------
Efetuar a chamada;
Quadro
Grelha de Observação
1min
-------------------------------
-------------------------------
Registar o sumário;
Videoprojector
Pontualidade
1min
-------------------------------
-------------------------------
Indução à prontidão;
Computador
Apresentar os objetivos da aula;
Windows
Assiduidade
Comportamento
Participação
Python 2.7.6
88
2min
Conteúdos
Tipos de dados
sequenciais – listas:
listas de tamanho
indefinido;
Métodos len, del e
append.
Objetivos
Entender os conceitos da
linguagem;
Atividades/Estratégias
Recursos
Avaliação
Tempo
80min
Diálogo com os alunos;
Ensino de Conceitos;
Saber trabalhar com listas de
tamanho indefinido, utilizando os
métodos len, del e append.
Exposição dos conteúdos de forma
interativa, alternado com questões aos
alunos e promovendo a discussão na sala
de aula;
Utilização do programa Python para
experimentar exemplos;
Interrogar os alunos ao desenvolver
programas de modo a desenvolver o seu
raciocínio;
Resolução de problemas utilizando listas
de tamanho indefinido e os métodos len,
del e append.
-------------------------------
-------------------------------
------------------------------
------------------------------
Resumo da Aula;
5min
Antevisão da próxima aula.
1min
Plano da Aula nº 15 - Módulo 17E
89
Aula Nº: 16
Ano: 12º - Período: 2º
Início: 13h35
Data: 29/01/2014
Sala: C 2.3
Fim: 15h05
Supervisores: Altina Ramos e Bento Silva
Orientador cooperante: Hélio Vilas
Estagiária: Elisabete Cunha
Disciplina: Programação e Sistemas de Informação
Módulo: 17E – Ferramentas de desenvolvimento de Páginas Web
Duração da aula: 90 minutos
Sumário: Fatiar/slicing listas;
Métodos da classe list;
Método randint da classe random;
Resolução de problemas;
Conteúdos
Objetivos
Atividades/Estratégias
Recursos
Avaliação
Tempo
-------------------------------
-------------------------------
Efetuar a chamada;
Quadro
Grelha de Observação
1min
-------------------------------
-------------------------------
Registar o sumário;
Videoprojector
Pontualidade
1min
-------------------------------
-------------------------------
Indução à prontidão;
Computador
Apresentar os objetivos da aula;
90
Assiduidade
Comportamento
2min
Conteúdos
Objetivos
Atividades/Estratégias
Recursos
Windows
Avaliação
Tempo
Participação
Python 2.7.6
Fatiar/slicing listas;
Inserção utilizando
slicing;
Entender os conceitos da
linguagem;
Saber trabalhar com slicing em
listas;
Métodos mais
utilizados da classe
list;
Saber utilizar os métodos da
classe list;
Pesquisa dos métodos
da classe list;
Saber pesquisar métodos na
classe list;
Método randint da
classe random.
Saber utilizar o método randint da
classe random.
80min
Diálogo com os alunos;
Ensino de Conceitos;
Exposição dos conteúdos de forma
interativa, alternado com questões aos
alunos e promovendo a discussão na sala
de aula;
Utilização do programa Python para
experimentar exemplos;
Interrogar os alunos ao desenvolver
programas de modo a desenvolver o seu
raciocínio;
Resolução de um problema utilizando
slicing, os métodos da classe list e o
método randint da classe random.
-------------------------------
-------------------------------
------------------------------
------------------------------
Resumo da Aula;
5min
Antevisão da próxima aula.
1min
Plano da Aula nº 16 - Módulo 17E
91
Anexo 4: Questionário inicial sobre levantamento de requisitos
Questionário programação
Que idade tens?
Possuis computador em casa?
o
Sim
o
Não
Possuis internet?
o
Sim
o
Não
Quais são as matérias na área da informática que tens maiores
dificuldades?
Quais são as matérias que dominas melhor na área da informática?
Gostas de programar?
o
Sim
92
o
Não
Tens alguma dificuldade em programação?
o
Sim
o
Não
Se respondeste sim à questão anterior, explica de que género é a tua
dificuldade.
Sugere uma estratégia que te motive para a programação.
O que ambicionas que este curso profissional te traga
profissionalmente?
Pretendes atingir o ensino superior?
o
Sim
o
Não
O que ambicionas para o teu futuro?
93
94
Anexo 5: Questionário sobre as aprendizagens realizadas pelos alunos
Aprendizagens
Qual o teu nome e apelido?
Tiveste alguma dificuldade na linguagem Python?
o
o
Sim
Não
Se respondeste "sim", à questão anterior, enumera a(s) tua(s)
dificuldade(s):
o
o
o
o
o
Operadores (aritméticos/lógicos)
Variáveis
Ciclo While
Strings
Listas
Explica de que género é(são) a(s) tua(s) dificuldade(s).
95
Anexo 6: Questionário sobre a avaliação final feita pelos alunos das minhas aulas
Avaliação das aulas
Numa escala de 1 a 5, sendo 1-medíocre, 2-insuficiente, 3-satisfaz, 4-bom e 5-muito bom. Marca um valor
desta escala para responderes às 7 questões que se seguem.
Realizei a tarefas que me foram indicadas?
1
2
3
4
5
Gostei da forma como as aulas foram lecionadas?
1
2
3
4
5
Gostei das atividades que me foram propostas?
1
2
3
4
5
A professora tirou as minhas dúvidas?
1
2
3
4
5
A professora criou um ambiente de interatividade?
1
2
3
4
5
96
Fiquei motivado para programar em Python?
1
2
3
4
5
Aumentei a minha autonomia no desenvolvimento de programas em Python?
1
2
3
4
5
97
Anexo 7: Código do programa sobre o problema “Jornada de futebol”
98
99