Today, many introductory computer science courses rely heavily on a specific programming language to convey fundamental programming concepts. For beginning students, the cognitive capacity required to operate with the syntactic forms of this language may overwhelm their ability to formulate a solution to a program. We recognize that the introductory computer science courses can be more effective if they convey fundamental concepts without requiring the students to focus on the syntax of a programming language. To achieve this, we propose a new teaching method based on the Design Recipe and Code Outlining (DRaCO) processes. Our new pedagogy capitalizes on the algorithmic intuitions of novice students and provides a tool for students to externalize their intuitions using techniques they are already familiar with, rather than with the syntax of a specific programming language. We validate the effectiveness of our new pedagogy by integrating it into an existing CS1 course at California Polytechnic State University, San Luis Obispo. We find that the our newly proposed pedagogy shows strong potential to improve students’ ability to program.

No description available.

The purpose of this study is to analyze which behaviors are or are not helpful for debugging when a novice is in a state of unproductive persistence. Further, this project will exploratorily use a variety of analytical techniques -- including association rule mining, process mining, frequent sequence mining, and machine learning-- in order to determine which approaches are useful for data analysis. For the study, programming process data from hundreds of novice programmers were analyzed to determine which behaviors were more or less likely to be correlated with escaping a state of unproductive persistence. Of these events, only three had a statistically significant difference in their rates of occurrence and large effect sizes: file, edit, and compile events. While the data set cannot reveal a user's motivation for a file event, the most logical explanation of these events is that the user is tracing the code. Thus, a higher rate of file events suggests that code tracing (with the goal of code comprehension) is a key behavior correlated with a student's ability to escape a state of unproductive persistence. On the other hand, editing events are far more common in unproductive states that are not escaped. A content analysis suggests that there are more trivial edits for users in an unescaped state of unproductive persistence. An important finding of this study is that an unproductive persistence is not just a phenomenon of the worst-performing students; rather, a third of users who completed the assignment had at least one unproductive state. This study also lends support to the idea that tinkering combined with code tracing is correlated with positive outcomes, but that less systematic tinkering is not effective behavior. Further, association rule mining and frequent sequence mining were effective tools for data analysis in this study. The findings from this study have two main practical implications for curriculum designers and instructors: (1) the need to normalize struggle and (2) possibilities for curriculum and tool development. This work is particularly important given that debugging is not normally a process evident to instructors, curriculum designers, tool developers, and computer science education researchers, either because it happens outside of class time and/or because it is a process and these stakeholders usually only see the end result; this project attempts to make the process of debugging more transparent.

In computer science, students could benefit from exposure to critical programming concepts from multiple perspectives. Peer review is one method to allow students to experience authentic uses of the concepts in a non-programming manner. Peer review provides students with the opportunity to evaluate other people's work and, in doing so, allows for a rich learning experience. While much is known about peer review and it has many uses in other disciplines, the literature, especially in computer science, does not spend much time on the perspective of and benefits to the reviewer. In this work, we examine how to implement the peer review process in early, object-oriented, computer science courses as a way to develop the reviewers' higher-level thinking skills, increase their knowledge of specific programming concepts, and to improve attitudes to help engage them in the activity. Specifically, we explore peer review and its effects on Abstraction, Decomposition, and Encapsulation and how the type of review (students reviewing their peers or reviewing materials from their instructor), influences these effects. We also look at how the students' attitudes relate to their engagement in and the benefits from the reviews. To study these ideas, we used peer review exercises in two CS2 classes at local universities over the course of a semester. We divided the students into three groups where one group reviewed their peers, one group reviewed their instructor, and one group completed small design or coding exercises. We measured the students' attitudes and their conceptual understanding during the semester with surveys, tests, and concept maps. We collected the completed reviews as well. We found that reviewing helped students learn Decomposition, especially those reviewing the instructor's programs. We did not find evidence of improvements to the students' level of thinking over the semester nor were there significant changes in their attitudes. However, the data showed that students assigned to review their peers were less likely to complete the assignments than the other students were. Overall, peer reviews are a valuable method for teaching Decomposition to CS2 students and can be used as an alternative way to learn object-oriented programming concepts. / Ph. D.

