Background and Context: Problem decomposition is a fundamental computational thinking skill that novice programmers struggle to develop. Understanding and improving decomposition skills remains challenging for educators.

Self-efficacy, sense of belonging, and imposter phenomenon are all phenomena related to an individual's perception of themselves and others. They are well-studied with mature, validated surveys, and they all have implications on personal performance, including in the CS education context. One question that none of the phenomena address, however, is how a student perceives their own performance relative to their peers. For example, none of these accepted measures considers a student who thinks that ''everyone in this classroom is smarter than me.'' In this paper, we propose a survey to measure a previously unexplored phenomenon experienced by computer science (CS) students. We call this phenomenon relative self-efficacy, and it measures how highly a student perceives their ability relative to their peers. No prior attempt has been made to measure how students rate themselves relative to others or to understand the causes and effects of these comparisons. We find that the underlying factors of our survey are distinct from those that measure sense of belonging. We also find that women are more likely to experience lower relative self-efficacy than men. Lastly, we find that GPA is weakly correlated with relative self-efficacy and suggest that there may be stronger, less obvious influences on relative self-efficacy.

The command shell and Git are important tools for computer scientists to learn and is taught in many computer science curricula. Many tools used by computer scientists are primarily interfaced through the command shell, such as Git. However, there have been few studies and interventions designed to assist in understanding student behaviors in the command shell and better teaching of it. This paper aims to provide an overview and reflection of a novel intelligent tutoring system we developed, the Shell Tutor, which assists in teaching students the command shell and Git. This paper will also analyze features of this tool to better understand student behaviors within the command shell while using this intelligent tutoring system: a logging system which will enable researchers to better understand student behaviors in using the tool and the command shell in general. A study conducted with students who used this tool illuminates the perceived effects on student learning and their perspectives of the tool, which are overwhelmingly positive.

Pausing behavior in introductory Computer Science (CS1) courses has been related to course outcomes and could be linked to a student's cognitive load. Using Cognitive Load Theory and Vygotsky's Zone of Proximal Development as a theoretical framework, this study empirically analyzes keystroke latencies, or pause times between keystrokes, with the goal of better understanding what types of assignments need more scaffolding than others. We report the characteristics of eleven assignments, introduce a method to analyze pausing behavior, and investigate how pausing behavior changes with assignment characteristics (e.g., introducing new programming constructs, engaging creativity through Turtle graphics, etc). We find evidence that pausing behavior does change based on the assignment characteristics and that assignments with particular characteristics, such as object-oriented principles, may be more likely to have excessive demands on student working memory. We also find evidence that assignment completion time may not be an accurate measure of assignment difficulty.

Keystroke data in programming reveals intricate patterns that reflect the behavior of programmers. These patterns hold promise for predicting grades and other applications, providing insights into the skills of both proficient and less proficient programmers. Analyzing these patterns can yield tailored feedback for students who need support, enabling effective interventions. Our study utilizes a keystroke dataset from the CS1 (Introduction to Computer Science) course at Utah State University. We developed novel features by combining elements like key presses, timestamps, source locations, and programming terminology, drawing on prior research, our insights, and an analysis of programming behavior. An ensemble-based feature selection method identifies key features, which are then used in hyperparameter optimization and grade prediction with six classification and three regression algorithms. We categorized grades into three levels: Low, Average, and High. Despite challenges such as class imbalance, plagiarism, limited data per assignment, and the ceiling effect, we attained a notable weighted F1 score of 78%. We also introduce an ensemble classification strategy, merging Isolation Forest outlier detection with a refined Random Forest classifier, achieving 80% accuracy on our test set. Additionally, we provide a detailed interpretation of our features, supported by results and a case study of our dataset. This research aims to enhance computer science education at the undergraduate level, focusing on improving its overall quality. Code and data are available https://github.com/DSAatUSU/Student-Coding-Behavior.git.

In this article, we report results from a randomized controlled trial where novice programmers completed code mimicking exercises -- writing and modifying code shown to them -- designed to help learn the basics of how variables work. Using a tailored code writing system with feedback on program correctness, we conducted a two-group design study where only one of the groups could see the program output and feedback on the correctness of the program they wrote, while the other group just saw feedback on correctness. Learning gain was measured using a code-reading multiple choice questionnaire as both a pretest and a posttest. Our data suggests that being able to see program output leads to higher learning gains for novices, when compared to just being able to see feedback on the correctness of the code. For more experienced students, we observed benefits from code mimicking in both groups, without a strong distinction between being able to see the output and not being able to see the output. Based on our experiment, we recommend that environments used by novices for learning programming should encourage -- or even require -- running the code before allowing submitting the program for assessment.

