Subgoal-Labeled Instructional Material Improves Performance and Transfer in Learning to Develop Mobile Applications

Mental models are mental representations of how an action changes a problem state. Creating a mental model early in the learning process is a strong predictor of success in computer science classes. One major problem in computer science education, however, is that novices have difficulty creating mental models perhaps because of the cognitive overload caused by traditional teaching methods. The present study employed subgoal-labeled instructional materials to promote the creation of mental models when teaching novices to program in Android App Inventor. Utilizing this and other well-established educational tools, such as scaffolding, to reduce cognitive load in computer science education improved the performance of participants on novel tasks when learning to develop mobile applications

Beyond Automated Assessment: Building Metacognitive Awareness in Novice Programmers in CS1

The primary task of learning to program in introductory computer science courses (CS1) cognitively overloads novices and must be better supported. Several recent studies have attempted to address this problem by understanding the role of metacognitive awareness in novices learning programming. These studies have focused on teaching metacognitive awareness to students by helping them understand the six stages of learning so students can know where they are in the problem-solving process, but these approaches are not scalable. One way to address scalability is to implement features in an automated assessment tool (AAT) that build metacognitive awareness in novice programmers. Currently, AATs that provide feedback messages to students can be said to implement the fifth and sixth learning stages integral to metacognitive awareness: implement solution (compilation) and evaluate implemented solution (test cases). The computer science education (CSed) community is actively engaged in research on the efficacy of compile error messages (CEMs) and how best to enhance them to maximize student learning and it is currently heavily disputed whether or not enhanced compile error messages (ECEMs) in AATs actually improve student learning. The discussion on the effectiveness of ECEMs in AATs remains focused on only one learning stage critical to metacognitive awareness in novices: implement solution. This research carries out an ethnomethodologically-informed study of CS1 students via think-aloud studies and interviews in order to propose a framework for designing an AAT that builds metacognitive awareness by supporting novices through all six stages of learning. The results of this study provide two important contributions. The first is the confirmation that ECEMs that are designed from a human-factors approach are more helpful for students than standard compiler error messages. The second important contribution is that the results from the observations and post-assessment interviews revealed the difficulties novice programmers often face to developing metacognitive awareness when using an AAT. Understanding these barriers revealed concrete ways to help novice programmers through all six stages of the problem-solving process. This was presented above as a framework of features, which when implemented properly, provides a scalable way to implicitly produce metacognitive awareness in novice programmers

Code Puzzle Completion Problems in Support of Learning Programming Independently

Middle school children often lack access to formal educational opportunities to learn computer programming. One way to help these children may be to provide tools that enable them to learn programming on their own independently. However, in order for these tools to be effective they must help learners acquire programming knowledge and also be motivating in independent contexts. I explore the design space of using motivating code puzzles with a method known to support independent learning: completion problems. Through this exploration, I developed code puzzle completion problems and an introductory curriculum introducing novice programmers to basic programming constructs. Through several evaluations, I demonstrate that code puzzle completion problems can motivate learners to acquire new programming knowledge independently. Specifically, I found that code puzzle completion problems are more effective and efficient for learning programming constructs independently compared to tutorials. Puzzle users performed 33% better on transfer tasks compared to tutorial users, while taking 21% less time to complete the learning materials. Additionally, I present evidence that children are motivated to choose to use the code puzzles because they find the experience enjoyable, challenging, and valuable towards developing their programming skills. Given the choice between using tutorials and puzzles, only 10% of participants opted to use more tutorials than puzzles. Further, 80% of participants also stated a preference towards the puzzles because they simply enjoyed the experience of using puzzles more than the tutorials. The results suggest that code puzzle completion problems are a promising approach for motivating and supporting independent learning of programming

The Example Guru: Suggesting Examples to Novice Programmers in an Artifact-Based Context

Programmers in artifact-based contexts could likely benefit from skills that they do not realize exist. We define artifact-based contexts as contexts where programmers have a goal project, like an application or game, which they must figure out how to accomplish and can change along the way. Artifact-based contexts do not have quantifiable goal states, like the solution to a puzzle or the resolution of a bug in task-based contexts. Currently, programmers in artifact-based contexts have to seek out information, but may be unaware of useful information or choose not to seek out new skills. This is especially problematic for young novice programmers in blocks programming environments. Blocks programming environments often lack even minimal in-context support, such as auto-complete or in-context documentation. Novices programming independently in these blocks-based programming environments often plateau in the programming skills and API methods they use. This work aims to encourage novices in artifact-based programming contexts to explore new API methods and skills. One way to support novices may be with examples, as examples are effective for learning and highly available. In order to better understand how to use examples for supporting novice programmers, I first ran two studies exploring novices\u27 use and focus on example code. I used those results to design a system called the Example Guru. The Example Guru suggests example snippets to novice programmers that contain previously unused API methods or code concepts. Finally, I present an approach for semi-automatically generating content for this type of suggestion system. This approach reduces the amount of expert effort required to create suggestions. This work contains three contributions: 1) a better understanding of difficulties novices have using example code, 2) a system that encourages exploration and use of new programming skills, and 3) an approach for generating content for a suggestion system with less expert effort

Learning programming via worked-examples: the effects of cognitive load and learning styles

