An Exploration of Novice Programmers' Comprehension of Conditionals in Imperative and Functional Programming

2Students of introductory programming courses are expected to develop higher-order thinking skills to inspect, understand and modify code. However, although novices can correctly write small programs, they appear to lack a more abstract, comprehensive grasp of basic constructs, such as conceiving the overall effect of alternative conditional flows. This work takes a little-explored perspective on the comprehension of tiny programs by asking students to reason about reversing conditionals in either an imperative or a functional context. More specifically, besides deciding if the given constructs can be reversed, students had to justify their choice by writing a reversing program or by providing suitable counterexamples. The students’ answers to four reversibility questions have been analysed through the lens of the SOLO taxonomy. 45% of students correctly identified the reversibility for the four code items; furthermore, more than 50% of each cohort were able to provide correct justifications for at least three of their four answers. Most incorrect answers were due to failures to consider border cases or to edit the conditional expressions appropriately to reverse the construct. Differences in comprehension between functional and imperative languages are explored indicating the explicit else paths of the functional examples facilitate comprehension compared with the implicit else (no update) of its imperative counterpart.partially_openopenMirolo, Claudio; Izu, CruzMirolo, Claudio; Izu, Cru

High-school students' mastery of basic flow-control constructs through the lens of reversibility

High-school students specialising in computing fields need to develop the abstraction skills required to understand and create programs. Novices' difficulties at high-school level, ranging from mastery of the "notional machine"to recognition of a program's purpose, have not been investigated as extensively as at tertiary level. This work explores high-school students' code comprehension by asking to reason about reversing conditional and iteration constructs. A sample of 205 K11 - 13 students from different institutions were asked to engage in a set of "reversibility tasklets". For each code fragment, they need to identify if its computation is reversible and either provide the code to reverse or an example of a value that cannot be reversed. For 4 such items, after extracting the recurrent patterns in students' answers, we have carried out an analysis within the framework of the SOLO taxonomy. Overall, 74% of answers correctly identified if the code was reversible but only 42% could provide the full explanation/code. The rate of relational answers varies from 51% down to 21%, the poorest performance arising for a small array-processing loop (and although 65% of the subjects had correctly identified the loop as reversible). The instruction level did not have a strong impact on performance, indicating such tasks are suitable for K11, when the basic flow-control constructs are usually introduced. In particular, the reversibility concept could be a useful pedagogical instrument both to assess and to help develop students' program comprehension

Task-related models for teaching and assessing iteration learning in high school

