Background and Context. The prominence of Generative AI (GenAI) has led students to seek academic support from these tools, altering the help-seeking landscape. Since GenAI can operate as an on-demand help resource, understanding the unique value of human staff can help instructors better serve students.

Peer code reviews involve students conducting a code review of a classmate's submission to a programming assignment. While peer code reviews have an established history of being used and studied in computing education, they have primarily been documented in introductory computing courses. This experience report describes how we implemented peer code reviews in an upper-division software engineering course that focuses on making modifications to large, existing code bases (i.e., brownfield development). We discuss the perceived learning benefits, perceived challenges, and agreement between peer and course staff reviews. Overall, students enjoyed being able to see different approaches to the programming task they had just submitted, but expressed concerns about feeling qualified to make effective peer code reviews due to their limited software engineering experience and the difficulty of assessing code design. We also find that students are capable of evaluating the functional correctness of their peer's submission, but struggle to give accurate assessments of their peer's design and code style. We conclude with recommendations specifically for instructors who wish to use peer code reviews in upper-division software engineering courses, such as using a structured template to scaffold the peer code reviews and allowing multiple opportunities to provide code reviews to improve students' self-efficacy.

Recent work has shown that incarcerated adult students reported a decrease in confidence in their ability to do well in the course as the course progressed, whereas non-incarcerated students in a traditional educational setting reported an increase in confidence over time on the same measure. Given these differences in student experiences between incarcerated adult students and traditional students, this work seeks to further understand the experiences of incarcerated adult in CS1, with a focus on their attitudes towards computing. Specifically, we used the Computing Attitude Survey (CAS) as a pre/post measurement in a CS1 course taught in prison. We found significant positive shifts for Problem Solving - Transfer and Fixed Mindset factors and a slight decrease for Real-World Connections. We additionally compare the results of the CAS survey between the incarcerated adult students in this study and those of non-incarcerated students reported in prior work.

Culturally Relevant Computing (CRC) has been shown to have positive effects on students, including increased classroom engagement, increased computing interest, and increased math performance. However, the vast majority of CRC studies take place in primary and secondary education, with little known about its efficacy in higher education. Despite the lack of literature on CRC in higher education, we believe that there may be CRC techniques presently being implemented in this context---yet not published in the research community. To investigate, we interviewed 21 professors from Hispanic Serving Institutions within the Computing Alliance for Hispanic Serving Institutions to document their implementation (if any) of CRC in the higher education context. Professors reported several CRC implementations including, but not limited to, culture in course materials, language-based approaches, providing opportunities outside the classroom, cultural sharing, and professional development. We conclude by discussing how these results may contribute to the promotion of leveraging students' cultures in higher education to serve students---particularly of minoritized backgrounds in computing.

Low-quality code can cost a company significant time and effort. As a result, code quality has been consistently studied in computing education research, especially in the context of CS1 students. However, less research has examined students' code quality while working on existing code bases (i.e., in tasks they are expected to do in industry). In this paper, we identify 1) common code quality defects introduced by upper-division students while contributing to an existing code base, 2) the severity, tool support, and language independence of those defects, and 3) programming experiences that may be associated with students' frequencies of defects, such as internship experience and use of Python (which was the language used in the programming tasks). In an upper division software engineering course, 48 students worked individually to 1) modify an existing feature and 2) implement a new feature in an open-source code base. Using an existing framework of code quality defects by Řechtáčková et al., we conducted a manual code review of all student submissions and found that students created defects related to Poor Design, Poor Documentation, Poor Formatting, and Unused Code at a high frequency. Students also seemed to copy-paste code from other files, which introduced defects related to Unused Code and Poor Design to their submission. Though our regression analysis did not reveal statistically significant predictors, students with prior internships, on average, introduced more code quality defects than those without any internship experience.

Program comprehension (PC) literature typically focuses on industry professionals comprehending large code bases or novice programmers comprehending short programs. As a result, limited work has aimed to understand how intermediate programmers comprehend large code bases, especially with the goal of supporting learners' incremental development of program comprehension expertise. Through the lens of the Block Model-a theory to support research on and teaching of PC-we aim to uncover 1) the comprehension process that intermediate programmers follow (i.e., top-down, bottom-up, etc.), and 2) common mappings between comprehension techniques used by intermediate programmers and comprehension blocks in the Block Model. We present a diary study of students' “process journals” inwhich they described their PC process while modifying the open-source idlelib code base. Our results showed that students typically followed a top-down and Text-first approach to understand a feature in the idlelib code base. Our findings also reveal how students used various program comprehension techniques (such as code navigation, using the IDE-based debugger, making experimental code changes, etc.) in terms of the Block Model. These findings make progress toward bridging our theoretical understanding of novices' comprehension process in small programs and expert's code comprehension process in large code bases by presenting a high sample size investigation of intermediate programmers' PC processes in a large, existing code base. Instructors can use our findings to understand which blocks in the Block Model are cover PC techniques, which can enable targeted teaching activities to impart PC skills.

Understanding incarcerated adult (IA) students' fears upon entering a CS1 course and how their confidence changes throughout the course can help us understand how well IA students' fears are being addressed, and help future instructors of CS1 in prison address them better. Building on recent work on non-CS majors' fears and confidence in introductory CS, we surveyed 45 IA students across two offerings of a CS1 course in prison on their fears going into the course, and confidence in their ability to succeed. We present a phenomenographic analysis of fears amongst IA students in CS1, and analyze relationships between these fears and change in confidence. In addition, we compare the fears expressed by IA students to those of non-CS majors from prior work. Findings include many IA students reporting no fears, but an overall decrease in confidence across both offerings of the course which was mostly accounted for by students who did express initial fears. We found 9 fears overlapping with those found in a prior study outside of the prison context (e.g., getting a bad grade), and 7 fears only identified in our study (e.g., interference from circumstances beyond my control).

Large language models (LLMs) are already heavily used by professional software engineers. An important skill for new university graduates to possess will be the ability to use such LLMs to effectively navigate and modify a large code base. While much of the prior work related to LLMs in computing education focuses on novice programmers learning to code, less work has focused on how upper-division students use and trust these tools, especially while working with large code bases. In this study, we taught students about various GitHub Copilot features, including Copilot chat, in an upper-division software engineering course and asked students to add a feature to a large code base using Copilot. Our analysis revealed a novel interaction pattern that we call one-shot prompting, in which students ask Copilot to implement the entire feature at once and spend the next few prompts asking Copilot to debug the code or asking Copilot to regenerate its incorrect response. Finally, students reported significantly more trust in the code comprehension features than code generation features of Copilot, perhaps due to the presence of trust affordances in the Copilot chat that are absent in the code generation features. Our study takes the first steps in understanding how upper-division students use Github Copilot so that our instruction can adequately prepare students for a career in software engineering.

Higher education is expanding in United States prisons, with a growing demand for STEM offerings. Academics from other disciplines have stressed the importance of culturally relevant pedagogy (CRP) in prison higher education, and computing in context has shown major benefits in CS1--- especially for women and nontraditional students. More work is needed to determine what contexts are relevant to incarcerated college students, and how to incorporate these into computing curricula. In this paper, we build on prior work on computing in context and culturally relevant techniques in computing. We analyze course data from a CS1 course taught in a college-in-prison program to answer the following research question: What contexts do incarcerated students in CS1 find relevant? We identify 24 topics pursued by students across 78 open-ended programming assignment submissions, the three most popular being business management, sports statistics, and physical health. These results offer insight into potential contexts that are meaningful to incarcerated college students to be incorporated into future computing curricula and interventions in prisons.

Live coding is a recommended teaching practice in which an instructor dynamically programs in front of students. However, findings related to students' engagement during live coding are mixed. Some works have reported that live codingseems to improve student engagement while others regard live coding as an activity in which students passively observe the instructor without asking questions or following along. Active live coding, in which students extend a live coding example and discuss with peers, incorporates active learning with the traditional live coding approach. We conducted a quasi-experimental study in which one section of an advanced introductory programming course was taught using active live coding (ALC) and the other was taught using traditional live coding (TLC). The goal of this work is to compare students' behavioral engagement in the two lectures using a classroom observation protocol called the Behavioral Engagement Related to Instruction (BERI) protocol. Our results from the 2,790 observations we collected indicate that traditional live coding engages only 65% of students, on average. However, we found a "persisting engagement'' effect of active live coding, where students were significantlymore engaged in the traditional live coding components of a lecture up to 20 minutesafter the active live coding component. Notably, the two lecture groups performed similarly on the Post-Lecture Questions, which were administered after each lecture as a review of the lecture material. Therefore, our results indicate an improved student engagement due to active live coding, but do not show a corresponding improvement in conceptual knowledge.

Since March of 2020, universities around the world have offered remote versions of courses to help limit the spread of COVID-19. Two years later, in the Spring 2022 quarter, the lectures in the CS1 course at our large, public research-intensive university were taught via two modalities---an in-person modality in which students attended traditional, in-person lectures and a blended modality in which students attended a remote lecture on Zoom. Every other course component---labs, discussions, office hours---were held in-person for both groups. The unique setup of the CS1 course allowed us to perform a comparative analysis of the outcomes and attitudes between the two groups. In this paper, we analyze the difference in course outcomes, peer support, competitive feelings in class, and students' sense of belonging between the groups. Our results indicate that students in the blended learning group attended lectures more frequently than their in-person counterparts yet performed 4-7%worse on the midterm and final exams. The blended learning group also experienced significantlyless feelings of competitiveness than their in-person counterparts. Interestingly, we discovered a consistent trend among our results indicating that the gap in grades, peer support, and classroom competitiveness between the blended group and in-person group was more pronounced among first- and second-year undergraduates than third- and four-year students. Despite the two learning groups having different instructors, our results shed light on the potential advantages and drawbacks of a blended learning experience in CS1 that instructors should consider when deciding on the format of their course.