Recent work in computing education has explored the idea of analyzing and grading using the process of writing a computer program rather than just the final submitted code. We build on this idea by investigating the effect on plagiarism when the process of coding, in the form of keystroke logs, is submitted for grading in addition to the final code. We report results from two terms of a university CS1 course in which students submitted keystroke logs. We find that when students are required to submit a log of keystrokes together with their written code they are less likely to plagiarize. In this paper we explore issues of implementation, adoption, deterrence, anxiety, and privacy. Our keystroke logging software is available in the form of an IDE plugin in a public plugin repository.

In a recent study, students were periodically prompted to self-report engagement while working on computer programming assignments in a CS1 course. A regression model predicting time-on-task was proposed. While it was a significant improvement over ad-hoc estimation techniques, the study nevertheless suffered from lack of error analysis, lack of comparison with existing methods, subtle complications in prompting students, and small sample size. In this paper we report results from a study with an increased number of student participants and modified prompting scheme intended to better capture natural student behavior. Furthermore, we perform a cross-validation analysis on our refined regression model and present the resulting error bounds. We compare with threshold approaches and find that, in at least one context, a simple 5-minute threshold of inactivity is a reasonable estimate for whether a student is on-task or not. We show that our approach to modeling student engagement while programming is robust and suitable for identification of students in need of intervention, understanding engagement behavior, and estimating time taken on programming assignments.

We consider the question of how to predict whether a student is on or off task while working on a computer programming assignment using elapsed time since the last keystroke as the single independent variable. In this paper we report results of an empirical study in which we intermittently prompted CS1 students working on a programming assignment to self-report whether they were engaged in the assignment at that moment. Our regression model derived from the results of the study shows power-law decay in the engagement rate of students with increasing time of keyboard inactivity ranging from a nearly 80% engagement rate after 45 seconds to 30% after 32 minutes of inactivity. We find that students remain engaged in programming for a median of about 8 minutes before going off task, and when they do go off task, they most often return after 1 to 4 minutes of disengagement. Our model has application in estimating the amount of engaged time students take to complete programming assignments, identifying students in need of intervention, and understanding the effects of different engagement behaviors.

Imagery is a cognitive process commonly used in sports in which athletes internally or externally visualize themselves performing a skill, allowing them to create an internal experience similar to the physical event. It is intended to allow participants to refine and perfect their performance. This paper investigates the use of imagery in the setting of computer programming. We explore the idea that watching a keystroke replay of yourself writing computer code that solves a specific problem can increase the speed and quality of a subsequent attempt at solving a similar problem as well as improve attitude and engagement. We investigate the theory of imagery, its application to computer programming, and we present results of a qualitative study. Our results suggest that using imagery could have a positive effect on the profitability of spending time reviewing code.

Syntax is a barrier to success for many students in Introductory Computer Programming (CS1). A supplemental approach to standard CS1 curricula that has gained attention recently is a "syntax-scaffolded" or "syntax-first" approach where students practice necessary syntax before a lesson on problem solving or program design. In this study, we analyze student perceptions of a syntax-first teaching method. For the first five weeks of a university semester, we assigned students syntax exercises to complete before coming to class. At the end of the semester they were given a prompt asking them to write their thoughts about the exercises. A qualitative approach was used to investigate student responses and understand perceived value of the exercises. Our results show a strong positive reaction to a syntax-first approach as well as an awareness among students of the exercises' effect on their own learning.

This paper investigates the idea of teaching programming language syntax before problem solving in Introductory Computer Programming (CS1). Theories of procedural skill acquisition imply that syntax should be taught with a pedagogy and curriculum quite different from that used in teaching problem solving. We draw from this literature to propose a practice-based pedagogy and curriculum to teach students syntax before they learn its application, something we call a "syntax-first" pedagogy, which uses skilled performance in syntax to scaffold learning of problem solving. We report results of a controlled study investigating whether learning syntax using pedagogy suitable for procedural skill acquisition (e.g. repetitive practice) prior to learning problem solving influences student performance. A syntax-first pedagogy is complementary to almost any other teaching approach: in our study, simply adding carefully designed syntax exercises to an existing CS1 course resulted in higher exam scores, lower student attrition, and evidence that plagiarism rates may be lower.

Analyzing keystroke data from students working on essay and programming tasks, we study to what extent the difference in task context influences performance in typing. Using data from two introductory programming courses offered at two separate institutions, we compare and contrast typing speed between programming and natural language tasks. We observe that students tend to be faster at typing (the same) character pairs when writing natural language text than when learning to write code. We show that students improve on typing character pairs that appear in frequently used words in programming languages, and that typing programming constructs also improves. We find that students are faster at detecting and erasing their mistakes when typing natural language text than when programming. Our results support theories regarding contextual memory, procedural memory, and practice, and have implications for course curriculum and pedagogy design.