A number of studies report about students’ difficulties with basic flow-control constructs, and specifically with iteration. Although such issues are less explored in the context of pre-tertiary education, this seems to be especially the case for high-school programming learning, where the difficulties concern both the “mechanical” features of the notional machine as well as the logical aspects connected with the constructs, ranging from the implications of loop conditions to a more abstract grasp of the underlying algorithms. For these reasons, the aim of this work is to: i) identifying methodological tools to enhance a comprehensive understanding of the iteration constructs, ii) suggest strategies to teach iterations. We interviewed 20 experienced upper secondary teachers of introductory programming in different kinds of schools. The interviews were mainly aimed at ascertaining teachers’ beliefs about major sources of issues for basic programming concepts and their approach to the teaching and learning of iteration constructs. Once teachers’ perception of students’ difficulties have been identified, we have submitted, to a sample of 164 students, a survey which included both questions on their subjective perception of difficulty and simple tasks probing their understanding of iteration. Data collected from teachers and students confirm that iteration is a central programming concept and indicate that the treatment of conditions and nested constructs are major sources of students’ difficulties with iteration. The interviews allowed us to identify a list of problems that are typically presented by teachers to explain the iterations. Hence, a catalogue of significant program examples has been built to support students’ learning, tasks with characteristics different from those typically presented in class. Based on the outcome of previous steps, a survey to collect related information and good practices from a larger sample of teachers has been designed. Data collected have been analysed distinguishing an orientation towards more conceptual objectives, and one towards more practical objectives. Furthermore, regarding evaluation, a orientation focused on process-based assessment and another on product-based assessment. Finally, based on the outcome of previous students’ survey and drawing from the proposed examples catalogue, we have designed and submitted a new students’ survey, composed of a set of small tasks, or tasklets, to investigate in more depth on high-school students’ understanding of iteration in terms of code reading abilities. The chosen tasklets covered the different topics: technical program feature, correlation between tracing effort and abstraction, the role of flow-charts, students’ perception of self-confidence concerning high-level thinking skills.A number of studies report about students’ difficulties with basic flow-control constructs, and specifically with iteration. Although such issues are less explored in the context of pre-tertiary education, this seems to be especially the case for high-school programming learning, where the difficulties concern both the “mechanical” features of the notional machine as well as the logical aspects connected with the constructs, ranging from the implications of loop conditions to a more abstract grasp of the underlying algorithms. For these reasons, the aim of this work is to: i) identifying methodological tools to enhance a comprehensive understanding of the iteration constructs, ii) suggest strategies to teach iterations. We interviewed 20 experienced upper secondary teachers of introductory programming in different kinds of schools. The interviews were mainly aimed at ascertaining teachers’ beliefs about major sources of issues for basic programming concepts and their approach to the teaching and learning of iteration constructs. Once teachers’ perception of students’ difficulties have been identified, we have submitted, to a sample of 164 students, a survey which included both questions on their subjective perception of difficulty and simple tasks probing their understanding of iteration. Data collected from teachers and students confirm that iteration is a central programming concept and indicate that the treatment of conditions and nested constructs are major sources of students’ difficulties with iteration. The interviews allowed us to identify a list of problems that are typically presented by teachers to explain the iterations. Hence, a catalogue of significant program examples has been built to support students’ learning, tasks with characteristics different from those typically presented in class. Based on the outcome of previous steps, a survey to collect related information and good practices from a larger sample of teachers has been designed. Data collected have been analysed distinguishing an orientation towards more conceptual objectives, and one towards more practical objectives. Furthermore, regarding evaluation, a orientation focused on process-based assessment and another on product-based assessment. Finally, based on the outcome of previous students’ survey and drawing from the proposed examples catalogue, we have designed and submitted a new students’ survey, composed of a set of small tasks, or tasklets, to investigate in more depth on high-school students’ understanding of iteration in terms of code reading abilities. The chosen tasklets covered the different topics: technical program feature, correlation between tracing effort and abstraction, the role of flow-charts, students’ perception of self-confidence concerning high-level thinking skills

Comparing Small Programs for Equivalence: A Code Comprehension Task for Novice Programmers

Novice programmers should develop program comprehension skills as they learn to code so that they are able both to read and reason about code created by others, and to reflect on their code when writing, debugging or extending it. This work takes a little-explored perspective on the comprehension of small programs by asking students to decide if two code segments are equivalent or not in terms of carrying out the same computation. A variation of Euclid's algorithm, that extends the greatest common divisor calculation to more than two numbers, was chosen for this work, as it has an adequate level of complexity and its semantics are not obvious. Four program transformations of the original code were developed: two transformations were equivalent and two were not. 73.5% of students were able to identify correctly the four options and 75.5% provided good insights on the equivalent program flow to justify their choices. The overall task has a SOLO mean of 3.19, which indicates code equivalence is a suitable and approachable task to analyse program execution at novice level. In addition, the data analysis suggests that students' code-reading abilities beyond basic tracing may be generally underestimated and we should investigate how to bridge the potential gap between reasoning about program execution and extracting its purpose

Fostering Program Comprehension in Novice Programmers - Learning Activities and Learning Trajectories