In a large CS class, it's likely that most students will never speak with the instructor. This presents challenges in terms of student engagement. As class time is limited for building rapport, out-of-class interventions are recommended, such as meeting with students in small groups to discuss non-class topics. If an instructor is to meet with all the students, how can the benefits be maximized while mitigating impacts on the instructor's time and students' access to help? What should be discussed? And how beneficial are such meetings, given that they will have to be short? This paper introduces Meet the Professor (MTP), a course element designed with these issues in mind. MTP was deployed in three sections of an upper-division course at UC San Diego. In end-of-course surveys, students broadly reported increases to rapport, most notably finding instructors to be more approachable than they previously thought. Overwhelmingly, students reported appreciation for meeting with the instructor and did not find that MTP interfered with other learning opportunities. Recommendations are provided for managing the instructor's time and maximizing the value of the intervention.

Efforts to bring incarcerated and formerly incarcerated individuals into the field of computing stand to improve equitable access to both computing jobs, and consequently the benefits of our tools and innovations through the inclusion of more diverse perspectives. This report describes the design and execution of a college level introductory computing course conducted with 26 students currently incarcerated at a prison in the United States in Fall 2022. We discuss the ways that the prison environment and the student body differ from traditional college computing classes, and how this impacted the design and execution of the course. We found that despite significant environmental barriers to learning to program, such as not having access to a code interpreter, there were unique affordances of the student population, including maturity and community, that could be leveraged in the course design and policies. We conclude with many lessons learned for the purpose of improving future offerings of computing courses in prisons.

Background and Context. Live coding is a teaching method in which an instructor dynamically writes code in front of students in an effort to impart skills such as incremental development and debugging. By contrast, traditional, static-code examples typically involve an instructor annotating or explaining components of pre-written code. Despite recommendations to use live coding and a wealth of qualitative analyses that identify perceived learning benefits of it, there are a lack of empirical evaluations to confirm those learning benefits, especially with respect to students’ programming processes.

Live coding---a pedagogical technique in which an instructor plans, writes, and executes code in front of a class---is generally considered a best practice when teaching programming. However, only a few studies have evaluated the effect of live coding on student learning in a controlled experiment and most of the literature relating to live coding identifies students' perceived benefits of live-coding examples. In order to empirically evaluate the impact of live coding, we designed a controlled experiment in a CS1 course taught in Python at a large public university. In the two remote lecture sections for the course, one was taught using live-coding examples and the other was taught using static-code examples. Throughout the term, we collected code snapshots from students' programming assignments, students' grades, and the questions that they asked during the remote lectures. We then applied a set of process-oriented programming metrics to students' programming data to compare students' adherence to effective programming processes in the two learning groups and categorized each question asked in lectures following an open-coding approach. Our results revealed a general lack of difference between the two groups across programming processes, grades, and lecture questions asked. However, our experiment uncovered minimal effects in favor of the live-coding group indicating improved programming processes but lower performance on assignments and grades. Our results suggest an overall insignificant impact of the style of presenting code examples, though we reflect on the threats to validity in our study that should be addressed in future work.

Recent research in computing has shown that student performance on prerequisite course content varies widely, even when students continue to progress further through the computing curriculum. Our work investigates instructors' perspectives on the purpose of prerequisite courses and whether that purpose is being fulfilled. In order to identify the range of instructor views, we interviewed twenty-one computer science instructors, at two institutions, that teach a variety of courses in their respective departments. We conducted a phenomenographic analysis on the interview transcripts, which revealed a wide variety of views on prerequisite courses. The responses shed light on various issues with prerequisite course knowledge, as well as issues around responsibility and conflicting pressures on instructors. These issues arise at the department level, as well as with individual course offerings.

Incremental development is the process of writing a small snippet of code and testing it before moving on. For students in introductory programming courses, the value of incremental development is especially higher as they may suffer from more syntax errors, lack the proficiency to address complicated bugs, and may be more prone to frustration when struggling to correct code. However, to evaluate the effectiveness of interventions that aim to teach programming processes such as incremental development, we need to develop measures to assess such processes. In this paper, we present a way to measure incremental development. By qualitatively analyzing 15 student coding interviews, we identified common behaviors in the programming process that relate to incremental development. We then leveraged a dataset of over 1000 development sessions -- about 52,000 code snapshots at compilation time -- to automatically detect the common behaviors identified in our qualitative analysis. Finally, we crafted a formal metric, called the "Measure of Incremental Development'' (MID), to quantify how effectively a student used incremental development during a programming session. The MID detects common non-incremental development patterns such as excessive debugging after large additions of code to automatically assess a sequence of snapshots. The MID aligns with human evaluations of incrementality with over 80% accuracy. Our metric enables new research directions and interventions focused on improving students' development practices.

Due to the exploratory nature of computational notebook development, a notebook can be extensively evolved even though it is small, potentially incurring substantial technical debt. Indeed, in interview studies notebook authors have attested to performing ongoing tidying and big cleanups. However, many notebook authors are not trained as software developers, and environments like JupyterLab possess few features to aid notebook maintenance. As software refactoring is traditionally a critical tool for reducing technical debt, we sought to better understand the unique and growing ecology of computational notebooks by investigating the refactoring of public Jupyter notebooks. We randomly selected 15,000 Jupyter notebooks hosted on GitHub and studied 200 with meaningful commit histories. We found that notebook authors do refactor, favoring a few basic classic refactorings as well as those involving the notebook cell construct. Those with a computing background refactored differently than others, but not more so. Exploration-focused notebooks had a unique refactoring profile compared to more exposition-focused notebooks. Authors more often refactored their code as they went along, rather than deferring maintenance to big cleanups. These findings point to refactoring being intrinsic to notebook development.

Previous work in computing has shown that Black, Latinx, Native American and Pacific islander (BLNPI), women, first-generation, and transfer students tend to have worse outcomes during their time in university compared to their majority counterparts. Previous work has also found that students' incoming prerequisite course proficiency is positively correlated with their outcomes in a course. In this work, we investigate the role that prerequisite course proficiency has on outcomes between these groups of students.

Students’ sense of belonging has been found to be connected to student retention in higher education. In computing education, prior studies suggest that a hostile culture and a feeling of non-belonging can lead women, Black, Latinx, Native American, and Pacific Islander students to drop out of the computing field at a disproportionately high rate. Yet, we know relatively little about how computing students’ sense of belonging presents and evolves (if at all) through their college courses, particularly in courses beyond the introductory level, and little is known about how sense of belonging impacts student outcomes in computing. In an extension of a previous study, we examined students’ sense of belonging in six early undergraduate computer science courses across three consecutive quarters at a large research-intensive institution in North America. We found that women and first generation students have a lower incoming sense of belonging across all courses. When exploring sense of belonging’s tie to student outcomes we found that lower sense of belonging was correlated with negative course outcomes in terms of pass rates and course performance. We also found that it is less tied to student performance as students get further into the CS curriculum. Surprisingly, there was no indication that sense of belonging is predictive of retention in terms of persistence to the next CS course outside of the first course in our two-course CS1 sequence.

Computer science students struggle in early computing courses as evinced by high failure rates and poor retention. As such, studies have attempted to characterize the root of student struggles from many perspectives, including cognitive, meta-cognitive, and social emotional. Typically, studies have limited their inquiry to a specific perspective or a single course. This paper reports the results of a broad student experience survey conducted across several computer science courses. Through a periodic survey, students rated various cognitive, socio-emotional, external, personal, and structural barriers in terms of how much each impacted their learning throughout the term. An exploratory factor analysis of these questions revealed four factors—personal obligations, lack of sense of belonging, in-class confusion, and lack of confidence—that capture a range of possible struggles students may face. We analyzed the prevalence of these factors across courses, performance quartiles, and demographic groups broken down by gender, race/ethnicity, and matriculation status. Students in lower performance quartiles report higher stress levels on multiple factors, with statistically significant differences found between all quartiles and courses, for most factors. Moreover, students from traditionally underrepresented groups report struggling more across all four factors, suggesting that they may be facing more challenges than classmates from represented populations. Overall, these findings indicate that student struggles are associated with stresses from many areas of their lives, suggesting that future interventions should target multiple areas of stress.

Spring 2020 brought enormous change to student learning, as universities scrambled to put into place support structures to aid students' learning in a remote context. Computer science education was both well-positioned for this change and faced unique challenges, e.g. that students often need significant (in-person) support with programming. In this study we examine how aspects of students' remote learning experience in spring 2020 compared to the same aspects in previous in-person, pre-COVID offerings of 6 lower- to mid-division computer science courses at UC San Diego (UCSD), a large US research university. We were in a unique position to make this comparison because we had been collecting data on several aspects of students' course experiences throughout the 2019-2020 academic year. We found, surprisingly, that most elements of students' experiences that we examined were unchanged, or even improved, in spring 2020. Students in spring reported similar or lower stress levels and found their courses similarly or less challenging relative to previous quarters. However, some aspects did degrade. Students had less connection with their peers (particularly in introductory classes), more interference from family obligations, and higher drop/fail rates in some classes. Surprisingly, these results hold across all assessed demographics. Our results indicate that the actions UCSD and its CS instructors took to mitigate the stresses of remote learning in spring 2020 were largely successful and provide implications for improving education beyond the pandemic.

Our prior work found differences in study habits between high- and low-performers in a small-scale qualitative study, and this work seeks to verify and extend these findings by examining the study habits of a larger population of CS1 students. To do this, we devised a survey based on the findings of our prior qualitative study. The responses of CS1 students reveals that some study habits are more frequently practiced by higher-performers then lower-performers or vice versa. One concern with these findings is that the differences in study habits might simply be explained by prior experience. As such, we compare study habits between students with and without prior experience as well. We find that although prior experience translates to better class performance, it is not associated with the same study habits as lower- and higher-performers, suggesting that prior experience and study habits are separately associated with better student performance. These findings encourage further inquiry into the role of study habits in student success and whether explicit instruction on better study habits might be the basis for successful future interventions.