We study programming process data from two introductory programming courses. Between the course contexts, the programming languages differ, the teaching approaches differ, and the spoken languages differ. In both courses, students' keystroke data -- timestamps and the pressed keys -- are recorded as students work on programming assignments. We study how the keystroke data differs between the contexts, and whether research on predicting course outcomes using keystroke latencies generalizes to other contexts. Our results show that there are differences between the contexts in terms of frequently used keys, which can be partially explained by the differences between the spoken languages and the programming languages. Further, our results suggest that programming process data that can be collected non-intrusive in-situ can be used for predicting course outcomes in multiple contexts. The predictive power, however, varies between contexts possibly because the frequently used keys differ between programming languages and spoken languages. Thus, context-specific fine-tuning of predictive models may be needed.

In this research work in progress paper, we discuss the possible benefits of separating syntax practice from problem-solving learning in an Introductory Computer Programming course. We propose a curriculum and associated development tool called Phanon that teach the rudiments of programming language through exercises done online outside of class. Having students complete exercises before class frees up classroom time and instructor face time for the higher-order learning tasks of problem decomposition and solving. We report results from a pilot study that are consistent with our hypothesis that these techniques result in improved student outcomes and attitudes and we discuss a future follow-up study.

Hierarchical data representations have been shown to be effective tools for coping with large-scale scientific data. Writing hierarchical data on supercomputers, however, is challenging as it often involves all-to-one communication during aggregation of low-resolution data which tends to span the entire network domain, resulting in several bottlenecks. We introduce the concept of indexing templates, which succinctly describe data organization and can be used to alter movement of data in beneficial ways. We present two techniques, domain partitioning and localized aggregation, that leverage indexing templates to alleviate congestion and synchronization overheads during data aggregation. We report experimental results that show significant I/O speedup using our proposed schemes on two of today's fastest supercomputers, Mira and Shaheen II, using the Uintah and S3D simulation frameworks.

Occlusion presents a major challenge in visualizing 3D flow and tensor fields using streamlines. Displaying too many streamlines creates a dense visualization filled with occluded structures, but displaying too few streams risks losing important features. We propose a new streamline exploration approach by visually manipulating the cluttered streamlines by pulling visible layers apart and revealing the hidden structures underneath. This paper presents a customized view-dependent deformation algorithm and an interactive visualization tool to minimize visual clutter in 3D vector and tensor fields. The algorithm is able to maintain the overall integrity of the fields and expose previously hidden structures. Our system supports both mouse and direct-touch interactions to manipulate the viewing perspectives and visualize the streamlines in depth. By using a lens metaphor of different shapes to select the transition zone of the targeted area interactively, the users can move their focus and examine the vector or tensor field freely.

We present an algorithm to compute an approximation of the generalized Voronoi diagram (GVD) on arbitrary collections of 2D or 3D geometric objects. In particular, we focus on datasets with closely spaced objects; GVD approximation is expensive and sometimes intractable on these datasets using previous algorithms. With our approach, the GVD can be computed using commodity hardware even on datasets with many, extremely tightly packed objects. Our approach is to subdivide the space with an octree that is represented with an adjacency structure. We then use a novel adaptive distance transform to compute the distance function on octree vertices. The computed distance field is sampled more densely in areas of close object spacing, enabling robust and parallelizable GVD surface generation. We demonstrate our method on a variety of data and show example applications of the GVD in 2D and 3D.

We present an efficient, flexible, adaptive-resolution I/O framework that is suitable for both uniform and Adaptive Mesh Refinement (AMR) simulations. In an AMR setting, current solutions typically represent each resolution level as an independent grid which often results in inefficient storage and performance. Our technique coalesces domain data into a unified, multiresolution representation with fast, spatially aggregated I/O. Furthermore, our framework easily extends to importance-driven storage of uniform grids, for example, by storing regions of interest at full resolution and nonessential regions at lower resolution for visualization or analysis. Our framework, which is an extension of the PIDX framework, achieves state of the art disk usage and I/O performance regardless of resolution of the data, regions of interest, and the number of processes that generated the data. We demonstrate the scalability and efficiency of our framework using the Uintah and S3D large-scale combustion codes on the Mira and Edison supercomputers.

Motivated by the need for correct and robust 3D models of neuronal processes, we present a method for reconstruction of spatially realistic and topologically correct models from planar cross sections of multiple objects. Previous work in 3D reconstruction from serial contours has focused on reconstructing one object at a time, potentially producing inter-object intersections between slices. We have developed a robust algorithm that removes these intersections using a geometric approach. Our method not only removes intersections but can guarantee a given minimum separation of objects. This paper describes the algorithm for geometric adjustment, proves correctness, and presents several results of our high-fidelity modeling.