This working group asserts that Program Comprehension (ProgComp) plays a critical part in the process of writing programs. For example, this paper is written from a basic draft that was edited and revised until it clearly presented our idea. Similarly, a program is written incrementally, with each step tested, debugged and extended until the program achieves its goal. Novice programmers should develop program comprehension skills as they learn to code so that they are able both to read and reason about code created by others, and to reflect on their code when writing, debugging or extending it. To foster such competencies our group identified two main goals: (g1) to collect and define learning activities that explicitly address key components of program comprehension and (g2) to define tentative theoretical learning trajectories that will guide teachers as they select and sequence those learning activities in their CS0/CS1/CS2 or K-12 courses. The WG has completed the first goal and laid down a strong foundation towards the second goal as presented in this report. After a thorough literature review, a detailed description of the Block Model is provided, as this model has been used with a dual purpose, to classify and present an extensive list of ProgComp tasks, and to describe a possible learning trajectory for a complex task, covering different cells of the Block Model matrix. The latter is intended to help instructors to decompose complex tasks and identify which aspects of ProgComp are being fostered

Fifty years of the Psychology of Programming

This paper reflects on the evolution (past, present and future) of the ‘psychology of programming' over the 50 year period of this anniversary issue. The International Journal of Human-Computer Studies (IJHCS) has been a key venue for much seminal work in this field, including its first foundations, and we review the changing research concerns seen in publications over these five decades. We relate this thematic evolution to research taking place over the same period within more specialist communities, especially the Psychology of Programming Interest Group (PPIG), the Empirical Studies of Programming series (ESP), and the ongoing community in Visual Languages and Human-Centric Computing (VL/HCC). Many other communities have interacted with psychology of programming, both influenced by research published within the specialist groups, and in turn influencing research priorities. We end with an overview of the core theories that have been developed over this period, as an introductory resource for new researchers, and also with the authors’ own analysis of key priorities for future research

The impact of different teaching approaches and languages on student learning of introductory programming concepts

Many students experience difficulties learning to program. They find learning to program in the object-oriented paradigm particularly challenging. As a result, computing educators have tried a variety of instructional methods to assist beginning programmers. These include developing approaches geared specifically toward novices and experimenting with different introductory programming languages. However, having tried these different methods, computing educators are faced with yet another dilemma: how to tell if any of these interventions actually worked?The research presented here was motivated by an interest in improving practices in computer science education in general and improving my own practices as a computer science educator in particular. Its purpose was to develop an instrument to assess student learning of fundamental and object-oriented programming concepts, and to use that instrument to investigate the impact of different teaching approaches and languages on students’ ability to learn those concepts.Students enrolled in programming courses at two different universities in the Mid-Atlantic region during the 2009-2010 academic year participated in the study. Extensive data analysis showed that the assessment instrument performed well overall. Reliability estimates ranged from 0.65 to 0.79. The instrument is intrinsically valid since the questions are based on the core concepts of the Programming Fundamentals knowledge area defined by the 2008 ACM/IEEE curricular guidelines. Support for content validity includes: 71% of correct responses varied directly with the students’ scores; all possible responses were selected at least once; and 21 out of 24 questions discriminated well between high and low scoring students. CS faculty reviewers indicated that 19 out of 24 questions reflected basic concepts and should be used again “as is” or with “minor changes.” Factor analysis extracted three comprehensible components, “methods and functions,” “mathematical and logical expressions,” and “control structures,” suggesting the instrument is on its way to effectively representing the construct “understanding of fundamental programming concepts.”Statistical analysis revealed significant differences in student performance based on language of instruction. Analyses revealed differences with respect to overall score and questions involving assignment, mathematical and logical expressions, and codecompletion. Language of instruction did not appear to affect student performance on questions addressing object-oriented concepts.Ph.D., Information Science and Technology -- Drexel University, 201

Gradually learning programming supported by a growable programming language

