Many studies have established that recursion is a notoriously difficult topic for CS1 students. We report on a quantitative controlled experiment involving N=100 CS1 students that characterizes student performance with linear recursion versus iteration across progressively more demanding programming activities defined by the Use–Modify–Create (UMC) framework. The study examines whether the order in which students practice the same programming tasks using iteration and linear recursion affects subsequent performance (RQ1), and compares performance using linear recursion versus iteration in terms of correctness (RQ2) and time-on-task (RQ3). Across activities, we find no meaningful effects of practice order, but observe a persistent correctness gap of approximately 10–20% across Use, Modify, and Create activities and approximately 40–50% longer time-on-task for linear recursion on active programming tasks (Modify and Create). These findings provide an empirical characterization of how CS1 students perform with linear recursion versus iteration under a conventional imperative-first curriculum, and clarify patterns of student proficiency that subsequent computing courses may rely upon.

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.

Microworlds have been proposed as an educational approach for engaging students and increasing motivation. However, the use of microworlds has largely been studied in the initial phases of learning to program (or entire courses). We adopted a microworld project at the end of our CS1 course to investigate its use in teaching students composition and creation of larger programs rather than initial familiarity with programming constructs. We here compare the impact of using a scaffolded, microworld project over a (previously used) non-scaffolded, non-microworld project. Based on data from N=303 students exposed to the two kinds of projects (145 in 2022 vs 158 in 2023), we compare the two cohorts according to a test of learning (TOL) based on the final exam grades. In 2023, we studied the impact further by considering the feel of learning (FOL) based on a qualitative student survey. The results show that the student grade-point average (TOL) increased significantly when we adopted the microworld project. Further, the microworld project appears to produce a high FOL.

This research-to-practice paper shows how to visualize the conceptual framework of object-oriented programming. 'Classes' and 'objects' (from the solution domain) are respectively visualized as ‘phenomena’ and 'concepts' (from the problem domain), thereby visualizing the connection between code and reality. In the spirit of bringing research-to-practice, we implemented a prototype programming environment for Java called ‘SHowMyCODE’ based on this conceptual visualization. We report on a controlled experiment involving N=138 introductory programming (CS1) students. The experiment involves three tasks with progression (USE, Modify, and Create) and compares a treatment group with the reality-code visualization vs a control group without the visualization. The results show that, for Use tasks, students are faster (but not more accurate) when using the reality-code visualisation. In contrast, for Create tasks, learners are more accurate (but not faster) when using the reality visualisation. Finally, we report that students appear to value a visualization that shows the reality-code connection above a generic visualization without this connection.

The underrepresentation of women in IT has been a long-standing issue. Research has shown that women’s first experience with computing education is vital in shaping their perception of the field and their perception of who “belongs” to it. In this Danish case study, we examine gender representation in the subject Informatics, which is the first mandatory, formal introduction to computing education for many students in Denmark. Across 25% of all Danish HHX high schools, we assess the teaching materials on parameters of gender representation in pronouns, names, images, audio/video material, and potential role models. Our results suggest an overall underrepresentation of women in textual and audio/video material, but not in images. We also find an overall absence of female role models, and a tendency for the materials to feature younger female role models than their male counterparts. We conclude with concrete recommendations for authors and publishers of teaching materials for ICT on the high school level.

When humans are exposed to environmental and physical stressors, cognitive performance is degraded. Even though several studies have examined the effect of various stressors individually, there are limited studies comparing the impact of different types. This study examined the effects of Heat, Noise, and Alcohol on cognitive performance during two programming tasks to quantify the impact of stressors on novice programmers. The experiment enrolled N=100 university student volunteers for a between-subjects experiment. Participants were randomly assigned to one of four conditions (M=25): a room with at 38 °C (100 °F), a room with conversational noise around 80 dBA, a blood alcohol content of 1.0‰, or a base condition. Two programming tasks were administered: one analysis task (reading programs) and one synthesis task (writing programs), taking about half an hour to complete in total. Short-term exposure to heat appears to not significantly affect neither reading nor writing programs; conversational noise significantly impacts analytical tasks but not synthesis tasks; while alcohol significantly worsens performance in both analytical and synthesis tasks. To provide a tangible summary for decision-makers able to influence conditions for novice programmers, an approximated comparison is provided, which “translates” negative cognitive effects of heat, noise, and alcohol to one another.