This research explored strategies for learning programming via worked-examples that promote schema acquisition and transfer. However, learning style is a factor in how much learners are willing to expend serious effort on understanding worked-examples, with active learners tending to be more impatient of them than reflective learners. It was hypothesised that these two learning styles might also interact with learners’ cognitive load. The research proposed a worked-example format, called a Paired-method strategy that combines a Structure-emphasising strategy with a Completion strategy. An experiment was conducted to compare the effects of the three worked-examples strategies on cognitive load measures and on learning performance. The experiment also examined the degree to which individual learning style influenced the learning process and performance. Overall, the results of the experiment were inconsistent. In comparing the effects of the three strategies, there were significant differences in reported difficulty and effort during the learning phase, with difficulty but not effort in favour of the Completion strategy. However no significant differences were detected in reported mental effort during the post-tests in the transfer phase. This was also the case for the performance on the post-tests. Concerning efficiency measures, the results revealed significant differences between the three strategy groups in terms of the learning process and task involvement, with the learning process in favour of the Completion strategy. Unexpectedly, no significant differences were observed in learning outcome efficiencies. Despite this, there was a trend in the data that suggested a partial reversal effect for the Completion strategy. Moreover, the results partially replicated earlier findings on the explanation effect. In comparing the effects of the two learning styles, there were no significant differences between active and reflective learners in the three strategy groups on cognitive load measures and on learning performance (nor between reflective learners in the Paired-method strategy and the other strategies). Finally, concerning efficiency measures, there was a significant difference between active learners in the three strategy groups on task involvement. Despite all these, effect sizes ranging from a medium to large suggested that learning styles might have interacted with learners’ cognitive load

Identification and Evaluation of Predictors for Learning Success and of Models for Teaching Computer Programming in Contemporary Contexts

Introductory undergraduate computer programming courses are renowned for higher than average failure and withdrawal rates when compared to other subject areas. The closer partnership between higher education and the rapidly expanding digital technology industry, as demonstrated by the establishment of new Degree Apprenticeships in computer science and digital technologies, requires efficient and effective means for teaching programming skills. This research, therefore, aimed to identify reliable predictors of success in learning programming or vulnerability to failure. The research also aimed to evaluate teaching methods and remedial interventions towards recommending a teaching model that supported and engaged learners in contemporary contexts that were relevant to the workplace. Investigation of qualifications designed to prepare students for undergraduate computer science courses revealed that A-level entrants achieved significantly higher programming grades than BTEC students. However, there was little difference between the grades of those with and those without previous qualifications in computing or ICT subjects. Analysis of engagement metrics revealed a strong correlation between extent of co-operation and programming grade, in contrast to a weak correlation between programming grade and code understanding. Further analysis of video recordings, interviews and observational records distinguished between the type of communication that helped peers comprehend tasks and concepts, and other forms of communication that were only concerned with completing tasks. Following the introduction of periodic assessment, essentially converting a single final assessment to three staged summative assessment points, it was found that failing students often pass only one of the three assignment parts. Furthermore, only 10% of those who failed overall had attempted all three assignments. Reasons for failure were attributed to ‘surface’ motivations (such as regulating efforts to achieve a minimum pass of 40%), ineffective working habits or stressful personal circumstances rather than any fundamental difficulty encountered with subject material. A key contribution to pedagogical practice made by this research is to propose an ‘incremental’ teaching model. This model is informed by educational theory and empirical evidence and comprises short cycles of three activities: presenting new topic information, tasking students with a relevant exercise and then demonstrating and discussing the exercise solution. The effectiveness of this model is evidenced by increased engagement, increased quiz scores at the end of each teaching session and increased retention of code knowledge at the end of the course

The synthesis of a unified pedagogy for the design and evaluation of e-learning software for high-school computing

In recent decades, several countries have applied a resurgent focus to high-school computer science in the hope that it will provide the foundations for strong and innovative national IT sectors. The UK is one example undertaking this transition, and experiencing the associated challenges placed on the teaching community. In parallel, recent years have seen a trend towards enriching education with digital resources, specifically e-learning software. This study offers a practical contribution to the computer science teaching community by supporting the provision of e-learning software, and hence the increased use of e-learning in high-school teaching. However, it recognises that there remains a concern over the inconsistent pedagogical quality of many e-learning implementations. To safeguard the pedagogical quality of e-learning software, this study offers a research contribution by defining: (1) a comprehensive set of pedagogical heuristics to inform the design of e-learning software; (2) an associated e-learning evaluation protocol to guide the evaluation and selection of e-learning software for use in schools; and in doing so, (3) contributes to the under-researched area of high- school computing pedagogy. The proposed pedagogy synthesises a vast body of knowledge on learning theories into a comprehensive, yet accessible, set of heuristics. These heuristics supplement existing literature by focusing more tightly and in depth on pedagogy, rather than usability. The pedagogy synthesises the following learning theories: constructivism, social constructivism, connectivism, and cognitive load, and additionally gives pedagogical focus to VARK learning styles, ARCS motivational design, collaborative learning, gamification, and computational thinking. The e-learning evaluation protocol builds upon existing best practice in evaluation procedures but is unique in its characteristics and focus. The study follows a rigorous three phase mixed methods exploratory design in which the e-learning pedagogy and evaluation protocol were explored and iteratively developed in concert with input and evaluation from education experts and teachers. In parallel, practice-based input was secured via student usage of prototype e-learning software designed in adherence to the pedagogy. The findings of this research offer preliminary validation of the appropriateness and comprehensiveness of the e- learning pedagogy, and the final phase demonstrates statistically significant learning increases based on student usage of the e-learning software prototype. Additionally, this research offers preliminary validation of the reliability and validity of the evaluation protocol. Building on the findings of this research, several possibilities are outlined to further empirically establish this research, or develop it further into new avenues