Previous studies show that CS students may not learn as much from their courses as we might expect. This could have ramifications on how students succeed in their future careers and may explain why researchers report a gap between industry expectations and the abilities of recent CS graduates. However, previous studies have also shown that students improve their prerequisite knowledge in subsequent courses. This study investigates the introductory data structures proficiency of students in different courses at various stages in our CS program, employing the validated Basic Data Structures Inventory (BDSI). Additionally, we investigate whether subpopulations, including transfer students and underrepresented groups, may be more prone to not attaining as much knowledge from our courses as we might expect. We find that students' knowledge of basic data structures is, on average, better in later courses. However, we also find subpopulations of students that perform worse than others or seem to not improve their knowledge in later courses. Specifically, we find students that transferred to our institution from a different school perform significantly worse on the BDSI than other students and do not improve their BDSI performance in later courses. We also find students from demographic backgrounds that are underrepresented in computing scored slightly, though not statistically significantly, worse than others. Our findings warrant future investigations on how our programs can better serve the students in the affected subpopulations.

The ability to effectively and efficiently test software is an important practice in software testing that is often under-emphasized in computer science education. Many students find learning about testing to be uninteresting and difficult to learn. This causes numerous students to develop inadequate testing habits, which can be detrimental to their professional careers. To encourage students to develop better testing habits, we used gamification to make the learning experience more engaging and enjoyable. In this paper we explore this idea by integrating gamification and statement coverage into a turn-based game called CoverBot. To test the effectiveness of CoverBot with respect to both teaching statement coverage and increasing engagement and enjoyment, we conducted a user study. We found that gamification makes the learning about statement coverage more engaging and enjoyable while also enhancing the participants performance and understanding of statement coverage.

Although elements of the academia-industry gap have been studied extensively, these studies have mostly ignored the primary stakeholder for changing academia: faculty. Building on a recent qualitative study that revealed a wide range of faculty views on the gap, this study quantitatively examines faculty views through a survey on the goals of CS education, how CS programs should address the academia-industry gap, and which barriers prevent adoption of remedies. Analysis of the 249 responses reveals that a majority of faculty share common goals in supporting student preparation for a career in industry. Moreover, faculty strongly view their own institutions as the prime party responsible for student preparation for careers in both academia and industry. We also find that whereas faculty are generally in agreement on what could be improved to provide students with better industry preparation, some reported far greater barriers to implementing those improvements than others.

In computer science classes it can be a challenge to ensure every student has a functioning development environment. Running pre-configured servers that provide students with remote access can help mitigate most of these setup issues, however they can also introduce new limitations of their own. We propose using DevContainers to overcome the local machine setup difficulties for the students. DevContainers allow the instructional staff to provision a development environment (a Docker image) with all the correct software versions pre-configured. This development environment can be used on any major OS through Docker. Moreover, through this DevContainer configuration, Microsoft Visual Studio Code can integrate seamlessly with the Docker container to provide an experience for the user that is practically the same as working on the native OS. This work examines the value of employing a DevContainer setup in an Advanced Data Structures course and provides details for those interested in using DevContainers in their courses.

Recent work has identified a mismatch between instructor expectations of students' mastery of prerequisite course content and their actual ability. This invites the question of why this mismatch exists. We first examined grades in prerequisite courses and found they meaningfully correlated with performance on an assessment testing their knowledge of prerequisite material. In addition, we found neither taking alternatives to the primary identified prerequisites nor the delay between taking prerequisite courses and the follow-on course meaningfully impacts performance. Second, we confirmed that prerequisite course grades are significantly correlated with the grade in the follow-on course-confirming that the grades in the previous courses convey some information about student understanding of those topics. Perhaps surprisingly, we found that grades in courses outside computing were similarly correlated as those courses inside computing, suggesting that underlying factors such as general study skills may be as important as the domain-specific knowledge itself.

Previous work has found that recent computer science graduates often experience difficulty transitioning into their new roles in industry due to a significant gap between their academic experiences and industry's expectations. Although multiple studies have identified the views of students and members of industry on the value of a CS degree as preparation for industry, the faculty perspective on this topic remains unclear. Understanding these views could shed light on why the academia-industry gap has persisted despite the attention. This study identified faculty views on the goals of an undergraduate education and a CS major, focusing on preparation for careers in industry. In order to identify a spectrum of faculty views, we interviewed 14 faculty from a variety of backgrounds across three institutions. A phenomenographic analysis of the transcripts reveals that many faculty believe that industry preparation is an important programmatic goal, yet they encounter significant resource obstacles to achieving that goal.

Although recent work in computing has discovered multiple techniques to identify low-performing students in a course, it is unclear what factors contribute to those students' difficulties. If we were able to better understand the characteristics of such students, we may be better able to help those students. This work examines the characteristics of low- and high-performing students through interviews with students from an introductory computing class. We identify a number of relevant areas of student behavior including how they approach their exam studies, how they approach completing programming assignments, whether they sought help after identifying misunderstandings, how and from whom they sought help, and how they reflected on assignments after submitting them. Particular behaviors within each area are coded and differences between groups of students are identified.

A number of recent studies in computer science education have explored the value of various data sources for early prediction of students' overall course performance. These data sources include responses to clicker questions, prerequisite knowledge, instrumented student IDEs, quizzes, and assignments. However, these data sources are often examined in isolation or in a single course. Which data sources are most valuable, and does course context matter? To answer these questions, this study collected student grades on prerequisite courses, Peer Instruction clicker responses, online quizzes, and assignments, from five courses (over 1000 students) across the CS curriculum at two institutions. A trend emerges suggesting that for upper-division courses, prerequisite grades are most predictive; for introductory programming courses, where no prerequisite grades were available, clicker responses were the most predictive. In concert, prerequisites and clicker responses generally provide highly accurate predictions early in the term, with assignments and online quizzes sometimes providing incremental improvements. Implications of these results for both researchers and practitioners are discussed.

While it is widely believed that taking a class's prerequisites is critical for success, less is known about how proficiency with the prerequisite knowledge from those courses affects performance in later courses. Specifically, it is unclear how well students understand material from prerequisite courses and whether that understanding may impact their outcomes in the subsequent course. Additionally, in subsequent courses, do students strengthen their knowledge from prerequisite courses and, if they do, does that improvement matter for the subsequent course? This study examines the prerequisite knowledge of 208 students in an upper-division data structures class at a large North American research university. Prerequisite proficiency on entry to the course was surprisingly low, with nearly a third of students demonstrating low proficiency and only a quarter high proficiency. Students modestly improved their proficiency during the term, lifting a third of those with low proficiency to at least medium proficiency. Overall, final exam performance was significantly correlated with prerequisite knowledge. For those with low initial proficiency, improvement in proficiency was significantly correlated with performance on the final. These results suggest that more attention needs to be placed on reinforcing prerequisite knowledge for those with low proficiency.

As enrollments and class sizes in postsecondary institutions have increased, instructors have sought automated and lightweight means to identify students who are at risk of performing poorly in a course. This identification must be performed early enough in the term to allow instructors to assist those students before they fall irreparably behind. This study describes a modeling methodology that predicts student final exam scores in the third week of the term by using the clicker data that is automatically collected for instructors when they employ the Peer Instruction pedagogy. The modeling technique uses a support vector machine binary classifier, trained on one term of a course, to predict outcomes in the subsequent term. We applied this modeling technique to five different courses across the computer science curriculum, taught by three different instructors at two different institutions. Our modeling approach includes a set of strengths not seen wholesale in prior work, while maintaining competitive levels of accuracy with that work. These strengths include using a lightweight source of student data, affording early detection of struggling students, and predicting outcomes across terms in a natural setting (different final exams, minor changes to course content), across multiple courses in a curriculum, and across multiple institutions.

In today's modern world, bugs in software systems incur significant costs. One promising approach to improve software quality is automated software verification. In this approach, an automated tool tries to prove the software correct once and for all. Although significant progress has been made in this direction, there are still many cases where automated tools fail. We focus specifically on one aspect of software verification that has been notoriously hard to automate: inferring loop invariants that are strong enough to enable verification. In this paper, we propose a solution to this problem through gamification and crowdsourcing. In particular, we present a puzzle game where players find loop invariants without being aware of it, and without requiring any expertise on software verification. We show through an experiment with Mechanical Turk users that players enjoy the game, and are able to solve verification tasks that automated state-of-the-art tools cannot.

Jigsaw learning is a cooperative learning technique enabling students to teach and learn from their peers. Although prior studies investigated the efficacy of Jigsaw learning in computing education by measuring student performance after Jigsaw activities, this work reports on student and instructor experiences with Jigsaw learning. Jigsaw activities were performed in lectures throughout the term and student experience data was collected through student surveys. The survey results reveal that 72% of survey respondents thought the Jigsaw activities helped their learning. Furthermore, 75% of respondents acknowledged their role in class as a more engaged learner and 44% of those students identified themselves as taking on the role of a teacher. The instructor found Jigsaw learning to be labor intensive but observed higher levels of student engagement.

Code changes are often reviewed before they are deployed. Popular source control systems aid code review by presenting textual differences between old and new versions of the code, leaving developers with the difficult task of determining whether the differences actually produced the desired behavior. Fortunately, we can mine such information from code repositories. We propose aiding code review with inter-version semantic differential analysis. During review of a new commit, a developer is presented with summaries of both code differences and behavioral differences, which are expressed as diffs of likely invariants extracted by running the system's test cases. As a result, developers can more easily determine that the code changes produced the desired effect. We created an invariant-mining tool chain, Getty, to support our concept of semantically-assisted code review. To validate our approach, 1) we applied Getty to the commits of 6 popular open source projects, 2) we assessed the performance and cost of running Getty in different configurations, and 3) we performed a comparative user study with 18 developers. Our results demonstrate that semantically-assisted code review is feasible, effective, and that real programmers can leverage it to improve the quality of their reviews.

As student enrollments in computer science increase, there is a growing need for pedagogies that scale. Recent evidence has shown Peer Instruction (PI) to be an effective in-class pedagogy that reports high student satisfaction even with large classes. Yet, the question of the scalability of traditional lecture versus PI is largely unexplored. To explore this question, this work examines publicly available student evaluations of computer science courses across a wide range of class sizes (50--374 students) over a four year period. It first compares evaluations regardless of size and confirms prior work that PI classes are better appreciated by students than traditional lecture. It then examines how course evaluations change with class size and provides evidence that PI achieves a smaller decline in evaluations as class size increases.