Computer Science (CS) is among the fastest-growing fields. To fill the abundance of positions in Computer Science, early learning experiences should be implemented to promote interest in the field. This research aims to observe the impact of a design-based computer science treatment on 5th-grade students' interest in computer science careers. The treatment consisted of nine one-hour lessons in which the researcher introduced computer science content to students. At the end of the treatment, participants developed an application to study for a state-wide science assessment. To measure a change in students' career interests following the treatment, an adapted version of the STEM Career Interest Survey (STEM-CIS), grounded by Social Cognitive Career Theory (SCCT), was implemented using a pre-survey-post-survey design. Qualitative data was collected using focus groups to explain quantitative findings further. The samples' post-survey (39.62) mean was greater than the pre-survey mean (37.17), but the paired t-test was just above the statical significance level of 0.05, t(28)= -2.04, p =.051. There was a statistically significant increase for the survey items that align with the SCCT aspects Interest (t(30)= -2.30, p =.028) and Contextual Support (t(30)= -2.25, p =.032). The researcher identified several themes related to a positive perception toward the treatment and computer science and general during qualitative data analysis. These findings indicate a design-based computer science treatment can increase 5th-grade students' interest in computer science careers. / Doctor of Philosophy / Learning experiences influence an individual's career development. This dissertation observes the impact of a design-based computer science project in a 5th-grade classroom. The researcher implemented a pre-survey-post-survey design to measure change following the treatment. The researcher calculated the difference between survey means and ran a matched paired t-test to determine the statistical significance. The results of the paired t-test were not statistically significant. Still, the survey items that aligned with interest and contextual support had a statistically significant increase following the treatment. Additionally, the researcher conducted focus groups to collect qualitative data to explain quantitative findings further. Content analysis of the qualitative data revealed participants had a positive perception of the treatment and computer science in general. These results imply that a design-based computer science treatment can increase 5th-grade students' interest in computer science careers.

Many universities across the United States have been experiencing an increased demand for computer science majors. Adjusting curriculum to meet increased demand runs the risk of damaging ongoing efforts to broaden participation in computer science. To manage growth, and increase the representation of women and underrepresented minorities in the field, we must first understand current patterns for participation, and factors that may impact access and persistence. Universities with common first-year engineering programs present an opportunity for addressing some of the barriers that have traditionally limited access to computer science to certain groups. In particular, common first-year programs could provide early positive experiences with computer programming which encourage more students to consider computer science as a viable major. To better understand how a common first-year engineering program may impact matriculation and persistence in computer science, I conducted studies to identify high-level patterns of participation in computer science, as well as how students experience programming instruction in an introductory engineering course. All studies share the same context: a large public research institution with a common first-year engineering program. Results indicate that women are leaving computer science at all points of the curriculum, contributing to a reduced representation of women earning CS degrees. In contrast, URM and first-generation students have higher representation at graduation than when declaring major interest before the start of their first year. / Doctor of Philosophy / Many universities across the United States have been experiencing an increased demand for computer science majors. Adjusting curriculum to meet demand runs the risk of damaging efforts to increase the diversity of the computer science workforce. To manage growth and increase the representation of women and underrepresented minorities (students who are not white or East Asian) in the field, we must first understand who currently studies computer science, and factors that lead to their success in the major. Universities with general first-year engineering programs present an opportunity for addressing some of the barriers that have traditionally discouraged women and underrepresented minorities from pursuing computer science. In particular, these programs could provide early positive experiences with computer programming which encourage more students to consider computer science as a possible major. To better understand how experiences during students’ first-year transition to college may impact decisions to major in computer science, I conducted studies to explore who enters computer science, and how they succeed in the major, as well as how students experience programming instruction in an introductory engineering course. All studies share the same context: a large public research institution with a general first-year engineering program. Results indicate that women are leaving computer science at all points of the curriculum, contributing to a reduced representation of women earning CS degrees. In contrast, underrepresented minority students and students with parents who did not receive a college degree, make up a higher percentage in the group graduating with a CS degree than in the group who declare CS as their first major.

Until recently, most educational tools have worked in silos. If a teacher wanted her students to complete small programming exercises, record videos, and collaborate through discussion boards, three disconnected tools were probably needed. Learning Tools Interoperability (LTI) is a communication protocol that enables different learning tools to talk to each other and share scores with a Learning Management System (LMS). While most commercial LMS now support LTI, most educational software developed by small research efforts do not. This is often because of the lack of resources needed to understand the working of LTI and the process of using LTI in their applications. Our aim is to encourage the use of LTI within the CS Education community. We have developed tutorials that include example applications. We also provide a use case of how LTI is implemented in the OpenDSA eTextbook system. As another use case, we have enabled auto-grading of Jupyter Notebook assignments by providing immediate feedback to students and updating scores to the Canvas gradebook. We provide a Jupyter plugin to upload notebook files to the Web-CAT auto-grading system. We integrate Aalto University's ACOS content into OpenDSA as a third use case. / Master of Science / Until recently, most educational tools have worked in silos. If a teacher wanted her students to complete small programming exercises, record videos, and collaborate through discussion boards, three disconnected tools were probably needed. These disconnected tools did not integrate with the Learning Management Systems (LMS), such as Canvas and Moodle. Instructors had to manually manage these separate tools and enter scores into the LMS. There are standards such as Learning Tools Interoperability (LTI) that these learning tools can implement to enable them to talk to each other and to share scores with an LMS. However, most educational software developed by small research efforts do not support LTI. This is often because of the lack of resources needed to understand the working of LTI and the process of using LTI in their applications. We aim to encourage the use of LTI within the CS Education community. We have developed tutorials that include example applications. We also provide a use case of how LTI is implemented in OpenDSA, an eTextbook system developed at Virginia Tech. As another use case, we have enabled auto-grading of Jupyter Notebook (documents that run in a browser and can contain equations, visualizations, live code, and text) assignments by providing immediate feedback to students and updating scores to the Canvas gradebook. We provide a plugin to upload notebook files to the WebCAT auto-grading system directly from the browser. We integrate Aalto University’s ACOS content (Python and Java exercises) into OpenDSA as a third use case.