Abundant research has investigated gender differences from the perspective of the individual, but little research has explored gender differences from a group perspective. This paper presents a survey-based quantitative exploration of gender differences when$N=138$students working in smaller (3 students) groups that are either men-majority (WMM) or men-only (MMM). The study was conducted during four weeks of CS1 project work, and the investigation focused on student struggle, task division, group satisfaction, and course outcomes. We observed four significant gender differences: (i) Many women students express a lack of confidence early in the project work, as do many men students that are part of mixed-gender (WMM) groups, but not men that are part of men-only (MMM) groups; (ii) In men-majority groups, women perform more ‘non-technical’ tasks than men (e.g., analysis, design, and report editing); and (iii) women students in men-majority groups are less satisfied with several aspects of the group work than men students in the same groups. These findings add to our understanding of group dynamics and collaboration (including what to avoid and where to pay extra attention) when assigning projects in smaller groups in computing education.

We present a long-term study of how university students experienced teaching/learning activities throughout the Covid-19 pandemic in Denmark1. We collected data through questionnaires from N=365 students enrolled in the "Introduction to Database Systems" course during four consecutive semesters (Spring 2020 to Fall 2021). The two years span the entire period of the pandemic’s interruption of normal on-site teaching, until restrictions were completely lifted in Denmark. The study investigates student preferences for online versus onsite teaching, and identifies the advantages of both, as well as changes in preferences throughout the pandemic. Quantitatively, the results demonstrate a preference for on-site over online teaching which was more pronounced for exercise classes than for lectures. Qualitatively, the study identifies several advantages of both online and on-site teaching; including a more engaging learning environment and better teacher-student interaction for on-site lectures, and flexibility and self-paced learning for online teaching. The primary changes identified were an increased sense of being able to focus online and a decrease in ease of asking questions online towards the later stages of the pandemic. Finally, we highlight the opportunity for universities to provide hybrid models of teaching, in order to care for diverse student preferences and needs.

This paper analyzes materials related to educational programmes from universities that differ significantly with regards to the percentage of women studying computing. To understand this difference better, we compare two extreme cases: the educational programme with the highest percentage of women (22%) versus the one with the lowest percentage (7%) in Denmark. Following the literature showing that there exists a correlation between gender and interest in topics distributed on the ¶EOPLE --ÞINGS spectrum, we check to what extent the promotional materials and course composition can be associated more with ¶EOPLE or rather with ÞINGS. Based on data from N=150 students who rated graphic and textual promotional materials and courses on the ¶EOPLE vs ÞINGS scale, we establish the following correlation: the programme with more women appear to be oriented significantly more towards ¶EOPLE (and less towards ÞINGS ) than the programme with less women. We hypothesize that this offers a tool to "adjust'' the gender appeal of computing educational programmes with regards to both recruitment and retention.

There is a strong need for a more equal gender balance within the computing field. In 1998, Richard A. Lippa [29] uncovered a relationship between gender and preference within the People–Things spectrum, with women preferring People-oriented activities to a higher degree than men. The aim of this paper is twofold. First of all, we wish to determine if a similar relation can be established in the particular context of computing educational activities. Second of all, we wish to see if Lippa’s findings can be extrapolated to contemporary high-school students. To do that, we designed and conducted an experiment involving around 500 Danish high-school students who have been asked to choose between a People-themed version vs an isomorphic Things-themed version of four activities representative for computing education. The results show that the odds of a woman preferring a task involving People is 2.7 times higher than those of a man. The odds of a student without prior programming experience preferring a task involving People is 1.4 times higher than those of a student with programming experience. If we compare women without programming experience to men with programming experience the effect is even more pronounced; indeed, the combined effect is 3.8 (2.7 × 1.4). Our study implies a recommendation for computing educators to, whenever possible, favor educational activities involving People over Things. This makes educational activities appeal more to female students (and to students without programming experience), while not making a difference for male students (or students with programming experience). Since the experiment measured only the appeal of tasks (the users were not expected to perform them) the results we obtained can be useful for recruitment processes where the overall image and appeal of material makes a difference.