Being able to identify low-performing students early in the term may help instructors intervene or differently allocate course resources. Prior work in CS1 has demonstrated that clicker correctness in Peer Instruction courses correlates with exam outcomes and, separately, that machine learning models can be built based on early-term programming assessments. This work aims to combine the best elements of each of these approaches. We offer a methodology for creating models, based on in-class clicker questions, to predict cross-term student performance. In as early as week 3 in a 12-week CS1 course, this model is capable of correctly predicting students as being in danger of failing, or not, for 70% of the students, with only 17% of students misclassified as not at-risk when at-risk. Additional measures to ensure more broad applicability of the methodology, along with possible limitations, are explored.

We present a novel block-based UI called Polymorphic Blocks, in which a connector's shape visually represents the structure of the data being passed through the connector. We use Polymorphic Blocks to add visual type information to block-based programming environments like Blockly or Scratch. We also use Polymorphic Blocks to represent logical proofs. In this context, if we erase all symbols, our UI becomes a puzzle game, where solving the puzzle amounts to building a proof. We show through a user study that our Logical Puzzle Game is faster, more fun, and more engaging than an equivalent pen-and-paper interface.

Energy-efficiency is a critical concern in continuously-running mobile applications, such as those for health and context monitoring. An attractive approach to saving energy in such applications is to defer the execution of delay-tolerant operations until a time when they would consume less energy. However, introducing delays to save power may have a detrimental impact on the user experience. To address this problem, we present Tempus, a new approach to managing the trade-off between energy savings and delay. Tempus saves power by enabling programmers to annotate power-hungry operations with states that specify when the operation can be executed to save energy. The impact of power management on timeliness is managed by associating delay budgets with objects that contain time-sensitive data. A static analysis and the run-time service ensure that power management policies will not delay an object more than its assigned budget. We demonstrate the expressive power of Tempus through a case study of optimizing two real-world applications. Furthermore, laboratory experiments show that Tempus may effectively manage the energy-delay trade-off on realistic workloads. For example, in a news application, five Tempus annotations may be used to create a policy that reduces the latency of downloading images 10 times compared to the original implementation without affecting energy consumption. Our experiments also indicate that the overhead of tracking budgets in Tempus is small.

Energy-efficiency is a key concern in continuously-running mobile applications, such as those for health and context monitoring. Unfortunately, developers must implement complex and customized power-management policies for each application. This involves the use of complex primitives and writing error-prone multithreaded code to monitor hardware state. To address this problem, we present APE, an annotation language and middleware service that eases the development of energy-efficient Android applications. APE annotations are used to demarcate a power-hungry code segment whose execution is deferred until the device enters a state that minimizes the cost of that operation. The execution of power-hungry operations is coordinated across applications by the APE middleware. Several examples show the expressive power of our approach. A case study of using APE annotations in a real mobile sensing application shows that annotations can cleanly specify a power management policy and reduce the complexity of its implementation. An empirical evaluation of the middleware shows that APE introduces negligible overhead and equals hand-tuned code in energy savings, in this case achieving 63.4% energy savings compared to the case when there is no coordination.

Maintenance and evolution are important parts for all successful software projects. In recent years, version control systems have played a key role in software development process. Not only do they provide a means to coordinate programmers, organize and manage source code, but they also persist the evolution history of the source code into their software repositories. Mining software repositories has provided many insights on the evolution of software, both for researchers and practitioners. In this paper we propose that versioned software contracts -- mined from software repositories -- can be a powerful tool for better understanding and supporting software evolution. Tooling support is critical, due to the complexities of configuring, compiling, and running the software to produce meaningful inferred contracts. This paper contributes both techniques and tool support for downloading, building, and analyzing open source software from social coding sites like GitHub. The tool automatically produces a description of software evolution represented by versions of program invariants.

We investigate the unique educational benefits of 1-on-1 competitive games, arguing that such games can be just as easy to design as single-player educational games, while yielding a more diverse and sustainable learning experience. We present a study of chess and StarCraft II in order to inform the design of similar educational games and their communities. We discuss a competitive game we designed to teach Java programming. We evaluate the game by discussing its user study. Our main contributions are 1) an argument that the use of 1-on-1 competition can solve two existing problems inherent to single-player games, 2) an analysis of the features that make competitive games effective learning environments, and 3) an early but encouraging description of the emergent learning environment one can expect from designing an educational game with these features.

Recent studies recognize that health is influenced broadly by a multitude of factors of different types, including medical, genetic, environmental, social and behavioral factors. Developing successful health interventions therefore requires taking into account all these factors as well as the interactions between them. However, intervention designers have traditionally had access only to a very limited subset of health data (typically medical record data). Other health data, such as environmental or physical activity data, although already collected and stored, have been very difficult to access, since they are maintained by different providers and isolated in their own proprietary silos. This prevents physicians and intervention designers from acquiring a true overview of all factors influencing a condition and acting towards its prevention or cure. To solve this problem, we propose DELPHI: a platform allowing the integration of disparate health data into a single Whole Health Information Model (WHIM), providing a 360-degree view of an individual's health. DELPHI supports the integration of data and thus enables the design of applications and services that utilize the WHIM to offer the next generation of health services. In this paper, we describe DELPHI's architecture, outline the technical challenges encountered and describe an asthma management use case that will be enabled by DELPHI.

This paper addresses how CodeSpells uses the metaphor of wizardry, along with an embodied API to engage students in learning to program in Java. Giving novice programmers a concrete representation of code has been encouraged and shown to help students understand the concepts with more ease. There have been many attempts to improve the novice learning experience by providing: a visual programming language, a hardware component or an application that is more approachable. The benefit of this research is that students are better able to understand how abstract code effects the environment.

Traditionally, computer science education research contributes new tools, techniques, and theories to improve institutionalized learning spaces e.g. classrooms. However, we take the position that the study and improvement of computer science learning spaces outside the classroom are just as important. We take a step toward illuminating the critical qualities of non-institutional computer science learning spaces by engaging in a grounded-theoretical examination of first-hand accounts of non-institutional learning. To further study the topic, we attempted to recreate (in the lab) a learning environment with many qualities that characterize non-institutional learning. To make this possible, we employed a modified version of CodeSpells -- a video game designed to teach Java programming in a way that engenders the sense of sustained, playful, creative exploration driven entirely by the learner. This study introduced 40 girls, ages 10 to 12, to programming for the first time. We use the results of both studies to develop a theoretical framework which we use to examine existing tools such as Scratch, Alice, and educational games in a new light.

Integrated Development Environments (IDEs) have come to perform a wide variety of tasks on behalf of the programmer, refactoring being a classic example. These operations have undeniable benefits, yet their large (and growing) number poses a cognitive scalability problem. Our main contribution is WitchDoctor - a system that can detect, on the fly, when a programmer is hand-coding a refactoring. The system can then complete the refactoring in the background and propose it to the user long before the user can complete it. This implies a number of technical challenges. The algorithm must be 1) highly efficient, 2) handle unparseable programs, 3) tolerate the variety of ways programmers may perform a given refactoring, 4) use the IDE's proven and familiar refactoring engine to perform the refactoring, even though the the refactoring has already begun, and 5) support the wide range of refactorings present in modern IDEs. Our techniques for overcoming these challenges are the technical contributions of this paper. We evaluate WitchDoctor's design and implementation by simulating over 5,000 refactoring operations across three open-source projects. The simulated user is faster and more efficient than an average human user, yet WitchDoctor can detect more than 90% of refactoring operations as they are being performed - and can complete over a third of refactorings before the simulated user does. All the while, WitchDoctor remains robust in the face of non-parseable programs and unpredictable refactoring scenarios. We also show that WitchDoctor is efficient enough to perform computation on a keystroke-by-keystroke basis, adding an average overhead of only 15 milliseconds per keystroke.

This paper describes the design, deployment, and empirical evaluation of WIISARD - a novel emergency response system that provides reliable communication in dynamic wireless environments without extensive communication infrastructure. The main contribution of this paper is an in-depth empirical study of network properties that emerge during a drill in which WIISARD is deployed with minimal infrastructure support. The drill involves 19 first responders and 41 victims. The properties of links established among first responders vary between phases of the drill and depend upon the responder's role in the drill. The rescue phase - in which responders are highly mobile as they triage victims - poses significant challenges to reliable communication. During this phase, the contacts between responders are short-lived; however, they are reestablished within minutes. Once a contact between responders is established, the quality of the link between those responders is usually high. The connectivity graph observed during the rescue phase is usually connected and has a small diameter although there are times when it has a large diameter or it is partitioned. While mobility increases network dynamics, we also observe that the mobility patterns characteristic of the emergency response workflow can be leveraged to disseminate data efficiently through data muling. WIISARD employs a gossip-based protocol and supports data dissemination through local communication and data muling to achieve 98% reliability during the drill exercise. These results indicate the feasibility of providing reliable communication in emergency response with minimal infrastructure in spite of network dynamics.

Programmers employ crosscutting concepts, such as design patterns and other programming idioms, when their design ideas cannot be efficiently or effectively modularized in the underlying programming language. As a result, implementations of these crosscutting concepts can be hard to change even when the code is well structured. In this article, we describe Arcum, a system that supports the modular maintenance of crosscutting concepts. Arcum can be used to both check essential constraints of crosscutting concepts and to substitute crosscutting concept implementations with alternative implementations. Arcum is complementary to existing refactoring systems that focus on meaning-preserving program transformations at the programming-language-semantics level, because Arcum focuses on transformations at the conceptual level. We present the underpinnings of the Arcum approach and show how Arcum can be used to address several classical software engineering problems.