Learning programming is a difficult task. The learning process is particularly disorienting when you are approaching programming for the first time. As a student you are exposed to several new concepts (control flow, variable, etc. but also coding, compiling etc.) and new ways to think (algorithms). Teachers try to expose the students gradually to the new concepts by presenting them one by one but the tools at student's disposal do not help: they provide support, suggestion and documentation for the full programming language of choice hampering the teacher's efforts. On the other side, students need to learn real languages and not didactic languages. In this work we propose an approach to gradually teaching programming supported by a programming language that grows---together with its implementation---along with the number of concepts presented to the students. The proposed approach can be applied to the teaching of any programming language and some experiments with Javascript are reported

Learning to Code: Effects of Programming Modality in a Game-based Learning Environment

As new introductory block-based coding applications for young students to learn basic computer science concepts, such as, loops and conditionals, continue to increase in popularity, it is necessary to consider the best method of teaching students these skills. Many of these products continue to exhibit programmatic misconceptions of these concepts and many students struggle with how to apply what they learn to a text-based format due to the difficulties with learning the syntactic structure not present in block-based programming languages. If the goal of teaching young students how to program is meant to develop a set of skills they may apply when learning more complex programming languages, then discerning how they are introduced to those practices is imperative. However, few studies have examined how the specific modality in which students are taught to program effects how they learn and what skills they develop. More specifically, research has yet to effectively investigate modality in the context of an educational coding game where the modality feature is controlled, and content is consistent throughout game-play. This is mainly due to the lack of available games with this feature designed into the application. This dissertation explores whether programming modality effects how well students can learn and transfer computer science concepts and practices from an educational programming game. I proposed that by being guided from a blocks-based to text-based programming language would instill a deeper understanding of basic computer science concepts and would support learning and improve transfer and performance on new challenging tasks. Two experimental studies facilitated game-play sessions on the developed application for this project. The first study was a 2x2 between subjects design comparing educational module (game versus basic) and programming modality (guided versus free choice). The findings from Study 1 informed the final version design for the module used in the second study where only the game module was used in order to focus the comparison between programming modality. Findings showed that students who coded using the game module performed better on a learning test. Study 2 results showed that students who are transitioned from blocks-based to text-based programming language learn basic computer science concepts with greater success than those with the free choice modality. A comparative study was conducted using quantitative data from learning measures and qualitative video data from the interviews during the challenge task of the second study. This study examined how students at the extreme levels of performance utilized the toggle switch feature during game-play and how the absence of the feature impacted how they completed the challenge task. This analysis showed two different methods of toggle switch usage being implemented by a high and low performing student. The high performing student utilized the resources more often during the challenge tasks in lieu of leveraging the toggle switch and were still able to submit high level code. Results suggest that a free choice student who uses the feature as a tool to check their prewritten code rather than a as short cut for piecing code together as blocks and submitting the text upon the final attempt. This practice leads to a shallower understanding of the basic concepts and make it extremely difficult to expand and apply that knowledge to a more difficult task. This dissertation includes five chapters: an introduction and theoretical framework, a game design framework and implementation description, two experimental investigations, and a quantitative and qualitative comparative analysis. Chapter one provides the conceptual and theoretical framework for the two experimental investigations. Chapter two describes the theory and design structure for the game developed for this dissertation work. Chapter three and four will discuss the effects of programming modality on learning outcomes. Specifically, chapter 3 focuses on implications of programming modality when determining how to implement changes for the design of the game for Study 2. Chapter five discusses a comparative analysis that investigated differing work flow patterns within the free choice condition between high and low performing students. Results from these three chapters illustrate the importance of examining this component of the computer science education process in supplemental games for middle and high school students. Additionally, this work contributes in furthering the investigation of these educational games and discusses implications for design of similar applications

Exploring student perceptions about the use of visual programming environments, their relation to student learning styles and their impact on student motivation in undergraduate introductory programming modules

My research aims to explore how students perceive the usability and enjoyment of visual/block-based programming environments (VPEs), to what extent their learning styles relate to these perceptions and finally to what extent these tools facilitate student understanding of basic programming constructs and impact their motivation to learn programming