Georgiana Haldeman

Program decomposition is a core skill in computer science that overlaps with program comprehension, refactoring, and design. Decomposition takes many forms, with one common task at the introductory level being the identification and extraction of meaningful abstraction into separate functions. However, there is limited empirical evidence about how the algorithmic structuring of code affects the difficulty of producing a meaningful decomposition. In this paper, we empirically study how different algorithmic implementations of the same underlying task affect students' ability to reason about good abstractions through method extraction. Grounded in a recent framework on code structuring, we design three functionally equivalent versions of the same task that differ only in how two latent functional patterns relate to each other: sequentially, hierarchically, or interleaved. Using a large-scale controlled study with 994 introductory programming students, we examine students' effort in decomposing the programs, the approaches they adopt, and their perceptions of whether the resulting decomposition improves readability and understanding. Our results show that interleaved functional composition is more difficult to decompose, providing initial empirical support for the framework's hypothesized ordering of composition pattern difficulty. Students also perceive their decompositions of the interleaved version to be less easy to read and understand. We also find that students describe many different approaches of decomposing, and we discuss several implications for teaching and future research.

Program decomposition is essential for developing maintainable and efficient software, yet it remains a challenging skill to teach and learn in introductory programming courses. What does program decomposition for procedural CS1 programs entail? How can CS1 students improve the decomposition of their programs? What scaffolded exercises can instructors use to teach program decomposition skills? We aim to answer all these questions by presenting a conceptual framework that (1) is grounded in the established code style principles, (2) provides a systematic approach that can be taught to students as an actionable strategy to improve the program decomposition of their programs, and (3) includes scaffolded exercises to be used in classroom activities. In addition, this systematic approach is automatable and can further be used to implement visualizers, automated feedback generators and digital tutors.

Characterising code quality is a challenge that was addressed by a previous ITiCSE Working Group (Börstler et al., 2017). As emerged from that study, educators, developers, and students have different perceptions of the aspects involved. The perception of code quality by CS1 students develops from the feedback they receive when submitting practical work. As a consequence of increasingly large classes and the widespread use of autograders, student code is predominantly assessed based on functional correctness, emphasising a machine-oriented perspective with scarce or no feedback given about human-oriented aspects of code quality. Such limited perception of code quality may negatively impact how students understand, create, and interact with code artefacts. Although Börstler et al. concluded that "code quality should be discussed more thoroughly in educational programs", the lack of materials and time constraints have slowed down progress in that regard. The goal of this Working Group is to support CS1 instructors who want to introduce a broader perspective on code quality in their classroom, by providing a curated list of examples and activities suitable for novices. In order to achieve this goal, we have extracted from the CS education literature a range of examples and activities, which have then been analysed and organised in terms of code quality dimensions. We have also mapped the topics covered in those materials to existing taxonomies relevant to code quality in CS1. Based on this work, we provide: (1) a catalogue of examples that illustrates the range of quality defects that could be addressed at CS1 level; and (2) a sample set of activities devised to introduce code quality to CS1 students. These materials have the potential to help educators address the subject in more depth.

Characterising code quality is a challenge that was addressed by Börstler et al. 's working group in 2017. As emerged from their study, educators, developers and students have different perceptions of the manifold aspects involved, and a major conclusion of that WG was that "code quality should be discussed more thoroughly in educational programs" [2, p. 70]. However, the lack of materials and the time constraints have slowed down progress in that regard. The goal of this working group is to propose manageable ways to address code quality in the CS1 classroom, with a particular focus on activities that help students become aware of and improve the quality of their code. To achieve this goal, we will (a) extract from the literature a comprehensive set of quality issues which will then be classified according to the appropriate strategies to fix them; and (b) circulate a survey to explore the instructors' views on code quality issues and the way they deal with (or ignore) them. Based on this work we aim to produce: (1) a taxonomy of code quality issues with associated examples, as well as (2) a sample set of teaching materials to introduce those issues to CS1 students.

Many of the effective practices studied in Computer Science Education Research (CER) tackle a common issue, which is that forming correct theories about programs and programming is challenging for novices and, therefore, rife for developing misconceptions. Combining aspects from all these practices, we developed a teaching model focused on correct theory formation about programs and programming (along all four dimensions of knowledge: factual, conceptual, procedural, and metacognitive). The proposed model is currently being implemented in one of the five sections of CS1 in Python at a small liberal arts college. Preliminary results based on the first midterm and anecdotal observations indicate improved learning, a lesser divide between high- and low-performing students, improved quality of student-submitted code, and other positive outcomes such as near-perfect attendance, improved student engagement with the material and other peers in the classroom, and a sense of enthusiasm about the subject.

As the global economy's demand for computer applications soars, the demand for well-trained computer science (CS) professionals is rising. This trend fuels a surge in CS undergraduate degree production which, in turn, puts a strain on departmental resources. In addition, CS departments have to contend with high dropout and failure rates, fragile learning and bimodal outcomes \citeRobins19. Thus, the need for effective teaching techniques in CS education is greater than ever. Some concepts and skills in CS are very difficult to acquire such as analyzing the running time of short pieces of code \citeAlbluwi21, and particularly, computing the running time of loops. Most instructors use a trace-sum-approximate flow chart described in \citeAlbluwi21 to teach students how to analyze the running time of code. The two most important skills in this analysis process are the tracing of code and the approximation of the sum of different number patterns, e.g. the sum of the linear number pattern 1+2+3+...+n is equal to \fracn*(n+1) 2 and it is approximated to O(n^2). Novice programmers struggle with both these integral skills \citeCunningham17, Farghally17. Visual systems have been recognized to improve students' understanding of these concepts \citeFarghally17. Several tools have been developed to assist students with running time analysis. Existing tools are targeted at students with more advanced training, such as a background in advanced data structures (AAV \citeFarghally17 ) or experience with code tracing and approximation of the sum of different number patterns (Compigorithm \citeSmith20 ). However, none of the existing tools teach students how to compute the running time at the introductory level, and this gap presented a unique opportunity for us. An effective run-time analysis visualization system for introductory courses must depict the tracing and approximation of the sum. We propose a design in which the depiction of the loop tracing for run-time analysis is done through the use of a table, where the columns represent loop variables and each row represents one iteration of the loop. More specifically, it tabulates the operations in the order they happen during the execution of the loop as shown in Figure~\reffig:ravic. The table is displayed alongside the program. The current line of code being executed is highlighted while the table information is updated. At the end of the execution, the number of operations is determined by summing all the operations in the table column-by-column from the right-most side to the left as shown in Figure~\reffig:ravic. The student controls the visualization using navigation arrows to go back and forth. Instructors use a similar technique in the tracing of loops, but this approach allows students to proceed at their own pace. The tool is currently being developed as an extension to VS Code.