Long-distance couples face considerable communication challenges in their relationships. Unlike collocated couples, long-distance couples lack awareness cues associated with physical proximity and must use technologies such as SMS or telephony to stay in sync. We posit that long-distance couples have needs that are not met by prevailing communication technologies, which require explicit action from the sender as well as the receiver. We built CoupleVIBE to explore the properties of an implicit messaging channel and observe how couples would use such a technology. CoupleVIBE is a mobile application that automatically pushes a user's location-information to her partner's mobile phone via vibrotactile cues. We present qualitative results of a four-week user study, studying how seven couples used CoupleVIBE. A key result is that CoupleVIBE's implicit communication modality operated as a foundation that helps keep couples in sync, with other modalities being brought into play when further interaction was needed.

With the emergence of wireless sensor networks, an enabling communication technology for distributed real-time systems, we face the critical challenge of meeting the end-to-end deadlines of real-time flows. This paper presents Real-time Flow Scheduling (RFS), a novel conflict-free real-time transmission scheduling approach for periodic real-time flows in wireless sensor networks. In contrast to existing transmission scheduling algorithms that ignore interference between transmissions or prevent spatial reuse within the same channel, RFS supports spatial reuse through a novel interference-aware transmission scheduling. While recent work on conflict-free transmission scheduling focused on specialized communication patterns such as queries and converge cast, RFS is designed for peer-to-peer real-time flows with arbitrary inter-flow interference. Moreover, RFS has three salient that make it particularly suitable for real-time systems: First, RFS includes a real-time schedulability analysis that accounts for interference between real-time flows. Second, RFS improves reliability by incorporating retransmissions in a flexible scheduling scheme. Finally, RFS enhances scalability by dividing the network into neighborhoods and provides real-time performance for flows crossing multiple neighborhoods through a novel application of the Release Guard protocol. RFS was evaluated through simulations based on the traces collected from an indoor wireless sensor network test bed. Compared to a traditional TDMA protocol, RFS reduces flow latencies by up to 2.5 times, while improving the real-time capacity by as much as 3.9 times.

Digital social media have transformed how we communicate and manage our relationships. Despite its portability, sketching as a social medium has been largely left behind. Given sketching's unique affordances for visual communication this absence is a real loss. Sketches convey visuo-spatial ideas directly, require minimal detail to render concepts, and show the peculiarities of handwriting. Sketching holds the promise to enrich how we communicate, and its ubiquity is critical for sharing information at opportune moments. We present the results of an exploratory field study of ubiquitous sketching for social media, documenting users' experiences with UbiSketch. This system integrates digital pens, paper, and mobile phones to support the transmission of paper sketches to online services. We learned that UbiSketch enabled participants to leverage sketching's unique affordances, that ubiquitous sketching creates a synergy with the practice of posting context-dependent information, and that it broadens and deepens social interaction.

Part of computer science education research focuses on the design of new technologies and techniques for improving educational experiences. However, for these systems and techniques to be truly impactful, their use must be disseminated to the larger instructor population. Single-instance workshops, where instructors are brought together to learn about a new technique or system so that they can possibly adopt it, are a common dissemination method. Unfortunately, rarely do we see reports regarding their effectiveness. In this case study, we report on two NSF-funded single-instance workshops designed to support adoption of the Ubiquitous Presenter (UP) active learning classroom presentation system. Though only 44% of workshop attendees used the system in their classrooms, 65% of those used the system repeatedly. Overall this impacted 1570 students. Additionally, 60% of our attendees used the active learning features of UP - a much higher usage rate than in the general UP user population. We reflect on the aspects of the workshops which seemed to promote, and hinder, instructor adoption and, finally, suggest some metrics for evaluating innovation dissemination workshops in general.

BACKGROUND: There is growing interest in the use of technology to enhance the tracking and quality of clinical information available for patients in disaster settings. This paper describes the design and evaluation of the Wireless Internet Information System for Medical Response in Disasters (WIISARD). MATERIALS AND METHODS: WIISARD combined advanced networking technology with electronic triage tags that reported victims' position and recorded medical information, with wireless pulse-oximeters that monitored patient vital signs, and a wireless electronic medical record (EMR) for disaster care. The EMR system included WiFi handheld devices with barcode scanners (used by front-line responders) and computer tablets with role-tailored software (used by managers of the triage, treatment, transport and medical communications teams). An additional software system provided situational awareness for the incident commander. The WIISARD system was evaluated in a large-scale simulation exercise designed for training first responders. A randomized trial was overlaid on this exercise with 100 simulated victims, 50 in a control pathway (paper-based), and 50 in completely electronic WIISARD pathway. All patients in the electronic pathway were cared for within the WIISARD system without paper-based workarounds. RESULTS: WIISARD reduced the rate of the missing and/or duplicated patient identifiers (0% vs 47%, p<0.001). The total time of the field was nearly identical (38:20 vs 38:23, IQR 26:53-1:05:32 vs 18:55-57:22). CONCLUSION: Overall, the results of WIISARD show that wireless EMR systems for care of the victims of disasters would be complex to develop but potentially feasible to build and deploy, and likely to improve the quality of information available for the delivery of care during disasters.

The emergence of aspect-oriented programming (AOP) languages has provided software designers with new mechanisms and strategies for decomposing programs into modules and composing modules into systems. What we do not yet fully understand is how best to use such mechanisms consistent with common modularization objectives such as the comprehensibility of programming code, its parallel development, dependability, and ease of change. The main contribution of this work is a new form of information-hiding interface for AOP that we call the crosscut programming interface, or XPI. XPIs abstract crosscutting behaviors and make these abstractions explicit. XPIs can be used, albeit with limited enforcement of interface rules, with existing AOP languages, such as AspectJ. To evaluate our notion of XPIs, we have applied our XPI-based design methodology to a medium-sized network overlay application called Hypercast. A qualitative and quantitative analysis of existing AO design methods and XPI-based design method shows that our approach produces improvements in program comprehensibility, in opportunities for parallel development, and in the ease when code can be developed and changed.

Being mobile influences not only the types of information people seek but also the ways they attempt to access it. Mobile contexts present challenges of changing location and social context, restricted time for information access, and the need to share attentional resources among concurrent activities. Understanding mobile information needs and associated interaction challenges is fundamental to improving designs for mobile phones and related devices. We conducted a two-week diary study to better understand mobile information needs and how they are addressed. Our study revealed that depending on the time and resources available, as well as the situational context, people use diverse and, at times, ingenious ways to obtain needed information. We summarize key findings and discuss design implications for mobile technology.

Mobile phones have the potential to be useful agents for their owners by detecting and reporting situations that are of interest. Several challenges emerge in the case of detecting and reporting nice to know situations. Being alerted of these events may not be of critical importance but may be useful if the user is not busy. For detection, the precision of sensing must be high enough to minimize annoying false notifications, despite the constraints imposed by the inaccuracy of commodity sensors and the limited battery power available on mobile phones. For reporting, the notifications cannot be too obtrusive to the user or those in the vicinity. Peripheral cues are appropriate for conveying information like proximity, but have been studied primarily in settings like offices where sensors and cueing mechanisms can be controlled.

Crosscutting is an inherent part of software development and can typically be managed through modularization: A module's stable properties are defined in an interface while its likely-to-change properties are encapsulated within the module [19]. The crosscutting of the stable properties, such as class and method names, can be mitigated with automated refactoring tools that allow, for example, the interface's elements to be renamed [9, 18]. However, often the crosscutting from design idioms (such as design patterns and coding styles) are so specific to the program's domain that their crosscutting would not likely have been anticipated by the developers of an automated refactoring system.

Classroom note taking tends to be a private activity, hiding a wealth of knowledge in both content and method. With the advent of the web, whose technology and culture seemingly invites everyone to share everything, we are prompted to ask how making note taking a public activity -- noteblogging -- might advance learning. What does a blog about a computer science classroom look like? What supports are needed to enable noteblogging as a form of auxiliary instruction? In this paper we overview the design and use of noteblogging as part of the Ubiquitous Presenter digital classroom system. With NoteBlogger, students with Tablet PCs take handwritten notes digitally on top of the instructor's slides, and their notes are instantly reviewable by other students in class using a web browser. We examine the impact of noteblogging on a CS1 course through interviews with bloggers (to reveal their motivation and understand their choice of content) and blog watchers (to learn when and why they watch). We also analyze the blogs in this CS1 course to identify their educational contribution. We find that noteblogging enables a unique classroom participation model that specifically engages more advanced students. Blog content spans many levels of intellectual engagement, which can support a range of learners in CS1 as well as perhaps model for them various levels of reflection.

Tactile feedback allows devices to communicate with users when visual and auditory feedback are inappropriate. Unfortunately, current vibrotactile feedback is abstract and not related to the content of the message. This often clash-es with the nature of the message, for example, when sending a comforting message.

Peer review is widely recognized for advancing student learning, in particular for developing reflective processes like critical thinking. The classroom is ripe for peer review because the subject matter is fresh and in-depth interactivity is possible. Yet the limited time available in class conflicts with peer review's deliberative nature. We hypothesize that peer review -- at least the initial stages of it -- can be supported in the classroom with tools for facilitating the rapid identification of interesting issues for discussion. The potential benefits of such a tool include: furthering the student-focus of in-class active learning activities, further implanting critical analysis skills through frequent in-class use, supporting immediate feedback, and enabling comparison of student and instructor-modeled critical analysis.This paper explores tool support for in-class lightweight preliminary peer-review (LPPR): peer review that is instigated in the classroom, but does not necessarily end there. We proposed that students classify peer solutions in 4 dimensions: correctness, comprehension (e.g., "do I understand this solution"), worthiness for discussion, and similarity to the evaluator's own solution. We designed an LPPR extension to Ubiquitous Presenter, and then conducted an exploratory study in a mock classroom setting. We found that LPPR can quickly identify a subset of student solutions that warrant immediate discussion, and that modest amounts of reflection arise from the LPPR process.