Prior research on recruitment of women to computing has established that computing tasks involving People rather than Things have been perceived as much more appealing by female high-school students (potentially recruitable as university computing students). This paper changes the focus from prospective to current university students and presents the results of a new experiment that advances and moves beyond earlier research in two crucial respects. First of all, the participants of the experiment are N=152 university students, who already study computing, rather than general high-school students. Second of all, the choice between a People-themed versus an isomorphic Things-themed version of an educational task now pertains to real (in fact, mandatory) assignments that the students had to perform, rather than hypothetical tasks. The change of experimental context, design, and methodology allows us to complement previous findings related to recruitment with suggestions significant for computing educational activities. The overall findings of the new experiment are consistent with that of the previous one. We find that, also at university, there is a visible preference for choosing People themed over Things themed computing tasks amongst women. The results also expose considerable variation between tasks in the effect of gender observed. At the same time, male students, in general, seem to be either indifferent to the themes or to slightly prefer People versions. This suggests that educators should consider favoring People themed assignments over ones involving Things.

Abstract Many software systems are today variational: they are built as program families or Software Product Lines. They can produce a potentially huge number of related programs, known as products or variants, by selecting suitable configuration options (features) at compile time. Many such program families are safety critical, yet the appropriate tools only rarely are able to analyze them effeciently. Researchers have addressed this problem by designing specialized variability-aware static (dataflow) analyses, which allow analyzing all variants of the family, simultaneously, in a single run without generating any of the variants explicitly. They are also known as lifted or family-based analyses. They take as input the common code base, which encodes all variants of a program family, and produce precise analysis results corresponding to all variants. These analyses scale much better than “brute force” approach, where all individual variants are analyzed in isolation, one-by-one, using off-the-shelf single-program analyzers. Nevertheless, the computational cost of lifted analyses still greatly depends on the number of features and variants (which is often huge). For families with a large number of features and variants, the lifted analyses may be too costly or even infeasible. In order to speed up lifted analyses and make them computationally cheaper, variability abstractions which simplify variability away from program families and lifted analyses have been introduced. However, the space of possible variability abstractions is still intractably large to search naively, with most abstractions being either too imprecise or too costly. We introduce here a method to efficiently find suitable variability abstractions from a large space of possible abstractions for a lifted static analysis. The main idea is to use a pre-analysis to estimate the impact of variability-specific parts of the program family on the analysis’s precision. The pre-analysis is fully variability-aware while it aggressively abstracts the other semantics aspects. Then we use the pre-analysis results to find out when and where the subsequent abstract lifted analysis should turn off or on its variability-awareness. The abstraction constructed in this way is effective in discarding variability-specific program details that are irrelevant for showing the analysis’s ultimate goal. We formalize this approach and we illustrate its effectiveness on several Java case studies. The evaluation shows that our approach which consists of running a pre-analysis followed by a subsequent abstract lifted analysis achieves competitive the precision-speed tradeoff compared to the standard lifted analysis.

Variability-sensitive verification pursues effective analysis of the exponentially many variants of a program family. Several variability-aware techniques have been proposed, but researchers still lack examples of concrete bugs induced by variability, occurring in real large-scale systems. A collection of real world bugs is needed to evaluate tool implementations of variability-sensitive analyses by testing them on real bugs. We present a qualitative study of 98 diverse variability bugs (i.e., bugs that occur in some variants and not in others) collected from bug-fixing commits in the Linux, Apache, BusyBox, and Marlin repositories. We analyze each of the bugs, and record the results in a database. For each bug, we create a self-contained simplified version and a simplified patch, in order to help researchers who are not experts on these subject studies to understand them, so that they can use these bugs for evaluation of their tools. In addition, we provide single-function versions of the bugs, which are useful for evaluating intra-procedural analyses. A web-based user interface for the database allows to conveniently browse and visualize the collection of bugs. Our study provides insights into the nature and occurrence of variability bugs in four highly-configurable systems implemented in C/C++, and shows in what ways variability hinders comprehension and the uncovering of software bugs.