Effective software testing identifies potential bugs and helps correct them, producing more reliable and maintainable software. As software development processes have evolved, incremental testing techniques have grown in popularity, particularly with introduction of test-driven development (TDD). However, many programmers struggle to adopt TDD's "test a little, code a little" approach and conventional computer science classrooms neglect evaluating software development as a process. In response, we explore influences on students' testing behaviors, effects of incremental testing strategies, and describe approaches to help computer science students adopt good testing practices. First, to understand students' perspectives and adoption of testing strategies, we investigated their attitudes toward different aspects of TDD. In addition, we observed trends in when and how thoroughly students tested their code and how these choices impacted the quality of their assignments. However, with insight into why students struggle to adopt incremental testing, we identified a need to assess their behaviors during the software development process as a departure from traditional product-oriented evaluation. By building upon an existing automated grading system, we developed an adaptive feedback system to provide customized incentives to reinforce incremental testing behaviors while students solved programming assignments. We investigated how students react to concrete testing goals and hint reward mechanisms and found approaches for identifying testing behaviors and influencing short-term behavioral change. Moreover, we discovered how students incorporate automated feedback systems into their software development strategies. Finally, we compared testing strategies students exhibited through analyzing five years and thousands of snapshots of students' code during development. Even when accounting for factors such as procrastinating on assignments, we found that testing early and consistently maintaining testing throughout development helps produce better quality code and tests. By applying our findings of student software development behaviors to effective testing strategies and teaching techniques, we developed a framework for adaptively scaffolding feedback to empower students to critically reflect over their code and adopt incremental testing approaches. / Ph. D.

Learning technologies in computer science education have been most closely associated with teaching of programming, including automatic assessment of programming exercises. However, when it comes to teaching computer science content and concepts, learning technologies have not been heavily used. Perhaps the best known application today is Algorithm Visualization (AV), of which there are hundreds of examples. AVs tend to focus on presenting the procedural aspects of how a given algorithm works, rather than more conceptual content. There are also new electronic textbooks (eTextbooks) that incorporate the ability to edit and execute program examples. For many traditional courses, a longstanding problem is lack of sufficient practice exercises with feedback to the student. Automated assessment provides a way to increase the number of exercises on which students can receive feedback. Interactive eTextbooks have the potential to make it easy for instructors to introduce both visualizations and practice exercises into their courses. OpenDSA is an interactive eTextbook for data structures and algorithms (DSA) courses. It integrates tutorial content with AVs and automatically assessed interactive exercises. Since Spring 2013, OpenDSA has been regularly used to teach a fundamental data structures and algorithms course (CS2), and also a more advanced data structures, algorithms, and analysis course (CS3) at various institutions of higher education. In this thesis, I report on findings from early adoption of the OpenDSA system. I describe how OpenDSA's design addresses obstacles in the use of AV systems. I identify a wide variety of use for OpenDSA in the classroom. I found that instructors used OpenDSA exercises as graded assignments in all the courses where it was used. Some instructors assigned an OpenDSA assignment before lectures and started spending more time teaching higher-level concepts. OpenDSA also supported implementing a ``flipped classroom'' by some instructors. I found that students are enthusiastic about OpenDSA and voluntarily used the AVs embedded within OpenDSA. Students found OpenDSA beneficial and expressed a preference for a class format that included using OpenDSA as part of the assigned graded work. The relationship between OpenDSA and students' performance was inconclusive, but I found that students with higher grades tend to complete more exercises. / Ph. D.

A Theory of Algorithms course is essential to any Computer Science curriculum at both the undergraduate and graduate levels. It is also considered to be difficult material to teach or to learn. In particular the topics of Computational Complexity Theory, reductions, and the NP-Complete class of problems are considered difficult by students. Numerous algorithm visualizations (AVs) have been developed over the years to portray the dynamic nature of known algorithms commonly taught in undergraduate classes. However, to the best of our knowledge, the instructional material available for NP-Completeness is mostly static and textual, which does little to alleviate the complexity of the topic. Our aim is to improve the pedagogy of NP-Completeness by providing intuitive, interactive, and easy-to-understand visualizations for standard NP Complete problems, reductions, and proofs. In this thesis, we present a set of visualizations that we developed using the OpenDSA framework for certain NP-Complete problems. Our paradigm is a three step process. We first use an AV to illustrate a particular NP-Complete problem. Then we present an exercise to provide a first-hand experience with attempting to solve a problem instance. Finally, we present a visualization of a reduction as a part of the proof for NP-Completeness. Our work has been delivered as a collection of modules in OpenDSA, an interactive eTextbook system developed at Virginia Tech. The tutorial has been introduced as a teaching supplement in both a senior undergraduate and a graduate class. We present an analysis of the system use based on records of online interactions by students who used the tutorial. We also present results from a survey of the students. / Master of Science