Research has shown that educational technology can broaden and enhance the use of active learning in large classrooms. An educational technology platform often relies on students to bring laptops or specialized wireless devices like clickers to interact through the system. Mobile phones are an attractive alternative, as most students already possess them, they have more capabilities than dedicated clickers, and yet are small enough to minimize interference with note taking on a classroom desk.This paper presents the design and use of a mobile phone extension to Ubiquitous Presenter, which allows students to submit solutions to active learning exercises in the form of text or photo messages. In an exploratory study, students found that text messaging worked well for exercises with multiple choice or short answers. Entering symbols common to computer science was difficult. Many problems were more suitable to photo messaging of a handwritten answer, although image quality must be managed. The phone's small size left space for the use of a notebook. The students had concerns about the message charges that would accrue in use. In conclusion, we offer recommendations to instructors and system designers interested in leveraging mobile phones to increase communication in the classroom.

Despite the automated refactoring support provided by today's IDEs many program transformations that are easy to conceptualize--such as improving the implementation of a design pattern--are not supported and are hence hard to perform. We propose an extension to the refactoring paradigm that provides for the modular maintenance of crosscutting design idioms, supporting both substitutability of design idiom implementations and the checking of essential constraints. We evaluate this new approach through the design and use of Arcum, an IDE-based mechanism for declaring, checking, and evolving crosscutting design idioms.

Location-based computing (LBC) is becoming increasing important in both industry and academia. A key challenge is the pervasive deployment of LBC technologies; to be effective they must run on a wide variety of client platforms, including laptops, PDAs, and mobile phones, so that location data can be acquired anywhere and accessed by any application. Moreover, as a nascent area, LBC is experiencing rapid innovation in sensing technologies, the positioning algorithms themselves, and the applications they support. Lastly, as a newcomer, LBC must integrate with existing communications and application technologies, including web browsers and location data interchange standard.This paper describes our experience in developing the Place Lab architecture, a widely used first-generation open source toolkit for client-side location sensing. Using a layered, pattern-based architecture, it supports modular development in any dimension of LBC, enabling the field to move forward more rapidly as these innovations are shared with the community as pluggable components. Our experience shows the benefits of domain-specific abstractions, and how we overcame high-level language constraints to support a wide array of platforms in this emerging space. We also describe our experience in re-engineering parts of the architecture based on the needs of the user community, including insights on software licensing issues.

The emergence of personal mobile computing and ubiquitous wireless networks enables powerful field applications of video streaming, such as vision-enabled command centers for hazardous materials response. However, experience has repeatedly demonstrated both the fragility of the wireless networks and the insatiable demand for higher resolution and more video streams. In the wild, even the best streaming video mechanisms result in low-resolution, low-frame-rate video, in part because the motion of first-person mobile video (e.g., via a head-mounted camera) decimates temporal (inter-frame) compression. We introduce a visualization technique for displaying low-bit-rate first-person video that maintains the benefits of high resolution, while minimizing the problems typically associated with low frame rates. This technique has the unexpected benefit of eliminating the "Blaire Witch Project" effect-the nausea-inducing jumpiness typical of first-person video. We explore the features and benefits of the technique through both a field study involving hazardous waste disposal and a lab study of side-by-side comparisons with alternate methods. The technique was praised as a possible command center tool, and some of the participants in the lab study preferred our low-bitrate encoding technique to the full-frame, high resolution video that was used as a control

In this demonstration participants will experience the potential for fast, scalable active learning in the classroom using standard web technology. Ubiquitous Presenter (UP) enables students with web-enabled devices (computers, laptops, Tablet PCs, cell phones, PDAs, etc.) to interact in (or outside) class in a range of manners and through a modality of their choosing [2,3]. Their input (via a web browser) is immediately and anonymously transmitted to the instructor machine, where it can be reviewed and selected for display to the class via digital projector. The instructor, using a Tablet PC, can additionally comment on, augment, or correct student input real time in class. These activities, along with instructor designed lecture slides and in-class ink are automatically archived on a web server for review after class by both instructors and students.

Experimentation has shown that in-class educational technologies, by permitting anonymous, authored participation, can dramatically alter student communications in the classroom. Now, the appearance of dual pen-and-keyboard computing devices in the university classroom, notably Tablet PCs, motivates thinking critically about how different expressive modalities could improve in-class student problem -solving and communication.This paper describes the use of Ubiquitous Presenter 2.0 in a study to discover the driving issues of multimodality for both in-class technologies and student exercises. This paper sensitizes instructors to the issues of modality and makes specific recommendations for application design. We find that the choice of modality is not merely one of efficiency or naturalness, but is loaded with numerous personal, social, and material considerations. Although use of the pen (over typed text) is generally preferred, we find that choice itself is critical to encouraging student creativity, collaboration, and communication.

Program understanding can be assisted by tools that match patterns in the program source. Lexical pattern matchers provide excellent performance and ease of use, but have a limited vocabulary. Syntactic matchers provide more precision, but may sacrifice performance, robustness, or power. To achieve more of the benefits of both models, we extend the pattern syntax of AWK to support matching of abstract syntax trees, as demonstrated in a tool called TAWK. Its pattern syntax is language-independent, based on abstract tree patterns. As in AWK, patterns can have associated actions, which in TAWK are written in C for generality, familiarity, and performance. The use of C is simplified by high-level libraries and dynamic linking. To allow processing of program files containing non-syntactic constructs such as textual macros, mechanisms have been designed that allow matching of ‘language-like’ macros in a syntactic fashion. We survey and apply prototypical approaches to concretely demonstrate the tradeoffs in program processing. Our results indicate that TAWK can be used to quickly and easily perform a variety of common software engineering tasks, and the extensions to accommodate non-syntactic features significantly extend the generality of syntactic matchers. Copyright © 2005 John Wiley & Sons, Ltd.