Preprocessor directives (#ifdefs) are often used to implement compile-time variability, despite the critique that they increase complexity, hamper maintainability, and impair code comprehensibility. Previous studies have shown that the time of bug finding increases linearly with variability. However, little is known about the cognitive process of debugging programs with variability. We carry out an experiment to understand how developers debug programs with variability. We ask developers to debug programs with and without variability, while recording their eye movements using an eye tracker. The results indicate that debugging time increases for code fragments containing variability. Interestingly, debugging time also seems to increase for code fragments without variability in the proximity of fragments that do contain variability. The presence of variability correlates with increase in the number of gaze transitions between definitions and usages for fields and methods. Variability also appears to prolong the "initial scan" of the entire program that most developers initiate debugging with.

Software projects embrace variability to increase adaptability and to lower cost; however, others blame variability for increasing complexity and making reasoning about programs more difficult. We carry out a controlled experiment to quantify the impact of variability on debugging of preprocessor-based programs. We measure speed and precision for bug finding tasks defined at three different degrees of variability on several subject programs derived from real systems.

Family-based (lifted) data-flow analysis for Software Product Lines (SPLs) is capable of analyzing all valid products (variants) without generating any of them explicitly. It takes as input only the common code base, which encodes all variants of a SPL, and produces analysis results corresponding to all variants. However, the computational cost of the lifted analysis still depends inherently on the number of variants (which is exponential in the number of features, in the worst case). For a large number of features, the lifted analysis may be too costly or even infeasible. In this paper, we introduce variability abstractions defined as Galois connections and use abstract interpretation as a formal method for the calculational-based derivation of approximate (abstracted) lifted analyses of SPL programs, which are sound by construction. Moreover, given an abstraction we define a syntactic transformation that translates any SPL program into an abstracted version of it, such that the analysis of the abstracted SPL coincides with the corresponding abstracted analysis of the original SPL. We implement the transformation in a tool, that works on Object-Oriented Java program families, and evaluate the practicality of this approach on three Java SPL benchmarks.

Model checking provides a convenient way to check whether a given software system is correct with respect to a set of relevant semantic properties. To use a model checker like SPIN [5], the software system must be modelled as a transition system (TS). Afterwards, the model checker can check the correctness of the translated TS by exhaustively exploring all possible transitions.

Feature-sensitive verification pursues effective analysis of the exponentially many variants of a program family. However, researchers lack examples of concrete bugs induced by variability, occurring in real large-scale systems. Such a collection of bugs is a requirement for goal-oriented research, serving to evaluate tool implementations of feature-sensitive analyses by testing them on real bugs. We present a qualitative study of 42 variability bugs collected from bug-fixing commits to the Linux kernel repository. We analyze each of the bugs, and record the results in a database. In addition, we provide self-contained simplified C99 versions of the bugs, facilitating understanding and tool evaluation. Our study provides insights into the nature and occurrence of variability bugs in a large C software system, and shows in what ways variability affects and increases the complexity of software bugs.

A software product line (SPL) encodes a potentially large variety of software products as variants of some common code base. Up until now, re-using traditional static analyses for SPLs was virtually intractable, as it required programmers to generate and analyze all products individually. In this work, however, we show how an important class of existing inter-procedural static analyses can be transparently lifted to SPLs. Without requiring programmers to change a single line of code, our approach SPLLIFT automatically converts any analysis formulated for traditional programs within the popular IFDS framework for inter-procedural, finite, distributive, subset problems to an SPL-aware analysis formulated in the IDE framework, a well-known extension to IFDS. Using a full implementation based on Heros, Soot, CIDE and JavaBDD, we show that with SPLLIFT one can reuse IFDS-based analyses without changing a single line of code. Through experiments using three static analyses applied to four Java-based product lines, we were able to show that our approach produces correct results and outperforms the traditional approach by several orders of magnitude.

We propose an algebra of languages and transformations as a means of compositional syntactic language extension. The algebra provides a layer of high-level abstractions built on top of languages (captured by context-free grammars) and transformations (captured by constructive catamorphisms). The algebra is self-contained in that any term of the algebra specifying a transformation can be reduced to a constant catamorphism, before the transformation is run. Thus, the algebra comes “for free” without sacrificing the strong safety and efficiency properties of constructive catamorphisms. The entire algebra as presented in the paper is implemented as the Banana Algebra Tool which may be used to syntactically extend languages in an incremental and modular fashion via algebraic composition of previously defined languages and transformations. We demonstrate and evaluate the tool via several kinds of extensions.

During Software Product Line (SPL) maintenance tasks, Virtual Separation of Concerns (VSoC) allows the programmer to focus on one feature and hide the others. However, since features depend on each other through variables and control-flow, feature modularization is compromised since the maintenance of one feature may break another. In this context, emergent interfaces can capture dependencies between the feature we are maintaining and the others, making developers aware of dependencies. To better understand the impact of code level feature dependencies during SPL maintenance, we have investigated the following two questions: how often methods with preprocessor directives contain feature dependencies? How feature dependencies impact maintenance effort when using VSoC and emergent interfaces? Answering the former is important for assessing how often we may face feature dependency problems. Answering the latter is important to better understand to what extent emergent interfaces complement VSoC during maintenance tasks. To answer them, we analyze 43 SPLs of different domains, size, and languages. The data we collect from them complement previous work on preprocessor usage. They reveal that the feature dependencies we consider in this paper are reasonably common in practice; and that emergent interfaces can reduce maintenance effort during the SPL maintenance tasks we regard here.

We show how to achieve typed and unambiguous declarative pattern matching on strings using regular expressions extended with a simple recording operator. We give a characterization of ambiguity of regular expressions that leads to a sound and complete static analysis. The analysis is capable of pinpointing all ambiguities in terms of the structure of the regular expres-sion and report shortest ambiguous strings. We also show how pattern matching can be integrated into statically typed programming languages for deconstructing strings and reproducing typed and structured values. We validate our approach by giving a full implementation of the ap-proach presented in this paper. The resulting tool, reg-exp-rec, adds typed and unambiguous pattern matching to Java in a stand-alone and non-intrusive manner. We evaluate the approach using several realistic examples. 1

We have used the SOLO Taxonomy to analyze 5,608 competencies stemming from 734 courses from the faculties of science at Aarhus University and University of Southern Denmark. Both faculties have formulated learning outcomes using this taxonomy. This has made it possible to systematically analyze competencies and compare different science subjects. In this talk, we will explain the analysis and outline our main findings.

From now on, a main goal in designing a language should be to plan for growth." Guy Steele: Growing a Language, OOPSLA'98 invited talk. We present our experiences with a syntax macro language which we claim forms a general abstraction mechanism for growing (domain-specific) extensions of programming languages. Our syntax macro language is designed to guarantee type safety and termination. A concept of metamorphisms allows the arguments of a macro to be inductively defined in a meta level grammar and morphed into the host language. We also show how the metamorphisms can be made to operate simultaneously on multiple parse trees at once. The result is a highly flexible mechanism for growing new language constructs without resorting to compile-time programming. In fact, whole new languages can be defined at surprisingly low cost. This work is fully implemented as part of the system for defining interactive Web services, but could find use in many other languages. 1.

We present the results of the project, which aims to design and implement a high-level domain-specific language for programming interactive Web services. A fundamental aspect of the development of the World Wide Web during the last decade is the gradual change from static to dynamic generation of Web pages. Generating Web pages dynamically in dialog with the client has the advantage of providing up-to-date and tailor-made information. The development of systems for constructing such dynamic Web services has emerged as a whole new research area. The language is designed by analyzing its application domain and identifying fundamental aspects of Web services inspired by problems and solutions in existing Web service development languages. The core of the design consists of a session-centered service model together with a flexible template-based mechanism for dynamic Web page construction. Using specialized program analyses, certain Web-specific properties are verified at compile time, for instance that only valid HTML 4.01 is ever shown to the clients. In addition, the design provides high-level solutions to form field validation, caching of dynamic pages, and temporal-logic based concurrency control, and it proposes syntax macros for making highly domain-specific languages. The language is implemented via widely available Web technologies, such as Apache on the server-side and JavaScript and Java Applets on the client-side. We conclude with experience and evaluation of the project.

We describe a static analysis of \bigwig\ programs that efficiently decides if all dynamically computed XHTML documents presented to the client will validate according to the official DTD. We employ two data-flow analyses to construct a graph summarizing the possible documents. This graph is subsequently analyzed to determine validity of those documents. By evaluating the technique on a number of realistic benchmarks, we demonstrate that it is sufficiently fast and precise to be practically useful.