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.

Decomposition and abstraction is an essential component of computational thinking, yet it is not always emphasized in introductory programming courses. In addition, as generative AI further reduces the focus on syntax and increases the importance of higher-level code reasoning, there is renewed opportunity to teach DA explicitly. In this paper, we introduce a framework for systematically assessing the complexity of code structuring tasks, where students must identify and separate meaningful abstractions within existing, unstructured code. The framework defines three dimensions of task complexity, each with multiple levels: repetition, code pattern, and data dependency. To support practical use, we provide example tasks mapped to these levels and offer an interactive tool for generating and exploring DA problems. The framework is designed to support the development of educational tasks that build students' skills with DA in the procedural paradigm.

Database education is a cornerstone under many of the more popular topics in computer science such as machine learning and visualization. Although, in recent years, more fundamental research into database education has come out, there are many more ways in which it can be extended. Research on the practice of teaching databases, namely on the educational materials and explanations of teachers, can help us create new building blocks for fundamental research. This working group aims to collect and present notional machines of different types, for a wide range of database subtopics. These materials offer and updated context for database educators to design their courses from, as well as open up pathways of further research into database education.

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.

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.

Autograding systems are being increasingly deployed to meet the challenges of teaching programming at scale. Studies show that formative feedback can greatly help novices learn programming. This work extends an autograder, enabling it to provide formative feedback on programming assignment submissions. Our methodology starts with the design of a knowledge map, which is the set of concepts and skills that are necessary to complete an assignment, followed by the design of the assignment and that of a comprehensive test suite for identifying logical errors in the submitted code. Test cases are used to test the student submissions and learn classes of common errors. For each assignment, we train a classifier that automatically categorizes errors in a submission based on the outcome of the test suite. The instructor maps the errors to corresponding concepts and skills and writes hints to help students find their misconceptions and mistakes. We apply this methodology to two assignments in our Introduction to Computer Science course and find that the automatic error categorization has a 90% average accuracy. We report and compare data from two semesters, one semester when hints are given for the two assignments and one when hints are not given. Results show that the percentage of students who successfully complete the assignments after an initial erroneous submission is three times greater when hints are given compared to when hints are not given. However, on average, even when hints are provided, almost half of the students fail to correct their code so that it passes all the test cases. The initial implementation of the framework focuses on the functional correctness of the programs as reflected by the outcome of the test cases. In our future work, we will explore other kinds of feedback and approaches to automatically generate feedback to better serve the educational needs of the students.

Computer science universities and colleges around the nation are experiencing large growth in enrollments. To maintain in-person interaction with students, large courses typically include multiple recitations, each led by a Teaching Assistant (TA). Students in each group struggle with various course content, and these weaknesses are best evaluated by the TAs working closely with the students. TAs, however, have only a superficial understanding of education theory, and instructors must closely monitor and evaluate the content of recitations. Existing instruction management systems can be used to organize course-wide content, but, to our knowledge, none of them operate at the granularity of recitations. This poster presents Dynamic Recitation, an open-source platform through which TAs and instructors can create and share practice problems and lesson plans tagged with the learning objectives that they cover. The poster illustrates the interface offered to the TAs for creating problems, designing lesson plans for individual sections, and submitting feedback about student progress. It shows examples of lesson plans created in the system, as well as reports that can be used to identify elements that promote desired learning objectives and refine recitations.

Autograding systems are increasingly being deployed to meet the challenge of teaching programming at scale. We propose a methodology for extending autograders to provide meaningful feedback for incorrect programs. Our methodology starts with the instructor identifying the concepts and skills important to each programming assignment, designing the assignment, and designing a comprehensive test suite. Tests are then applied to code submissions to learn classes of common errors and produce classifiers to automatically categorize errors in future submissions. The instructor maps the errors to concepts and skills and writes hints to help students find their misconceptions and mistakes. We have applied the methodology to two assignments from our Introduction to Computer Science course. We used submissions from one semester of the class to build classifiers and write hints for observed common errors. We manually validated the automatic error categorization and potential usefulness of the hints using submissions from a second semester. We found that the hints given for erroneous submissions should be helpful for 96% or more of the cases. Based on these promising results, we have deployed our hints and are currently collecting submissions and feedback from students and instructors.

With the number of Computer Science (CS) jobs on the rise, there is a greater need for Computer Science graduates than ever. At the same time, most CS departments across the country are only seeing 25-30% of female students in their classes, meaning that we are failing to draw interest from a large portion of the population. In this work, we explore the gender gap in CS at Rutgers University using three data sets that span thousands of students across 3.5 academic years. By combining these data sets, we can explore interesting issues such as retention, as students progress through the CS major. For example, we find that a large percentage of women taking the Introductory CS1 course for majors do not intend to major in CS, which contributes to a large increase in the gender gap immediately after CS1. This finding implies that a large part of the retention task is attracting these women to further explore the major. We correlate our findings with initiatives that some CS programs across the country have taken to significantly improve their gender diversity, and identify initiatives that we can start with in our effort to increase the diversity in our program. These findings may also be applicable to the computing programs at other large public research universities.