THE 27th International Conference on Software Engineering (ICSE '05) was held in St. Louis, Missouri, 15-21 May 2005. Of the 313 papers submitted to the conference, 44 were published in the conference proceedings, and, of those, four of the best were selected and invited for revision and extension. The papers cover four diverse topics but share rigorous technical presentations of novel work, substantially validated or evaluated. The papers are briefly summarized.

At the heart of the ICSE-2005 program are the 44 research papers selected by the Program Committee (PC) from the 313 submissions to the conference. All submissions were rigorously reviewed by the PC -- each submission received reviews from at least three different PC members. The PC then met on 5-6 November 2004 in Newport Beach, California, USA, to discuss the submissions and make the final selections for the program. Each of the papers selected for publication in the proceedings and presentation at the conference was chosen on its own merits and without comparison to any others.The papers selected cover a wide range of research areas, which are not always amenable to a simple classification. Nevertheless, the papers are clustered into sessions that broadly represent the dominant research themes of the work described.The PC comprised 43 members drawn from a wide cross section of the software engineering community. The PC members worked hard to put the program of research papers together. Each PC member received an average of 22 papers to review prior to the PC meeting, followed by a substantial e-mail conversation and two full days discussing papers at the PC meeting. It was our pleasure and privilege to work with such a professional group of people to produce the quality of the program before you. Our deepest thanks go to the PC.We must also thank the organizers of SIGSOFT FSE 2005, who generously hosted our PC meeting and assisted in numerous local arrangements. In particular, we thank Dick Taylor, Debra Brodbeck, and Susan Knight. Their help in producing a trouble-free, enjoyable PC meeting helped keep the PC's spirits high through two long days.We would be remiss if we did not lavish praise and thanks on Richard van de Stadt and the CyberChair conference management system. CyberChair streamlined many of the PC's activities, and Richard added several new features to CyberChair that saved us days of work in staging the PC meeting.Finally, we thank our General Chair, Catalin Roman, for bringing us together, making us partners in creating ICSE 2005, and giving us the guidance and freedom we needed to create the best possible research program. In doing so, he has given us one of the most rewarding experiences of our professional lives.

Realityflythrough is a telepresence/tele-reality system that works in the dynamic, uncalibrated environments typically associated with ubiquitous computing. By harnessing networked mobile video cameras, it allows a user to remotely and immersively explore a physical space. RealityFlythrough creates the illusion of complete live camera coverage in a physical environment. This paper describes the architecture of RealityFlythrough, and evaluates it along three dimensions: (1) its support of the abstractions for infinite camera coverage, (2) its scalability, and (3) its robustness to changing user requirements.

The University of Washington's Classroom Presenter lecturing system enables an active lecturing environment by combining a standard electronic slide presentation format with the capability for extemporaneous ink annotations by instructors and students using Tablet PCs. Thus, it can promote more interactive, student-centered learning. While many students may own laptops, few are yet Tablet devices. Also, Presenter uses multicast networking, which has availability and reliability issues. Ubiquitous Presenter (UP) expands Presenter via common web technologies to support non-Tablet audiences and enhance student control. UP enables students, using internet web browsers, to (a) synchronously or asynchronously view the slides and ink that are broadcast by the instructor, as well as (b) provide contextual submissions via text overlaid on the instructor's slides. The only compromises are that non-Tablet students cannot produce ink, and that professor ink is provided after a small time delay.

The growing popularity of aspect-oriented languages, such as AspectJ, and of corresponding design approaches, makes it important to learn how best to modularize programs in which aspect-oriented composition mechanisms are used. We contribute an approach to information hiding modularity in programs that use quantified advising as a module composition mechanism. Our approach rests on a new kind of interface: one that abstracts a crosscutting behavior, decouples the design of code that advises such a behavior from the design of the code to be advised, and that can stipulate behavioral contracts. Our interfaces establish design rules that govern how specific points in program execution are exposed through a given join point model and how conforming code on either side should behave. In a case study of the HyperCast overlay network middleware system, including a real options analysis, we compare the widely cited oblivious design approach with our own, showing significant weaknesses in the former and benefits in the latter.

There are a variety of digital tools for enabling people who are separated by time and space to communicate and collaborate on shared interests and tasks. The widespread use of some of these tools, such as instant messaging and group chat, coupled with the increasingly widespread availability of wireless access to the Internet (WiFi), have created new opportunities for using these collaboration tools by people sharing physical spaces in real time. The use of these tools to augment face-to-face meetings has created benefits for some participants and distractions-and detractions-for others. Our panelists will discuss some of the advantages and disadvantages of these emerging uses of collaborative tools.

One way to improve inferences on sensor data is to tune the algorithms through a time-consuming offline procedure. A less expensive and potentially more accurate method is to use an online procedure based on feedback from users, who often know best what the data means to them. We present a method for user-assisted location inference based on 802.11b wireless signal strengths. A user 'corrects' system geolocations by clicking on a map, recording a 'virtual access point' (VAP) at the selected point for future inferences. A best VAP is selected using simple criteria, including the VAP's creator. This permit using other's VAPs while getting their own if one exists, capturing user-specific behavior. The system is also self-maintaining with respect to changing access point deployments. Indoor experiments show very good accuracy for this simple method.

Ubiquitous context-aware computing systems present several challenges in their construction. Principal among them is the tradeoff between easily providing new context-aware services to users and the tight integration of those services, as demanded by the small form factor of the devices typically found in ubiquitous computing environments. Performance issues further complicate the management of this tradeoff. Mechanisms have been proposed and toolkits developed for aiding the construction of context-aware systems, but there has been little consideration of how to specialize, organize, and compose these mechanisms to meet the above requirements. We motivate and describe a software architecture that provides the desired integration and extensibility of services in a context-aware application infrastructure. A key result is the fissioning of intuitive class organizations, both across layers and within layers, to achieve the required integration of services and separation of concerns.

A compiler course with a long-term project is a staple of many undergraduate computer science curricula, and often a cornerstone of a program's applied-engineering component. Software engineering expertise can help a student complete such a course, yet that expertise is often lacking. This problem can be addressed without detracting from the core class materials by integrating a few simple software engineering practices into the course. A domain-specific, risk-driven approach minimizes overhead and reinforces the compiler's material, while treating the project as a "real world" enterprise reinforces key engineering lessons. The method might be called "syntax-directed software engineering," being driven by specification centered around a BNF-style grammar. Engineering lessons are reinforced with general engineering principles and contextualization of the subject matter. The approach can be taught without substantial software engineering background. The domain-specific risk-driven software engineering approach can be applied in other courses such as operating systems by redesigning the practices around its domain.

Software maintenance and evolution are the dominant activities in the software lifecycle. Modularization can separate design decisions and allow them to be independently revolved, but modularization often breaks down and complicated global changes are required. Tool support can reduce the costs of these unfortunate changes, but current tools are limited in their ability to manage information for large-scale software evolution. We argue that the map metaphor can serve as an organizing principle for the design of effective tools for performing global software changes. We describe the design of Aspect Browser, developed around the map metaphor, and discuss a case study of removing a feature from a 500000 line program written in Fortran and C.

Many software engineering tools such as program slicers must perform data-flow analysis in order to extract necessary information from the program source. These tools typically borrow much of their implementation from optimizing compilers. However, since these tools are expected to analyze programs in their entirety, rather than functions in isolation, the time and space performance of the dataflow analyses are of major concern. We present techniques that reduce the time and space required to perform dataflow analysis of large programs. We have used these techniques to implement an efficient program slicing tool for C programs and have computed slices of programs with more than 100,000 lines of code.

Program refactoring-transforming a program to improve readability, structure, performance, abstraction, maintainability, or other features-is not applied in practice as much as might be desired. One deterrent is the cost of detecting candidates for refactoring and of choosing the appropriate refactoring transformation. This paper demonstrates the feasibility of automatically finding places in the program that are candidates for specific refactorings. The approach uses program invariants: when a particular pattern of invariant relationships appears at a program point, a specific refactoring is applicable. Since most programs lack explicit invariants, an invariant detection tool called Daikon is used to infer the required invariants. We developed an invariant pattern matcher for several common refactorings and applied it to an existing Java code base. Numerous refactorings were detected, and one of the developers of the code base assessed their efficacy.

Much progress has been made in the precision and performance of program slicers, but many challenges remain, such as cost-effective implementation and finding a role for slicing in software development.

The concept of information hiding modularity is a cornerstone of modern software design thought, but its formulation remains casual and its emphasis on changeability is imperfectly related to the goal of creating added value in a given context. We need better explanatory and prescriptive models of the nature and value of information hiding. We evaluate the potential of a new theory---developed to account for the influence of modularity on the evolution of the computer industry---to inform software design. The theory uses design structure matrices to model designs and real options techniques to value them. To test the potential utility of the theory for software we apply it to Parnas's KWIC designs. We contribute an extension to design structure matrices, and we show that the options results are consistent with Parnas's conclusions. Our results suggest that such a theory does have potential to help inform software design.

Explicitly stated program invariants can help programmers by identifying program properties that must be preserved when modifying code. In practice, however, these invariants are usually implicit. An alternative to expecting programmers to fully annotate code with invariants is to automatically infer likely invariants from the program itself. This research focuses on dynamic techniques for discovering invariants from execution traces. This article reports three results. First, it describes techniques for dynamically discovering invariants, along with an implementation, named Daikon, that embodies these techniques. Second, it reports on the application of Daikon to two sets of target programs. In programs from Gries's work (1981) on program derivation, the system rediscovered predefined invariants. In a C program lacking explicit invariants, the system discovered invariants that assisted a software evolution task. These experiments demonstrate that, at least for small programs, invariant inference is both accurate and useful. Third, it analyzes scalability issues, such as invariant detection runtime and accuracy, as functions of test suites and program points instrumented.

Explicitly stated program invariants can help programmers by characterizing certain aspects of program execution and identifying program properties that must be preserved when modifying code. Unfortunately, these invariants are usually absent from code. Previous work showed how to dynamically detect invariants from program traces by looking for patterns in and relationships among variable values. A prototype implementation, Daikon, accurately recovered invariants from formally-specified programs, and the invariants it detected in other programs assisted programmers in a software evolution task. However, Daikon suffered from reporting too many invariants, many of which were not useful, and also failed to report some desired invariants.

Interactive program analysis tools are often tailored to one particular representation of programs, making adaptation to a new language costly. One way to ease adaptability is to introduce an intermediate abstraction—an adaptation layer—between an existing language representation and the program analysis tool. This adaptation layer translates the tool's queries into queries on the particular representation.

Article Free Access Share on Dynamically discovering likely program invariants to support program evolution Authors: Michael D. Ernst Dept. of Computer Science & Engineering, University of Washington, Box 352350, Seattle WA Dept. of Computer Science & Engineering, University of Washington, Box 352350, Seattle WAView Profile , Jake Cockrell Dept. of Computer Science & Engineering, University of Washington, Box 352350, Seattle WA Dept. of Computer Science & Engineering, University of Washington, Box 352350, Seattle WAView Profile , William G. Griswold Dept. of Computer Science & Engineering, University of California San Diego, 0114, La Jolla, CA Dept. of Computer Science & Engineering, University of California San Diego, 0114, La Jolla, CAView Profile , David Notkin Dept. of Computer Science & Engineering, University of Washington, Box 352350, Seattle WA Dept. of Computer Science & Engineering, University of Washington, Box 352350, Seattle WAView Profile Authors Info & Claims ICSE '99: Proceedings of the 21st international conference on Software engineeringMay 1999 Pages 213–224https://doi.org/10.1145/302405.302467Published:16 May 1999Publication History 249citation1,521DownloadsMetricsTotal Citations249Total Downloads1,521Last 12 Months208Last 6 weeks71 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Understanding large software systems is difficult. Traditionally, automated tools are used to assist program understanding. However, the representations constructed by these tools often require prohibitive time and space. Demand-driven techniques can be used to reduce these requirements. However, the use of pointers in modern languages introduces additional problems that do not integrate well with these techniques. We present new techniques for effectively coping with pointers in large software systems written in the C programming language and use our techniques to implement a program slicing tool.First, we use a fast, flow-insensitive, points-to analysis before traditional data-flow analysis. Second, we allow the user to parameterize the points-to analysis so that the resulting program slices more closely match the actual program behavior. Such information cannot easily be obtained by the tool or might otherwise be deemed unsafe. Finally, we present data-flow equations for dealing with pointers to local variables in recursive programs. These equations allow the user to select an arbitrary amount of calling context in order to better trade performance for precision.To validate our techniques, we present empirical results using our program slicer on large programs. The results indicate that cost-effective analysis of large programs with pointers is feasible using our techniques.

With a meaning-preserving restructuring tool, a software engineer can change a program's structure to ease future modifications. However, deciding how to restructure the program requires a global understanding of the program's structure, which cannot be derived easily by directly inspecting the source code. We describe a manipulable program visualization—thestar diagram—that supports the restructuring task of encapsulating a global data structure. The star diagram graphically displays information pertinent to encapsulation, and direct manipulation of the diagram causes the underlying program to be restructured. The visualization compactly presents all statements in the program that use the given global data structure, helping the programmer to choose the functions that completely encapsulate it. Additionally, the visualization elides code unrelated to the data structure and to the task and collapses similar expressions to help the programmer identify frequently occurring code fragments and manipulate them together. The visualization is mapped directly to the program text, so manipulation of the visualization also restructures the program. We present the star diagram concept and describe an implementation of the star diagram built upon a meaning-preserving restructuring tool for Scheme. We also describe our creation of star diagram generators for C programs, and we test the scalability of the star diagram using large C and MUMPS programs.

Informally, a call graph represents calls between entities in a given program. The call graphs that compilers compute to determine the applicability of an optimization must typically be conservative: a call may be omitted only if it can never occur in any execution of the program. Numerous software engineering tools also extract call graphs with the expectation that they will help software engineers increase their understanding of a program. The requirements placed on software engineering tools that compute call graphs are typically more relaxed than for compilers. For example, some false negatives—calls that can in fact take place in some execution of the program, but which are omitted from the call graph—may be acceptable, depending on the understanding task at hand. In this article, we empirically show a consequence of this spectrum of requirements by comparing the C call graphs extracted from three software systems (mapmaker, mosaic, and gcc) by nine tools (cflow, cawk, CIA, Field, GCT, Imagix, LSME, Mawk, and Rigiparse). A quantitative analysis of the call graphs extracted for each system shows considerable variation, a result that is counterintuitive to many experienced software engineers. A qualitative analysis of these results reveals a number of reasons for this variation: differing treatments of macros, function pointers, input formats, etc. The fundamental problem is not that variances among the graphs extracted by different tools exist, but that software engineers have little sense of the dimensions of approximation in any particular call graph. In this article, we describe and discuss the study, sketch a design space for static call graph extractors, and discuss the impact of our study on practitioners, tool developers, and researchers. Although this article considers only one kind of information, call graphs, many of the observations also apply to static extractors of other kinds of information, such as inheritance structures, file dependences, and references to global variables.

In parallel programming, the need to manage communication, load imbalance, and irregularities in the computation puts substantial demands on the programmer. Key properties of the architecture, such as the number of processors and the cost of communication, must be exploited to achieve good performance, but coding these properties directly into a program compromises the portability and flexibility of the code because significant changes are then needed to port or enhance the program. We describe a parallel programming model that supports the concise, independent description of key aspects of a parallel program-including data distribution, communication, and boundary conditions-without reference to machine idiosyncrasies. The independence of such components improves portability by allowing the components of a program to be tuned independently, and encourages reuse by supporting the composition of existing components. The isolation of architecture-sensitive aspects of a computation simplifies the task of porting programs to new platforms. Moreover, the model is effective in exploiting both data parallelism and functional parallelism. This paper provides programming examples, compares this work to related languages, and presents performance results.

Restructuring software to improve its design can lower software maintenance costs. One problem encountered during restructuring is formulating the new design. A meaning-preserving program restructuring tool with a star diagram manipulable visualization can help a programmer redesign a program based on abstract data types. However, the transformational support required for meaning-preserving restructuring is costly to provide. Also, programmers encounter comprehension and recall difficulties in complex restructuring tasks. Consequently, transformations were replaced with visual and organizational aids that help a programmer to plan and carry out a complex restructuring. For example, a star diagram manipulation called trimming was added, which mimics the way that basic restructuring transformations affect the star diagram display, allowing a programmer to plan a restructuring without depending upon restructuring transformations. With the ability to annotate trimmed star diagram components, plans can be recorded and later recalled. Programmer-controlled elision was added to help remove clutter from star diagram views. We implemented a star diagram planning tool for C programs, measured its elision capabilities, and performed a programmer study. We found that elision is effective in controlling star diagram size, and the study revealed that each programming team successfully planned its restructuring in rather different, unanticipated ways. These experiments resulted in important improvements in the tool's software design and user interface.

Restructuring software to improve its design can lower software maintenance costs. One problem in carrying out such a restructuring is planning the new detailed design. The star diagram manipulable visualization can help a programmer redesign a program based on abstract data types. However, our measurements revealed that the view can be too large for a programmer to effectively assimilate. Also, design plans can be expressed only by restructuring, although our studies revealed that it is beneficial to preplan a restructuring. Finally, the tool user can build a star diagram for only a single data structure, although an abstract data type might actually have several components or have multiple instantiations.Exploiting basic properties of the star diagram can mitigate these problems. First, programmer-controlled elision can remove clutter from the star diagram view. Second, elision and annotation of star diagram components can mimic restructuring, thereby supporting the planning of a restructuring. Such support also allows for the planning of a non-restructuring maintenance task. Finally, to dynamically control what data structures are visualized, the tool user can union star diagrams.We built a star diagram planning tool for C programs, measured its elision capabilities, and performed a programmer study for the encapsulation of a widely-used data structure in a 28,000 line program. We found that the amount of elision can be substantial, but is not always adequate. In the study we found that each programming team successfully planned their restructuring in rather different, unanticipated ways.

Maintaining the consistency of multiple program representations in a program manipulation tool is difficult. I describe a hybrid software architecture for a meaning-preserving program restructuring tool. Layering is the primary architectural paradigm, which successively provides increasingly integrated and unified abstract machines to implement the tool. However, layering does not provide adequate control over extensibility or the independence of components, so I also adopt the paradigm of keeping the key program abstractions separate throughout the layering, providing independent columns of abstract data types. A pair of columns is integrated by a mapping column that translates elements in one column's data type into related elements in the other column's data type. Thus, integration of function and separation of representation can be achieved simultaneously. This hybrid architecture was crucial in overcoming severe performance problems that became apparent once the basic tool was completed. By taking advantage of the independence of the columns and the special characteristics of meaning-preserving restructuring, it was possible to extend one representation column of the architecture to the uppermost layer to provide the required access for efficient updating without compromising independence. The cost of the extended architecture is that the upper layers are no longer as simple because they expose operations that only guarantee consistency under careful usage. However, the structural constraints of the hybrid architecture and the models for building the more complicated layers minimizes the negative impact of this tradeoff.>

A software engineer can use a meaning-preserving program restructuring tool during maintenance to change a program's structure to ease modification. One common restructuring action is to create a new abstract data type by encapsulating an existing data structure. Data encapsulation simplifies modification by isolating changes to the implementation and behavior of an abstract data type. To perform encapsulation, a programmer must understand how the data structure is used in the code, identify abstract operations performed on the data structure, and choose concrete expressions to be made into functions. We provide a manipulable program visualization, called the star diagram, that both highlights information partinent to encapsulation and supports the application of meaning-preserving restructuring transformations on the program through a direct-manipulation user interface. The visualization graphically and compactly presents all statements in the program that use the given global data structure, helping the programmer to choose the functions that completely encapsulate it. Additionally, the visualization elides code unrelated to the data structure and to the task, and collapses similar expressions to allow the programmer to identify frequently occurring code fragments and manipulate them together. The visualization is mapped directly to the program text, so manipulation of the visualization also restructures the program. We describe the design, implementation, and application of the star diagram, and evaluate its ability to assist data encapsulation in large programs.

The paper by E.A.T. Merks et al. (see ibid., vol. 18, p. 19-32, 1992) "Language design for program manipulation" identifies design principles for a procedural or object-oriented language whose programs will be easier to manipulate. However, it neglects to relate these design principles to existing, broader, design principles, and in some instances omits good examples of languages meeting their criteria. The author relates the new principles to more fundamental design principles, and provides the needed examples of languages meeting their criteria. Together these additions can better help designers of new programming languages that are amenable to manipulation.>

Automated assistance for meaning-preserving global restructuring is an approach for helping software engineers improve the structure of programs, thus lowering the costs of maintenance. The consturction of a restructuing tool encounters many conflicting goals---such as simplicity. extensibility, and good performance---that cannot be met without some compromise. In particular, the current technique for assisting restructuring uses a costly program representation---a Program Dependence Graph (PDG) with alias information---that is not practical to recompute from scratch after each restructuring transformation. There are at least two possible solutions. A commonly suggested approach for efficiently updating data flow representations is to use a generic incremental algorithm that does not make use of the special nature of the restructuring. This approach is general, but it does not yet handle aliasing fully. By taking advantage of the special nature of the restructuring transformations it is possible to implement a more efficient update than generic update that also handles aliasing. The idea is to implement direct updates to the PDG that are analogous to the changes on the program text. The downsides to direct update are that it is application-specific, applies only to semantically restricted applications like restructuring, and may be more complex. The choice between the two techniques requires an understanding of the current and future needs of the tool's users.This paper describes the direct approach of updating the PDG and related representations for restructuring, provides techniques for managing its complexity, critiques its advantages and shortcomings relative to generic incremental update, and presents performance results.

Abstract Two key features in the Icon programming language are tables and sets. An Icon program may use one large set or table, or thousands of small ones. To improve space and time performance for these diverse uses, their hashed data structures were reimplemented to dynamically resize during execution, reducing the minimum space requirement and achieving constant‐time access to any element for virtually any size set or table. The implementation is adapted from Per‐Åke Larson's dynamic hashing technique by using well‐known base‐2 arithmetic techniques to decrease the space required for small tables without degrading the performance of large tables. Also presented are techniques to prevent dynamic hashing from interfering with other Icon language features. Performance measurements are included to support the results.

Maintenance tends to degrade the structure of software, ultimately making maintenance more costly. At times, then, it is worthwhile to manipulate the structure of a system to make changes easier. However, manual restructuring is an error-prone and expensive activity. By separating structural manipulations from other maintenance activities, the semantics of a system can be held constant by a tool, assuring that no errors are introduced by restructuring. To allow the maintenance team to focus on the aspects of restructuring and maintenance requiring human judgment, a transformation-based tool can be provided—based on a model that exploits preserving data flow dependence and control flow dependence—to automate the repetitive, error-prone, and computationally demanding aspects of restructuring. A set of automatable transformations is introduced; their impact on structure is described, and their usefulness is demonstrated in examples. A model to aid building meaning-preserving restructuring transformations is described, and its realization in a functioning prototype tool for restructuring Scheme programs is discussed.

It is shown how a communication abstraction called the port ensemble can simplify the handling of boundary conditions and the efficient porting of programs. A port ensemble provides an explicit interface between computation and communication descriptions, thus separating the communication structure from the details of local computation and from the compiler. Port ensembles structure ports, symbolic names to and from which process can write and read values. To simplify the expression of boundary conditions, ports can be bound not only to ports on other processors, but also to nonexistent neighbors (along the edge of the computation) using special objects that represent and implement constants, variables, and arbitrary functions. Port ensembles also provide direct access to the communication structure, which simplifies changing the structure to one appropriate for a new target architecture.>

The ability to extend programs dynamically has clear advantages. However, providing efficient yet sufficiently flexible support for such capabilities system-wide presents significant challenges. We describe a design and implementation of an extension mechanism that depends heavily on interpretive techniques, including call arbitration, dynamic linking, and multilanguage extensions. We discuss these mechanisms in the context of our Extension Interpreter, which embodies our ideas and provides a framework for discussing the efficiency and generality of the implementation. Our current implementation runs under BSD UNIX 4.2 and 4.3 on VAXes and SUN workstations. Extensions can be written in both C and in Icon, demonstrating our ability to address problems both of compiled and interpreted languages.