Desenvolvimento de apps Android e utilização de teste de pensamento computacional num curso profissional de programador/a de informática

Desenvolvimento de Apps Android e Utilização de Teste de Pensamento Computacional num Curso Profissional de Programador/a de Informática Universidade do Minho Instituto de Educação Maurício Braga Morais outubro de 2022 Desenvolvimento de Apps Android e Utilização de Teste de Pensamento Computacional num Curso Profissional de Programador/a de Informática Maurício Braga Morais UMinho|2022 Maurício Braga Morais outubro de 2022 Desenvolvimento de Apps Android e Utilização de Teste de Pensamento Computacional num Curso Profissional de Programador/a de Informática Trabalho efetuado sob a orientação da Doutora Maria Altina Silva Ramos Relatório de Estágio Mestrado em Ensino de Informática Universidade do Minho Instituto de Educação ii Direitos de Autor e Condições de Utilização do Trabalho por Terceiros Este é um trabalho académico que pode ser utilizado por terceiros desde que respeitadas as regras e boas práticas internacionalmente aceites, no que concerne aos direitos de autor e direitos conexos. Assim, o presente trabalho pode ser utilizado nos termos previstos na licença abaixo indicada. Caso o utilizador necessite de permissão para poder fazer um uso do trabalho em condições não previstas no licenciamento indicado, deverá contactar o autor, através do RepositóriUM da Universidade do Minho. Atribuição-NãoComercial-CompartilhaIgual CC BY-NC-SA https://creativecommons.org/licenses/by-nc-sa/4.0/ iii Agradecimentos Agradeço à Universidade do Minho, aos meus Professores, aos meus Colegas do Mestrado, à Escola onde realizei a Intervenção Pedagógica, aos Alunos do 11ºTPI, à DGES, e a todos mais que participaram neste projeto de formação de um novo professor. Em especial, agradeço, Ao Professor Doutor António Osório, À Professora Doutora Altina Ramos, Ao Professor José Pereira, À Professora Doutora Susana Caires, Ao Professor Doutor Marcos Román—González, Ao Sr. Rui Silva, Ao Ricardo, Pedro Reis, Cátia, Isabel, Andreia, André, Rui, Nuno Ferreira e Marco, À minha Família, tão pequena e tão querida, minha Mãe, meu Pai e minha Irmã, E à Olivia, minha sobrinha, que, na sua alternância entre choros e sorrisos, relembra-me que não somos máquinas. iv Declaração de Integridade Declaro ter atuado com integridade na elaboração do presente trabalho académico e confirmo que não recorri à prática de plágio nem a qualquer forma de utilização indevida ou falsificação de informações ou resultados em nenhuma das etapas conducente à sua elaboração. Mais declaro que conheço e que respeitei o Código de Conduta Ética da Universidade do Minho. v Desenvolvimento de Apps Android e Utilização de Teste de Pensamento Computacional num Curso Profissional de Programador/a de Informática Resumo O presente relatório documenta a intervenção pedagógica supervisionada, realizada numa turma do 11º ano do Curso Programador/a de Informática, no âmbito da Unidade Curricular Estágio, do Mestrado de Ensino de Informática da Universidade do Minho. O tema de ensino-aprendizagem foi a construção de interfaces gráficas e programação de interatividades, com o objetivo de criar programas para dispositivos móveis Android. A questão de investigação relacionou-se com o pensamento computacional, e com a utilização de ferramentas a ele associadas, no contexto do tema em estudo. Como parte da estratégia de motivação, segundo o modelo Atenção-Relevância-Confiança-Satisfação (ARCS), de Keller, utilizou-se o Android Studio, na perspetiva dos tópicos introdutórios da aprendizagem em espiral, de Bruner. As características dos alunos levaramme à opção pela Aprendizagem Baseada em Casos (CBL), sobretudo porque (i) na CBL, os alunos já têm algum conhecimento prévio, receberam formação antecipada, e (ii) após uma sessão de CBL, há pouca, ou nenhuma, tarefa de autoestudo. A seleção das Apps, feita em conjunto com o Professor Cooperante, seguiu os seguintes critérios: (i) introduzir conceitos básicos Android num nível de complexidade adequado para o 11º ano de escolaridade, (ii) ser enquadrável no período previsto para a minha intervenção, (iii) possuir uma estrutura favorável ao método demonstrativo-interrogativo, na fase inicial da aula, e à atividade prática dos alunos, na fase seguinte, (iv) estar relacionada com o tema da educação física, referida positivamente pelos alunos no inquérito do início do ano. Ao longo da minha intervenção, os alunos desenvolveram duas Apps: Índice de Massa Corporal (IMC) e Índice Cintura-Quadril (ICQ), e enviaram-me os seus trabalhos individuais. A avaliação dos trabalhos revelou que mais de 50% dos alunos cumpriram mais de 50% dos critérios de correção adotados nas duas Apps, sendo a segunda mais complexa que a primeira. A auto e heteroavaliação dos alunos foi favorável à intervenção realizada. Ao início e ao final da intervenção pedagógica, foi aplicado o teste de Pensamento Computacional (CTt), de Román-González, adaptado por mim à linguagem Java. Os resultados médios da turma apontaram no mesmo sentido dos já descritos para alunos espanhóis, singapurenses e suíços, do ensino secundário. O resultado individual do CTt pode funcionar como um teste diagnóstico do estádio em lógica de programação, colaborando para delinear a zona de desenvolvimento proximal, de Vygotsky, e para os critérios da estratégia de Programação em Pares. Palavras-chave: Android Studio, Aprendizagem Baseada em Casos, Criação de App, Programação para Dispositivos Móveis Android, Teste de Pensamento Computacional. vi Android App Development and Computational Thinking Test in a Computer Programmer VET Course, ISCED-4 Abstract The present report documents the supervised pedagogical intervention, carried out in an 11th year class of a Computer Programmer Course, within the scope of a Curricular Internship for the Master of Computer Science Teaching course at the University of Minho. The teaching-learning process was the construction of graphical interfaces and programming of interactivity, with the objective of creating programs for Android mobile devices. The research question was related to computational thinking and the use of tools associated with it, in the context of the subject under study. As part of the motivation strategy, according to Keller's Attention-Relevance-ConfidenceSatisfaction (ARCS) model, Android Studio was used, from the perspective of Bruner's introductory spiral learning topics. The characteristics of the students led me to opt for Case-Based Learning (CBL), mainly because (i) at CBL, students already have some prior knowledge, received early training, and (ii) after a CBL session, there is little , or no, self-study task. The selection of Apps, made together with Professor Cooperante, followed the following criteria: (i) introduce basic Android concepts at a level of complexity suitable for the 11th grade, (ii) be within the period foreseen for my intervention, (iii) have a structure favorable to the demonstrative-interrogative method, in the initial phase of the class, and to the practical activity of the students, in the following phase, (iv) to be related to the theme of physical education, mentioned positively by the students in the initial survey of the year. During my intervention, students developed two Apps: Body Mass Index (BMI) and Waist-Hip Index (WCI), and sent me their individual works. The evaluation of the works revealed that more than 50% of the students fulfilled more than 50% of the correction criteria adopted in the two Apps, the second being more complex than the first. The students' self and hetero-assessment was favorable to the intervention performed. At the beginning and at the end of the pedagogical intervention, the Computational Thinking Test (CTt), by Román-González, adapted by me to the Java language, was applied. The average results of the class pointed in the same direction as those already described for Spanish, Singaporean and Swiss secondary school students. The individual CTt result may work as a diagnostic test of the stage in programming logic, helping to delineate Vygotsky's zone of proximal development, and for the criteria of the Pair Programming strategy. Keywords: Android Studio, App Creation, Case-Based Learning, Computational Thinking Test, Programming for Android Mobile Devices, vii Índice Geral Direitos de Autor e Condições de Utilização do Trabalho por Terceiros ................................................ ii Agradecimentos............................................................................................................................. iii Declaração de Integridade .............................................................................................................. iv Resumo ......................................................................................................................................... v Abstract ........................................................................................................................................ vi Índice de Conteúdos…………………………………………………………………………………………………………… vii Índice de Figuras ........................................................................................................................... ix Índice de Tabelas ......................................................................................................................... xii Lista de Abreviaturas, Acrónimos e Siglas ...................................................................................... xiii Índice de Conteúdos 1. Introdução ............................................................................................................................ 1 2. Revisão da Literatura ............................................................................................................. 2 2.1. TIC e Programação Informática ........................................................................................... 2 2.2. Iniciativas de Promoção da Programação Informática .......................................................... 3 2.3. Apps Para Alunos & Apps De Alunos da Escolaridade Obrigatória ......................................... 4 2.3.1. Apps para Alunos ........................................................................................................ 5 2.3.2. Apps de Alunos............................................................................................................ 6 2.4. O Pensamento Computacional na Escolaridade Obrigatória em Portugal .............................. 7 2.5. Lecionação e Avaliação do Pensamento Computacional ....................................................... 9 2.6. O Teste de Pensamento Computacional de Román-González .............................................. 10 3. Contextualização ................................................................................................................. 12 3.1. Orientadores e Área da Intervenção Pegagógica ................................................................. 12 3.2. A Escola ............................................................................................................................ 12 3.3. A Disciplina, os Horários e a Sala de Aula .......................................................................... 13 3.4. A Turma ............................................................................................................................ 14 3.5. Os Principais Acontecimentos que Impactaram a Escola .................................................... 16 4. Plano de Intervenção Pedagógica Supervisionada .................................................................. 19 4.1. Tema ................................................................................................................................ 19 4.2. Objetivos ........................................................................................................................... 19 4.3. Estratégias de Ação da Intervenção ................................................................................... 19 4.4. Estratégias de Avaliação da Intervenção ............................................................................. 22 4.5. Justificação das Estratégias da Intervenção ........................................................................ 23 5. Intervenção Pedagógica ....................................................................................................... 27 5.1. Aulas ................................................................................................................................ 29 5.1.1. Sessão 1 – terça-feira 15 de março 2022, Turno 2 .................................................... 29 5.1.2. Sessão 2 – terça-feira 15 de março 2022, Turno 1 .................................................... 36 5.1.3. Sessão 3 – sexta-feira 18 de março 2022, Turno 1 .................................................... 39 5.1.4. Sessão 4 – sexta-feira 18 de março 2022, Turno 2 .................................................... 44 5.1.5. Sessão 5 – terça-feira 22 de março 2022, Turno 2 .................................................... 47 5.1.6. Sessão 6 – terça-feira 22 de março 2022, Turno 1 .................................................... 54 1 1. Introdução O presente relatório, elaborado no âmbito da unidade curricular Estágio, do Mestrado em Ensino da Informática da Universidade do Minho, refere-se à Prática de Ensino Supervisionada desenvolvida numa Escola Secundária Pública de Braga. A intervenção realizou-se numa turma do 11º ano do Curso Profissional de Programador/a de Informática, no ano letivo 2021-22, especificamente na disciplina de Programação Móvel, módulo 0817. Tendo como referência o currículo definido para a disciplina, o tema da intervenção incidiu sobre a construção e programação de interfaces gráficas, com vista à criação de aplicações para Android. Organizei o relatório em seis capítulos: 1Introdução; 2Revisão da Literatura; 3Contextualização; 4Plano de Intervenção Pedagógica; 5A Intervenção Pedagógica; e 6Reflexões sobre o Trabalho Futuro. A seguir, as Referências Bibliográficas, os Apêndices e os Anexos. Os conteúdos dos Apêndices e Anexos foram agrupados preferencialmente em ordem cronológica de criação/utilização. No anexo A constam as definições adotadas neste relatório, para casos em que não há uma definição única, designadamente, o que é Informática, o que é Ensino de Informática e o que é Pensamento Computacional. As figuras e tabelas sem indicação de autor são de minha autoria. 2 2. Revisão da Literatura 2.1. TIC e Programação Informática A definição do Perfil do Aluno à Saída da Escolaridade Obrigatória (PASEO) foi fundamental para clarificar os conhecimentos, capacidades e competências pretendidos para a Informática (Martins et al., 2017). Na sequência do PASEO, o Decreto-Lei 55/2018, de 6 de julho reviu o currículo dos ensinos básico e secundário e, entre outros aspetos, decidiu a expansão da lecionação das Tecnologias de Informação e Comunicação (TIC) a toda a escolaridade obrigatória (Figura 1). Ao mesmo tempo, o DL 55/2018 introduziu uma maior liberdade para que cada escola possa estabelecer estratégias, no sentido de os seus alunos desenvolverem adequadamente as competências previstas no PASEO, através do conhecimento do meio onde esteja inserida. Assim, no 2.º ciclo, os 325 minutos semanais da área Educação Artística e Tecnológica podem distribuir-se entre TIC e mais 3 disciplinas; no 3.º ciclo, os 175 minutos de Educação Artística e Tecnológica podem distribuir-se entre TIC e mais 2 disciplinas. Na vertente profissional do ensino secundário, está previsto todos os cursos terem a disciplina de TIC, numa carga horária total de 100 horas; não obstante, o DL 55/2018 também prevê que, em função da necessidade de reforço das aprendizagens, em vez de TIC, a escola pode optar por uma Oferta de Escola, de frequência obrigatória. Em relação ao ensino secundário, o currículo da vertente Científico-Humanista prevê apenas uma disciplina, opcional, Aplicações Informáticas B , no 12º ano. Com vista a colmatar o défice de competências e conhecimentos dos alunos desta vertente, a Associação Nacional dos Professores de Informática (ANPRI) entregou ao Ministério da Educação uma proposta de criação de uma disciplina bienal de Informática, para o curso Científico-Humanístico de Ciências e Tecnologias (ANPRI, 2021a). Figura 1. Esquema Resumido do Ensino de Informática na Escolaridade Obrigatória 3 Quanto ao 1º ciclo do Ensino Básico, não está prevista a lecionação especializada de TIC, uma vez que a revisão curricular consagra a monodocência, com exceção da disciplina de Inglês (Conselho de Ministros, 2018). O que dizem as Aprendizagens Essenciais (AEs) de TIC, do 2º e 3º ciclos, relativamente à programação informática? Nas AEs do 5º, 6º e 9º anos, as atividades de programação indicadas são a introdução à programação por blocos, a programação para interagir com robots e outros artefactos tangíveis, e a exploração dos conceitos de programação para dispositivos móveis, respetivamente. No 7º e 8º anos, as AEs não referem atividades de programação (DGE, 2018a). No ensino secundário, vertente científico-humanista, as AEs de Aplicações Informáticas B apontam para a elaboração de programas simples, utilizando uma linguagem de programação imperativa (DGE, 2018b). Nos cursos profissionais não pertencentes à área 481, Ciências Informáticas, a disciplina de TIC possui o módulo opcional 2, Introdução à Programação , que prevê a realização de atividades orientadas para a criação e análise de algoritmos e das diversas fases de programação de uma aplicação - decompor, testar, depurar e reformular. Nos cursos profissionais da área 481, as linguagens de programação estão presentes nos cursos 481040, Programador/a de Informática (C/C++, SQL, Java, C#, Asp.Net, Python), e 481039, Técnico/a de Informática – Sistemas (C/C++, Java). A lecionação de SQL também ocorre no curso Técnico de Multimédia , área 213, Audiovisuais e Produção dos Media (ANQEP, 2022). 2.2. Iniciativas de Promoção da Programação Informática As iniciativas já consolidadas são as Olimpíadas de Informática (Figura 2), a Hora do Código (Figura 3) e o PAPTICe (Figura 5). A estas, soma-se o projeto Programação e Robótica na Escola , desde março de 2022 (Figura 4). As Olimpíadas Nacionais de Informática (ONI) são um concurso de programação destinado a alunos do ensino secundário, de caráter individual. Para resolver os problemas propostos, as linguagens de programação permitidas são o C, C++, Pascal, Java e Python. A organização da ONI está a cargo do Professor Pedro Ribeiro, da Universidade do Porto. Figura 2. Olimpíadas Nacionais de Informática, logotipo (ONI, 2017) 4 Os melhores classificados podem representar Portugal nas Olimpíadas Internacionais de Informática (IOI), que realiza-se anualmente desde 1989 (Azevedo, 2021). Em 2022, a IOI ocorreu na Indonésia, com mais de 300 participantes, sendo que dois alunos portugueses receberam menção honrosa (IOI, 2022). Iniciado em 2013, nos Estados Unidos, a Hora do Código é um evento anual, geralmente em dezembro, que procura despertar o interesse de professores e alunos do ensino básico para a programação informática e a importância da literacia digital, através de atividades lúdicas. As escolas podem inscrever-se diretamente no site www.code.org ou através da ANPRI (ANPRI, 2021a). O Concurso Nacional PAPTICe é uma iniciativa promovida pela ANPRI, com o apoio de múltiplos parceiros, que visa reconhecer o trabalho dos alunos dos cursos profissionais nos seus projetos de fim de curso, denominados PAP (Prova de Aptidão Profissional). As três áreas em concurso são Software, Artefactos (Hardware, Redes, Robótica e Eletrónica) e Multimédia. O concurso, cuja primeira edição foi em 2018, apoia-se em critérios de excelência, inovação, criatividade e empreendedorismo, sendo distinguido com o selo “uma ação INCoDe.2030”. Na edição de 2022, concorreram 34 projetos de 21 instituições de ensino (ANPRI, 2022). O projeto Programação e Robótica na Escola é promovido pela Direção Geral de Educação (DGE, 2022). O webinar de lançamento esteve a cargo do Professor João Piedade (Piedade & Dorotea, 2020). 2.3. Apps Para Alunos & Apps De Alunos da Escolaridade Obrigatória A expressão App, abreviatura de Application , corresponde a um programa de computador, ou parte de um software, projetado para uma finalidade específica, que se pode baixar num telemóvel ou outro dispositivo móvel (Cambridge Dictionary, 2022). Além do código para o cálculo das variáveis, ou para a ação entre classes, ou ambos, a programação de uma App inclui a parte visual, que vai ser manuseada pelo utilizador final, a qual também tem de ser codificada. Figura 3. Hora do Código, logotipo (ANPRI, 2021b) Figura 5. PAPTICe, logotipo (ANPRI, 2022) Figura 4. Projeto Programação e Robótica na Escola, logotipo (DGE, 2022) 5 O programador tem à sua disposição uma linguagem de 3ª geração para construir o ecrã do utilizador final, que vai funcionar em linguagem de 5ª geração, e conta com os software de apoio para fazer chegar as instruções à linguagem de máquina, 1ª geração (Figura 6). 2.3.1. Apps para Alunos Nos dias de hoje, é ponto assente para os professores que o telemóvel pode ser usado em atividades escolares (Silva et al., 2020). Neste sentido, observa-se uma tendência mundial de criação de aplicações para dispositivos móveis, como recurso de ensino-aprendizagem (E-A), tanto da parte de grandes e pequenas empresas de software como de teses e artigos académicos. Em junho de 2021, a Google lançou o Grasshopper com as instruções em Português (Figura 7). Trata-se de uma aplicação web gratuita, projetada como uma série de puzzles e questionários em complexidade crescente, nos quais os conceitos da lógica de programação vão sendo inseridos suavemente, em linguagem JavaScript. No âmbito da unidade curricular ACMDI, da Universidade do Minho, propus o Grasshopper como material didático para o 9º ano, numa disciplina de iniciação à programação (Morais, 2022). O site do Ministério da Educação de Portugal disponibiliza a App em: https://appseducacao.rbe.mec.pt/2019/10/11/grasshopper/ Figura 6. Níveis Hierárquicos das Linguagens de Programação (adapt. Null & Lobur, 2019) Figura 7. Aplicação Grasshopper de Iniciação à Programação (adapt. Markezine, 2022) 6 A monitorização da dieta e atividade física, adaptada de uma App Android, foi aplicada por Abreu (2020) em alunos do 3º ciclo e do Secundário, no Fundão e na Covilhã (Figura 8). A App foi planeada numa perspetiva aliciante e adaptada aos jovens. Na sua globalidade, a App possui funcionalidades de gamificação, informação, planos de dieta, treino, dicas e curiosidades, cálculo de passos e calorias. Os jovens envolvidos no estudo, na sua maioria, manifestaram aprovação à iniciativa. A aprendizagem de conceitos e lógica de programação, em ambiente MIT App Inventor, foi descrita com alunos do 12º ano de Cursos Científico-Humanísticos, em Évora. A análise dos resultados indicou melhorias na autonomia e na consolidação dos conceitos (Mateus, 2021). Nunes (2019) implementou a programação do teorema de Pitágoras, com alunos do 9º ano e MIT App Inventor, e testou a sua utilização com alunos do 8º ano, num colégio em Lisboa. 2.3.2. Apps de Alunos As informações sobre trabalhos de programação móvel desenvolvidos por alunos da escolaridade obrigatória em Portugal foram obtidas, na sua maioria, no website da ANPRI, na seção referente ao concurso PAPTICe , que apresenta a lista dos trabalhos em concurso. De 2018 a 2021, pelo menos 9 projetos estiveram em concurso, sendo que, em 2021, o projeto give IT easy , relacionado com a doação de alimentos e bens de primeira necessidade, foi o vencedor na categoria software (Figura 9). O facto de este projeto ter três autores pode indicar uma elevada carga horária de dedicação ao tema, além do necessário acompanhamento dos professores orientadores. Figura 8. App Hábitos de Vida Saudável (Abreu, 2020) 7 No ano de 2022, o vencedor do PAPTICe na categoria software foi uma App, desenvolvida na Escola Secundária Henriques Nogueira, de Torres Vedras. O projeto denomina-se Aplicação Móvel e Website para os Utilizadores das Agostinhas , do aluno Sérgio Gribleac Silva (ANPRI, 2022). Independentemente do concurso PAPTICe , encontrei dois alunos que divulgaram individualmente as suas Apps de PAPs: a App S-Notas , por Diogo Reis, na Escola Secundária de Tomaz Pelayo, em Santo Tirso, em 2015 (Figura 10); e a App Rastreador de Localização GPS , por Ricardo Gonçalves, na Escola Técnica Profissional de Mafra, em 2016 (Gonçalves, 2016). Também as escolas podem divulgar informação sobre Apps de alunos, nas suas páginas oficiais. Em 2020, o Agrupamento de Escolas de Canelas, em Vila Nova de Gaia, acolheu três PAPs com Apps: uma App de envio de mensagens, e duas Apps de encomendas de refeições – das quais uma incorpora realidade aumentada (AgrCanelas, 2020). Neste mesmo ano, a Escola Secundária José Saramago, de Mafra, divulgou 5 PAPs de jogos sendo 1 App, denominada FunnyRunner , de Bernardo Bento (ESJS-Mafra, 2020). 2.4. O Pensamento Computacional na Escolaridade Obrigatória em Portugal O ensino-aprendizagem de pensamento computacional consta formalmente nas AEs da disciplina de Matemática do 1.º, 3.º, 5.º e 7.º anos de escolaridade, a partir de 2022/23. Em 2023/24, deverá iniciar-se no 2.º, 4.º, 6.º e 8.º anos de escolaridade e, em 2024/25, no 9.º ano (MEC PT, 2021b). A Figura 11 mostra alguns dos elementos comuns aos pensamentos computacional e matemático, como resolução de problemas, modelação, análise de dados e interpretação (Shute et al., 2017). Figura 9. App Vencedora, PAPTICe 2021 (adapt. ANPRI, 2022) Figura 10. App S-Notas, (adapt. Reis, 2015) 8 A implementação das novas AEs de Matemática foi precedida de um estudo, realizado em 2020, com 593 docentes do ensino pré-escolar e do 1º ciclo de todo o país, no qual investigaram-se as necessidades de formação de educadores e professores. As principais recomendações do estudo apontam para (i) um plano organizacional de oferta formativa, que promova a proximidade de centros de formação e instituições de ensino superior, e (ii) um plano de formação profissional dos docentes, que assegure que possam participar de comunidades de aprendizagem prática (Ramos et al., 2022). O modo de inserção do pensamento computacional no ensino secundário ainda não está definido. As novas AEs de Matemática no secundário entraram em discussão pública em junho de 2022, com final previsto para setembro de 2022. O grupo coordenador dos trabalhos, criado em 2018, preocupase em disponibilizar “ferramentas de análise dos processos sociais que estão na base do exercício de uma cidadania ativa”. “Valorizar o pensamento computacional” é uma das propostas em discussão (TERçA, 2022). Neste sentido, é de referir que o pensamento computacional consta nas AEs da disciplina bienal de Informática, proposta pela ANPRI para o curso Científico-Humanístico de Ciências e Tecnologias (ANPRI, 2021a). Por sua vez, a ENSICO, que propõe o ensino das ciências da computação em toda a escolaridade obrigatória, também defende a ênfase em pensamento computacional neste percurso (ENSICO, 2022). Em 15/09/2022, a Sociedade Portuguesa de Matemática (SPM), emitiu parecer sobre a proposta das novas AEs de Matemática. Relativamente ao pensamento computacional, afirma “a SPM subscreve o parecer da ENSICO no que se refere ao Pensamento Computacional” (SPM, 2022). Figura 11. Semelhanças entre Pensamentos Computacional e Matemático (Shute et al., 2017) 9 2.5. Lecionação e Avaliação do Pensamento Computacional Entre os vários desafios para a introdução curricular do pensamento computacional, na escolaridade obrigatória, podem citar-se a definição dos conteúdos e metodologias de ensino, assim como os critérios de avaliação da aprendizagem. Em relação à lecionação, um conteúdo consensual é a programação informática, porque o aprendente interioriza os conceitos computacionais, como sequências, ciclos, condicionais, operadores, paralelismo, e os aplica na prática, ao experimentar e iterar, testar e depurar, reutilizar e remixar, abstrair e modularizar (Hsu et al., 2018; Román-González et al., 2017; Scherer et al., 2019). Qual a relação entre pensamento computacional e programação informática? Uma analogia de fácil compreensão é proposta por Moreno-León et al.(2019): em resumo, o pensamento computacional é uma capacidade cognitiva humana que ganha vida aquando da programação de computadores, uma competência instrumental. Não obstante, o pensamento computacional pode ser projetado em problemas que não envolvam diretamente tarefas de programação. A relação assemelha-se à existente entre a aptidão verbal e a alfabetização. A aptidão verbal é considerada uma habilidade cognitiva enquanto a alfabetização (leitura e escrita) é classificada como competência instrumental, que requer um processo de ensino-aprendizagem. Um analfabeto pode ter aptidão verbal e usá-la em tarefas que não envolvam leitura nem escrita. Por outro lado, a aptidão verbal não é estanque, pode ser desenvolvida, aperfeiçoada, não somente através da leitura, mas também, por exemplo, pela audição de livros eletrónicos. Do mesmo modo, outras atividades podem contribuir para o pensamento computacional como, por exemplo, a aprendizagem de conceitos e práticas computacionais em atividades desplugadas (AD). Tais atividades não utilizam dispositivos digitais, implicando, geralmente, algum tipo de movimento físico dos participantes. Há evidências empíricas crescentes sobre a eficácia da contribuição de ADs no desenvolvimento do pensamento computacional na escolaridade obrigatória (Marques, 2021; Pereira A. , 2021). Relativamente à avaliação, na investigação de Bocconi et al. (2022), 10 em 24 países europeus declararam dificuldade em avaliar a aprendizagem do pensamento computacional no 1º e 2º ciclos ( primary school level ) e 13 países no 3º ciclo ( lower secondary level ). Neste sentido, as questões que vêm sendo formuladas para o projeto Bebras, em todos os países participantes, inclusive Portugal (Castor Informático, 2021), podem constitutir uma base de dados que os professores poderão consultar para a elaboração de testes (Lockwood & Mooney, 2018; Román-González et al., 2019; Tang et al., 2020). Cutumisu et al. (2019) efetuaram uma revisão sistemática, daí resultando 39 estudos empíricos, sobre pensamento computacional publicados entre 2014 e 2019. Segundo os autores, a maioria dos estudos teve como alvo os alunos da escolaridade obrigatória, usou a forma de teste e avaliou 10 principalmente o pensamento algorítmico, abstração, decomposição de problemas, pensamento lógico e dados. Não obstante, os autores destacam que poucos estudos foram devidamente validados em ambientes educacionais. O teste de pensamento computacional (CTt) de Román-González (2016), é um dos testes validados e foi adotado, com adaptações, na intervenção pedagógica descrita neste relatório. 2.6. O Teste de Pensamento Computacional de Román-González Román-González (2016) desenvolveu o CTt aquando dos seus estudos de doutoramento. O teste foi pensado para aplicação na escolaridade obrigatória, sem a necessidade de conhecimento prévio de informática. Como base, para validar avaliações de conhecimento em informática, Román-González refere que adotou o guia prático de Buffum et al. (2015, referido por Román-González, 2016, p.529), estando este guia alinhado com os padrões internacionais para testes psicológicos e educacionais (AERA, APA, & NCME, 2014, referido por Román-González, 2016, p.526). O autor também refere que o CTt é consistente com outros testes de raciocínio computacional voltados para o ensino fundamental/médio, como o Teste de Medição de Habilidades Básicas de Programação (Mühling et al., 2015, referido por Román-González, 2016, p.544) e a Avaliação Comutativa (Weintrop & Wilensky, 2015a, referido por Román-González, 2016, p.556). O CTt foi inicialmente concebido com uma extensão de 40 questões, de escolha múltipla, tendo a versão final 28 questões, após um processo de validação realizado por 20 especialistas. As figuras 12 e 13 exemplificam o formato das perguntas e respostas do teste. A íntegra do teste CTt encontra-se no anexo F da tese de Román-González, disponível em https://redined.educacion.gob.es/xmlui/handle/11162/157859 Figura 12. Teste Original CTt, Resposta em Setas; Tarefa: Sequência, (Román-González, 2016) 17 Com vista a controlar a contaminação nas escolas após as férias de Natal e Ano Novo, o calendário escolar foi alterado e o regresso aconteceu a 10 de janeiro. Os cinco dias a menos de aulas foram compensados com menos dois dias nas férias de Carnaval e menos três dias na interrupção da Páscoa. Considero ter sido uma decisão correta, pois houve um grande aumento de casos de COVID entre 4 e 19 de janeiro de 2022, devido à nova variante Ómicron (Figura 17). Com o controlo da pandemia, a 21 de abril de 2022 terminou do uso obrigatório de máscara na maior parte dos espaços fechados, inclusive nas escolas (Godinho, 2022). Ainda estava a comunidade escolar a usar máscara quando, em 24 de fevereiro, a RTP1 interrompeu a programação para anunciar a eclosão de uma guerra entre a Rússia e a Ucrânia (Portugal News, 2022). Nos dias que se seguiram, centenas de milhares de residentes na Ucrânia deixaram o país, em busca de refúgio; muitos vieram para Portugal. A 7 de março, Braga recebeu um autocarro com refugiados de guerra (RTP, 2022); inúmeras ações humanitárias e demonstraçãoes de apoio foram realizadas (Figura 18). Figura 17: Casos COVID-19, 03/2020 a 01/2022 (adapt. Inácio & Sequeira, 2022) 18 Não tenho conhecimento de estudos sobre os efeitos da guerra na Ucrânia na população adolescente das cidades portuguesas que receberam refugiados, mas é possível que tenham sido impactados. Num conflito armado, fortemente noticiado pelos media, mesmo as famílias e as comunidades não envolvidas diretamente são também perturbadas psicologicamente e muitos aspetos da vida normal são afetados, nomeadamente a produtividade do trabalho e da aprendizagem (Garry & Checchi, 2020). Até o momento em que escrevo este relatório, outubro de 2022, a guerra na Ucrânia continua. Figura 18. Demonstração em Braga, abril de 2022 19 4. Plano de Intervenção Pedagógica Supervisionada 4.1. Tema O tema de ensino-aprendizagem (E-A) da intervenção foi a criação de programas para dispositivos móveis Android, doravante denominado “criação de Apps para Android”, inserido no módulo Programação de Sistemas Web em Java , da disciplina Programação Móvel . A questão de investigação pedagógica (QIP) subjacente à intervenção foi: “Como o pensamento computacional, e ferramentas a ele associadas, podem contribuir no E-A de Apps para Android?” 4.2. Objetivos A nível geral, esta intervenção pedagógica visou contribuir para o desenvolvimento das competências associadas ao Perfil do Aluno à Saída da Escolaridade Obrigatória (PASEO) (Martins et al., 2017), através da promoção de um ambiente colaborativo nas atividades escolares, do estudo autónomo e da reflexão crítica, entre outras. Os objetivos específicos que se pretenderam alcançar foram (i) Fomentar a motivação no estudo da programação (ii) Desenvolver a criação de Apps para Android (iii) Recolher e tratar dados relacionados com o pensamento computacional em programação (iv) Identificar as perceções dos alunos relativamente à qualidade da intervenção realizada e à sua aprendizagem. 4.3. Estratégias de Ação da Intervenção Para acompanhar e registar o desenvolvimento das competências do PASEO durante a intervenção, elaborei a minha Grelha de Observação dos Alunos (GOA) com base em Cunha (2015), porque o seu modelo não só explicita e distingue as competências transversais (assiduidade, pontualidade, comportamento) das capacidades e atitudes (participação e empenho, demonstraçao de autonomia e iniciativa própria), como também apresenta indicadores coerentes para o seu preenchimento. As adaptações que fiz foram as seguintes: - Agrupei os tópicos assiduidade e pontualidade, porque a plataforma Nónio permite distinguir a presença normal (P) da presença atrasada/falta de pontualidade (FP). - Separei em dois o tópico “participação e empenho”, porque considerei que um aluno que faz perguntas é um aluno participativo, mas pode acontecer de fazer perguntas apenas por ter preguiça de 20 pensar, então, não é empenhado. Considerei que “empenho” assemelha-se a resiliência: o aluno continua a tentar resolver o problema mesmo quando não tem resultados favoráveis imediatos. - Quanto ao tópico “demonstração de autonomia e iniciativa própria”, também me parece que são capacidades diferentes pois o aluno pode adquirir autonomia para realizar os trabalhos solicitados, sem apoio do professor nem dos colegas, ao longo das aulas, enquanto “iniciativa própria” é uma capacidade mais relacionada com a motivação, ou seja, o aluno está motivado e inicia um trabalho sem que o professor lho tenha solicitado. Assim, mantive “autonomia” e retirei “iniciativa própria”pois considerei que, no caso de observar uma situação deste tipo, a mesma deveria ser descrita à parte, com algum detalhe. De facto, ao longo da minha intervenção, só por uma vez presenciei um aluno a ter a iniciativa própria de tentar criar um jogo de computador, mas estava no seu computador pessoal, fora do contexto da aula. Com isso, a GOA compôs-se de: Assiduidade e Pontualidade, Comportamento, Participação, Empenho, e Autonomia. Para o seu preenchimento, adotei os seguintes indicadores:  Assiduidade e Pontualidade: Presente = P; Faltou = F; Falta de Pontualidade = FP; Falta Justificada = FJ; Falta injustificada = FI.  Comportamento: Adequado = A; Inadequado = I; Não consegui observar = ?.  Participação, Empenho, Autonomia: Sim =S; Não =N; Não se Aplica =N/A; Não consegui observar=? A GOA final consta no apêndice III. Como referência para estimular a motivação no estudo da programação, objetivo (i), adotei o modelo ARCS (Atenção – Relevância – Confiança - Satisfação), de John Keller (1987; Moura & Carvalho, 2010). Tendo em conta as suas tabelas com sugestões de ação para as 4 estratégias, selecionei as propostas que considerei compatíveis com o meu modo de ser e que estavam ao meu alcance desempenhar (Tabela 22). Para implementar a criação de Apps para Android, objetivo (ii), aderi à metodologia de Aprendizagem Baseada em Caso (CBL) (Merseth, 1991; Koslosky, 1999; Wijnia et al., 2017; Pereira, P. 2021). Os conteúdos teórico-práticos da aprendizagem basearam-se no manual online oficial da Google, Codelabs for Android Developer Fundamentals., o qual contém instruções passo a passo para a programação Android, na linguagem de programação Java e na linguagem de notação XML, utilizando o Android Studio. Desde setembro de 2022, está disponível a versão 2 do manual (Google Developers, 2022b). O plano previa a criação de três Apps, selecionadas em conjunto com o Professor Cooperante. A escolha das Apps deveu-se a terem um nível de complexidade adequado para o 11º ano e serem enquadráveis na época do ano letivo prevista para a minha intervenção (2º período, após as férias de 21 carnaval). O facto de os alunos terem mencionado gosto e interesse pelas aulas de educação física, no questionário do início do ano, levou à suposição que a conversão para App Android dos programas Índice de Massa Corporal (IMC) e Índice Cintura-Quadril (ICQ), previamente estudados em Java, na unidade de formação de curta duração (UFCD) 0816, poderia ser bem recebida e despertar-lhes entusiasmo. A terceira App, Contato, seria precedida pela introdução dos conceitos sobre Atividades e Intentos, lecionados a seguir à segunda App. Na previsão inicial, a intervenção de 15 aulas em cada turno foi pensada da seguinte forma: 4 aulas por App (3 Apps = 12 aulas) + 1 aula para os conceitos de Atividades e Intentos + 2 aulas para as 2 aplicações do CTt. As aulas foram planeadas para terem uma parte inicial expositiva, em que o professor mostra o aspeto e as funcionalidades da App terminada. A seguir, o professor mostra as partes do código no IDE para completar a App, seguindo a lógica do pensamento computacional (decomposição, reconhecimento de padrões, abstração, algoritmia, modelação & simulação e avaliação). A exposição é intercalada com perguntas. A cada passo (decomposição), o professor faz menção a um problema que os alunos conhecem, seja da aula passada ou do período passado, e interroga sobre como o problema foi resolvido (reconhecimento de padrões). De seguida, o professor mostra a solução para o caso em questão (abstração, algoritmia, modelação & simulação e avaliação). As aulas estão descritas no tópico 5.1. A estratégia para o objetivo (iii), recolher e tratar dados relacionados com o pensamento computacional em programação, foi a aplicação do teste de pensamento computacional de RománGonzález (2016), doravante designado como CTt, que adaptei à linguagem Java (Apêndice I). Para isso, solicitei e recebi autorização da Professora Supervisora. Os passos seguintes relacionaram-se com a autorização da Direção Geral da Educação (DGE), setor de Monitorização de Inquéritos em Meio Escolar (MIME). A submissão à DGE/MIME, através do site http://mime.dgeec.mec.pt/ constou de um formulário e de anexos com o parecer da Professora Supervisora do Projeto (Anexo D), a autorização dos autores do teste/questionário original e da respetiva tradução (Anexos B e C) e o modelo da Declaração de Consentimento Informado, Livre e Esclarecido (Apêndice II). O pedido associado recebeu o n.º0807900001. Após a autorização (Anexo E), foi necessário dar o devido conhecimento ao Diretor da Escola e enviar aos Encarregados de Educação duas vias da Declaração de Consentimento Informado, Livre e Esclarecido, solicitando a devolução de uma via assinada pelo Encarregado e pelo Aluno. O CTt foi aplicado nos dias 15/3 e 1/4; a descrição da sua aplicação na intervenção consta nos tópicos 5.1.1.,5.1.2. e 5.1.10. Para o objetivo (iv), identificar as perceções dos alunos relativamente à qualidade da intervenção realizada e à sua aprendizagem, a estratégia consistiu em quatro iniciativas, nomeadamente a aplicação de dois inquéritos em que, no primeiro, avaliaram sobretudo o professor e a intervenção e, no segundo, 22 autoavaliaram-se (Apêndices IV e IX respetivamente), e a realização de duas reuniões/entrevistas individuais (Apêndices VI e VIII). Os procedimentos sobre o objetivo (iv) estão descritos no texto introdutório do capítulo 5, intervenção não sumariada, e no final do tópico 5.1.10. Para a QIP, Como o pensamento computacional, e ferramentas a ele associadas, podem contribuir no E-A de Apps para Android? , a estratégia de ação foi a consulta aos artigos de Marcos Román-González e Sue Sentance, por investigarem o pensamento computacional na escolaridade obrigatória, além de uma consulta intensiva ao Google Scholar , auxiliada pelo software Publish or Perish (Harzing, 2007), com uma grande variedade de palavras-chave, e suas combinações, em que as 5 mais frequentes foram computational thinking skills, develop mobile apps, computer science education, code learning, vocational secondary school , e respetivas correspondentes em português. 4.4. Estratégias de Avaliação da Intervenção Os elementos utilizados na avaliação formativa foram (i) a GOA, (ii) a aplicação do CTt, (iii) as reuniões/entrevistas individuais e (iv) a autoavaliação dos alunos. De referir que o PIPS previa a realização de entrevistas focus group. No entanto, no decorrer das aulas, pareceu-me que os resultados do CTt e das Apps IMC e ICQ deviam ser apresentados individualmente aos alunos, de modo que os pudéssemos comentar livremente, sem constrangimentos e com respeito à privacidade, tal como recomendado nos tópicos S3.2 e S4.3, por Keller (1987). Assim, os encontros dos dias 19 e 26/4 tiveram um caráter duplo de reunião e entrevista curta: reunião porque mostrei-lhes os seus resultados (Apêndices V e VII), esclareci dúvidas e mostrei os gráficos dos resultados globais da turma; entrevista curta porque, no tempo restante, fiz perguntas mais ou menos padronizadas e gravei as suas respostas (Apêndices VI e VIII). A avaliação sumativa correspondeu à correção dos trabalhos individuais sobre as Apps IMC e ICQ, enviados para o meu email institucional. Os critérios de correção valorizaram os acertos das tarefas que envolviam funções (denominadas “métodos”, em Java) porque, pela aplicação e correção do CTt no primeiro dia da minha intervenção, pude verificar que a maior parte dos erros da turma situava-se nas questões finais do teste, nomeadamente nos tópicos com condicional while (21 a 24) e com funções (25 a 28). Diante disso, procurei reforçar a lecionação dos métodos Java durante a intervenção (Ferreira, 2021, p.10). No tópico 5.2, apresento os resultados e respetiva análise. Os códigos-fonte que fiz para as Apps constam nos apêndices X e XI. A estratégia de validação da QIP, no contexto específico da intervenção, baseou-se na dupla aplicação do CTt, sendo a interpretação dos resultados apoiada pelas observações e reflexões de autores 23 que o aplicaram em condições semelhantes, nomeadamente Guggemos et al.(2022), Chan et al.(2020) e Román-González (2016). Resultados e análise no tópico 5.2. 4.5. Justificação das Estratégias da Intervenção A motivação é considerada um importante factor não cognitivo que afeta o desempenho académico dos alunos. Não há controvérsia sobre os benefícios da motivação intrínseca; em contrapartida, o reconhecimento da importância da motivação extrínseca é mais recente (Yunlong & LIU, 2022). Com vista a auxiliar os professores em táticas motivacionais, Keller (1987) desenvolveu o modelo ARCS que consiste em (i) atrair e manter a Atenção dos alunos, (ii) demonstrar a Relevância do conteúdo, ou ensinar o conteúdo de modo Relevante, (iii) gerar Confiança, transmitindo aos alunos uma expectativa positiva sobre os seus resultados de aprendizagem e (iv) recompensar os seus esforços, de modo a produzir Satisfação. O desenvolvimento de Apps para dispositivos móveis, através do IDE Android Studio, é uma unidade curricular lecionada atualmente em Institutos politécnicos, por exemplo nos Institutos Politécnicos de Lisboa (ISEL), Tomar (IPT), e Cávado e Ave (IPCA). Esta técnica possui elevados graus de abstração e complexidade. Com efeito, o Android Studio é a ferramenta mais completa e atualizada para programação Android (Google Developers, 2022a). Contudo, o facto de um tema ser lecionado no ensino superior não impede que partes introdutórias do seu conteúdo sejam lecionadas previamente, na escolaridade obrigatória. A expansão da programação informática a níveis cada vez mais iniciais do ensino formal tem sido defendida por muitos autores e posta em prática por vários países. Através do artigo de Armoni (2014), a propósito do alargamento do ensino de informática à toda a escolaridade obrigatória em Israel, conheci o postulado que Bruner escreveu no início do capítulo 3 do seu livro The Process of Education , de 1960: “ We begin with the hypothesis that any subject can be taught effectively in some intellectually honest form to any child at any stage of development ”. Ou seja, segundo Bruner, em princípio, a faixa etária do aprendente não é causa de limitação de um dado conteúdo de aprendizagem, uma vez que, pela teoria da espiral da aprendizagem (de sua autoria), os níveis de complexidade dos conteúdos vãose desenvolvendo ao longo do tempo (Figura 19). Figura 19. Espiral de Aprendizagem de Bruner (adaptado de Vemuru et al., 2013) 24 Assim, para além da não limitação a priori , a utilização do Android Studio pode contribuir para as boas práticas de informática (Quadros-Flores, 2011) e funcionar como um factor de motivação extrínseca, pois os alunos do ensino profissional sabem que existe a UC mais aprofundada no ensino superior. Segundo o modelo ARCS, trata-se de uma motivação do tipo “Relevância - Utilidade futura - R3.1 - Declarar explicitamente como a instrução se relaciona com as atividades futuras dos alunos” (Keller, 1987). Do ponto de vista da lógica da sequência dos conteúdos curriculares, pode dizer-se que a programação para Android é lecionada em PM porque (i) a arquitetura do Android está intimamente ligada à linguagem Java, e aos seus recursos de desenvolvimento de software, tendo os alunos estudado Java no 1º período. Do mesmo modo, o Android Studio é o IDE adotado por ter sido desenvolvido a partir do IDE IntelliJ IDEA (Toporov, 2013), o qual os alunos utilizaram no 1º período, representando uma oportunidade de aplicação/consolidação de conhecimento. No que respeita às metodologias de E-A, Freeman e co-autores (2014) publicaram uma metaanálise de 225 estudos, sobre alunos da área de ciências, com comparações entre os resultados de exames dos que tiveram formação em metodologia tradicional versus os resultados com formação em metodologias ativas. A comparação estatística mostrou que, no ensino superior, há diferenças significativas nos resultados, consoante a metodologia de ensino, sendo muito favorável às metodologias ativas. Contudo, no mesmo artigo, Freeman destacou que, na escolaridade obrigatória (K-12), a diferença a favor das metodologias ativas não foi tão significativa e recomendou uma melhor avaliação para alunos mais jovens. Em 2021, Brod relembrou que o tipo de interação aluno-professor deve ter em consideração o estádio cognitivo do aluno, de modo que, nos estádios mais iniciais da aprendizagem, a intervenção do professor deve ser no sentido de garantir que o aluno tenha acesso aos conhecimentos fundamentais de um dado conteúdo de uma forma clara e por um período suficiente para o interiorizar. A Figura 20, adaptada por Brod, ilustra as muitas variáveis envolvidas numa metodologia ativa para aprendizagem de ciências. As metodologias ativas pressupõem que o aluno já possui, ou é capaz de desenvolver durante o processo, os principais pré-requisitos de sucesso da aprendizagem, nomeadamente o interesse pessoal, o conhecimento anterior, as capacidades cognitivas e a capacidade de monitorizar e autoregular os processsos cognitivos. Num contexto educacional formal de ensino de ciências, a aprendizagem envolve a familiarização com as especificidades do setor em causa (por exemplo, o vocabulário), a manipulação matemática de dados, a simulação de modelos e a realização de experiências práticas. 25 As componentes das metodologias ativas são o próprio aluno, os seus pares e o professor; a qualidade e a quantidade de interação entre eles varia consoante a metodologia adotada. Em resumo, a escolha da metodologia de ensino de um conteúdo deve ter em conta a idade e o contexto sociológico do aprendente e ser adequada ao seu estádio de autonomia e desenvolvimento metacognitivo. Em muitos casos, metodologias com maior intervenção do professor podem ser adequadas. McLean (2016) refere que a metodologia de Aprendizagem Baseada em Caso (Case‐Based Learning, CBL) é uma ferramenta de ensino-aprendizagem usada na área da saúde, para dar ajudar na conexão da teoria à prática. Nos pressupostos da CBL, algum conhecimento básico é transmitido antes do período de aprendizagem - ao contrário da metodologia de Aprendizagem Baseada em Problema (Problem‐Based Learning, PBL) em que muitas vezes a informação é pesquisada durante o período de aprendizagem, podendo não haver informação prévia (Wijnia et al., 2017). Deste ponto de vista, para alunos do ensino secundário, a CBL pode ser mais apropriada que a PBL. No que respeita ao pensamento computacional na escolaridade obrigatória, e à utilização de ferramentas a ele associadas, a revisão de Bocconi et al.(2022), que abrangeu 30 países, relata 12 países que inserem o pensamento computacional ao nível da Educação e Formação Profissional Inicial (EFPi), ou seja, até o 3º ciclo, e 15 países onde é inserido ao nível do ensino secundário profissional (EFP). Em relação a Portugal, os autores mencionaram a realização de entrevista com os representantes oficiais, mas não incluem o país na lista dos que lecionam o pensamento computacional no ensino profissional (Bocconi et al., 2022, item 4.6, fig. 8). Figura 20. Pré-requisitos do Aprendente para Beneficiar das Metodologias Ativas, num Contexto Educacional Formal de Ensino de Ciências (adapt. Brod, 2021) 26 A relevância da estratégia adotada na QIP pode ser demonstrada através de autores que tenham relatado resultados favoráveis em estratégias semelhantes. No seu artigo de revisão, Butler (2018) cita vários autores que consideram a realização de um teste não só como uma ferramenta de avaliação mas também como uma atividade que pode promover aprendizagem. Em relação à avaliação da aprendizagem cognitiva, Iz e Fok (2007) apresentaram exemplos de testes de escolha múltipla até ao nível Analisar, da taxonomia de Bloom (Figura 21), para conteúdos de geomática. Comparativamente, parece-me razoável supor que o teste de Román-González, adaptado para Java, também atinge o nível Analisar, nas questões finais do teste (21-28). A principal autocrítica de Román-González à estrutura do seu teste CTt é o facto de ser focado em “conceitos computacionais” e apenas apresentar problemas lógicos e visual-espaciais, com labirintos e desenhos geométricos, ignorando outros aspetos do pensamento computacional, como, por exemplo, a narrativa interativa digital (Brennan & Resnick, 2012; Burke, 2012; Howland & Good, 2015; referidos por Román-González et al., 2017). No contexto da intervenção pedagógica descrita no presente relatório, a fragilidade do CTt apontada por Román-González foi, na verdade, uma mais-valia, pois os respondentes eram alunos de um curso profissional de programação informática e o que se pretendia verificar eram os seus estádios de conhecimento de conceitos de programação. Figura 21. Verbos e Atividades segundo a Taxonomia de Bloom Revisada (Hokkanen, 2015) 33 Passei à ligação código-tela. Expliquei que, para o código Java poder trabalhar com as telas Android, é preciso que o Java reconheça os elementos da tela – os Views ; temos de especificar uma ligação entre os objetos Java e os elementos View do XML, os quais são reconhecidos através de uma chave identificadora - o ID . No ficheiro activity_main , indiquei os atributos ID , e pedi aos alunos que renomeassem os IDs dos elementos usando uma convenção fácil de os identificar. Avisei que, sempre que fossem renomear IDs , que o fizessem através do comando Refactor > Rename (Figura 28). Avisei que o nome dos elementos View deve ser diferente dos objetos Java; enquanto o Java deve usar CamelCase e evitar underscores , o XML deve evitar maiúsculas e ligar palavras com underscores . Na classe MainActivity , declarei todos objetos Widget: são um grupo de classes que representam os elementos View interativos, como os TextViews (Figura 29). Convencionei a nomenclatura conhecida como Notação Húngara: prefixo indicando o tipo (txt - TextView ; edtxt - EditText) , seguido pelo nome. Figura 27. Mensagem Logcat do Botão Limpar Figura 28. Renomeação dos IDs dos Elementos View Figura 29. Declaração de Objetos Widget 34 Expliquei brevemente o método onCreate , o qual cria a tela quando a App é iniciada; tem um submétodo setContentView , o qual “inflaciona” o layout, isto é, preenche o ecrã da App com os elementos View localizados na pasta de recursos ‘res’(R), pelo do argumento R.layout.activity_main . Expliquei sobre o método findViewById para ligar objetos TextView e EditTex t aos Views . Tal como o setContentView , também busca elementos na pasta de recursos, e encontra-os pelos seus IDs ; o seu argumento é ‘R.id.elemento_View’ (Figura 30). Passei à programação do botão Limpar. Expliquei que “limpar” um texto não é apagar o que está escrito, mas “rescrever em branco”. Chamei o método setText do edtxtPeso com uma String vazia. Os alunos testaram a App no emulador, e o número do Peso foi “apagado” ao tocar no botão Limpar. Apliquei o mesmo método para todos os objetos Widget de texto no manipulador Limpar (Figura 31). Até aqui, a lecionação sedimentou conceitos aprendidos nas aulas anteriores: onClick para botões, findViewById para ligar objetos, setText para rótulos. Doravante, os alunos iriam aprender novos conceitos: o método getText ; e a conversão de valores com o método toString . Passei à programação do botão Calcular; disse-lhes para fazerem a ligação tela-código e o teste Logcat . Expliquei como o método getText busca valores dos objetos TextView e EditText. No entanto, estes objetos armazenam os valores em variáveis que não são do tipo String; é preciso convertê-los primeiro, através do método toString . Testei no emulador este método conversor com uma variável local strPeso , mostrando-a no rótulo IMC (Figura 32). Figura 31. Manipulador de Eventos Limpar com setText Figura 30. Ligação Código-Tela com findViewById 35 Propus que os alunos fizessem o mesmo para a ‘Altura’, mostrando o valor no rótulo ‘Mensagem’. Por esta altura, o tempo de sessão terminou, o Turno 2 saiu da sala, e entraram os alunos do Turno 1. A aula correu bem: os alunos não dispersaram, não houve problemas técnicos com o questionário do Google Forms, nem com o Android Studio. A gestão de tempo podia ter sido melhor; não tive tempo de explicar a conversão das Strings para Doubles , prevista na planificação. Ao rever a sessão em casa, penso que foi desnecessário repetir o teste Logcat para o botão Calcular. Figura 32. Teste de Receção do Valor do Peso 36 5.1.2. Sessão 2 – terça-feira 15 de março 2022, Turno 1 Sumário: 1º Teste Pensamento Computacional. Início da app IMC. A segunda sessão seguiu um percurso parecido ao da primeira, exceto que avançou apenas até à ligação findViewById no método onCreate . Fiz uma exposição curta sobre o conceito de Pensamento Computacional; disse aos alunos que iria comparar a pontuação dos testes CTt e analisar se a aprendizagem de Android contribui para o desenvolvimento desta habilidade. Avisei que depois dos testes iria fazer entrevistas individuais aos alunos sobre os resultados obtidos. Quando o teste começou, avisei também que a questão nº10 tinha um erro (Figura 33). O teste terminou em 40 minutos e os alunos saíram para o intervalo. Depois do intervalo, iniciei a aula de Android com uma curta revisão dos conceitos da App Hello Toast; as ligações tela-código para o botão Count e ligações código-tela para ambos o botão e o rótulo de contagem. O novo conceito a aprender nesta aula seria a caixa de texto; como fazer as suas ligações código-tela, e como manipular os valores escritos nelas. Tabela 6. Planificação da Sessão 2 37 Demonstrei o funcionamento da App IMC no projetor; os alunos baixaram o projeto com a tela préfeita na página do Nónio. Direcionei os alunos ao ficheiro activity_main , e dei instruções para adicionar o atributo onClick ao botão Limpar e criar o manipulador de eventos. Os alunos testaram o botão Limpar com o Logcat , confirmando que a ligação tela-código estava a funcionar. Para programar o botão Limpar, expliquei como primeiro os elementos View têm de ter um ID . Indiquei os atributos de identificação no activity_main , e os alunos renomearam os IDs através do comando Refactor > Rename . Adverti que renomeassem com uma notação simples e que diferenciasse dos objetos Java. Declarei objetos Widget no MainActivity – os TextViews e os EditTexts . Expliquei o método setContentView , o qual “inflaciona” o layout com os recursos da pasta ‘res’. Os alunos fizeram a ligação código-tela dos objetos Widget com o método findViewById . Alguns alunos lembraram-se deste conceito, aprendido no “Hello Toast”. Passei à programação do botão Limpar. Expliquei que “apagar” um texto é o mesmo que “sobrescrever” com uma String vazia. Fiz uma analogia das funções Getter e Setter do Java, com as funções getText e setText . Estas funções foram chamadas no manipulador Limpar para os quatro objetos de texto da App. Os alunos testaram o botão Limpar para apagar quaisquer textos digitados, confirmando que os objetos estão ligados aos elementos View . Para programar o botão Calcular, comecei por mencionar as Hints “Quilos” e “Metros”, e a fórmula de cálculo no rótulo IMC. Expliquei que são atributos XML, que funcionam como rótulos temporários, e que servem para indicar o tipo de dado a ser inserido na caixa de texto (Figura 34). Figura 33. Questão 10 do teste CTt; Opção C Corrigida 38 Comecei a programar o botão Calcular através de um teste de receção de dados: o valor digitado na caixa ‘Peso’ seria copiado para o rótulo ‘IMC’, e o valor da ‘Altura’ para o rótulo ‘Mensagem’. Por esta altura, o tempo de sessão estava quase a terminar. Informei que na próxima aula iríamos aprender este novo método de buscar valores das caixas de texto, o getText . Esta sessão correu melhor que a primeira. A sequência dos conteúdos fluiu mais facilmente; consegui cumprir a planificação deste turno, com tempo de sobra. Depois de lecionar o método setText , tentei avançar um pouco a matéria de modo a acompanhar no turno anterior. Talvez não devesse ter mencionado os Hints nesta aula: este atributo estava planeado para a sessão do ICQ. Devia ter mantido o foco no getText das caixas de texto. Quanto à notação húngara: há quem discorde da sua utilidade, mas creio que serve de apoio para iniciantes de programação. Figura 34. Hints nas Caixas de Texto e no Rótulo IMC 39 5.1.3. Sessão 3 – sexta-feira 18 de março 2022, Turno 1 Sumário: Continuação da app IMC, função Calcular Comecei por rever os conceitos: atributo onClick , manipulador de eventos, objetos TextView e EditText. Relembrei a ligação dos objetos às Views pelo findViewById e o método setText . Repeti a programação botão Limpar. Chamei os métodos setText com Strings vazias para todos os objetos Widget de texto. Digitei o código enquanto perguntava aos alunos ‘o que é que este comando faz?’, ‘porque é que se faz isto?’, ‘o que vem a seguir?’, etc. Enquanto consolidava os conceitos da aula anterior, cometi um erro, e este mostrou-se ao testar no emulador: o botão Limpar não funcionava. Perguntei “alguém reparou o que fiz de errado?”, e depois encontrei o erro: o atributo onClick foi criado no botão Calcular ao invés do Limpar. Na sessão seguinte iria demonstrar o Debugger para resolver um problema intencional com exceções nulas. Tabela 7. Planificação da Sessão 3 40 Continuei a programação do botão Calcular. Expliquei como este manipulador deve receber os valores das caixas de texto, fazer um cálculo e escrever nos rótulos o resultado. Relembrei que a função que recebe valores é a getText ,e fiz um teste de receção do valor Peso (Figura 35) Mostrei como fazer para o botão Calcular receber os valores Peso e Altura, e converter esses valores em Strings , com os métodos encadeados getText e toString . Depois, fiz o botão mostrar essas Strings nos rótulos IMC e Mensagem (Figura 36). Observei os alunos a codificarem. Perguntei ao turno “como fariam para somar o Peso e Altura?”. Um aluno disse que era preciso criar variáveis. Expliquei que as Strings têm de ser convertidas para Double para poder fazer cálculos; depois de calcular, o valor Double volta a ser convertido para String , para poder ser escrito no rótulo IMC. À medida que ia explicando, digitei comentários entre as linhas de código para ajudar a compreensão dos passos da conversão (Figura 37). Expliquei como a variável Double (com maiúscula) é um objeto com métodos próprios de conversão: de String para Double utiliza-se o parseDouble, e toString para vice-versa. Disse aos alunos para aplicarem estes métodos para efetuarem a soma, e depois subtituírem pelo cálculo do IMC. Figura 35. Teste getText para Peso Figura 36. Conversão do Peso e Altura para String Figura 37. Conversão de Strings para Doubles e Teste de Soma de Valores 41 Pu-los a programar e circulei pela sala a tirar dúvidas. Um aluno conseguiu concisar o código sem usar nenhuma variável auxiliar String e Double , de modo que o manipulador Calcular reduziu-se a apenas uma linha de comando (Figura 38) Passei à importação da classe IMC. Fui ao painel de projeto e transferi o ficheiro de classe para a pasta Java de domínio (neste caso: com.example.imc ), e adicionei o comando package . O professor José Pereira advertiu que esta operação devia ser feita de outro modo – criar uma nova classe Java, e colar o código IMC na classe criada. Esperei que os alunos criassem as novas classes; reparei que a maioria não tinha os trabalhos IMC com eles, pediram trabalhos emprestados a outros colegas. Mostrei a classe IMC no projetor, com o construtor e a função calculaIMC (Figura 39). Expliquei a programação do método Calcular começando por instanciar um objeto IMC. Os parâmetros do construtor IMC são o Peso e Altura; estes valores devem ser recebidos pelos métodos getText e pelos conversores toString e parseDouble (Figura 40). Perguntei “qual o próximo passo?”, e um aluno respondeu “é chamar o calculador e pôr no setText”. Concordei, mas adverti que o valor de retorno do calculaIMC é um objeto Double , e o setText só aceita objetos String . Disse para converterem para String com o método toString (Figura 41). Figura 38. Concisão Máxima do Manipulador Calcular Figura 39. Classe IMC, sem o Método Classifica Figura 40. Instanciação do Objeto IMC 42 Após testarem o código no emulador, apontei para o txtImc . setText e perguntei “porque é que o Android Studio fez este realçado a amarelo?” Expliquei que é um aviso do analisador do compilador: apesar do código não ter erros de sintaxe, ainda pode induzir a erros (bugs) devido à não especificação ou incompatibilidade de versões. Neste caso, ao converter um objeto Double, com numeros reais e várias casas decimais, para um objeto String, é aconselhado especificar a localidade, porque, dependendo do país, a vírgula pode não ser reconhecida como separador decimal (por exemplo, nos EUA usa-se ponto). Recomendei usarem a função String . format . O problema é que esta função não recebe objetos Double . Então modifiquei o método calculaIMC para retornar primitivas double (Figura 42) A função String.format pode ter até três parâmetros – localizador, especificador de formato, e o valor a ser formatado. Para o localizador, usa-se Locale . US; para o especificador, %.2f (isto é, um floating point com duas casas decimais); e para o valor, o resultado do calculoIMC (Figura 43). Observei os alunos a fazerem a conversão. Reparei que alguns ainda estavam no construtor IMC, aparentemente confusos com o uso dos Double.parseDouble . Voltei a explicar que o Double é um objeto com funções próprias, e double é uma variável primitiva. Passei à prevenção contra exceções nulas. Projetei o emulador no quadro e perguntei “O que acontece se eu clicar no ‘Calcular’ sem ter nada no Peso e na Altura?”, e demonstrei como o programa pára de funcionar, ou ‘estoura’. Expliquei que aconteceu um erro de excepção, no qual tentámos passar um valor nulo para o método getText.toString de um dos objetos EditText . Expliquei que, para evitar estas exceções, deve-se criar uma condição if para verificar se as caixas de texto estão vazias. Se estiverem, o método Calcular deve terminar com return , e indicar no rótulo Figura 41. Conversão com Double.toString Figura 43. Conversão com String.format Figura 42. Método calculaIMC com doubles 49 O utilizador deve preencher pelo menos a Cintura e Quadril para a App poder calcular o ICQ. O utilizador deve preencher pelo menos a Cintura, Quadril e o Sexo para a App poder calcular o ICQ, e a classificação do ICQ. As caixas de texto Nome e CC são acessórias, mas o Nome pode ser chamado na mensagem de classificação (por exemplo, “João, o seu ICQ está dentro do recomendado”). Ao tocar no botão Limpar, todos os rótulos e caixas de texto são apagados. O ecrã principal deve ser rolável, e também deve ter uma tela pré-configurada para a orientação horizontal, na qual o título e os botões ficam fixos no topo e no fundo. Após demonstrar o funcionamento da App, os alunos iniciaram o Android Studio e criaram um novo projeto, do template Empty Activity , com o SDK mínimo de API 21: Android 5 (Lollipop). Abri o painel activity_main, e expliquei-lhes a estrutura da App ICQ. A App deve ser organizada em três secções: cabeçalho, corpo e rodapé. O cabeçalho é composto por um rótulo com o nome da aplicação. O corpo é composto pelas várias caixas de texto, que servem para receber os dados a serem calculados. O rodapé é composto pelos dois botões que executam as funções da App. Os alunos devem organizar a tela com 3 Viewgroups do tipo ConstraintLayout , e 1 ViewGroup do subtipo ScrollView, do tipo FrameLayout . Os ConstraintLayouts servem para restringir (constrain) os elementos View dento deles. O ScrollView permite ver estes Views na orientação horizontal pela rolagem da tela. Figura 52. App ICQ em Oorientação Vertical (esquerda) e Horizontal (direita). 50 Transformei o rótulo Hello World no cabeçalho. Disse para abrirem o rótulo“ Hello World ” no painel dos Atributos; fui ao Constraint Widget , e removi a restrição de baixo (bottom) . Isto fez com que o rótulo ficasse adjacente ao topo do seu layout-pai (Figura 53). Os atributos devem ser: id ”header_title”; text “Índice Cintura-Quadril"; padding “10dp”; background “color/holo_blue_dark". Assim, o rótulo passou a ser o cabeçalho (Figura 54). Passei para a construção do rodapé. Na palete, selecionei um elemento ConstraintLayout na lista de Layouts , e arrastei-o para debaixo do cabeçalho. Arrastei os constraints do começo (lado esquerdo), fim (lado direito) e fundo (lado de baixo) às bordas da tela (Figura 55). Configurei os atributos do novo ConstraintLayout : - id :"constraintlayout2"; - layout_width "match_parent"; - layout_height "200dp". Adverti aos alunos que é importante atribuir uma chave de identificação aos layouts, assim será possível fazer constraints entre elementos mesmo quando os pontos de conexão não estão visíveis no editor de Design. Defini o id do ConstraintLayout original como "constraintlayout1”. Expliquei o porquê de a altura do rodapé estar excessivamente alta - devemos definir uma altura excessiva para permitir espaço suficiente para arrastar os botões para dentro deste layout. Quando estiver terminado, a altura do rodapé poderá ser redefinida como “wrap_content” . Figura 53. Construção do Cabeçalho: Modificação do rótulo Hello World Figura 54. Construção do Cabeçalho: Padding e Background Color Figura 55. Construção do Rodapé: ConstraintLayout 51 Arrastei dois elementos Button da palete para dentro do rodapé; depois arrastei os constraints de modo a que fiquem centrados e empilhados (Figura 56). Assim, o rodapé consiste de um ConstraintLayout separado, com dois botões. Isto foi para que os botões estejam sempre visíveis na borda inferior quando o ecrã estiver em orientação horizontal; se os botões não fizerem parte do ScrollView , não serão rolados para baixo com o resto. Circulei pela sala a observar o progresso dos alunos. Alguns estavam a passar à frente das instruções, já a construir as caixas de texto, enquanto outros estavam a tentar seguir a estrutura cabeçalho-corpo-rodapé, com dificuldades nos constraints. Reparei que, da maneira que muitos estavam a fazer – apenas com um layout – quando fossem testar a App no emulador, todos elementos iriam ser rolados para cima junto com a tela. Esta estrutura foi planeada com três layouts para que apenas o ScrollView no centro rolasse a tela, enquanto o cabeçalho e o rodapé se mantinham estáticos – mas os alunos estavam a ter dificuldades com esta implementação de três layouts. Avisei que a estrutura de três layouts podia ser opcional. O importante era que conseguissem aplicar o ScrollView . Por esta altura, os alunos saíram para o intervalo. Quando voltaram, passei à construção do corpo da App. A partir da palete, arrastei um elemento ScrollView para baixo do cabeçalho. Disse para arrastarem os constraints de modo a que o ScrollView ficasse estendido desde a margem de fundo do cabeçalho até à margem de topo do rodapé. No painel dos atributos do ScrollView , configurei-os com: layout_height "0dp" (match_constraint); fillViewport "true"; layout_constraintTop_toBottomOf "@id/header_title"; layout_constraintBottom_toBottomOf "@id/constraintLayout2". Expliquei que, para o atributo layout_height “0dp”, se a altura do ScrollView for definida como zero (ou match_constraint ), ele adapta-se como se fosse wrap_content , mas não se sobrepõe a outros layouts externos a ele, e fica adjacente ao elemento restrito acima dele - o cabeçalho. Figura 56. Construção do Rodapé: Botões Figura 57. Corpo com ScrollView 52 O atributo fillViewport “true” faz com que o ScrollView estenda a sua altura até ficar igual à altura do dispositivo; isto permite arrastar as caixas de texto para dentro do constraintlayout2 . Expliquei que o ScrollView não permite constraints dentro dele, porque é uma subclasse de FrameLayout . Como faz parte de um ViewGroup diferente, segue regras e métodos diferentes. Quando o ScrollView é arrastado da palete para o editor de Design, traz com ele, por padrão, um LinearLayout com orientação vertical, por isso apaguei esta parte do código. Para poder usar atributos constraint nos elementos do ScrollView , é preciso inserir um ConstraintLayout dentro dele. Inseri um terceiro ConstraintLayout ; dentro do ScrollView no meio da tela. Configurei os seus atributos como: id “constraintlayout3”; layout_width “match_parent”; layout_height “0dp”. Assim, a tela passou a ter um corpo rolável capaz de ligar elementos com constraints . O próximo passo foi a adição destes elementos -- as caixas de texto e os rótulos. Passei a mostrar como o processo de adicionar vários elementos View alinhados pode ser feito de um modo eficiente e sistemático através de uma cadeia vertical. Expliquei que uma cadeia (Chain) é um grupo de elementos View vinculados uns nos outros com constraints bidirecionais, podendo ser distribuídos vertical ou horizontalmente. Adicionei o primeiro elo (Chain Head) e arrastei uma caixa de texto para o corpo. Liguei os constraints às bordas laterais da tela e do cabeçalho(). Arrastei mais quatro caixas de texto e mais dois rótulos para o corpo, um em baixo do outro. Selecionei-os todos, cliquei com o botão direito no primeiro elo, e a partir da lista drop-down, selecionei Chains > Create Vertical Chain . Depois, fiz o alinhamento da cadeia com Center > Horizontally : Criaram-se constraints laterais ligadas às bordas para todos os elos da cadeia (Figura 59). Defini um estilo para a cadeia (Chain Style), isto é, a distribuição de espaço entre elos encadeados. A partir do primeiro elo, selecionei Chains > Vertical Chain Style > packed . A cadeia ficou com os elos centrados no layout (Figura 59). Expliquei que este estilo impede a variação do espaçamento entre os elos, quando a App for orientada horizontalmente, ou quando for utilizada em telemóveis com ecrãs muito compridos. Figura 58. Primeiro Elo da Cadeia Vertical 53 Defini uma margem para os espaçamentos: selecionei todos os elos, abri o separador dos atributos e fiz uma pesquisa (Search) para filtrar atributos com nome “margin” ; expandi a lista layout_margin , e atribuí “ 16dp ”. Passei à orientação horizontal. No painel de Design, abri o seletor de orientação e fiz Create Landscape Variation. Automaticamente, o Android Studio criou um ficheiro de layout para orientação horizontal na pasta de projeto res/layout/activity_main; este novo ficheiro XML tem o sufixo ( _land) . Circulei pela sala e vi os alunos fazerem as suas telas. Alguns conseguiram colocar e alinhar sem o uso do Chains , e alguns dos que usaram Chains estavam a experimentar com outros estilos de espaçamento além do Packed . Voltei à secretária, e adicionei os rótulos permanentes; arrastei seis Textviews ao lado das caixas de texto, e liguei os constraints de fim e de começo. Passei para a ligação dos Baselines dos rótulos. Os constraints do tipo Baseline fazem um alinhamento ao nível da linha do sublinhado dos textos. No primeiro rótulo, com o botão direito selecionei “ Show Baseline ”. O rótulo criou uma linha curva no nódulo do lado de baixo; arrastei essa linha para o Baseline da caixa de texto adjacente, e os elementos alinharam-se. Repeti este processo para os rótulos restantes (). Disse aos alunos para tentarem fazer o mesmo processo. Dediquei o resto da aula a tirar dúvidas sobre constraints e baselines . No final, avisei que a aula seguinte seria dedicada à programação Java da App ICQ. Figura 59. Cadeia Centrada Horizontalmente Figura 60. Rótulos e Caixas de Texto com as suas Baselines Alinhadas 54 5.1.6. Sessão 6 – terça-feira 22 de março 2022, Turno 1 Sumário: Conclusão da app IMC com metodo classifica. Início da app ICQ com construção da tela . A segunda sessão seguiu o mesmo percurso da primeira, exceto que esta avançou apenas até à orientação horizontal de layout . Fiz uma revisão da aula anterior; perguntei sobre as ligações código-tela do findViewById , e telacódigo do atributo onClick ; perguntei sobre a conversão de Strings para Doubles através de método parseDouble , e a de Double para String com String.format. Na aula anterior, o Turno 1 tinha ficado pela verificação de caixas de texto vazias; retomei a parte final deste tópico, na qual o rótulo Mensagem chama o método setText para escrever uma String a indicar que falta inserir o Peso, ou a Altura (Figura 61). Passei para o método classifica. Esta função consiste de uma série de condições if que retornam Strings diferentes consoante a gama de valores do resultado do cálculo IMC; estas Strings aparecem na tela quando o método classifica é chamado pelo setText do rótulo Mensagem. Tabela 10. Planificação da Sessão 6 Figura 61. Verificação Correta: Condicionais if com retorno 55 Circulei pela sala, observando o código dos alunos; todos tinham trazido o trabalho anterior do IMC em Java e estavam a copiar a função. Alguns ainda tinham dúvidas na parte de conversão de Double para String , e passei alguns minutos a esclarecer individualmente. A primeira aula de 45 minutos terminou, e mostrei no projetor o meu email institucional para enviarem os trabalhos; avisei que, para os alunos que ainda não tinham terminado, a data limite de entrega seria até terça da semana seguinte, 29 de março. Também avisei os alunos que ainda não tinham entregue o consentimento para o teste CTt que o fizessem, caso contrário não divulgaria os resultados. Comecei a lecionação da App ICQ. Para esta App, os alunos iriam começar a partir de um novo projeto Android do template Empty Activity , e construir a tela do zero. Com o problema do endereço SDK resolvido, abri o emulador e demonstrei a estrutura da App: é composta por 3 layouts - 2 do tipo constraint, 1 do tipo ScrollView ; o primeiro layout (cabeçalho) tem 1 rótulo, o segundo (corpo) tem 5 caixas de texto e 2 rótulos, e o terceiro (rodapé) tem 2 botões. Para este turno, decidi adiar a explicação do funcionamento dos botões para a aula seguinte; não haveria tempo suficiente para começar a programá-los nesta aula. Mostrei como construir o cabeçalho, alterando os atributos do rótulo Hello World inicial. Para o rodapé, mostrei como criar um novo ConstraintLayout e dimensioná-lo no canto inferior da tela, de modo a haver espaço para os dois botões. Arrastei os dois botões da palete para o rodapé, e disse-lhes para reconfigurarem o atributo de altura do rodapé para wrap_content , de modo a economizar espaço entre os botões e o corpo. Construí o corpo, introduzindo um ScrollView com um constraintLayout dentro dele; expliquei que a rolagem do ecrã não deve incluir os botões – por isso usamos um layout do tipo constraint separado. Avisei que quem estiver com muita dificuldade em fazer os três layouts, pode construir apenas um, e que deve pôr nele o ScrollView de modo a possibilitar a rolagem do ecrã. Para a orientação horizontal, expliquei como criar um ficheiro de layout ao selecionar Landscape no botão de Orientation Preview; abri o separador land/activity_main.xml , e mostrei como economizar a altura do modo horizontal, e reposicionar os botões Calcular e Limpar lado-a-lado (Figura 62). Avisei que este novo ficheiro de layout horizontal não é atualizado quando são feitas mudanças no ficheiro de layout retrato original. 56 Por esta altura, a sessão estava quase a terminar, por isso dediquei-me a tirar dúvidas acerca dos constraints e do ScrollView até os alunos saírem. Revendo estas sessões, acho que não expliquei bem a estrutura de classes dos ViewGroups . Esta informação é desnecessária para um principiante. Basta saberem que o ScrollView não funciona com Constraints ; o porquê disto é demasiado complexo. Também fiquei com a sensação de que o alinhamento das Baselines foi um passo puramente acessório; no entanto, é importante conhecer este atributo, pois se duas Views de texto adjacentes tiverem tamanhos de letra diferentes, sem este atributo elas ficam desalinhadas. No início da aula, um dos alunos não conseguiu baixar o ficheiro de projeto Android da página da disciplina; a internet estava muito lenta para baixar um ficheiro de 15 Mb. Transferi o projeto pessoalmente no PC do aluno através da minha Pen-drive USB. Mais tarde, após pesquisar em casa, descobri que estava a disponibilizar os projetos Android para os alunos de maneira ineficiente: exportava o projeto, e fazia upload dessa pasta “zipada” na plataforma Nónio. Aprendi que existe um passo importante a ser feito antes de transferir um projeto: através do painel Build > Clean Project , o qual remove as pastas Build , reduzindo-o consideravelmente de tamanho (de 15Mb a aprox. 500Kb). É possível que a causa do erro de localização do SDK tenha sido o facto de os ficheiros de projeto que eu disponibilizava não terem passado pelo Clean Project , e algumas das configurações mantiveram o endereço original do SDK do meu computador. Figura 62. Layout da App ICQ em Orientação Horizontal 57 5.1.7. Sessão 7 – sexta-feira 25 de março 2022, Turno 1 Sumário: Continuação da app ICQ. Ligações tela-código e classe-código. Para esta sessão estava previsto completar a App ICQ de modo a poder começar na semana seguinte a lecionação de uma App com Intents . No entanto, muitos alunos não avançaram na construção das telas. Pensei em disponibilizar uma App ICQ com as telas já feitas, para aqueles que estavam a ter dificuldades; mas reconsiderei, pois esta parte da disciplina contém critérios que contam para a avaliação final. Retomei a lecionação do Turno 1 com a criação dos três layouts. Confesso que contava que alguns alunos tivessem terminado os elementos da tela em casa, mas nenhum fez qualquer avanço na App fora do tempo de aulas. Expliquei a organização das caixas de texto em cadeia vertical. Arrastei cinco caixas Plain Text, selecionei-as e fiz Create Vertical Chain . As caixas de texto ligaram-se todas com constraints entre si; depois com Center Horizontally, ligaram-se entre as bordas da tela. Defini o estilo para o espaçamento entre as caixas de texto como Packed , e a margem entre elas foi definida em grupo, com um filtro no painel Atributos para layout_margin , com o valor 16dp . Observei os alunos a construírem as telas. Reparei que poucos alunos implementaram os três layouts, e também poucos tinham implementado o ScrollView . Tabela 11. Planificação da Sessão 7 58 Passei à introdução dos novos atributos das caixas de texto - InputType e o Hint . Expliquei como os Hints são textos de indicação, que se apagam depois de digitar na caixa de texto. Hints poderiam até substituir o rótulos de Nome , Sexo , etc, mas, para esta App, servem como informação adicional. Para a caixa de texto Nome, o Hint deve indicar que há um limite de 20 caracteres; para o Sexo, digitar apenas uma letra, M ou F, aceitando maiúscula ou minúscula; para o CC, um limite de 8 caracteres numéricos; para a Cintura e Quadril, deve indicar que a escala é em centímetros; e para o rótulo IMC, indica a fórmula ”Cintura/Quadril”, a qual será sobrescrita com o resultado. Introduzi o atributo InputType . Mostrei que as caixas de texto podem ser configuradas para receberem diferentes tipos de dados. Para caracteres alfabéticos, inseri inputType =”text” e deixei a lista de sugestões aparecer; dos vários tipos, selecionei “textPersonName” . É possível concatenar configurações: por exemplo, com “ textPersonName|textCapWords ”, testei no emulador e mostrei como a primeira letra de cada palavra é “capitalizada”. Para limitar caracteres a 20, inseri maxlength= ”20”. Parei a demonstração dos atributos e deixei os alunos configurarem as outras caixas de texto. Passei à programação da MainActivity . Ao invés do IMC, comecei pelas ligações código-tela ao declarar os objetos Widget . Nesta parte, muitos alunos fizeram o esperado: copiaram o código do método onCreate do IMC e conformaram-no para o ICQ. Fizeram o mesmo para o método Limpar. Passei para a programação do botão Calcular; comecei por importar a classe ICQ, e mostrei o código no projetor. Lembrei que a App ICQ não precisa de todos os valores de entrada (inputs) para efetuar o cálculo. Disse que devemos criar primeiro um construtor ICQ que receba apenas os inputs númericos da Cintura e Quadril (Figura 63). No manipulador Calcular, instanciei um objeto icq2 com dois parâmetros (Figura 64); os valores do nome, sexo e CC são usados para outros objetos. Expliquei que este é o conceito de sobrecarga de construtores, e que para o ICQ utilizaríamos pelo menos dois construtores diferentes. Figura 63. Classe ICQ: Construtor com 2 parâmetros 65 A sessão prolongou-se com retrospectivas dos conceitos das aulas anteriores. Para o Turno 2, depois do intervalo, fiz uma demonstração de como fazer uma depuração de exceções nulas, através do Debugger (Figura 70). Não tive tempo de demonstrar o Debugger para o Turno 1. Antes de a aula terminar, solicitei a todos que enviassem os trabalhos ICQ por email. Os alunos dos dois turnos enviaram os seus trabalhos e saíram. Mesmo assim, ao chegar em casa, verifiquei que faltavam os trabalhos de dois alunos. Figura 70. Demonstração do Debugger 66 5.1.10. Sessões 11 e 12 – sexta-feira 1 de abril 2022, Turnos 1 e 2 Tabela 14. Planificação das Sessões 11 e 12 67 Sumário: Conceito de Intento (Intents). Início da app DuasAtividades. 2º Teste de Pensamento Computacional. Questionário de Avaliação do Prof. Estagiário. No última dia, os conceitos a serem ensinados foram os Intents – que são métodos para comunicação entre duas ou mais Activities . A Professora Supervisora Altina Ramos e o meu colega Pedro Sequeira estiveram presentes nas aulas do T2. Houve três faltas no T1, duas no T2; e um aluno do T2 chegou 15 minutos atrasado. Comecei por recordar como aprendemos a criar Apps com apenas uma Activity . O próximo passo seria aprender a gerir a ligação entre duas Activities numa App (Figura 71). Expliquei como a Activity principal – MainActivity – é a que aparece na tela quando o utilizador abre uma App, e que, embora as Activities de uma App funcionem umas com as outras, cada Activity é independente das outras; pode-se iniciar uma Activity numa App “A” e permitir que outra App “B” inicie atividades usando os dados da App “A”. Dei exemplos de Apps contendo várias Activities: uma para tirar fotos com a câmara do telemóvel, e outra para enviar as fotos e-mail; Disse que a comunicação entre Activities na mesma App é feita através dos Intents . Expliquei a diferença entre Intents: no Intent implícito, a atividade de recebimento não é especificada; declara-se uma ação geral a ser executada e o sistema procura localizar uma atividade que consiga lidar com a ação solicitada; enquanto que, no Intent explícito, a atividade de recebimento é especificada, pelo nome da classe da atividade. Em geral, os intentos explicitos são usados para iniciar componentes no próprio aplicativo, por exemplo, para mover entre telas na interface do utilizador. Figura 71. Diapositivo sobre Activities 68 Demonstrei no emulador a App DuasAtividades_Levar (Figura 72): consiste de duas telas, uma para a atividade principal MainActivity , e outra para uma segunda atividade, SecondActivity . O utilizador só visualiza uma tela de cada vez, ambas têm um cabeçalho de cor diferente. No centro, a MainActivity tem uma caixa de texto, e a SecondActivity tem um rótulo. No rodapé, a MainActivity tem dois botões: ‘Enviar com Dados’ e ‘Enviar sem Dados’; ao tocar no ‘Enviar com Dados’, a App abre a tela da SecondActivity , e o conteúdo da caixa de texto é copiado para o rótulo da SecondActivity . Ao tocar no ‘Enviar sem Dados’, o rótulo da segunda tela mantém-se igual. A SecondActivity tem um botão no rodapé chamado ‘Voltar’; ao ser tocado, tal como o botão ‘Enviar sem Dados’, apenas muda de tela. Os alunos baixaram o projeto “DuasAtividades_layout”, da página do Nónio; o projeto continha apenas as telas feitas. Tal como na primeira aula da App IMC, o objetivo era programar os botões da App com o código Java. Comecei por programar o botão Enviar Sem Dados, cuja funcão serve como conceito de base para esta sessão: usar um Intent para iniciar (start) outra atividade. Expandi o painel do projeto, e mostrei que esta App tem dois ficheiros XML na pasta de recursos : activity_main e activity_second . Figura 72. App DuasAtividades_LevarDados 69 No ficheiro activity_main , criei o manipulador do botão Enviar Sem Dados com o atributo onClick . Mostrei como adicionar um Intent explícito à classe principal, ao instanciar um novo objeto Intent dentro do manipulador enviarSemDados (Figura 73) Expliquei o construtor do Intent ; tem dois parâmetros: um de Contexto, que permite acesso a outras classes no mesmo domínio, e outro de Classe, que explicita a classe com que o Intent vai trabalhar. Neste caso, o Contexto é o domínio do projeto ( this ), e a classe é a SecondActivity . Aconselhei nomear os Intents especificando o que eles fazem ( irParaSecondAct ). Chamei o método startActivity para o Intent criado, e testei no emulador. Cliquei no botão Enviar Sem Dados, e o ecrã mudou para a tela da SecondActivity. Perguntei aos alunos “Como faço para voltar à MainActivity , sem ser pelo botão de navegação para voltar atrás?”. Disse que o “voltar atrás” trata-se de terminar a atividade SecondActivity . Expliquei que o Intent de irParaSecondActivity inicia uma nova atividade, mas a atividade inicial MainActivity ainda estava a correr na aplicação. No ficheiro de layout activity_second , inseri o atributo onClick no botão Voltar, e automaticamente fui para o ficheiro de classe correspondente, SecondActivity . Inseri o método finish no manipulador Voltar (Figura 74). Testei o botão no emulador, “voltando” para a tela da MainActivity . Disse a todos para programarem o Intent nos seus projetos. Dediquei alguns minutos a observar o código dos alunos. Passei à programação dos Extras. Expliquei que a classe Intent inclui chaves Extras como constantes que começam com prefixo EXTRA; por exemplo, pode-se usar Intent.EXTRA_EMAIL para indicar endereços de e-mail como Strings . Disse que devemos definir as nossas próprias chaves, convencionalmente como variáveis estáticas, começando com o prefixo EXTRA_. Para garantir que a chave seja exclusiva, o valor da String da chave deve conter o domínio todo da aplicação (Figura 75). Figura 73. Instanciação de um Objeto Intent; Método startActivity Figura 74. Manipulador Voltar: Método finish Figura 75. Declaração da Chave Extra_Dados com Domínio 70 Criei um EditText chamado edtxtMain para a caixa de texto da MainActivity , e fiz a ligação códigotela no onCreate . Com um objeto EditText para receber os dados e uma chave Extra para transferi-los, passei à programação do segundo botão, Enviar com Dados. Tal como no Enviar sem Dados: criei um Intent para iniciar a classe SecondActivity . Antes de a iniciar, chamei o método putExtra do Intent criado, com dois parâmetros: a chave Extra, que armazena os dados a serem transferidos, e a variável String , a ser armazenada (Figura 76). Na classe SecondActivity ; criei um rótulo (TextView) para mostrar a String da chave Extra_Dados e fiz a sua ligação com o elemento View . Para receber um Intent com dados, é preciso criar um Intent que os receba; instanciei-o dentro do onCreate com o método getIntent ; com o nome intentMainAct . (Figura 77) Criei uma String auxiliar chamada dadosMain para buscar a String do Extra_Dados . Chamei o método getStringExtra do intentMainAct , e nele chamei a Extra_Dados da MainActivity. Finalmente, usei o método setText do rótulo para escrever a String dadosMain (Figura 78). Testei a App no emulador com uma mensagem “ hello ” na MainActivity , e esta apareceu na SecondActivity . Disse para programarem os Intents e os Extras , e circulei pela sala a observar os programas. Este foi o ponto final da lecionação em comum aos dois turnos. No dia 01/04, o T1 tinha mais tempo de aula, então, continuei a lecionação dos Intents por mais uma aula de 45 minutos: A App deve verificar se a Extra_Dados está vazia. Estando, deve enviar uma mensagem para o utilizador a dizer “Sem Dados Recebidos”. Figura 76. Manipulador Enviar Com Dados: Método putExtra Figura 77. Receção do Intent com Método getIntent Figura 78. Método getStringExtra 71 Desta vez, insisti que os alunos do Turno 1 revissem os conceitos anteriores para resolver as questões atuais; disse-lhes para usarem o método isEmpty para o caso da chave estar vazia, e um else em caso contrário. Sugeri que utilizassem a mesma lógica de verificação de caixas de texto vazias usada nas Apps IMC e ICQ. Apercebi-me que havia alunos com diferentes tipos de dificuldades. Alguns tinham compreendido que o mecanismo de verificação é basicamente If – Intent – getString – isEmpty , mas não sabiam que método certo para buscar Strings é getStringExtra . Outros não tinham percebido que a verificação deve ser feita na SecondActivity , e tentaram aplicar o método getString no EditText da MainActivity . Só os melhores alunos escreveram o código do mecanismo if de forma correta (Figura 79) depois de terem pesquisado no Codelabs Android Fundamentals. Houve até um aluno muito bom que foi criativo e aplicou um Toast em vez de setText! (Figura 80) Depois de observar o progresso de alguns, revelei que o código if que eles tinham implementado tinha resolvido um problema, mas criado outro – a App passou a ‘estourar’ ao clicar-se no botão Enviar Sem Dados. Expliquei que é uma exceção: o método OnCreate está a verificar se a chave Extra_Dados tem a String vazia, antes de verificar se a própria chave existe. A linha do else declara e busca uma String de um Extra, mas quando clicamos no Enviar Sem Dados, o Intent cria a atividade SecondActivity , mas não cria uma chave estática com o putExtra . Figura 80. Verificação de Extras Vazios com Mensagem Toast Figura 79. Verificação de Extras Vazios Incompleto 72 Por isso, é preciso verificar primeiro se a chave Extra existe no Intent. Para isso, cria-se préviamente um if que chama o sub-método hasExtra (Figura 81). Em 01/04, apliquei o segundo teste CTt na última aula de cada turno. Orientei os alunos para acederem aos emails e entrarem no Google Forms. O conteúdo foi o mesmo do primeiro teste, porém, troquei a ordem das questões e das escolhas múltiplas: as questões ímpares foram trocadas pelas questões pares, e as opções A e C foram trocadas pelas B e D. O teste realizou-se dentro da normalidade. Terminado o CTt, entreguei a cada aluno o inquérito, anónimo, em papel, “Questionário de Avaliação da Qualidade do Professor Estagiário, do Curso e Autoavaliação do Estudante” (Apêndice IV). Recolhi os questionários dos dois turnos no mesmo envelope, mantendo o anonimato. Os resultados, compilados e analisados, apresento no tópico 5.2.4. Figura 81. Verificação de Extras Vazios com o Método hasExtra 73 5.2. Resultados e Análise A intervenção não sumariada que, no capítulo 4, classifiquei como “reuniões-entrevistas”, e, na introdução do capítulo 5, como tutoria/reunião/entrevista, no presente tópico é denominada apenas como “entrevistas”. Os formulários criados para a recolha de dados estão disponíveis nos Apêndices. 5.2.1. Grelha de Observação dos Alunos Os resultados de observação dos alunos foram compilados por turno (Figuras 82-86; “NA” corresponde a “Não se Aplica”, e “?” indica “Não consegui observar”). Para os tópicos assiduidade & pontualidade, e comportamento, utilizei as observações das aulas sumariadas e das entrevistas. Nos tópicos participação, empenho, e autonomia, incluí apenas as aulas sumariadas. No que respeita à assiduidade e pontualidade (Figura 82), considerando a totalidade dos alunos e as faltas totais, e não um aluno em particular, verifiquei, para o T1, um comparecimento médio a 87% das aulas, portanto, 13% de faltas (F), enquanto, para o T2, o destaque foram as faltas de pontualidade (FP), ou seja, os alunos chegaram atrasados, ou no início da aula ou depois dos intervalos, 16% das vezes, em média. Considerei que ambos os turnos tiveram um comportamento adequado nas aulas sumariadas e nas entrevistas (Figura 83), embora um dos turnos fosse menos disciplinado que o outro. Coincidentemente, ou não, no turno menos disciplinado, havia um ambiente de camaradagem e conversa e partilha de informação entre os alunos, durante as aulas; nos intervalos, formavam grupos de 4 a 6 alunos e às vezes reunia-se o turno todo. No turno mais disciplinado, os alunos interagiram mais com o professor; nos intervalos das aulas, formavam grupos pequenos, de 2 a 3 alunos, havendo também alunos solitários. Figura 83. Comportamento, Turnos 1 e 2 Figura 82. Assiduidade e Pontualidade, Turnos 1 e 2 74 A maioria dos alunos fez perguntas durante as aulas sumariadas; considerei que sim (S), isso é participar (Figura 84). Relativamente ao empenho, diante da grande quantidade de trabalhos ICQ incompletos, atribuí sim (S) apenas aos 2 alunos que assinalaram “Tentei fazer os trabalhos IMC e ICQ em casa”, na autoavaliação (tópico 5.2.5.), ambos do T1 (Figura 86). Relativamente à autonomia, todos os alunos assinalaram que precisaram de algum tipo de ajuda, do professor ou dos colegas, para realizar os trabalhos, na autoavaliação (5.2.5). Assim, considerei que “N” não desenvolveram autonomia (Figura 85). Em resumo, pareceu-me que o conjunto da turma caminhou positivamente no sentido de atingir as competências associadas ao PASEO, mas as componentes de empenho e estudo autónomo precisam ser reforçadas. Figura 84. Participação, Turnos 1 e 2 Figura 86. Empenho, Turnos 1 e 2 Figura 85. Autonomia, Turnos 1 e 2 81 A comparação estatística de duas amostras emparelhadas é preferencialmente realizada pelo teste t de Student, porém, um dos requisitos é a simetria da distribuição (Anexo I). Quando os dados afastamse da curva normal, realizam-se os testes não paramétricos correspondentes. No presente caso, a solução foi aplicar o teste não paramétrico de Wilcoxon para 2 amostras emparelhadas. Pela tabela de valores críticos de W, encontrou-se, em n= 13 e α = 0,05, o valor crítico W igual a 17. Feitos os cálculos para os dados do 11ºTPI, os valores absolutos dos somatórios positivo e negativo foram 30 e 58, respetivamente. A comparação com o valor crítico W mostrou que o menor valor do somatório era maior que o valor crítico, pelo que, a hipótese nula não foi rejeitada, ou seja, os resultados de 15/03 e 01/04 não são significativamente diferentes (Grande, 2016; Yeager, 2022; Stat, 2022). Tendo em conta os resultados médios do teste CTt dos alunos do 11ºTPI nos dois dias (18,11 em 28, Tabela 16), parece-me coerente deduzir que os acertos estão no mesmo patamar dos estudantes espanhóis (18,05 em 28, Román González, 2016, p. 389) e suíços (18,45 em 28, Guggemos et al., 2022, p.10), uma vez que as avaliações basearam-se no CTt e os alunos tinham um nível semelhante de idade e escolaridade (os resultados de Chan et al., 2021 não estão apresentados porque não os percebi). A tabela 17 mostra os temas e as tarefas associadas às questões do CTt (Román-González, 2016, anexo F) assim como o índice de dificuldade, pi, do 11ºTPI, médio dos dias 15/3 e 01/04, expresso pelo cociente entre o número de alunos que acertaram a questão e o número total de alunos que realizaram o teste (quanto maior o pi, maior o número de acertos). Figura 91. Frequências de Pontuação no teste CTt em 15/3 e 01/04 82 A Figura 92 mostra o índice de dificuldade por questão, pi, segundo a média dos testes de 15/03 e 01/04/2022. Como esperado, as questões entre a 21 e a 28, as mais complexas, foram as que tiveram mais frequência de erros. Os conceitos envolvidos são o uso da condicional while (21 a 24) e de função simples (25 a 28), pelo que, é preciso reforçá-los. Tabela 17. Teste CTt, Temas, Tarefas e Índice de Dificuldade, pi, do 11ºTPI 83 Em relação às questões 12 e 15, que apresentaram um claro viés na ordem crescente de dificuldade para o 11º TPI, o autor do teste CTt também observou este facto aquando da aplicação com alunos espanhóis, considerando-as excessivamente difíceis (Román-González, 2016, p.439-440). Na reflexão do autor do teste, a maior dificuldade da questão 12 deve-se à existência de um aninhamento simples: o ciclo (loop) definido, repetir vezes, está dentro de um ciclo ( loop ) indefinido, repetir até. Segundo Mühling e Hubwieser (2015, citado por Román-González, 2016, p.439), os alunos mais jovens têm dificuldade em resolver questões com loop indefinido em aninhamento. Na questão 15, há um duplo aninhamento: loop definido, repetir vezes, dentro de uma condicional simples ('sim'), e este, por sua vez, dentro de um loop indefinido, repetir até. Na aplicação do CTt com alunos suíços, Guggemos et al. mantiveram a questão 12 e removeram a 15 do CTt, mas não apresentaram os acertos às questões referindo apenas que 67,8% dos alunos foram sinalizados com necessidades de apoio específico (2022, p.20). Nas entrevistas individuais, perguntei aos alunos a sua opinião sobre a questão 15 (Apêndice VI). Das muitas respostas, uma que me pareceu interessante foi a do aluno Q: "… ah, sim, foi um caso de precipitação, como viram que a primeira era verdadeira, já ninguém olhou as outras [opções]. Talvez se começasse com a certa e depois as meio-certas...". De facto, nos dois testes a resposta certa era a alínea D, embora o problema constasse na questão nº 15, no dia 15/3, e tenha passado a questão nº 16, no dia 01/04. No dia 15/3, dos 13 alunos que erraram a resposta, 12 escolheram a alínea C; a 01/04, 11 alunos escolheram a alínea A, inclusive o que tinha acertado a pergunta no 1º teste. Dos 14 alunos entrevistados, apenas 1 sugeriu a eliminação da pergunta, pelo que, antes de eliminar a pergunta, numa próxima aplicação, pode valer a pena testar a hipótese do aluno Q e observar o número de acertos. É de referir que nenhum aluno mencionou que o teste CTt seria de difícil compreensão pelo facto de estar escrito em Java. Também considero relevante o facto de, para alunos da mesma faixa etária, as Figura 92. Índice de Dificuldade pi das questões do CTt, 11º TPI 84 perguntas com menos acertos serem as mesmas, independentemente da nacionalidade espanhola, portuguesa ou suíça. Concluídas as entrevistas e o tratamento dos dados, apresentados neste tópico 5.2.3, considero que foi atingido o objetivo (iii) do plano de intervenção pedagógica, Recolher e Tratar Dados Associáveis ao Pensamento Computacional em Programação . 5.2.4. Avaliação ao Professor Estagiário O Questionário de Avaliação da Qualidade do Professor Estagiário e do Curso foi aplicado anonimamente, em 01/04/2022, a seguir à segunda aplicação do CTt. Elaborei o questionário com base nos trabalhos de Pérez-Poch (2021) e Marsh & Roche(1997). O questionário é constituído por 11 perguntas, sendo 8 de resposta politómica, do tipo Likert, com 4 opções (Raramente/Às vezes/Muitas vezes/Quase sempre) e 3 de resposta dicotómica (Não/Sim). Das 11 perguntas, 5 dizem respeito à ação do professor em sala de aula (2, 3, 4, 5, 6), 3 abordam a planificação do curso (7, 8, 9), 1 quantifica a opinião sobre o professor, na globalidade (10) e 2 são de autoavaliação (1,11). Ao final, há uma 12ª questão, opcional, de resposta aberta, sobre sugestões de melhoria (Apêndice IV). Para facilitar a análise, os resultados foram convertidos em percentagem e agrupados por tipo de conteúdo. Nas questões relativas à ação do professor em sala de aula (Tabela 18) e à planificação do curso Tabela 19), havia duas respostas favoráveis ao professor, sendo uma muito favorável (quase sempre) e outra favorável com ressalvas (muitas vezes), e duas desfavoráveis, com a mesma nuance (às vezes – desfavorável com ressalvas; raramente – muito desfavorável). Tabela 18. Avaliação dos Alunos Relativamente à Ação do Professor em Sala de Aula 85 Numa interpretação rápida, considerei que, nos tópicos entusiasmo e atitude pessoal, a maioria dos alunos (> 50%) fez uma avaliação muito favorável à minha atuação, ao indicarem que consegui que as aulas fossem agradáveis e que mostrei-me acessível aos estudantes, quase sempre. Quanto aos tópicos organização, interação com o grupo, a opinião da maioria foi favorável, com ressalvas, ao indicarem que, muitas vezes, dei explicações claras, estimulei as perguntas do grupo e apresentei vários pontos de vista. O tópico conteúdo, foi o único que teve três tipos de opinião: a maioria expressou-se favorável, com ressalvas (50%), e 36% considerou muito favorável, mas 14% dos alunos (2 em 14) expressaram opinião desfavorável, com ressalvas, ao indicar “às vezes”. Em relação à planificação dos curso (Tabela 19), 93% dos alunos consideraram que os métodos de avaliação foram adequados, 100% estiveram de acordo com a bibliografia disponibilizada, e 79% atribuíram ao curso um grau de dificuldade nomal, comparativamente a outras disciplinas de informática, havendo também que o considerasse difícil (14%) e fácil (7%). Quanto às avaliações quantitativas, 64% dos alunos atribuíram, ao professor e ao curso, uma nota entre 15 e 18, enquanto 36% outorgaram uma nota superior a 18 valores (Tabela 20). Na autoavaliação (Tabela 21), os alunos consideram a 100% que aprenderam coisas valiosas e foram mais exigentes com as suas próprias notas, tendo 71% revelado uma expetativa entre 11 e 14 valores e 29% entre 15 e 18 valores. Tais pedidos moderados de recompensa podem estar relacionados com a autoavaliação do seu empenho no curso, como mostra o questionário do tópico 5.2.5. Tabela 19. Avaliação dos Alunos sobre a Planificação do Curso Tabela 20. Avaliação Global Quantitativa sobre o Professor Estagiário 86 Na questão opcional de sugestão de melhoria, apenas três alunos responderam, designadamente: “As aulas foram bastante interessantes e gostei bastante das aulas que nos foram proporcionadas pelo forte do professor Maurício Morais. Gostava de o ter por perto e que continuasse como professor na nossa turma!”; “Gostei, espero que volte, gostei das suas aulas”; “Forma de ensino calmo e bem explicado com disponibilidade para tirar dúvidas sempre que possivel”. Do meu ponto de vista, estes três comentários elogiosos constituíram uma atitude de encorajamento ao meu trabalho, um “vá em frente” e não uma lisonja porque, ao observar as outras respostas, verifiquei que nenhum dos três deu-me pontuação máxima em todos os tópicos: na avaliação global, dois pontuaram-me entre 15 e 18 e, nos tópicos de atuação em sala de aula, o “muitas vezes” foi mais frequente que o “quase sempre”. Gostei da atitude destes três alunos pois souberam ser empáticos, sem deixar de afirmar a sua opinião crítica. 5.2.5. Autoavaliação dos Alunos Na presente intervenção pedagógica, efetuei dois momentos de autoavaliação dos alunos: (i) em 01/04, no final da intervenção sumariada, no mesmo questionário em que avaliaram o professor, foi solicitada uma opinião sobre as suas impressões pessoais, sem que soubessem os seus resultados de avaliação; (ii) em 26/04, após mostrar os resultados sobre os testes CTt e das Apps, a autoavaliação incidiu sobre as suas atitudes em sala de aula, as dificuldades sentidas e as perspetivas futuras. O segundo questionário, composto por 14 perguntas dicotómicas (verdadeiro/falso), foi nominal e voluntário e feito na aula do Prof. José Pereira, depois da entrevista individual; recolhi-os no final da aula. Todos os alunos que participaram das entrevistas de 26/04 entregaram o questionário preenchido e completo. O questionário é de minha autoria, específico sobre a intervenção e espelha as minhas interrogações e suposições (Apêndice IX). Analisando as respostas, compreendi melhor a perceção dos alunos, e a minha própria, sobre o tempo de E-A que vivenciámos. A figura 93 mostra os resultados globais, em percentagem, para facilitar a leitura. À afirmação “Compreendi o que era esperado fazer nos trabalhos IMC e ICQ”, 94% confirmaram saber o que era suposto fazerem. “Quando tive dúvidas perguntei ao professor”, 94% confirmaram. “Quando tive dúvidas perguntei aos colegas”, 88% o fizeram. “Fui capaz de resolver os trabalhos propostos sem ajuda do professor e dos colegas”, 100% dos alunos Tabela 21. Autoavaliação Qualitativa e Quantitativa dos Alunos 87 rejeitaram a afirmação. “Precisei de apoio na construção das telas” foi confirmado por 56% e rejeitado por 44% dos alunos. “Precisei de apoio no código Java”, 88% certificaram. “O ambiente Android Studio é complicado”, 63% disseram que não. “Faltam-me bases de Java para bem compreender o Android”, 69% pensam que sim. “Um trabalho consegui terminar, mas o outro não”, foi o caso de 63% dos alunos. “Não consegui terminar os trabalhos IMC e ICQ na aula”, 63% não conseguiu. “Tentei fazer os trabalhos IMC e ICQ em casa”, 13% dos alunos tentaram completar os trabalhos em casa. “Interesso-me pela matéria e tenciono continuar a programar Apps para Android”, 63% tenciona continuar a programar Apps. “Interesso-me pela matéria, mas não tenciono continuar a programar Apps para Android”, 81% rejeitou abandonar a aprendizagem Android. ”Não gosto de programação Android”, 75% dos alunos rejeitaram desgostar de Android. Em geral, as respostas dos alunos seguiram o mesmo sentido das minhas observações de aula. As respostas que mais me impactaram foram (i) a confirmação de 63% que sabiam que não acabaram os trabalhos em sala de aula, conforme eu já tinha verificado durante a correção, e, mesmo assim, só 13% tentaram completar os trabalhos em casa, e (ii) apesar de tão pouco empenho, 63% declararam que tencionam continuar a programar Apps no futuro. Tal como no tópico 3.4, da contextualização, os alunos voltaram a evidenciar neste questionário a pouca perceção que têm do efeito dos seus comportamentos cotidianos na sua vida futura. No âmbito do Diretor de Turma, talvez alguma coisa pudesse ser feita, no sentido de conversar com os Encarregados de Educação. No âmbito dos Professores das disciplinas, talvez seja viável propor uma atividade interdisciplinar, individual ou em grupo, que os estimule a um estudo autónomo fora do horário da aula. 88 Figura 93. Autoavaliação de Desempenho dos Alunos do 11º TPI sobre a Intervenção Pedagógica, em percentagem de respostas V/F 94 94 88 0 56 88 38 69 38 38 13 63 19 25 6 6 13 100 44 13 63 31 63 63 88 38 81 75 0 50 100 1. Compreendi o que era esperado fazer nos trabalhos IMC e ICQ 2. Quando tive dúvidas perguntei ao professor. 3. Quando tive dúvidas perguntei aos colegas. 4. Fui capaz de resolver os trabalhos propostos sem ajuda do professor e dos colegas. 5. Precisei de apoio na construção das telas. 6. Precisei de apoio no código Java. 7. O ambiente Android Studio é complicado. 8. Faltam-me bases de Java para bem compreender o Android. 9. Um trabalho consegui terminar, mas o outro não. 10. Não consegui terminar os trabalhos IMC e ICQ na aula. 11. Tentei fazer os trabalhos IMC e ICQ em casa. 12. Interessome pela matéria e tenciono continuar a programar apps para Android. 13. Interessome pela matéria, mas não tenciono continuar a programar apps para Android. 14. Não gosto de programação Android. % de Alunos Autoavaliação de Desempenho dos Alunos 11º TPI sobre a Intervenção Pedagógica % V % F 89 5.3. Reflexões 5.3.1. O meu Desempenho na Intervenção Para além da minha reflexão individual, considero que houve quatro períodos temporais de reflexão coletiva, descritos a seguir, que muito contribuíram para a minha perceção do meu desempenho na intervenção pedagógica. (i) Ao longo da intervenção, o exercício de autoavaliação foi auxiliado pelos emails semanais partilhados por nós três: eu, o Professor Cooperante e a Professora Supervisora, antes da primeira intervenção da semana. Nos dias de intervenção, o Professor Cooperante sempre esteve presente na aula e, nos intervalos, entre a saída de um turno e a entrada do seguinte, fazia os seus comentários e chamadas de atenção. Além disso, no decorrer das três semanas de intervenção, a Professora Supervisora assistiu à intervenção em um turno, todas as semanas, e, ao final das intervenções, conversávamos sobre as minhas impressões, se eu considerava que tinha atingido os objetivos a que me tinha proposto, e ela fazia comentários diretos e objetivos; não obstante, só ao final da intervenção apercebi-me da profundidade das suas palavras. (ii) Nas intervenções não sumariadas de 19 e 26/04, pude inteirar-me e refletir sobre as perceções dos alunos em relação aos tópicos de ensino-aprendizagem e de investigação da intervenção. (iii) A 27 de abril, houve a reunião preliminar de avaliação de intervenção pedagógica, 15 às 17h, comigo, o Professor Cooperante e a Professora Supervisora, na Escola Secundária. Neste dia fizemos um análise aprofundada da minha intervenção. Apercebi-me que a grande maioria das observações dos Orientadores eram pertinentes e que devia refletir sobre elas. (iv) A 22 de julho os meus Orientadores e eu voltámos a reunir, para a sessão final de avaliação e comentários sobre a Grelha de Avaliação da Prática Profissional do Estagiário (GAPPE), desta vez com a presença do meu colega de estágio, Pedro Sequeira, que também foi avaliado pelos Orientadores. Neste dia, eu e ele realizámos a auto e heteroavaliação dos tópicos B e C do GAPPE. Para fins de apresentação no presente relatório, organizei a lista dos meus 5 principais pontos, fracos e fortes, nas vertentes atuação e planificação da intervenção, segundo a minha autoavaliação, mas tendo em conta os comentários dos Orientadores e dos Alunos (Tabela 22). 90 5.3.2. Limitações da Intervenção A experiência prática que a Intervenção Pedagógica Supervisionada proporcionou-me fez toda a diferença na minha aprendizagem como professor. A convivência com os alunos, nas aulas e nas entrevistas, com os seus trabalhos de programação, e com os testes CTt, e as suas avaliações sobre a minha atuação, são inesquecíveis. Não obstante, pelo facto de a intervenção ter ocorrido num intervalo de tempo muito compacto, penso que a minha falta de experiência atrapalhou o meu desempenho. Sim, é um facto que foi possível Tabela 22: Autoavaliação das Vertentes Atuação e Planificação da Intervenção. 97 Freeman, S., Eddy, S. L., McDonough, M., Smith, M. K., Okoroafor, N., & Jordt, H. &. (2014). Active learning increases student performance in science, engineering, and mathematics. In Proceedings of the national academy of sciences, 111(23) (pp. 8410-8415). Garry, S., & Checchi, F. (2020). Armed conflict and public health: into the 21st century. Journal of Public Health, 42(3) (pp. 287-298). Godinho, R. M. (2022). Marcelo promulga fim do uso obrigatório de máscara. Diário de Notícias 21/04/2022. Obtido de https://www.dn.pt/sociedade/mascaras-deixam-de-ser-obrigatorias-nas-escolas-14788325.html Gonçalves, R. (2016). PAP, Rastreador de Localização GPS. Escola Técnica Profissional de Mafra. Obtido de https://pt.slideshare.net/RicardoGonalves123/gps-location-tracker-apresentao-de-pap-61254165 Google Developers. (2022a). Conheça o Android Studio . Obtido de https://developer.android.com/studio/intro?hl=pt-br Google Developers. (2022b). Codelabs for Android Developer Fundamentals . Obtido de Google: https://developer.android.com/courses/fundamentals-training/toc-v2 Grande, T. (2016). Wilcoxon Signed-Rank Test in Excel . Obtido de https://www.youtube.com/watch?v=mJtbhGETU88 Guggemos, J., Seufert, S., & Román-González, M. (2022). Computational Thinking Assessment–Towards More Vivid Interpretations. Technology, Knowledge and Learning (pp. 1-30). Harzing, A.W. (2007) Publish or Perish. Obtido de https://harzing.com/resources/publish-or-perish Hokkanen, I. (2015). Bloom Taxonomy Verbs and Activities . Obtido de https://www.slideshare.net/IidaHokkanen/bloomtaxonomy-action-verbs-and-activities e https://www.itcilo.org/es/node/1768 Hsu, T. C., Chang, S. C., & Hung, Y. T. (2018). How to learn and how to teach computational thinking: Suggestions based on a review of the literature. Computers & Education, 126 (pp. 296-310). Inácio, A. M., & Sequeira, P. (2022). Abertura das escolas faz disparar casos. 500 mil em apenas duas semanas. Diário de Notícias. Obtido de Diário de Notícias 20/01/2022: https://www.dn.pt/sociedade/abertura-das-escolas-fazdisparar-casos-500-mil-em-apenas-duas-semanas-14508000.html IOI, I. O. (2022). IOI Results 2022. Indonesia. Obtido de https://stats.ioinformatics.org/delegations/2022 Iz, H. B., & Fok, H. S. (2007). Use of Bloom's taxonomic complexity in online multiple choice tests in Geomatics education. In Survey Review, 39(305) (pp. 226-237). Jain, R. (2017). Summarizing Measured Data. Washington University, St Louis, USA. Obtido de https://www.cse.wustl.edu/~jain/cse567-17/ftp/k_12smd.pdf Kaoneill. (2020). Computational Thinking. The-elements-of-computational-thinking. Teacher in Training. North Carolina State University, USA. Obtido de https://koneilleci201.wordpress.ncsu.edu/2020/01/28/computational-thinking/ Keller, J. M. (1987). Development and use of the ARCS model of instructional design. Journal of instructional development, 10(3) (pp. 2-10). Obtido de https://ocw.tudelft.nl/wp-content/uploads/Development-and-Use-of-the-ARCS-Model-ofInstructional-Design.pdf Koslosky, M. A. (1999). Aprendizagem Baseada em Casos – Um ambiente para ensino de lógica de programação. Dissertação de Doutoramento. Universidade Federal de Santa Catarina, Brasil. Obtido de https://repositorio.ufsc.br/bitstream/handle/123456789/81012/146842.pdf?sequence=1 Liang, Z., Nishi, M., & Kishida, I. (2021, December). Teaching Android App Development to First Year Undergraduates: Textual Programming or Visual Programming? In 2021 IEEE International Conference on Engineering, Technology & Education (TALE) (pp. 01-08). Obtido de 98 https://ieeexplore.ieee.org/abstract/document/9678602?casa_token=_zlpp4I9GlQAAAAA:_ZlwczLtHwXzfpzaVdX 0DfmasP-BRK2qMesuw6nOcJ6oejz0P4rsPzPHF9sAgHVO4_m-JjIPtMk Lockwood, J., & Mooney, A. (2018). Developing a computational thinking test using Bebras problems. Obtido em https://mural.maynoothuniversity.ie/10316/1/AM-Developing-2017.pdf Lopes, J. A. (2003). Problemas de Comportamento, Problemas de Aprendizagem e Problemas de Ensinagem. ISBN: 9728535-92-9. Adaptado por Caires, S. (2021). In notas de aula da UC Gestão da Sala de Aula (pp. 107-168). Universidade do Minho. Magson, N. R., Freeman, J. Y., Rapee, R. M., Richardson, C. E., Oar, E. L., & Fardouly, J. (2021). Risk and protective factors for prospective changes in adolescent mental health during the COVID-19 pandemic. Journal of youth and adolescence, 50(1) (pp. 44-57). Markezine. (2022). Grasshopper, o App de Programação para Iniciantes. Educação Informática. Obtido de https://www.makerzine.com.br/educacao/grasshopper-o-app-de-programacao-para-iniciantes/ Marques, A. S. (2021). Iniciação à Programação no 1.º Ciclo do Ensino Básico: Análise da implementação da medida a alunos do 3.º ano. Dissertação de Doutoramento. Universidade da Beira Interior. Obtido de https://ubibliorum.ubi.pt/bitstream/10400.6/11156/1/8%20-%20 Marsh, H. W., & Roche, L. A. (1997). Making students' evaluations of teaching effectiveness effective: The critical issues of validity, bias, and utility. American psychologist, 52(11) (p. 1187). Obtido de https://psycnet.apa.org/record/199743129-003 Martins, G. D., Gomes, C. A., Brocardo, J., Pedroso, J. V., Camilo, J. L., Silva, L. M., & Rodrigues, S. M. (2017). Perfil dos alunos à saída da escolaridade obrigatória. Ministério da Educação/DGE. Portugal. Obtido de https://comum.rcaap.pt/bitstream/10400.26/22377/1/perfil_dos_alunos.pdf Mateus, P. I. (2021). Aprendizagem baseada em projetos e ensino da programação com recurso ao App Inventor. Dissertação de Mestrado. Universidade de Évora. McLean, S. F. (2016). Case-based learning and its application in medical and health-care fields: a review of worldwide literature. Journal of medical education and curricular development, 3, JMECD-S20377. MEC PT, M. d. (2021). Despacho n.º 8209/2021 de 19 de agosto. D. R. 2ª série C. 161 p. 115-116. Obtido de https://dre.pt/dre/detalhe/despacho/8209-2021-169831748 Merseth, K. K. (1991). The early history of case-based instruction: Insights for teacher education today. Journal of Teacher Education, 42(4) (pp. 243-249). Morais, M. (2022). Proposta de Utilização da App Grasshopper na Escolaridade Obrigatóriano Âmbito da Lógica de Programação – Iniciação à Programação de Computadores. UC ACMDI. Universidade do Minho. Obtido de https://acmdi-grasshopper.blogspot.com/2022/02/ Morais, M., Gonçalves, C., & Reis, P. (2021). Aplicação da Metodologia PRIMM em Trabalhos de Computação Física. UC Metodologia de Ensino de Informática II. Universidade do Minho. Obtido de http://www.mei2.pt/ Moreno-León, J., Robles, G., Román-González, M., & Rodríguez García, J. D. (2019). Not the same: a text network analysis on computational thinking definitions to study its relationship with computer programming. Revista Interuniversitaria de Investigación en Tecnología Educativa (RIITE), 7 (pp. 26-35) Moura, A., & Carvalho, A. A. (2010). Enquadramento teórico para integração de tecnologias móveis em contexto educativo. ticEDUCA2010 – I Encontro Internacional TIC e Educação. , 19-20 Novembro, IE-UL, Lisboa. Obtido de https:// 99 http://repositorio.uportu.pt:8080/jspui/bitstream/11328/454/2/Enquadramento%20te%C3%B3rico%20para%20 a%20%20integra%C3%A7%C3%A3o.2010.pdf Neto, L. D. (2020). Quem ou o que pensa? Uma busca de aportes para questões filosóficas suscitadas pela revolução informática atual. Universidade Federal de São Paulo, Brasil. Obtido de https://philpapers.org/archive/DEHQOO.pdf Null, L., & Lobur, J. .. (2019). Essentials of Computer Organization and Architecture. 5th edition. Jones & Bartlett Publishers. ISBN: 9781284136852. Nunes, J. M. (2019). Mobile learning e pensamento computacional: contributos para o desenvolvimento de aplicações em contextos educativos. Dissertação de Doutoramento. Universidade Aberta. Olimpíadas Nacionais de Informática (ONI). (2017). Obtido de https://oni.dcc.fc.up.pt/2017/ e https://apdsi.pt/2022/olimpiadas-de-informatica-2022-ja-sao-conhecidos-os-quatro-alunos-que-irao-representarportugal-nas-olimpiadas-internacionais-de-informatica/ Pedro, A., Mato, J. F., Piedade, J., & Dorotea, N. (2017). Probótica, Programação e Robótica no Ensino Básico. . Instituto de Educação, Universidade de Lisboa. Obtido de https://www.dge.mec.pt/sites/default/files/ERTE/origramacao_robotica/probotica__linhas_orientadoras_2017.pdf Peracaula-Boscha, M., & González-Martínez, J. (2022). Developing Computational Thinking Among Preservice Teachers. ATEE (pp. 57-60). Obtido de https://library.oapen.org/bitstream/handle/20.500.12657/55676/9788855184120.pdf?sequence=1#page=59 Pereira, A. (2021). Eles não sabem nem sonham, que a Educação comanda a Vida! Dissertação de Mestrado. Instituto Politécnico do Porto. Obtido de https://recipp.ipp.pt/handle/10400.22/19582 Pereira, P. A. (2021). Programação de dispositivos móveis. Programa de UC, ISEL-PT. Obtido de https://www.isel.pt/disciplinas/programacao-de-dispositivos-moveis-leirt Pérez-Poch, A. (2021). Programación de Dispositivos Móviles: una propuesta docente adaptada a un entorno híbrido. Asociación de Enseñantes Universitarios de la Info (AENUI). In Actas de las XXVII Jornadas sobre la Enseñanza Universitaria de la Informática (pp. 211-218). Obtido de https://upcommons.upc.edu/handle/2117/350168 Piedade, J., & Dorotea, N. A. (2020). A Robótica Educacional como Recurso Pedagógico para Aprender Programação e Desenvolver Competências de Pensamento Computacional: Práticas de Futuros de Informática. In Formação no Contexto do Pensamento Computacional, da Robótica e da Inteligência Artificial na Educação, 89. Obtido de https://www.researchgate.net/profile/Joao-Piedade4/publication/347489511_Formacao_no_contexto_do_pensamento_computacional_da_robotica_e_da_intelige ncia_artificial_na_educacao/links/5fddf3c092851c13fe9d4426/ Portugal News. (24 de Fevereiro de 2022). RTP interrompe programação devido à guerra na Ucrânia. Obtido de https://portugalnews.online/rtp/rtp-interrompe-programacao-devido-a-guerra-na-ucrania/ Quadros-Flores, P. (2011). Os Dez Princípios de uma Boa Prática com TIC. A par dos tempos que correm, as TIC e o centenário da República. Obtido de https://recipp.ipp.pt/bitstream/10400.22/6333/1/ART_PaulaFlores_2011.pdf Queirós, R. (2016). Android. Desenvolvimento de Aplicações com Android Studio (p. 291). FCA. Lisboa. ISBN 978-972-722819-5. 100 Rádio e Televisão de Portugal (RTP). (2022). Refugiados Ucranianos, chegaram dois autocarros a Portugal. Obtido de https://www.rtp.pt/noticias/pais/refugiados-ucranianos-chegaram-dois-autocarros-a-portugal_v1389562 Ramos, J. L., Espadeiro, R. G., & Monginho, R. (2022). Introdução à programação, robótica e ao pensamento computacional na educação pré-escolar e 1.º ciclo do ensino básico. Necessidades de formação de educadores e professores. Universidade de Évora: ISBN 978-972-778-252-9. Obtido de https://digital.dge.mec.pt/sites/default/files/documents/2022/177-14551b4676f7711407147b60af2f9a3f.pdf Reis, D. R. (2015). Prova de Aptidão Profissional. Tema S-Notas. Escola Secundária de Tomaz Pelayo, Santo Tirso. Obtido de https://prezi.com/l3c3kssmqfnp/prova-de-aptidao-profissional/ República Portuguesa. (2022). Testes à Covid-19 nas escolas para o ano letivo 2021/2022 . Obtido de https://www.portugal.gov.pt/pt/gc22/comunicacao/noticia?i=testes-a-covid-19-nas-escolas-para-o-ano-letivo20212022 Rich, P. J., Mason, S. L., & O'Leary, J. (2021). Measuring the effect of continuous professional development on elementary teachers’ self-efficacy to teach coding and computational thinking. Computers & Education, 168, 104196. Román González, M. (2016). Codigoalfabetización y pensamiento computacional en educación primaria y secundaria: validación de un instrumento y evaluación de programas. Dissertação de Doutoramento. UNED, Espanha. Obtido de https://redined.educacion.gob.es/xmlui/hand Román-González, M., Moreno-León, J. & Robles, G. (2019). Combining assessment tools for a comprehensive evaluation of computational thinking interventions. In Computational Thinking Education (pp. 79-98). Springer, Singapore. Román-González, M., Pérez-González, J. C., & Jiménez-Fernández, C. (2017). Which cognitive abilities underlie computational thinking? Criterion validity of the Computational Thinking Test. Computers in human behavior, 72, 678-691. Rosado, N. F. (2020). Estratégias de aprendizagem da programação na educação básica e secundária: um estudo exploratório com recurso ao método de" pair programming. Dissertação de Mestrado. Universidade de Évora. Scherer, R., Siddiq, F., & Sánchez Viveros, B. (2019). The cognitive benefits of learning computer programming: A metaanalysis of transfer effects. Journal of Educational Psychology, 111(5), 764. School of Informatics. (2016). What is informatics? University of Edinburg. Obtido de https://www.ed.ac.uk/sites/default/files/atoms/files//what20is20informatics.pdf Sentance, S., & Waite, J. (2017, November). PRIMM: Exploring pedagogical approaches for teaching text-based programming in school. In Proceedings of the 12th Workshop on Primary and Secondary Computing Education (pp. 113-114). Sentance, S., & Waite, J. (2021, August). Teachers’ Perspectives on Talk in the Programming Classroom: Language as a Mediator. In Proceedings of the 17th ACM Conference on International Computing Education Research (pp. 266280). Sentance, S., Waite, J., & Kallia, M. (2019). Teaching computer programming with PRIMM: a sociocultural perspective. Computer Science Education, 29(2-3) (pp. 136-176). Shute, V. J., Sun, C., & Asbell-Clarke, J. (2017). Demystifying computational thinking. Educational Research Review, 22 (pp. 142-158). Silva, B. D., Ramos, M. A., Lencastre, J. A., & Bento, M. (2020). Utilização inovadora de dispositivos móveis no processo educativo. In Patrícia Lupion Torres (org.) Ciência, Inovação e Ética: tecendo redes e conexões para a produção do conhecimento (pp. 331-357). Curitiba: SENAR-PR. 101 Sitthiworachart, J., & Joy, M. (2008). Computer support of effective peer assessment in an undergraduate programming class. In Journal of computer assisted learning, 24(3) (pp. 217-231). Sousa, S. I. (2016). Utilização da estratégia Pair Programming no ensino da programação de sistemas de comunicação com recurso a sockets. Dissertação de Mestrado. Universidade de Lisboa. Obtido de https://repositorio.ul.pt/bitstream/10451/24621/1/ulfpie051099 SPM, S. P. (2022). Parecer da Sociedade Portuguesa de Matemática à Proposta de Revisão Curricular das Aprendizagens Essenciais de Matemática A para o Ensino Secundário. 15/07/2022. Obtido de https://www.spm.pt/files/images/documentos/pareceres/SPM%20Parecer%20AEs%20Ensino%20Secundario%20 %202022%20%20.pdf Stat. (2022). Critical Values of the Wilcoxon Signed Ranks Test. University of Florida, USA. Obtido de https://users.stat.ufl.edu/~winner/tables/wilcox_signrank.pdf Tafur-Morales, C., Gabriel-Cheng, D., & Cabanillas-Carbonell, M. (2021, November). Mobile App to Make Better the Obesity Prevention Process in Adolescents. In 2021 International Conference on e-Health and Bioengineering (EHB) (pp. 14). IEEE. Tang, X., Yin, Y., Lin, Q., Hadad, R., & Zhai, X. (2020). Assessing computational thinking: A systematic review of empirical studies. Computers & Education , 148 , 103798. Tenenaula, J. A., & Buñay, A. M. (2020). Correlación entre perfil lipídico y medidas antropométricas en adolescentes de cuatro Unidades Educativas de Riobamba. Bachelor's thesis. Universidad Nacional de Chimborazo, Equador. Obtido de http://dspace.unach.edu.ec/handle/51000/6664 TERçA. (2022). Mudanças a Matemática do Ensino Secundário entram em Discussão Pública. In Diário de Aveiro. 07/06/2022. Obtido de https://www.diarioaveiro.pt/noticia/83511 Toporov, E. (2013). IntelliJ IDEA is the base for Android Studio, the new IDE for Android developers. Obtido de JetBrains: https://blog.jetbrains.com/blog/2013/05/15/intellij-idea-is-the-base-for-android-studio-the-new-ide-for-androiddevelopers/ Tóth, T., & Lovászová, G. (2021). Visual Vs. Textual Programming: A Case Study on Mobile Application Programming by Teenagers. In Ad Alta: Journal of Interdisciplinary Research. Weintrop, D., & Wilensky, U. (2015, August). Using commutative assessments to compare conceptual understanding in blocksbased and text-based programs. In Proceedings of the eleventh annual international conference on international computing education research (pp. 101-110). Wijnia, L., Loyens, S. M., Noordzij, G., Arends, L. R., & Rikers, R. M. (2017). The effects of problem‐based, project‐based, and case‐based learning on students' motivation: A meta‐analysis. Eindrapport NRO-project (pp. 405-15). Wing, J. (2017). Computational thinking’s influence on research and education for all. In Italian Journal of Educational Technology, 25(2) (pp. 7-14). Ortona, Italy: Edizioni Menabò. Obtido de https://www.learntechlib.org/p/183466/ Yeager, K. (2022). Spss Tutorials: Paired Samples T Test. Kent State University, USA. Obtido de https://libguides.library.kent.edu/spss/pairedsamplesttest Yunlong, J., & LIU, Y. (2022). Structure and effects of motivation: From the perspective of the motivation continuum. In Advances in Psychological Science, 30: 1589-1603 doi: 10.3724/SP.J.1042.2022.01589. Obtido de https://journal.psych.ac.cn/xlkxjz/EN/10.3724/SP.J.1042.2022.01589 102 Apêndices 103 Apêndice I Teste de Pensamento Computacional (Román-González, 2016)  O teste é composto por 28 perguntas, distribuídas por 16 páginas com 2 perguntas cada.  Todas as perguntas têm 4 opções de resposta (A, B, C ou D) das quais apenas uma é a correta.  Não é necessário responder a todas as perguntas. Número Institucional de aluno: ______________________________________ Questão 1: Qual a sequência de passos que leva o Pac-Man pelo caminho até ao Fantasma? Opção A Opção B Opção C Opção D Questão 2: Que passo falta na sequência para levar o Pac-Man pelo caminho até ao Fantasma? Opção A Opção B Opção C Opção D Questão 1: A B C D ? Questão 2: A B C D 104 Questão 3: Para levar o Pac-Man até ao Fantasma pelo caminho assinalado, qual a linha da sequência que está errada? moveParaFrente(); // Linha A viraEsquerda(); // Linha B moveParaFrente(); moveParaFrente(); // Linha C viraEsquerda(); // Linha D moveParaFrente(); Questão 4: Qual a sequência que o Lápis deve seguir para desenhar o quadrado? Cada um dos lados mede 100 pixéis. Cada um dos ângulos mede 90 graus. Opção A moveParaFrente(100); viraDireita(90); moveParaFrente(100); viraEsquerda(90); moveParaFrente(100); viraDireita(90); moveParaFrente(100); Opção B moveParaFrente(25); viraDireita(90); moveParaFrente(25); viraEsquerda(90); moveParaFrente(25); viraDireita(90); moveParaFrente(25); Opção C moveParaFrente(50); viraDireita(90); moveParaFrente(50); viraDireita(90); moveParaFrente(50); viraDireita(90); moveParaFrente(50); Opção D moveParaFrente(100); viraDireita(90); moveParaFrente(100); viraDireita(90); moveParaFrente(100); viraDireita(90); moveParaFrente(100); Questão 3: A B C D Questão 4: A B C D 105 Questão 5: Qual a sequência que leva o Pac-Man pelo caminho até ao Fantasma? Número de repetições Opção A Opção B Opção C Opção D Questão 6: Quantas vezes se deve repetir esta sequência para levar o Pac-Man pelo caminho até ao Fantasma? Opção A x 2 Opção B x 1 Opção C x 4 Opção D x 3 Questão 5: A B C D Questão 6: A B C D x1 x5 x3 x4 x1 ? 106 Questão 7: Para que o Lápis desenhe o seguinte retângulo (50 pixéis de largura, 100 pixéis de altura), qual a linha da sequência que está errada? for (i=0; i < 4; i++) // Linha A { moveParaFrente(50); viraEsquerda(90); // Linha B moveParaFrente(100); // Linha C viraEsquerda(90); // Linha D } Questão 8: Qual a sequência que leva o Pac-Man pelo caminho até ao Fantasma? Opção A for (i=0; i < 4; i++) { for (i=0; i < 3; i++) { moveParaFrente(); } viraDireita(); } moveParaFrente(); Opção B for (i=0; i < 3; i++) { for (i=0; i < 4; i++) { moveParaFrente(); } viraDireita(); } moveParaFrente(); Opção C for (i=0; i < 3; i++) { for (i=0; i < 4; i++) { moveParaFrente(); viraDireita(); } } moveParaFrente(); Opção D for (i=0; i < 4; i++) { moveParaFrente(); } for (i=0; i < 3; i++) { viraDireita(); } moveParaFrente(); Questão 7: A B C D Questão 8: A B C D 113 Questão 21: Qual a sequência que leva o Pac-Man pelo caminho até aos Morangos, e faz com que ele coma o número de Morangos indicado? Opção A while (haCaminhoFrente()) { moveParaFrente(); } for (i=0; i<3; i++) { comeMorango(); } Opção B while (haCaminhoFrente()) { moveParaFrente(); } for (i=0; i<4; i++) { comeMorango(); } Opção C while (haCaminhoFrente()) { moveParaFrente(); } for (i=0; i<5; i++) { comeMorango(); } Opção D while (haCaminhoFrente()) { moveParaFrente(); for (i=0; i<3; i++) { comeMorango(); } } Questão 22: Qual a sequência que leva o Pac-Man pelo caminho até aos Morangos, e faz com que ele coma o número de Morangos indicado? Opção A while (haCaminhoFrente()) { for (i=0; i<5; i++) { moveParaFrente(); } for (i=0; i<3; i++) { comeMorango(); }} Opção B while (haCaminhoFrente()) { moveParaFrente(); for (i=0; i<3; i++) { comeMorango(); } } Opção C while (haCaminhoFrente()) { for (i=0; i<3; i++) { moveParaFrente(); } for (i=0; i<5; i++) { comeMorango(); }} Opção D while (haCaminhoFrente()) { moveParaFrente(); } for (i=0; i<3; i++) { comeMorango(); } 3 Questão 21: A B C D Questão 22: A B C D 3 3 3 3 3 114 Questão 23: O que falta na sequência para o levar Pac-Man a comer os Morangos pelo caminho? while (haCaminhoFrente()) { for (i=0; _____? ; i++) { moveParaFrente(); } if (haMorango()) { comeMorango(); } } Opção A i < 1 Opção B i < 2 Opção C i < 3 Opção D i < 5 Questão 24: O que falta na sequência (___?) para levar o Pac-Man a comer os Morangos pelo caminho? while (haCaminhoFrente()) { moveParaFrente(); if (haMorango()) { _____________? { comeMorango(); } } } Opção A while (haCaminhoFrente()) Opção B while (haCaminhoFrente()==false) Opção C while (haMorango()) Opção D while (haMorango()==false) 1 1 3 3 Questão 23: A B C D Questão 24: A B C D 115 Questão 25: Se tivermos uma função que desenha um quadrado (100 pixéis de lado), qual a sequência que o Lápis deve executar para desenhar a seguinte figura? desenhaQuadrado(){ for (i=0; i<4; i++) { moveParaFrente(100); viraDireita(90); }} Opção A for (i=0; i<3; i++) { desenhaQuadrado(); } viraDireita(120); Opção B for (i=0; i<3; i++) { desenhaQuadrado(); viraDireita(120); } Opção C for (i=0; i<3; i++) { desenhaQuadrado(); } viraDireita(90); Opção D for (i=0; i<3; i++) { desenhaQuadrado(); viraDireita(90); } Questão 26: Se tivermos uma função que desenha um triângulo equilátero (50 pixéis de lado), o que falta na sequência para que o Lápis desenhe a seguinte figura? desenhaTriangulo(){ for (i=0; i<3; i++) { moveParaFrente(50); viraEsquerda(120); }} for (i=0; _____? ; i++) { desenhaTriangulo(); saltaParaFrente(50); } Opção A i < 15 Opção B i < 5 Opção C i < 4 Opção D i < 3 Questão 25: A B C D Questão 26: A B C D 3 0 º 3 0 º 116 Questão 27: Se tivermos a função “come5Morangos( )”, qual a sequência que leva o Pac-Man pelo caminho e faz com que ele coma o número de Morangos indicado? come5Morangos(){ for (i=0; i<5 ; i++) { comeMorango(); }} 5 5 5 Opção A moveParaFrente(); viraDireita(); for (i=0; i<3 ; i++) { moveParaFrente(); come5Morangos(); } Opção B moveParaFrente(); viraDireita(); for (i=0; i<3 ; i++) { come5Morangos(); } moveParaFrente(); Opção C moveParaFrente(); viraDireita(); for (i=0; i<5 ; i++) { moveParaFrente(); come5Morangos(); } Opção D moveParaFrente(); viraDireita(); for (i=0; i<5 ; i++) { come5Morangos(); } moveParaFrente(); Questão 28: Se tivermos a função “andaCome4Morangos”, o que falta na sequência ( ___?) para fazer com que o Pac-Man siga pelo caminho e coma todos os Morangos? andaCome4Morangos(){ moveParaFrente(); viraDireita(); moveParaFrente(); for (i=0; i<4 ; i++) { comeMorango(); } viraEsquerda(); } 4 4 4 4 4 Opção A i < 3 Opção B i < 4 Opção C i < 5 Opção D i = 5 Questão 27: A B C D for(i=0; ___?; i++) { andaCome4Morangos(); } Questão 28: A B C D 117 Apêndice II Declaração de Consentimento Informado, Livre e Esclarecido Exm.º Senhor (a) Encarregado (a) de Educação, O meu nome é Maurício Braga Morais e frequento o Estágio Profissional do Mestrado em Ensino de Informática, da Universidade do Minho, sob a orientação dos Professores Altina Ramos, da Universidade do Minho, e José Pereira, da Escola Secundária XXXXXXXXXXXXXXXXX. Neste contexto, estou a desenvolver, integrado na disciplina de Programação de Dispositivos Móveis, um projeto de investigação intitulado “Em que medida o Android Studio e a metodologia baseada em casos contribuem para a aprendizagem de programação e para o desenvolvimento do pensamento computacional?” Esta investigação tem os seguintes objetivos: □ Promover o uso consciente, pelos alunos, dos princípios e procedimentos do pensamento computacional para que estejam aptos a acompanhar os avanços tecnológicos que virão. □ Contribuir para o aumento da motivação no estudo da programação. □ Identificar a contribuição da intervenção pedagógica no desenvolvimento do pensamento computacional dos alunos Para realizar esta investigação, há a necessidade de efetuar uma recolha de dados através da aplicação de um questionário individual e anónimo aos alunos. O questionário é de natureza puramente técnica, não contém perguntas pessoais. Em geral, as perguntas do questionário têm um enunciado com uma imagem e são oferecidas quatro hipóteses de solução, das quais o aluno deve escolher uma. Além do questionário, vai decorrer uma entrevista do tipo focus group , ou seja, uma entrevista curta, sobre a temática do estudo, em um pequeno grupo, com recurso a gravação áudio. Consoante o andamento do projeto, poderá ser necessário fazer gravações áudio e vídeo de algumas aulas nomeadamente durante a realização das atividades que serão propostas aos alunos, para facilitar a posterior análise dos dados recolhidos. Esclareço desde já que estes recursos audiovisuais têm apenas um interesse documental para efeitos de investigação e para que eu possa, posteriormente, analisar as situações de aula. Não serão divulgados por meio 118 nenhum, manter-se-ão confidenciais. Se necessário, poderão ser consultados pelos orientadores, sempre em total sigilo investigativo. Todos os dados audiovisuais serão guardados apenas durante o tempo em que se mantiverem necessários para a publicação da tese e de trabalhos relacionados com este estudo, sendo destruídos após esse tempo. Além disso, a identidade dos alunos, bem como os seus rostos serão sempre preservados, já que nunca serão referidos os seus nomes, mostrados os seus rostos nem será identificada a escola onde o trabalho será realizado. Por fim, uma vez terminado o meu trabalho pedagógico, preciso que os alunos avaliem os vários aspetos da minha atuação e avaliem a eles mesmos. Este questionamento vai ocorrer por meio de um inquérito individual e anónimo, no qual os alunos selecionam as opções que lhes parecerem mais adequadas. De modo a autorizar esta recolha de dados, peço que assine o seguinte termo de consentimento informado. O seu educando também deve aceitar a participação neste estudo, pelo que deve também ele assinar este termo de consentimento informado. A participação neste estudo é completamente voluntária, e qualquer participante pode abandonar o estudo a qualquer momento, sem qualquer tipo de problema associado. Grato pela atenção, Com os melhores cumprimentos, O investigador, …………………………………………………………… Maurício Braga Morais Data: 14/02/2022 Para mais esclarecimentos, poderá contactar-me por: Contacto telefónico: XXX XXX XXX Email:pg4062[email protected]ho.pt 119 Declaração de Consentimento Informado, Livre e Esclarecido Eu, ……………………………………………………………………………, encarregado(a) de educação do(a) aluno(a) ………………………………………………………………………, da turma ……, declaro ter lido e compreendido este documento, e autorizo/não autorizo (sublinhar a sua opção) a recolha de dados presentes nesta declaração de consentimento informado, livre e esclarecido, nos moldes que foram aqui apresentados, permitindo a utilização dos dados de forma voluntária, confiando em que apenas serão utilizados para esta investigação e nas garantias de confidencialidade e anonimato que me são dadas pelo/a investigador/a. ……………… , …. de ………..… de 2022 Assinatura do Encarregado de Educação ……………………………………………………… Eu, ……………………………………………………………… ,aluno(a) da turma…, aceito participar neste estudo e contribuir para a recolha de dados que me for solicitada, de acordo com o que está afirmado nesta declaração de consentimento informado, livre e esclarecido. ……………… , …. de ………..… de 2022 Assinatura do Aluno …………………………………………………. ESTE DOCUMENTO É COMPOSTO DE 3 PÁGINA/S E FEITO EM DUPLICADO: UMA VIA PARA O/A INVESTIGADOR/A, OUTRA PARA A PESSOA QUE CONSENTE 120 Apêndice III Grelha de Observação dos Alunos Curso 481040, UFCD 0817, 11º ano TPI, Escola Carlos Amarante Data: ____________ Aula: _________________________ Turno: _________ Nome do Aluno Assiduidade e Pontualidade Comportamento Participação Empenho Autonomia Preenchimento da grelha: - Assiduidade e Pontualidade: P = Presente; F = Faltou; FP = Falta de Pontualidade; FJ = Falta Justificada; FI = Falta injustificada. - Comportamento: A= Adequado; I = Inadequado; ? = Não consegui observar. - Participação, Empenho, Autonomia: S = Sim; N/A = Não se Aplica; ? = Não consegui observar; N = Não. Observações __________________________________________________________________________________ __________________________________________________________________________________ __________________________________________________________________________________ __________________________________________________________________________________ __________________________________________________________________________________ 121 Apêndice IV Questionário de Avaliação da Qualidade do Professor Estagiário, do Curso e Autoavaliação do Estudante MBM (2022), inspirado em Pérez Poch (2021) e Marsh & Roche(1997) Curso 481040, UFCD 0817, 11º ano TPI, Escola Carlos Amarante Âmbito de avaliação A tua opinião Qualidade da aprendizagem Aprendi coisas que considero valiosas □ Não; □ Sim Entusiasmo O professor conseguiu que as suas aulas fossem agradáveis □ Raramente; □ Às vezes; □ Muitas vezes; □ Quase sempre Organização As explicações do professor foram claras □ Raramente; □ Às vezes; □ Muitas vezes; □ Quase sempre Interação com o grupo O professor estimulava as perguntas do grupo e dava respostas satisfatórias □ Raramente; □ Às vezes; □ Muitas vezes; □ Quase sempre Atitude pessoal O professor mostrou-se acessível aos estudantes □ Raramente; □ Às vezes; □ Muitas vezes; □ Quase sempre Conteúdo O professor apresentou vários pontos de vista quando foi necessário □ Raramente; □ Às vezes; □ Muitas vezes; □ Quase sempre Exames Os métodos de avaliação do curso foram equitativos e adequados □ Não; □ Sim Trabalhos do curso A bibliografia e o material recomendado para este curso são corretos e adequados □ Não; □ Sim Carga de trabalho e dificuldade Este curso comparado com outros de informática, foi: □ Muito fácil; □ Fácil; □ Normal; □ Difícil; □ Muito difícil Visão Geral A nota geral que dás ao professor e ao curso é: □ Menor que 5; □ entre 6 e 10; □ entre 11 e 14; □ entre 15 e 18; □ maior que 18 Autoavaliação Pelo teu desempenho neste curso, a nota que esperas ter é: □ Menor que 5; □ entre 6 e 10; □ entre 11 e 14; □ entre 15 e 18; □ maior que 18 Tens alguma sugestão de melhoria? (opcional) __________________________________________________________________________________ __________________________________________________________________________________ __________________________________________________________________________________ __________________________________________________________________________________ __________________________________________________________________________________ 122 Apêndice V Grelha de Avaliação do Teste de Pensamento Computacional Curso 481040, UFCD 0817, 11º ano TPI, Escola Carlos Amarante Nome: _______________________; Nº: ____________ Turno: _________ Consentimento Informado?______ 15/03, _______ certas em 28, Nota em 20v _______ 01/04, _______ certas em 28, Nota em 20v _______ Os números das questões e a posição da alternativa correta não foram os mesmos em 15/3 e 01/04 Questão nº, Conceito 15/03 Nº das questões erradas 01/04 Nº das questões erradas (Nº e alínea reconvertidos à 15/3) Comparação 1 a 4, Sequências 5 a 8, Loop repeat times 9 a 12, Loop repeat until 13 a 16, Condicional if 17 a 20, Condicional if/else 21 a 24, Condicional while 25 a 28, Funções Comentário geral __________________________________________________________________________________ __________________________________________________________________________________ __________________________________________________________________________________ 129 Aluno - L O que achaste do trabalho, de converter IMC e ICQ para uma aplicação Android? "Foi bom para aprender um bocado." Gostas de programação em Android? "Sim, não é mau." O que é mais difícil para ti no Android Studio? "É o código. A parte de programar as aplicações." Aluno - M O que é mais difícil para ti no Android Studio? "O Java." Achas a interface do Android Studio confusa? "Não, dá para entender mais ou menos. Só que não sou muito bom em inglês." Aluno - N Achaste o Android Studio difícil? "Não acho muito difícil, mas ao mesmo tempo é um bocado complexo. São muitas coisas." O que é mais difícil para ti no Android Studio? "O código Java." Gostaste do Android Studio? "Sim, gostei. Até mais que o Visual Studio. Gostei da parte do layout - do Design." Aluno - O Que achas do Android Studio? "Não estou a desgostar, mas baralho-me um pouco. Não estou muito à vontade para trabalhar." Tens mais dificuldade com o Java ou com o XML? “Com o Java. Com as telas também baralho-me um pouco, mas com tempo chego lá." Sentes que estás a aprender? "Sim. No início custou um pouco, mas já estou a aprender." Aluno - P Tens mais dificuldade com o Java ou com o XML? "O código [Java] é mais difícil." Achas que as aulas estavam a ir num bom ritmo? "Acho que sim. Mais ou menos." Aluno - Q O que é mais difícil para ti no Android Studio? "Acho que é o código [Java]..." Achas que estás a conseguir acompanhar? "Mais ou menos." 130 Apêndice IX Autoavaliação do Aluno sobre o seu desempenho nas aulas lecionadas pelo Prof. Estagiário Maurício Morais no período de 15/03 a 01/04/2022 Curso 481040, UFCD 0817, 11º ano TPI, Escola Carlos Amarante Nome: ……………………………………………………………………………………………………… Nº………………………………… Indique se as afirmações são verdadeiras V, ou falsas, F, de acordo com o seu perfil. 1) Compreendi o que era esperado fazer nos trabalhos IMC e ICQ 2) Quando tive dúvidas perguntei ao professor. 3) Quando tive dúvidas perguntei aos colegas. 4) Fui capaz de resolver os trabalhos propostos sem ajuda do professor e dos colegas. 5) Precisei de apoio na construção das telas. 6) Precisei de apoio no código Java. 7) O ambiente Android Studio é complicado. 8) Faltam-me bases de Java para bem compreender o Android. 9) Um trabalho consegui terminar, mas o outro não. 10) Não consegui terminar os trabalhos IMC e ICQ na aula. 11) Tentei fazer os trabalhos IMC e ICQ em casa. 12) Interesso-me pela matéria e tenciono continuar a programar apps para Android. 13) Interesso-me pela matéria, mas não tenciono continuar a programar apps para Android. 14) Não gosto de programação Android. 131 Apêndice X Código-Fonte App IMC IMC: activity_main.xml <?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLay out xmlns:android="http://schemas.android.com/apk/r es/android" xmlns:app="http://schemas.android.com/apk/resauto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity"> <TextView android:id="@+id/header_title" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="16dp" android:fontFamily="sans-serif" android:text="@string/main_header_title" android:textSize="24sp" android:textStyle="bold" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf= "parent" app:layout_constraintTop_toTopOf="parent"/> <TextView android:id="@+id/rtl_peso" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginStart="32dp" android:text="@string/main_rtl_peso" android:textSize="20sp" android:textStyle="bold" app:layout_constraintBaseline_toBaselineOf="@+i d/edtxt_peso" app:layout_constraintEnd_toStartOf= "@+id/edtxt_peso" app:layout_constraintHorizontal_bias="0.5" app:layout_constraintHorizontal_chainStyle="pac ked" app:layout_constraintStart_toStartOf= "parent" /> <EditText android:id="@+id/edtxt_peso" android:layout_width="wrap_content" android:layout_height="50dp" android:layout_marginTop="8dp" android:ems="8" android:hint="@string/main_hint_edtxt_peso" android:inputType="numberDecimal" android:digits="0123456789." app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf= "parent" app:layout_constraintTop_toBottomOf= "@+id/header_title" /> <TextView android:id="@+id/rtl_altura" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginStart="32dp" android:text="@string/main_rtl_altura" android:textSize="20sp" android:textStyle="bold" app:layout_constraintBaseline_toBaselineOf="@+i d/edtxt_altura" app:layout_constraintEnd_toStartOf= "@+id/edtxt_altura" app:layout_constraintHorizontal_bias="0.5" app:layout_constraintHorizontal_chainStyle="pac ked" app:layout_constraintStart_toStartOf= "parent" /> <EditText android:id="@+id/edtxt_altura" android:layout_width="wrap_content" android:layout_height="50dp" android:layout_marginTop="8dp" android:ems="8" android:hint= "@string/main_hint_edtxt_altura" android:inputType="numberDecimal" android:digits="0123456789." app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf= "parent" app:layout_constraintTop_toBottomOf= "@+id/edtxt_peso" /> <TextView android:id="@+id/rtl_imc" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginStart="32dp" android:text="@string/main_rtl_imc" android:textSize="20sp" android:textStyle="bold" app:layout_constraintBaseline_toBaselineOf="@+i d/txt_imc" app:layout_constraintEnd_toStartOf= "@+id/txt_imc" app:layout_constraintHorizontal_bias="0.5" app:layout_constraintHorizontal_chainStyle="pac ked" app:layout_constraintStart_toStartOf= "parent" /> <TextView android:id="@+id/txt_imc" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="12dp" android:ems="8" android:text="@string/main_txt_imc" android:textSize="20sp" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf= "parent" app:layout_constraintTop_toBottomOf= "@+id/edtxt_altura"/> <TextView android:id="@+id/txt_msg" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="12dp" android:ems="8" android:text="" android:textSize="20sp" android:textStyle="bold" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf= "parent" app:layout_constraintTop_toBottomOf= "@+id/txt_imc" /> 132 <Button android:id="@+id/btn_calcular" android:onClick="calcular" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="20dp" android:ems="12" android:text="@string/main_btn_calcular" android:textSize="20sp" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf= "parent" app:layout_constraintTop_toBottomOf= "@+id/txt_msg" /> <Button android:id="@+id/btn_limpar" android:onClick="limpar" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="12dp" android:ems="12" android:text="@string/main_btn_limpar" android:textSize="20sp" app:layout_constraintEnd_toEndOf= "parent" app:layout_constraintStart_toStartOf= "parent" app:layout_constraintTop_toBottomOf= "@+id/btn_calcular" /> </androidx.constraintlayout.widget.ConstraintLa yout> IMC: Imc.java package com.example.imc; public class Imc{ public double peso, altura, imc; public String strClassifica; // getters double getPeso(){return peso;} double getAltura(){return altura;} double getImc(){return imc;} // setters void setPeso(double peso){this.peso=peso;} void setAltura(double altura){ this.altura=altura;} void setImc(){imc = peso/(altura*altura);} void setClassifica(){ setImc(); if (imc < 18) { strClassifica = "Peso baixo";} if (imc >= 18 && imc < 24.9){ strClassifica = "Peso normal";} if (imc >= 25 && imc < 29.9){ strClassifica = "Pré-obesidade";} if (imc >= 30 && imc < 34.9){ strClassifica = "Obesidade grau I";} if (imc >= 35 && imc < 39.9){ strClassifica = "Obesidade grau II";} if (imc >= 40) { strClassifica = "Obesidade grau III";} } String getClassifica(){ setClassifica(); return strClassifica; } } 133 IMC: MainActivity.java package com.example.imc; import androidx.appcompat.app.AppCompatActivity; import android.os.Bundle; import android.util.Log; import android.view.View; import android.widget.EditText; import android.widget.TextView; public class MainActivity extends AppCompatActivity { public TextView txtIMC, txtMsg; public EditText edtxtPeso, edtxtAltura; Imc imc = new Imc(); @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); edtxtPeso = findViewById(R.id.edtxt_peso); edtxtAltura = findViewById(R.id.edtxt_altura); txtIMC = findViewById(R.id.txt_imc); txtMsg = findViewById(R.id.txt_msg); } public void calcular(View view) { Log.i("btn_calcular", "onClick funciona!"); // verificar se os edtxts estão vazios if (edtxtPeso.getText().toString().isEmpty()) { txtMsg.setText("Peso?"); edtxtPeso.requestFocus(); return; } if (edtxtAltura.getText().toString().isEmpty()) { txtMsg.setText("Altura?"); edtxtAltura.requestFocus(); return; } // converter inputs para Double e guardar variaveis no objeto imc imc.setPeso(Double.parseDouble(edtxtPeso.getText().toString())); imc.setAltura(Double.parseDouble(edtxtAltura.getText().toString())); // chamar metodo de calculo imc.setImc(); // converter resultado Double para String // String strImc = String.valueOf(imc.getImc());// sem formatação String strImc = String.format("%.2f", imc.getImc()); // 2 casas decimais // escrever resultado no textview Imc txtIMC.setText(strImc); // escrever classificação no textview msg txtMsg.setText(imc.getClassifica()); } public void limpar(View view) { Log.i("btn_limpar", "onClick funciona!"); edtxtPeso.setText(""); edtxtAltura.setText(""); txtIMC.setText(""); txtMsg.setText(""); edtxtPeso.requestFocus(); } } 134 Apêndice XI Código-Fonte App ICQ ICQ: activity_main.xml <?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget. ConstraintLayout xmlns:android= "http://schemas.android.com/apk/res/android" xmlns:app= "http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:id="@+id/ConstraintLayout_1" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity"> <TextView android:id="@+id/header_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:background= "@android:color/holo_blue_dark" android:padding="10dp" android:text="@string/header_title" android:textAlignment="center" android:textColor="@color/white" android:textSize="20sp" android:textStyle="bold" app:layout_constraintTop_toTopOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintBottom_toTopOf= "@id/ScrollView_1"/> <ScrollView android:id="@+id/ScrollView_1" android:layout_width="match_parent" android:layout_height="0dp" app:layout_constraintTop_toBottomOf= "@id/header_title" app:layout_constraintBottom_toTopOf= "@id/Constraintlayout_3"> <androidx.constraintlayout.widget. ConstraintLayout android:id="@+id/Constraintlayout_2" android:layout_width="match_parent" android:layout_height="wrap_content" android:textAlignment="center"> <TextView android:id="@+id/rtl_nome" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_margin="16dp" android:text="@string/rtl_nome" android:textSize="16sp" android:textStyle="bold" app:layout_constraintBaseline_toBaselineOf= "@+id/edtxt_nome" app:layout_constraintEnd_toStartOf= "@+id/edtxt_nome" app:layout_constraintHorizontal_chainStyle= "packed" /> <EditText android:id="@+id/edtxt_nome" android:layout_width="200dp" android:layout_height="48dp" android:layout_margin="16dp" android:ems="10" android:hint="@string/hint_nome" android:inputType= "textPersonName|textCapWords" android:textSize="16sp" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent" /> <TextView android:id="@+id/rtl_sexo" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_margin="16dp" android:text="@string/rtl_sexo" android:textSize="16sp" android:textStyle="bold" app:layout_constraintBaseline_toBaselineOf= "@+id/edtxt_sexo" app:layout_constraintEnd_toStartOf= "@+id/edtxt_sexo" app:layout_constraintHorizontal_chainStyle= "packed" /> <EditText android:id="@+id/edtxt_sexo" android:layout_width="200dp" android:layout_height="48dp" android:layout_margin="16dp" android:digits="0123456789" android:ems="10" android:hint="@string/hint_sexo" android:inputType="textShortMessage" android:textSize="16sp" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf= "parent" app:layout_constraintTop_toBottomOf= "@+id/edtxt_nome" /> <TextView android:id="@+id/rtl_cc" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_margin="16dp" android:text="@string/rtl_cc" android:textSize="16sp" android:textStyle="bold" app:layout_constraintBaseline_toBaselineOf= "@+id/edtxt_cc" app:layout_constraintEnd_toStartOf= "@+id/edtxt_cc" app:layout_constraintHorizontal_chainStyle= "packed" /> <EditText android:id="@+id/edtxt_cc" android:layout_width="200dp" android:layout_height="48dp" android:layout_margin="16dp" android:ems="10" android:hint="@string/hint_cc" android:inputType="number" android:digits="0123456789" android:textSize="16sp" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf= "parent" app:layout_constraintTop_toBottomOf= "@+id/edtxt_sexo" /> <TextView android:id="@+id/rtl_cintura" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_margin="16dp" android:text="@string/rtl_cintura" android:textSize="16sp" 135 android:textStyle="bold" app:layout_constraintBaseline_toBaselineOf= "@+id/edtxt_cintura" app:layout_constraintEnd_toStartOf= "@+id/edtxt_cintura" app:layout_constraintHorizontal_chainStyle= "packed" /> <EditText android:id="@+id/edtxt_cintura" android:layout_width="200dp" android:layout_height="48dp" android:layout_margin="16dp" android:ems="10" android:hint="@string/hint_cintura" android:inputType="number" android:digits="0123456789" android:textSize="16sp" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toBottomOf= "@+id/edtxt_cc" /> <TextView android:id="@+id/rtl_quadril" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_margin="16dp" android:text="@string/rtl_quadril" android:textSize="16sp" android:textStyle="bold" app:layout_constraintBaseline_toBaselineOf= "@+id/edtxt_quadril" app:layout_constraintEnd_toStartOf= "@+id/edtxt_quadril" app:layout_constraintHorizontal_chainStyle= "packed" /> <EditText android:id="@+id/edtxt_quadril" android:layout_width="200dp" android:layout_height="48dp" android:layout_margin="16dp" android:ems="10" android:hint="@string/hint_quadril" android:inputType="number" android:digits="0123456789" android:textSize="16sp" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf= "parent" app:layout_constraintTop_toBottomOf= "@+id/edtxt_cintura" /> <TextView android:id="@+id/rtl_icq" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_margin="16dp" android:text="@string/rtl_icq" android:textSize="16sp" android:textStyle="bold" app:layout_constraintBaseline_toBaselineOf= "@+id/txt_icq" app:layout_constraintEnd_toStartOf= "@+id/txt_icq" app:layout_constraintHorizontal_chainStyle= "packed" /> <TextView android:id="@+id/txt_icq" android:layout_width="200dp" android:layout_height="wrap_content" android:layout_margin="16dp" android:hint="@string/hint_icq" android:textSize="16sp" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toBottomOf= "@+id/edtxt_quadril" /> <TextView android:id="@+id/txt_mensagem" android:layout_width="200dp" android:layout_height="wrap_content" android:layout_margin="16dp" android:text="@string/rlt_mensagem" android:textSize="16sp" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toBottomOf= "@+id/txt_icq" app:layout_constraintBottom_toBottomOf= "parent"/> </androidx.constraintlayout.widget. ConstraintLayout> </ScrollView> <androidx.constraintlayout.widget. ConstraintLayout android:id="@+id/Constraintlayout_3" android:layout_width="match_parent" android:layout_height="wrap_content" android:textAlignment="gravity" app:layout_constraintBottom_toBottomOf= "@id/ConstraintLayout_1" app:layout_constraintStart_toStartOf="parent" app:layout_constraintEnd_toEndOf="parent"> <Button android:id="@+id/btn_calcular" android:onClick="calcular" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="12dp" android:ems="12" android:text="@string/btn_calcular" android:textSize="16sp" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent" app:layout_constraintBottom_toTopOf= "@id/btn_limpar"/> <Button android:id="@+id/btn_limpar" android:onClick="limpar" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="10dp" android:layout_marginBottom="16dp" android:ems="12" android:text="@string/btn_limpar" android:textSize="16sp" app:layout_constraintTop_toBottomOf= "@id/btn_calcular" app:layout_constraintStart_toStartOf="parent" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintEnd_toEndOf="parent" /> </androidx.constraintlayout.widget. ConstraintLayout> </androidx.constraintlayout.widget. ConstraintLayout> 136 ICQ: Icq.java package com.example.icq; public class Icq { public int cc; public double cintura, quadril, icq; public String nome, sexo, classifica = ""; // construtor 2 parametros public Icq(double cintura, double quadril){ this.cintura = cintura; this.quadril = quadril; setIcq(); } // construtor 5 parametros public Icq(String nome, String sexo, int cc, double cintura, double quadril){ this.nome = nome; this.sexo = sexo; // strings this.cc = cc; // int this.cintura = cintura; this.quadril = quadril; // doubles setIcq(); setClassifica(); } void setIcq(){ this.icq = (double) cintura / (double) quadril; // (casting) } void setClassifica() { switch (sexo) { case "": classifica = "Sexo?"; break; case "M": case "m": if (icq > 1) { classifica = "Acima do recomendado. Masculino <= 1.00"; } else { classifica = "Dentro do recomendado. Masculino <= 1.00"; } break; case "F": case "f": if (icq > 0.8){ classifica = "Acima do recomendado. Feminino <= 0.80"; } else { classifica = "Dentro do recomendado. Feminino <= 0.80"; } break; default: // digitar outro sexo para listar valores das variaveis classifica = "nome= " + nome + " cc= " + cc + " cint= " + cintura + " quad= " + quadril; break; } } } ICQ: MainActivity.java package com.example.icq; import androidx.appcompat.app.AppCompatActivity; import android.util.Log; import android.view.View; import android.widget.TextView; import android.widget.EditText; import android.os.Bundle; import java.util.Locale; public class MainActivity extends AppCompatActivity { public TextView txtICQ, txtMensagem; public EditText edtxtNome, edtxtSexo, edtxtCC, edtxtCintura, edtxtQuadril; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); edtxtNome = findViewById(R.id.edtxt_nome); edtxtSexo = findViewById(R.id.edtxt_sexo); edtxtCC = findViewById(R.id.edtxt_cc); edtxtCintura = findViewById(R.id.edtxt_cintura); edtxtQuadril = findViewById(R.id.edtxt_quadril); 137 txtICQ = findViewById(R.id.txt_icq); txtMensagem = findViewById(R.id.txt_mensagem); // CC é input type password. usar este metodo para não ocultar numeros edtxtCC.setTransformationMethod(null); } public void calcular(View view) { if(edtxtNome.getText().toString().isEmpty()){ txtMensagem.setText("Nome?"); edtxtNome.requestFocus(); return; } if(edtxtSexo.getText().toString().isEmpty()){ txtMensagem.setText("Sexo?"); edtxtSexo.requestFocus(); return; } if(edtxtCC.getText().toString().isEmpty()){ txtMensagem.setText("CC?"); edtxtCC.requestFocus(); return; } if(edtxtCintura.getText().toString().isEmpty()){ txtMensagem.setText("Cintura?"); edtxtCintura.requestFocus(); return; } if(edtxtQuadril.getText().toString().isEmpty()){ txtMensagem.setText("Quadril?"); edtxtQuadril.requestFocus(); return; } // 2 parametros mínimos para chamar setIcq sem saber o sexo Icq icq2 = new Icq( Double.parseDouble(edtxtCintura.getText().toString()), Double.parseDouble(edtxtQuadril.getText().toString())); // 5 parametros para chamar setIcq e classificar segundo o sexo Icq icq5 = new Icq( edtxtNome.getText().toString(), edtxtSexo.getText().toString(), Integer.parseInt(edtxtCC.getText().toString()), icq2.cintura, icq2.quadril); String strIcq = String.format(Locale.US, "%.2f", icq2.icq); txtICQ.setText(strIcq); txtMensagem.setText(icq5.classifica); } public void limpar(View view) { edtxtCC.setText(""); edtxtNome.setText(""); edtxtSexo.setText(""); edtxtCintura.setText(""); edtxtQuadril.setText(""); txtICQ.setText(""); txtMensagem.setText(""); edtxtNome.requestFocus(); } } 138 Anexos