Programming instructors often conduct collaborative learning activities, such as Peer Instruction (PI), to enhance student motivation, engagement, and learning gains. However, the impact of group discussion and formation mechanisms on student performance remains unclear. To investigate this, we conducted an 11- session experiment in a large, in-person CS1 course. We employed both random and expertise-balanced grouping methods to examine the efficacy of different group mechanisms and the impact of expert students’ presence on collaborative learning. Our observations revealed complex dynamics within the collaborative learning environment. Among 255 groups, 146 actively engaged in discussions, with 96 of these groups demonstrating improvement for poor-performing students. Interestingly, our analysis revealed that different grouping methods (expertise-balanced or random) did not significantly influence discussion engagement or poor-performing students’ improvement. In our deeper qualitative analysis, we found that struggling students often derived benefits from interactions with expert peers, but this positive effect was not consistent across all groups.We identified challenges that expert students face in peer instruction interactions, highlighting the complexity of leveraging expertise within group discussions.

Computer Science programs have seen high enrollments in recent years, which contributed to widening the capacity gap. One way to address this problem is to hire more teaching-focused faculty at both research and non-doctoral granting institutions. Although this kind of hiring has already been taking place in several institutions, PhD-granting CS departments have not been able to produce enough PhDs to meet the increasing demand, especially for PhD holders with interest in - and capacity for - teaching. In this paper, we describe our experience with the initial phase of building a training program within our (large, land grant, R1) institution, targeting graduate students interested in pursuing an academic teaching-focused career in CS. Through a semester-long set of meetings, conversations, and activities, we worked with participants on improving their teaching skills and applying effective pedagogies in the classroom. At the end of the semester, we surveyed participants about the value of those meetings to them, ideas for improvement, and perspectives for future directions. Most participants rated the meetings positively in terms of content relevance and usefulness, and the opportunity to connect and interact with other participants and invited faculty members. We also discuss the lessons learned and best practices, which can be widely applied by other departments looking to better prepare their graduate students for a CS teaching-focused faculty position.

The content in Formal Languages courses is mathematical in nature, and requires students to engage with proofs and algorithms to grasp core concepts. Conventional textbooks on Formal Languages predominantly employ textual explanations, with assignments often entailing manual problem solving. Some educators incorporate tools like JFLAP, which helps students construct models and apply algorithms to enhance interaction with the subject matter. However, students must put considerable effort into reading and solving problems manually to reach comprehension. Drawing inspiration from the Programmed Instruction (PI) teaching methodology, we have developed an innovative eTextbook for Formal Languages that facilitates better understanding of these ideas. The PI approach requires students to read a bit, ideally a sentence or paragraph, and then answer a question or complete an exercise related to that information. Depending on their response, students can progress to subsequent information frames or re-attempt the exercise. Our objective is to present the entirety of a Formal Languages curriculum through the PI approach. To evaluate the pedagogical effectiveness of our new eTextbook, we conducted a survey to ask students for their feedback on their experience with the Programmed Instruction etextbook. We also conducted performance evaluations on two offerings of the Formal Languages course. Students' grades are compared to assess learning gains between visualizations with exercises, and with PI frames. The evaluation shows that the Programmed Instruction ebook improved students' grades in almost all topics covered by the ebook.

Many SIGCSE attendees are either developing or using online educational tools, and all will benefit from better interoperability among these tools and better analysis of the clickstream data coming from those tools. New tools for analyzing big data leveraged by AI (e.g., deep learning for assessment) in turn improve both content and pedagogy, thus setting up a virtuous cycle fueling learning discoveries and leveraging innovation in AI: Online technologies → big data analysis → better online technologies. This NSF-supported workshop is the latest in a series of SPLICE workshops, and is a continuation of our event at SIGCSE 2023, where the SPLICE-Portal, a dedicated socio-technical research infrastructure for Computing Education Research, was presented. This year, we continue the work with several new SPLICE community working groups, including those on Dashboards, Large Language Models, Parsons Problems, and Smart Learning Content Protocols. We continue to build upon our existing collaborations developed over the course of the project to engage more members of the community in tasks that will advance the project agenda.

COVID-19 caused universities to switch from traditional face-to-face (F2F) course delivery to completely online in Spring 2020. This transition took place on short notice in the middle of the semester. We present results from surveys of students in two CS courses offered at Virginia Tech. Results indicate differing perceptions in the two courses regarding the usefulness of course components before and after the transition for each course. A logistic regression model indicates that for each course, different course components both before and after the transition significantly affect students' preferences for course modality.

Students often skip through instructional material without paying enough attention to the content, resulting in less understanding. Inspired by the Programmed Instruction (PI) technique, we implemented extensions to an eTextbook system to support instructional slideshows with a large number of interspersed questions. Students must answer a question correctly to pass to the next slide. This completely changes how students interact with the material. Our initial results show a significant increase in students' grades when they used PI for a Formal Languages course.

The material taught in a Formal Languages and Automata (FLA) course is mathematical in nature and requires students to practice proofs and algorithms to understand the content. Traditional FLA textbooks are heavy on prose, and homework typically consists of solving many paper exercises. Instructors often make use of Finite State Machine simulators like the JFLAP package. JFLAP allows students to interactively build models and apply different algorithms to these models, providing both a more interactive and a more visual approach. However, course materials have still traditionally relied largely on prose and hand-graded exercises, limiting both the interaction and the amount of practice. In this paper, we propose an eTextbook with integrated tools (simulators and auto-graded exercises) that allow for greater interactivity and levels of engagement. To evaluate the pedagogical effectiveness of our approach, we conducted performance evaluations across different offerings of an FLA course. Results indicate that students using the integrated eTextbook performed better than did a control group using a traditional textbook approach. Students gave positive feedback regarding the usefulness of the auto-graded exercises for practicing different FLA concepts.

When faced with a large and complex project for the first time, students face numerous self-regulatory challenges that they may be ill-equipped to overcome. These challenges can result in degraded project outcomes, as commonly observed in programming-intensive mid-level CS courses. We have previously found that success in these situations is associated with a disciplined personal software process. Procrastination is a prominent failure of self-regulation that can occur for a number of reasons, e.g., low expectancy of success, low perceived value of the task at hand, or decision-paralysis regarding how to begin when faced with a large task. It is pervasive, but may be addressed through targeted interventions. We draw on theory related to goal theory and problem-solving in engineering education to evaluate the value of explicit project milestones at curbing procrastination and its negative impacts on relatively long-running software projects. We conduct a quasi-experiment in which we study differences in project and course outcomes between students in a treatment (with milestones) and control group (without milestones). We found that students in the treatment group were more likely to finish their projects on time, produced projects with higher correctness, and finished the course with generally better outcomes. Within the treatment group, we found that students who completed more milestones saw better outcomes than those who completed fewer milestones. We found no differences in withdrawal or failure rates between the treatment and control groups. An end-of-term survey indicated that student perceptions of the milestones were overwhelmingly positive.

As incorporating software testing into programming assignments becomes routine, educators have begun to assess not only the correctness of students’ software, but also the adequacy of their tests. In practice, educators rely on code coverage measures, though its shortcomings are widely known. Mutation analysis is a stronger measure of test adequacy, but it is too costly to be applied beyond the small programs developed in introductory programming courses. We demonstrate how to adapt mutation analysis to provide rapid automated feedback on software tests for complex projects in large programming courses. We study a dataset of 1389 student software projects ranging from trivial to complex. We begin by showing that although the state-of-the-art in mutation analysis is practical for providing rapid feedback on projects in introductory courses, it is prohibitively expensive for the more complex projects in subsequent courses. To reduce this cost, we use a statistical procedure to select a subset of mutation operators that maintains accuracy while minimizing cost. We show that with only 2 operators, costs can be reduced by a factor of 2–3 with negligible loss in accuracy. Finally, we evaluate our approach on open-source software and report that our findings may generalize beyond our educational context.

Jupyter Notebooks are becoming more widely used, both for data science applications and as a convenient environment for learning Python. Currently, grading of assignments done in Jupyter Notebooks is typically done manually. Manual grading results in students receiving feedback only long after the assignment is complete. We implemented support for auto-grading programs written in Jupyter Notebooks within the Web-CAT auto-grading system. Scores received are directly reported to the Canvas gradebook. A Jupyter notebook extension allows students to upload their notebook files to Web-CAT directly. Survey results from class use show that 80% of students believe that getting immediate feedback from Web-CAT improved their performance. Instructors report that this implementation has significantly reduced their workload.

The SIGCSE-Members listserv has been archiving posts by the Computer Science Education community for the past 22 years. This paper characterizes the post collection, in order to better understand the nature of the community from a quantitative perspective. We apply a number of email mining techniques, including a topical analysis through N-grams. Threads, posters, and posts are characterized in terms of duration and temporally. We also demonstrate how emails from the listserv can be successfully classified using machine learning algorithms, and report on an unsuccessful attempt to predict thread popularity. All of the scripts we used to collect, process, and analyze the data are freely available in the hopes that other researchers will replicate, refine, and extend our results.

We share approaches for coordinating the use of many online educational tools within a CS2 course, including an eTextbook, automated grading system, programming practice website, diagramming tool, and debugger. These work with other commonly used tools such as a response system, forum, version control system, and our learning management system. We describe a number of approaches to deal with the potential negative effects of adopting so many tools. To improve student success we scaffold tool use by staging the addition of tools and by introducing individual tools in phases, we test tool assignments before student use, and we adapt tool use based on student feedback and performance. We streamline course management by consulting mentors who have used the tools before, starting small with room to grow, and choosing tools that simplify student account and grade management across multiple tools.

Debugging is an important part of the software development process, studied by both the CS education and software engineering communities. Most prior work has focused either on novice or professional programmers. Intermediate-to-advanced students (such as those enrolled in post-CS2 Data Structures courses) who are working on large and complex projects have largely been ignored. We present results from an empirical observational study that examined junior-level undergraduate students' debugging practices on relatively large (4-week lifecycle) projects, using IDE clickstream data collected by a custom Eclipse plugin. Specifically, we hypothesize that there are differing debugging behaviors exhibited, and that differing behaviors lead to differing project out-comes. For example, how often do students use the symbolic debugger available in modern IDEs, versus how often do they use diagnostic print statements, or both? What triggers a debugging session? What follows a debugging session? Does it matter when in the project lifecycle that debugging takes place? We have a number of interesting preliminary results. When using the debugger, there was a negative relationship between step-over and step-into actions versus final course grades, indicating that when students "spin their wheels" while debugging, they tend to perform more poorly. Students also tend to perform better on the project when debugging takes place earlier in the overall project life-cycle. We developed an algorithm to identify diagnostic print statements in the students' projects. We found that over 90% used at least one diagnostic print statement, and about 75% used the symbolic debugger, at least once in any given project.

Software testing is an important aspect of the development process, one that has proven to be a challenge to formally introduce into the typical undergraduate CS curriculum. Unfortunately, existing assessment of testing in student software projects tends to focus on evaluation of metrics like code coverage over the finished software product, thus eliminating the possibility of giving students early feedback as they work on the project. Furthermore, assessing and teaching the process of writing and executing software tests is also important, as shown by the multiple variants proposed and disseminated by the software engineering community, e.g., test-driven development (TDD) or incremental test-last (ITL). We present a family of novel metrics for assessment of testing practices for increments of software development work, thus allowing early feedback before the software project is finished. Our metrics measure the balance and sequence of effort spent writing software tests in a work increment. We performed an empirical study using our metrics to evaluate the test-writing practices of 157 advanced undergraduate students, and their relationships with project outcomes over multiple projects for a whole semester. We found that projects where more testing effort was spent per work session tended to be more semantically correct and have higher code coverage. The percentage of method-specific testing effort spent before production code did not contribute to semantic correctness, and had a negative relationship with code coverage. These novel metrics will enable educators to give students early, incremental feedback about their testing practices as they work on their software projects.

The material taught in a Formal languages course is mathematical in nature and requires students to practice proofs and algorithms to understand the content. Traditional Formal Languages textbooks are heavy on prose rather than visuals, and homework consists of solving many paper exercises. Some instructors make use of Finite State Machine simulators like JFLAP. JFLAP allows students to build different models and apply algorithms on these models, which improves student interaction with the material. However, students still need to read a significant amount of text without direct and immediate feedback on their understanding. Inspired by the Programmed Instruction (PI) teaching method, we have begun developing a new Formal Languages eText-book capable of conveying these concepts more intuitively (through visualizations) and more interactively (through the use of PI methods). Under PI methods, students read a little, ideally a sentence or a paragraph, and then answer a question related to that information. Based on the question response, students can go further and complete other frames of information or retry to solve the same question. To evaluate the pedagogical effectiveness of our new eTextbook, we will conduct time and performance evaluations across two offerings of a Formal Languages course. We will compare the time spent by students using materials with text and exercises only, with text and visualizations, and with the PI frames to determine levels of students engagement. Students grades will be compared to assess learning gains.

Recursion is one of the most important and hardest topics in lower division computer science courses. As it is an advanced programming skill, the best way to learn it is through targeted practice exercises. But the best practice problems are time consuming to manually grade by an instructor. As a consequence, students historically have completed only a small number of recursion programming exercises as part of their coursework. We present a new way for teaching such programming skills. Students view examples and visualizations, then practice a wide variety of automatically assessed, small-scale programming exercises that address the sub-skills required to learn recursion. The basic recursion tutorial (RecurTutor) teaches material typically encountered in CS2 courses. Students who used RecurTutor had significantly better grades on recursion exam questions than did students who used typical instruction. Students who experienced RecurTutor spent significantly more time on solving recursive programming exercises than students who experienced typical instruction, and came out with a significantly higher confidence level.

Parameter estimation in discrete or continuous deterministic cell cycle models is challenging for several reasons, including the nature of what can be observed, and the accuracy and quantity of those observations. The challenge is even greater for stochastic models, where the number of simulations and amount of empirical data must be even larger to obtain statistically valid parameter estimates. The two main contributions of this work are (1) stochastic model parameter estimation based on directly matching multivariate probability distributions, and (2) a new quasi-Newton algorithm class QNSTOP for stochastic optimization problems. QNSTOP directly uses the random objective function value samples rather than creating ensemble statistics. QNSTOP is used here to directly match empirical and simulated joint probability distributions rather than matching summary statistics. Results are given for a current state-of-the-art stochastic cell cycle model of budding yeast, whose predictions match well some summary statistics and one-dimensional distributions from empirical data, but do not match well the empirical joint distributions. The nature of the mismatch provides insight into the weakness in the stochastic model.

Data science keeps growing in popularity as an introductory computing experience, in which students answer real-world questions by processing data. Armed with carefully prepared pedagogical datasets, computing educators can contextualize assignments and projects in societally meaningful ways, thereby benefiting students' long-term professional careers. However, integrating data science into introductory computing courses requires that the datasets be sufficiently complex, follow appropriate organizational structure, and possess ample documentation. Moreover, the impact of a data science context on students' motivation remains poorly understood. To address these issues, we have created an open-sourced manual for developing pedagogical datasets (freely available at https://think.cs.vt.edu/pragmatics). Structured as a collection of patterns, this manual shares the expertise that we have gained over the last several years, collecting and curating a large collection of real-world datasets, used in a dozen of universities worldwide. We also present new evidence confirming the efficacy of integrating data science in an introductory computing course. As a significant extension of our ongoing work, this study not only validates existing positive assessment, but also provides fine-grained nuance to the potential of data science as a motivational educational element.

Understanding basic manipulation of object references is a conceptual prerequisite to understanding many data structures, beginning with linked lists and trees. Unfortunately, there is often a gap between introductory programming courses that introduce reference variables and creation of objects, and second-semester programming courses that immediately skip to introducing linked lists. As a consequence, students begin using references extensively during Data Structures and Algorithms courses without enough knowledge about how references work. To fill this gap, we created a tutorial about basic use of references and the manipulation of objects using references. The tutorial, implemented as part of the OpenDSA eTextbook system, focuses on learning through visualizations and interactive exercises. Students work a series of small code-writing exercises, inspired by the JhavePOP system. These exercises use simple program visualization to let students see the result of running their program. Manipulative exercises test student proficiency at reading and understanding small sections of code that use references to link objects. All exercises are automatically assessed, providing immediate feedback. Our evaluation of the tutorial's effectiveness will focus on identifying and correcting student misconceptions. Optional sections of the tutorial introduce the program stack and the dynamic memory heap.

CS Education makes heavy use of online educational tools like IDEs, Learning Management Systems, eTextbooks, interactive programming environments, and other smart content. Instructors and students would benefit from greater interoperability between tools. CS Ed researchers increasingly make use of the large collections of data generated by click streams coming from them. However, we all face barriers that slow progress: (1) Educational tools do not integrate well. (2) Information about CS learning process and outcome data generated by one system is not compatible with that from other systems. (3) CS problem solving and learning (e.g., coding solutions) is different from the type of data (discrete answers to questions or verbal responses) that current educational data mining focuses on. This BOF will discuss ways that we might support and better coordinate efforts to build community and capacity among CS Ed researchers, data scientists, and learning scientists toward reducing these barriers. CS Ed infrastructure should support broader re-use of innovative learning content that is instrumented for rich data collection, formats and tools for analysis of learner data, and best practices to make large collections of learner data available to researchers. Achieving these goals requires engaging a large community of researchers to define, develop, and use critical elements of this infrastructure to address specific data-intensive research questions.

We present quantitative analyses performed on character-level program edit and execution data, collected in a junior-level data structures and algorithms course. The goal of this research is to determine whether proposed measures of student behaviors such as incremental development and procrastination during their program development process are significantly related to the correctness of final solutions, the time when work is completed, or the total time spent working on a solution. A dataset of 6.3 million fine-grained events collected from each student's local Eclipse environment is analyzed, including the edits made and events such as running the program or executing software tests. We examine four primary metrics proposed as part of previous work, and also examine variants and refinements that may be more effective. We quantify behaviors such as working early and often, frequency of program and test executions, and incremental writing of software tests. Projects where the author had an earlier mean time of edits were more likely to submit their projects earlier and to earn higher scores for correctness. Similarly earlier median time of edits to software tests was also associated with higher correctness scores. No significant relationships were found with incremental test writing or incremental checking of work using either interactive program launches or running of software tests, contrary to expectations. A preliminary prediction model with 69% accuracy suggests that the underlying metrics may support early prediction of student success on projects. Such metrics also can be used to give targeted feedback to help students improve their development practices.

Good project management practices are hard to teach, and hard for novices to learn. Procrastination and bad project management practice occur frequently, and may interfere with successfully completing major programming projects in mid-level programming courses. Students often see these as abstract concepts that do not need to be actively applied in practice. Changing student behavior requires changing how this material is taught, and more importantly, changing how learning and practice are assessed. To provide proper assessment, we need to collect detailed data about how each student conducts their project development as they work on solutions. We present DevEventTracker, a system that continuously collects data from the Eclipse IDE as students program, giving us in-depth insight into students' programming habits. We report on data collected using DevEventTracker over the course of four programming projects involving 370 students in five sections of a Data Structures and Algorithms course over two semesters. These data support a new measure for how well students apply "incremental development" practices. We present a detailed description of the system, our methodology, and an initial evaluation of our ability to accurately assess incremental development on the part of the students. The goal is to help students improve their programming habits, with an emphasis on incremental development and time management.

To successfully bring introductory computing to non-CS majors, one needs to create a curriculum that will appeal to students from diverse disciplines. Several educational theories emphasize the need for introductory contexts that align with students' long-term goals and are perceived as useful. Data Science, using algorithms to manipulate real-world data and interpreting the results, has emerged as a field with cross-disciplinary value, and has strong potential as an appealing context for introductory computing courses. However, it is not easy to find, clean, and integrate datasets that will satisfy a broad variety of learners. The CORGIS project (https://think.cs.vt.edu/corgis) enables instructors to easily incorporate data science into their classroom. Specifically, it provides over 40 datasets in areas including history, politics, medicine, and education. Additionally, the CORGIS infrastructure supports the integration of new datasets with simple libraries for Java, Python, and Racket, thus empowering introductory students to write programs that manipulate real data. Finally, the CORGIS web-based tools allow learners to visualize and explore datasets without programming, enabling data science lessons on day one. We have incorporated CORGIS assignments into an introductory course for non-majors to study their impact on learners' motivation, with positive initial results. These results indicate that external adopters are likely to find the CORGIS tools and materials useful in their own pedagogical pursuits.

We present initial results from our work towards developing a concept inventory for algorithm analysis (AACI) at the post-CS2 level. We used a Delphi process to identify a list of algorithm analysis topics that were considered both important and hard by surveying a panel of experienced instructors. Through a similar survey process, we identified a list of student misconceptions related to the identified topics. Based on this, a set of pilot AACI items were developed. We validated the misconceptions list by analyzing student responses to four administrations of the pilot AACI in two different universities during Fall 2015 and Spring 2016. Results revealed that a sufficient number of students held most of the misconceptions identified in the list.

Algorithm Visualizations (AVs) have been used for years as an interactive method to convey data structures and algorithms concepts. However, AVs have traditionally focused on illustrating the mechanics of how an algorithm works. We have developed visualizations that we name Algorithm Analysis Visualizations (AAVs), that focus on conveying algorithm analysis concepts. We present our findings from an initial evaluation study of the effectiveness of AAVs when applied to a semester long Data Structures course. AAVs were evaluated in terms of student engagement, student satisfaction, and student performance. Results indicate that the intervention group students spent significantly more time with the AAVs than did the control group students who used primarily textual content. Students gave positive feedback regarding the usefulness of the AAVs in illustrating algorithm analysis concepts. Students from the intervention group had better performance on the algorithm analysis part of the final exam than did control group students.

A key retention issue when educating computing novices is ensuring that the frustrations of mastering programming fundamentals do not demotivate and discourage students from studying the discipline. In particular, non-CS majors often struggle to find relevance in traditional computing curricula that tend to either emphasize abstract concepts, focus on non-practical entertainment (e.g., game and animation design), or rely on decontextualized settings. To address these issues, this paper introduces BlockPy, a block-based environment for Python (http://www.blockpy.com). BlockPy is a web-based, open-access programming environment that supports introductory programming with an emphasis on data science. It promotes long-term transfer by scaffolding an introduction to textual programming (Python) through a block-based programming view, ideal for beginners of any background. By supporting the latest Learning Tools Interoperability (LTI) standards, BlockPy is designed to support both informal learners and formal class settings. Specifically, it can be configured to provide guiding feedback for its interactive programming problems, so as to support learners at their own pace. The results from a pilot study of the initial deployment and utilization of BlockPy indicate the potential of the environment to address many of the problems faced by novice learners.

This special session will explore practical results from the educational theory of Instructional Design (ID), with particular focus on the widespread similarities between a process for creating successful courses and a process for creating successful software. We present a small set of specific practices that should be easy for CS educators to adopt. In particular, the session will cover the popular Dick & Carey model, meant for beginners to ID. This model helps instructors rigorously define who they will teach to, what they will teach, how they will assess, and (only then) how they will teach. The approach is parallel to Software Engineering techniques such as Test-Driven Development, Requirements Engineering, and Iterative Development.

Data Structures and Algorithms (DSA) courses are considered critical in any computer science curriculum. DSA courses emphasize topics related to procedural dynamics (how an algorithm works) and algorithm analysis (the algorithm's efficiency). Historically, algorithm visualizations (AVs) have dealt almost exclusively with portraying algorithm dynamics, and there are few examples of visualizations related to algorithm analysis topics. We have developed a new generation of visualizations that we term Algorithm Analysis Visualizations (AAVs) to convey algorithm analysis concepts. We present the motivation behind AAVs, and outlines a methodology for their evaluation. We present results from student surveys and the analysis of student interaction logs from the OpenDSA eTextbook used by several CS3-level classes during the period of Fall 2014 through Fall 2015. Initial results from Fall 2014 revealed that students were not spending enough time reading the algorithm analysis material presented as textual content. Our results from a preliminary deployment of AAVs in Spring 2015 showed that students interacted with AAVs for significantly longer than the control group spent reading the previous text-based algorithm analysis material. We will present additional results from our ongoing experiment in Fall2015 (control group without AAVs) and Spring2016 (test group with additional AAVs).

The open-source OpenDSA eTextbook system is seeing rapidly growing use around the world. It combines textbook-quality tutorial material with many algorithm visualizations (AVs), simulations, and a large collection of interactive exercises, including small programming exercises. Its materials are re-configurable for specific classes. Being implemented in HTML5, it requires only a web browser to be accessible to students. Available content now includes comprehensive coverage for Data Structures and Algorithms courses, and rapidly growing content for Programming Languages, Translators, and Formal Languages courses. This session will provide a demonstration of the most innovative features of OpenDSA as they might be used by students and instructors in a range of Computer Science courses.

The OpenDSA eTextbook system provides a practical way for instructors to adopt algorithm visualizations (AVs), state ma-chine simulations, and interactive practice exercises into a variety of courses, including CS2, Data Structures, Algo-rithms, Programming Languages, and Formal Languages. An OpenDSA eTextbook can be used either as a complete re-placement for your traditional textbook and assignments or as supplemental readings, auto-graded assignments, or student practice. In this workshop, we present use cases from success-ful adoption of OpenDSA into existing courses. We will guide you past the real-life hurdles and pitfalls that get in the way of using AVs, interactive exercises, and simulators. We show you how to adopt OpenDSA exercises, how to configure existing OpenDSA materials to suit your needs, and provide an over-view of how to create new AVs or exercises. This workshop is about letting you engage students with highly interactive mate-rials in ways that you have said for years that you wanted to do.

In computer science, procrastination and related problems with managing programming projects are viewed as primary causes of student attrition. Unfortunately, the most successful techniques for reducing procrastination (such as courses in study skills) are resource-intensive and do not scale to large classrooms. In this paper, we describe three course interventions that are designed to be scalable for large classrooms and require few resources to implement. Reflective writing assignments require students to consciously consider how their time management choices impact their classroom performance. Schedule sheets force students to actively plan out the time required to solve a programming project. Email alerts inform students of their progress relative to their peers as they work on an assignment, and suggest ways to improve behavior if their progress is found to be unsatisfactory. We implemented these interventions in a junior-level data structures course and analyzed data from 330 students over two semesters. Separate analyses of reflective writing responses, schedule sheet contents, and e-mail alert contents are discussed, along with student opinions about the value and effectiveness of each treatment. We found a statistically significant relationship between the time when work is completed and its quality, with late work being of lower quality. We found that one of the three interventions had a statistically significant effect on reducing late work: e-mail alerts sent to students to make them more aware of how they were doing with respect to expectations were associated with both a reduction in assignments completed late, and an increase in assignments completed at least one day early. This result was found despite the fact that students reported subjectively that e-mail alerts were of marginal utility.

Procrastination is a common problem for students. Many believe procrastination may keep otherwise competent students from succeeding. However, the most effective interventions for procrastination are resource-intensive---providing supplemental training or courses in study skills and self-regulation. These techniques do not scale to large courses. This paper investigates three new classroom interventions designed to be low-cost and low-effort to implement. Reflective writing assignments ask students to reflect on how their time management choices affect their work. Project schedule sheets require students to plan out and schedule specific tasks on their projects. E-mail situational awareness alerts give students feedback on how their progress compares to others, and to expectations. 353 students over two semesters of a junior-level advanced data structures course participated in a study where these interventions were investigated. While neither reflective writing assignments nor schedule sheets produced any significant effect, e-mail alerts were associated with both significantly reduced rates of late program submissions, and increased rates of early program submissions. As a result, this intervention shows promise for further investigation as a potential strategy for reducing late submissions among students.

Open educational resources - assignments, labs, course notes, and other types of materials made available for anyone interested in using them - have the potential to have a significant positive impact on courses and students at many institutions. Distribution and use of course materials is also an important factor in encouraging the adoption and use of innovative teaching practices. However, the use of open resources is still somewhat uncommon, with most instructors preferring to use their own materials.

Recent years have seen the emergence of applications and concepts that rely on the involvement of the general public (the "crowd") and, consequently, create big data (e.g., MOOCs, search engines, crowdsourcing, crowdfunding, citizen/crowd science, and more). Education in particular is changing dramatically with the use of online resources and courses that generate large streams of data. In this special session, we ask: What research questions in computer science education can be explored using big data? And how can computer science education researchers apply big data analysis to support education in other disciplines? To answer these and related questions, we focus in this special interactive session on how computer science education research can be promoted by integrating big data into the research process.

No abstract available.

This workshop introduces participants to CORGIS, a technology developed under the auspices of an NSF-funded project at Virginia Tech. The CORGIS Datasets Project comprises a software architecture framework and carefully engineered client libraries through which students can access either large datasets or those generated by real-time web services from domains, including weather reports, stocks, earthquakes, and news updates. The CORGIS technical scaffolding gradually introduces students to some of the most vexing complexities of distributed computing. To support the diverse needs of computing educators when teaching introductory CS classes, each CORGIS dataset is available in Python, Java, and Racket, with compatibility on key platforms. The dataset libraries are available through an online curated gallery, designed to be easily adapted to instructors' specific academic needs, including the ability to rapidly prototype new CORGIS libraries. With CORGIS, computing educators can introduce important big data or real-time distributed computing concepts without overwhelming students with the low-level details that working with such data typically requires.

While computing is becoming increasingly distributed, programming projects in introductory classes remain mostly divorced from the student's day-to-day computing experiences. These experiences entail interacting with real-time Web-based data from sources that include weather reports, news updates, and restaurant recommendations. The disconnect between student experiences and the content of their programming projects is known to drive some students away from computing. In addition, to adequately prepare students for the realities of modern software engineering, educators should introduce issues pertaining to distributed computing early in the curriculum. To address these problems, we have created RealTimeWeb - an architectural framework that makes real-time web data accessible for introductory programming projects. The framework effectively introduces important real-time distributed computing concepts without overwhelming students with the low-level details that working with such data typically requires. Preliminary results indicate that our approach can be effective in the context of a typical CS2 course, and that real-time data is relevant to students. RealTimeWeb libraries and associated resources are publicly available for use, with multiple language bindings to many real-time data sources. A rapid-prototyping tool available through the project's website facilitates the development of client libraries with easily accessible APIs for new real-time Web-based data sources.

As the use of online interactive tutorials becomes more widespread, there will be more opportunities to use fine-grained interaction log data to deduce student behavior. Log data can help debug usability or pedagogical problems with the tutorials, or guide redesign to discourage pedagogically poor student behavior. OpenDSA is a collection of open source interactive materials for teaching data structures and algorithms. We present a case study analysis of the activity logs from use of OpenDSA tutorials by roughly 150 students over several weeks. We identified clusters of student use based on when they completed exercises, verified the reliability of estimated time requirements for exercises, provided evidence that a majority of students do not read the text, and found evidence that students complete additional exercises after obtaining credit. Furthermore, we determined that slideshow use was fairly high, but that skipping to the end of slideshows was common.

This workshop introduces participants to RealTimeWeb, a technology developed under the auspices of an NSF-funded project at Virginia Tech. RealTimeWeb is a software architecture framework that makes real-time web data, such as weather reports, news updates, and restaurant recommendations, accessible for introductory programming projects. The presented technology offers technical scaffolding for the students to gradually ease into (or completely circumvent if appropriate) some of the most vexing complexities of distributed computing. At the heart of RealTimeWeb are carefully engineered client libraries through which students can access the data provided by real-time web services. To support computing educators teaching introductory CS classes in a variety of programming languages, each library is available in Python, Java, and Racket, with compatibility on key platforms, including Android. These libraries are readily available through an online curated gallery, designed to be quickly adapted to instructors' specific academic needs. This gallery also provides a tool for rapidly prototyping new libraries based on our framework. RealTimeWeb enables computing educators to introduce important real-time distributed computing concepts without overwhelming students with the low-level details that working with such data typically requires. This workshop introduces RealTimeWeb via a hands-on approach by introducing participants to the core functionality of our architectural framework and client libraries. The workshop proceeds in three parts in which we: (1) present RealTimeWeb by working through a case study of creating a programming project in a typical CS 2 course; (2) demonstrate how the framework can be used to rapidly prototype a new library of the participants' choice; and (2) critically discuss the technology in small and large groups.

Algorithm visualizations are widely viewed as having the potential for major impact on computer science education, but their quality is highly variable. We report on the software development practices used by creators of algorithm visualizations, based on data that can be inferred from a catalog of over 600 algorithm visualizations. Since nearly all are free for use and many provide source code, they might be construed as being open source software. Yet many AV developers do not appear to have used open source best practices. We discuss how such development practices might be employed by the algorithm visualization community, and how they might lead to improved algorithm visualizations in the future. We conclude with a discussion of OpenDSA, an open-source project that builds on earlier progress in the field of algorithm visualization and hopes to use open-source procedures to gain users and contributors.

Learning abstract concepts in data structures and algorithms (DSA) courses is often difficult for students. To improve understanding of DSA topics, numerous algorithm visualization (AV) systems and stand-alone AVs have been developed, supporting a wide range of algorithms and different engagement strategies. Prior studies show that active engagement of students is necessary to make AVs educationally effective. In this paper, we introduce JSAV, a new JavaScript framework for creating engaging algorithm visualizations with active learning features. JSAV is meant to be used with HTML5-based online learning materials. We describe the special features of JSAV that support active learning, and discuss its potential for use in online education projects.

We present a study to evaluate OpenDSA, an open source, online system combining textbook-quality content with algorithm visualizations and interactive exercises for data structures and algorithms courses. We hypothesize that answering many questions and exercises with immediate feedback allows students to know whether they are on track with their learning. In a quasi-experimental study, a control group received lecture and textbook for three weeks. The treatment section spent class time working through equivalent content and exercises in OpenDSA. A post-test compared the two. An opinion survey examined students' perception and opinions about the experience. Detailed interaction logs were used to analyze student use of the tutorials and exercises to understand how they used the system.

Textbook pricing has become a hot-button issue in academe. Allegations are rife that textbook prices are increasing faster than tuition, and that some students spend even more on textbooks than on tuition. The matter is complicated by rapidly changing technology and the expectations that print textbooks may soon be obsolete. This panel brings together two textbook editors from major publishers and two authors with extensive experience in new media to discuss why textbooks are so expensive and how the market is likely to change in the foreseeable future.

A problem with teaching large classes of introductory programming students is that students need copious practice but instructors do not have time to grade thousands of student programs. Large classes might require the instructor to restrict the graded programs to a handful. However, students need much more practice than this, and experience shows that if an assignment is not being graded then many students will not do it. Also, if the same problem is assigned to all students, copying of answers will occur. Programs that generate unique assignments and automatically grade submissions have been developed. Beginning with a brief example, this session will focus on experiences attendees have had with such approaches, and what an idealized system might look like, including exemplar use cases.

Educational portals such as Algoviz.org contain rich information resources, and a key concern is directing the users to specific resources that are of interest to them. While AlgoViz has significant traffic, we cannot count on active user participation in the form of explicit ratings of individual resources. Often called a "cold-start" problem, this scenario is well-known in community-based websites. Lacking active user data, we instead use log data to deduce user trends. We describe our techniques for clustering users based on the log data. We show how this cluster analysis can be used to refine searching and browsing within AlgoViz. Our approach has the potential to be useful for a wide range of educational resource portals.

OpenDSA is an open-source, community-based effort to create a complete active-eBook for Data Structures and Algorithms courses at the undergraduate level. Active-eBooks go beyond hypertextbooks, being a close integration of text and images with interactive visualizations and assessment activities. They solve two major problems: The difficulty of conveying dynamic process with static media, and the need by students to have many practice exercises and immediate feedback. Development in HTML5/JavaScript allows maximum portability. OpenDSA will proceed with broad participation from the algorithm visualization community. Focusing on reuse of materials, instructors can pick and choose content and modify as desired.

What should the textbook of tomorrow look like in a world of ubiquitous access to computing? Hypertextbooks have proved difficult to create and been fundamentally passive experiences. Commercial eBooks are merely books printed on an electronic screen instead of paper. New technologies such as HTML5 make it feasible to develop interactive applications that integrate with web services to provide a rich, pedagogically effective learning environment compatible with a range of computing platforms. We seek to generate discussion by participants to describe what they hope to see in online textbooks in the near future, and what resources and support would be required for them to adopt such a thing into their own courses.

Search engines are mostly targeted toward the generic user but educators have specific information needs with specialized information-seeking behaviors. When designing a course, educators may create a syllabus, lecture slides, and use tools as lecture aides. These resources are scattered across a large number of websites and require time and effort in finding them. To design a useful system for educators we must understand the problems they face when they seek, use, and re-use online resources. With that in mind, the Ensemble team conducted focus groups to identify current practices and problems in locating online resources for educational purposes. The data provides better understanding of the information-seeking process of educators that can lead to better educational resource sites.

We present data showing strong correlation between students' time management and a successful outcome on programming assignments. Students who spread their work over more time will produce a better result without additional expenditure of total effort. We examined performance of students who sometimes did well and sometimes did poorly, and found that their good performance occurred on the projects where they displayed better time management. While these results will not surprise most instructors, hard data is more compelling than intuition when trying to train students to use good time management.

Algorithm visualizations (AVs) are widely viewed as having the potential for improving computer science education. However, the rate of AV use and overall impact on education does not match the positive interest in their use that instructors report. Surveys of CS faculty show that impediments to successful use of AVs in the classroom include difficulties in finding quality AVs on desired topics, difficulties in adapting AVs to a given classroom setting, and lack of knowledge on the best way to deploy AVs. This indicates a need for better support for instructors, to get them past these barriers. We seek to provide this support through an online educational community that relies on a new model based less on the "digital library" approach of information gained by going to a site and searching. Instead, the focus is on community-added content through members' discussions, reviews, and ratings of content items. The AlgoViz community effort will better focus the future direction of AV development and use.

No abstract available.

We present findings regarding the state of the field of Algorithm Visualization (AV) based on our analysis of a collection of over 500 AVs. We examine how AVs are distributed among topics, who created them and when, their overall quality, and how they are disseminated. There does exist a cadre of good AVs and active developers. Unfortunately, we found that many AVs are of low quality, and coverage is skewed toward a few easier topics. This can make it hard for instructors to locate what they need. There are no effective repositories of AVs currently available, which puts many AVs at risk for being lost to the community over time. Thus, the field appears in need of improvement in disseminating materials, propagating known best practices, and informing developers about topic coverage. These concerns could be mitigated by building community and improving communication among AV users and developers.

Models of regulatory networks become more difficult to construct and understand as they grow in size and complexity. Large models are usually built up from smaller models, representing subsets of reactions within the larger network. To assist modelers in this composition process, we present a formal approach for model composition, a wizard-style program for implementing the approach, and suggested language extensions to the Systems Biology Markup Language to support model composition. To illustrate the features of our approach and how to use the JigCell Composition Wizard, we build up a model of the eukaryotic cell cycle "engine" from smaller pieces.

MOTIVATION: Models of regulatory networks become more difficult to construct and understand as they grow in size and complexity. Modelers naturally build large models from smaller components that each represent subsets of reactions within the larger network. To assist modelers in this process, we present model aggregation, which defines models in terms of components that are designed for the purpose of being combined. RESULTS: We have implemented a model editor that incorporates model aggregation, and we suggest supporting extensions to the Systems Biology Markup Language (SBML) Level 3. We illustrate aggregation with a model of the eukaryotic cell cycle 'engine' created from smaller pieces. AVAILABILITY: Java implementations are available in the JigCell Aggregation Connector. See http://jigcell.biol.vt.edu. CONTACT: [email protected]

We present our findings on the state of the field of algorithm visualization, based on extensive search and analysis of links to hundreds of visualizations. We seek to answer questions such as how content is distributed among topics, who created algorithm visualizations and when, the overall quality of available visualizations, and how visualizations are disseminated. We have built a wiki that currently catalogs over 350 algorithm visualizations, contains the beginnings of an annotated bibliography on algorithm visualization literature, and provides information about researchers and projects. Unfortunately, we found that most existing algorithm visualizations are of low quality, and the content coverage is skewed heavily toward easier topics. There are no effective repositories or organized collections of algorithm visualizations currently available. Thus, the field appears in need of improvement in dissemination of materials, informing potential developers about what is needed, and propagating known best practices for creating new visualizations.

Abstract This work describes the Site‐Specific System Simulator for Wireless System Design (S4W), a problem‐solving environment (PSE) that integrates visualization and computational tools with a high‐level graphical user interface. S4W improves the ability of wireless system engineers to design an indoor wireless system by encouraging them to think in terms of designing the system for optimal performance. Issues of computation management, data management, and location of resources are hidden from the user. The complex nature of data sets in the domain of wireless simulations calls for a customized set of visualization tools. Therefore, a number ofad hocvisualizations were developed for S4W. A study comparing the integrated system with an earlier, unintegrated version is presented. This helps to demonstrate the productivity gains that a PSE provides. Copyright © 2007 John Wiley & Sons, Ltd.

Converting a biochemical reaction network to a set of kinetic rate equations is tedious and error prone. We describe known interface paradigms for inputing models of intracellular regulatory networks: graphical layout (diagrams), wizards, scripting languages, and direct entry of chemical equations. We present the JigCell Model Builder, which allows users to define models as a set of reaction equations using a spreadsheet (an example of direct entry of equations) and outputs model definitions in the Systems Biology Markup Language, Level 2. We present the results of two usability studies. The spreadsheet paradigm demonstrated its effectiveness in reducing the number of errors made by modelers when compared to hand conversion of a wiring diagram to differential equations. A comparison of representatives of the four interface paradigms for a simple model of the cell cycle was conducted which measured time, mouse clicks, and keystrokes to enter the model, and the number of screens needed to view the contents of the model. All four paradigms had similar data entry times. The spreadsheet and scripting language approaches require significantly fewer screens to view the models than do the wizard or graphical layout approaches.

The location, type, and severity of external defects on hardwood logs and stems are the primary indicators of overall log quality and value. External defects provide hints about the internal log characteristics. Defect data would improve the sawyer's ability to process logs such that a higher valued product (lumber) is generated. Using a high-resolution laser log scanner, we scanned and digitally photographed 162 red-oak and yellow-poplar logs. By means of a new robust estimator that performs circle fitting, a residual image is extracted from laser scan data that are corrupted by extreme outliers induced by the scanning equipment and loose bark. The residuals provide information to identify defects with height differentiation from the log surface. Combining simple shape definition rules with the height map allows most severe defects to be detected by determining the contour levels of a residual image. In addition, bark texture changes can be examined such that defects not associated with a height change might be detected.

Summary form only given. We present a sophisticated and efficient parallel scheme for the DIRECT global optimization algorithm of Jones et al. (1993). Although several sequential implementations for this algorithm have been successfully applied to large scale MDO problems, few parallel versions of the DIRECT algorithm have addressed well algorithm characteristics such as a single starting point, an unpredictable workload, and a strong data dependency. These challenges engender many interesting design issues including domain decomposition, data access and management, and workload balancing. A hierarchical parallel scheme has been developed to address these challenges at three levels. Each level is supported by parallel and distributed data structures to access shared data sets, distribute workload, or exchange messages. Parameter estimation problems in systems biology provide an ideal application context for the present work. Global nonlinear parameter estimation results obtained on a 200 node Linux cluster are given for a cell cycle model for frog eggs.

Many algorithm visualizations have been created, but little is known about which features are most important to their success. We believe that pedagogically useful visualizations exhibit certain features that hold across a wide range of visualization styles and content. We began our efforts to identify these features with a review that attempted to identify an initial set of candidates. We then ran two experiments that attempted to identify the effectiveness for a subset of features from the list. We identified a small number of features for algorithm visualizations that seem to have a significant impact on their pedagogical effectiveness, and found that several others appear to have little impact. The single most important feature studied is the ability to directly control the pace of the visualization. An algorithm visualization having a minimum of distracting features, and which focuses on the logical steps of an algorithm, appears to be best for procedural understanding of the algorithm. Providing a good example for the visualization to operate on proved significantly more effective than letting students construct their own data sets. Finally, a pseudocode display, a series of questions to guide exploration of the algorithm, or the ability to back up within the visualization did not show a significant effect on learning.

This paper presents a family of programming projects appropriate to a sophomore-level data structures course, centered around the concept of a buffer pool serving as the access intermediary to a disk file. These projects provide a meaningful vehicle for practicing object-oriented design techniques and teach fundamental material on file processing and manipulating binary data. I begin with a concrete example, a heap stored on disk and mediated by a buffer pool. Several important intellectual concepts introduced by such a project are enumerated. Significant extensions and alternatives to the basic project are then described. I conclude with some observations on the role of file processing in modern CS curricula, and the significance of recent trends away from coverage of these topics.

SUMMARY: We describe the JigCell Model Builder (JCMB), a tool for creating biochemical reaction network models. JCMB is designed for ease of use and its interface uses the standard spreadsheet metaphor. The JigCell Run Manager (JCRM) is a tool for organizing the large collections of simulation runs typically required by reaction network modeling activities. AVAILABILITY: JCMB and JCRM are part of the JigCell suite available at http://jigcell.biol.vt.edu.

A global optimization technique is applied to solve the optimal transmitter placement problem for indoor wireless systems. An efficient pattern search algorithm - DIviding RECTangles (DIRECT) of Jones et al.- has been connected to a parallel three-dimensional radio propagation ray tracing modeler running on a 200-node Beowulf cluster of Linux workstations. Surrogate functions for a parallel wideband code-division multiple-access (WCDMA) simulator were used to estimate the system performance for the global optimization algorithm. Power coverage and bit-error rate are considered as two different criteria for optimizing locations of a specified number of transmitters across the feasible region of the design space. This paper briefly describes the underlying radio propagation and WCDMA simulations and focuses on the design issues of the optimization loop.

We seek to provide a theoretical basis for the development of problem solving environments that support creativity. This paper combines flow theory, the systems model of creativity, and a newly developed workflow of problem solving to produce a theory of the creative problem solving user, WorkFlow. It extends the definition of usability to include creativity and identifies key areas and methods for the support of creativity in problem solving.

Abstract As the power of computational Grids increases, there is a corresponding need for better usability for large and diverse communities. The focus in this paper is on supporting multidisciplinary communities of scientists and engineers. We discuss requirements for Grid computing environments (GCEs) in this context, and describe several core support technologies developed to meet these requirements. Our work extends the notion of a programming environment beyond the compile–schedule–execute paradigm, to include functionality such as collaborative application composition, information services, and data and simulation management. Systems designed for five different applications communities are described. These systems illustrate common needs and characteristics arising in multidisciplinary communities and motivate a high‐level design framework for building GCEs that meet those needs. Copyright © 2002 John Wiley & Sons, Ltd.

We describe problems associated with accessing data resources external to the application, which we term externalities, in replicated synchronous collaborative applications. Accessing externalities such as files, databases, network connections, environment variables, and the system clock is not as straightforward in replicated collaborative software as in single-user applications or centralized collaborative systems. We describe ad hoc solutions that add to development cost and complexity because the developer must program different behavior for different replicas. We introduce a novel general approach to accessing externalities uniformly in a replicated collaborative system. The approach uses a semireplicated architecture where the actual externality resides at a single location and is accessed via replicated proxies. This approach allows developers of replicated synchronous groupware to (1) use similar externality access mechanisms as in traditional single-user applications, and (2) program all replicas to execute the same behavior. We describe a general design for proxied access to read-only, write-only, and read-write externalities and discuss the tradeoffs of this semireplicated approach over full, literal replication and the class of applications to which this approach can be successfully applied. We also describe details of a prototype implementation of this approach within a replicated collaboration-transparency system, called Flexible JAMM (Java Applets Made Multiuser).

We describe a visualization tool to aid aircraft designers during the conceptual design stage. The conceptual design for an aircraft is defined by a vector of 10-30 parameters. The goal is to find a vector that minimizes an objective function while meeting a series of constraints. VizCraft integrates the simulation code that evaluates the design with visualizations for analyzing the design individually or in contrast to other designs. VizCraft allows the designer to easily switch between the view of a design in the form of a parameter set, and a visualization of the corresponding aircraft. The user can easily see which, if any, constraints are violated. VizCraft also allows the user to view a database of designs using parallel coordinates.

This article presents a critique of conventional collaboration transparency systems, also called “application-sharing” systems, which provide the real-time shared use of legacy single-user applications. We find that conventional collaboration transparency systems are inefficient in their use of network resources and lack support for key groupware principles: concurrent work, relaxed WYSIWIS, and group awareness. Next, we present an alternative approach to implementing collaboration transparency that provides many features previously seen only in collaboration-aware applicaitons. Our approach is based on a replicated architecture where selected single-user interface components are dynamically replaced by multiuser versions. The replacement occurs at run-time and is transparent to the single-user application and its developers.. As an instance of this approach, we describe its incorporation into a Java-based collaboration transparency system for serializable, Swing-based Java applications, called Flexible JAMM (Java Applets Made Multiuser). To validate that the flexible collaboration transparency system is truly an improvement over conventional systems, we conducted an empirical study of collaborators performing both tightly and loosely coupled tasks using Flexible JAMM versus a representative conventional collaboration transparency system, Microsoft NetMeeting. Completion times were significantly faster in the loosely coupled task using Flexible JAMM and were not adversely affected in the tightly coupled task. Accuracy was equivalent for both systems. Participants greatly preferred Flexible JAMM.

Conventional collaboration-transparency systems, which provide real-time shared use of legacy single-user applications, are inefficient in their use of network resources and lack support for key groupware principles: concurrent work, relaxed WYSIWIS, and group awareness. We present an alternative implementation approach to collaboration transparency that provides many features previously seen only in collaboration-aware applications. Our approach is based on an object-oriented replicated architecture where selected single-user interface objects are dynamically replaced by multi-user extensions. The replacement occurs at run-time and is transparent to the single-user application and its developers. As an instance of this approach, we describe its incorporation into a new Java-based collaboration-transparency system for serializable, Swing-based Java applications, called Flexible JAMM (Java Applets Made Multiuser). We conducted an empirical study to evaluate the effectiveness of Flexible JA...

We describe an aircraft design problem in high dimensional space, with D typically being 10 to 30. In some respects this is a classic optimization problem, where the goal is to find the point that minimizes an objective function while satisfying a set of constraints. However, evaluating an individual point is expensive, and the high dimensionality makes many approaches to solving the problem infeasible. The difficulty of the problem means that aircraft designers would benefit from any insights that can be provided. We discuss how simple visualizations have already proved beneficial, and then describe how visualization might be of further help in the future.

People interact together in all aspects of life and, as computers have become prevalent, users seek computer support for their interactions.The WWW provides an unprecedented opportunity for users to interact with each other, and the advent of JavaThfl has created a consistent computing environment to support synchronous collaboration.We describe JAMM, a prototype Java runtime environment that supports the shared use of existing Java applets, thus leveraging the existing base of software for synchronous collaboration.Our approach is based on a replicated architecture, where each user maintains their own copy of the Java applet, and the users' input events are broadcast to each applet copy.We discuss solutions to certain key problems, such as unanticipated sharing, supporting late-joiners, and replicating input sources other than user inputs (e.g., files, sockets, and random number generators).

Students in Computer Science are constantly asked to understand dynamic processes in the form of computer algorithms. Aside from a pseudocode or computer program implementation, a higher order description for the algorithm is usually

A data structure and update algorithm are presented for a prototype real-time collision avoidance safety system simulating a multirobot workspace. The data structure is a variant of the octree, which serves as a spatial index. The authors use the N-objects octree, which indexes a collection of 3D primitive solids. These primitives make up the two seven-degree-of-freedom robot arms and workspace modeled by the system. Octree nodes containing mor than a predetermined number N of primitives are decomposed. This rule keeps the octree small, as the entire world model for the application can be implemented using a few dozen primitives. As robot arms move, the octree is updated to reflect their changed positions. Modification to the octree is rarely required. Incidents in which one robot arm comes too close to another arm or an object are reported. Cycle time for interpreting current arm joint angles, updating the octree to reflect new positions, and detecting/reporting imminent collisions averages 30 ns on an Intel 80386 processor running at 20 MHz.>

This paper describes QUILT, a prototype geographic information system (GIS) that uses the quadtree data structure as the underlying representation for cartographic data. While QUILT contains many features typically available in a GIS, its primary purpose is to serve as a testbed for the design and testing of new data structures and algorithms for use in computer cartography. Quadtree variants for region, point and line data are implemented using the linear quadtree, organized on disk by a B-tree. QUILT provides a simple attribute attachment system which associates non-spatial data with geographic objects. The user views QUILT as an augmented LISP environment. QUILT's geographic functions include conversion of rasters to and from quadtrees; subset operations to select specified geographic objects; map editing, display, windowing, intersection and union operations; polygon expansion; and computation of geographic object properties such as the centroid, area, perimeter and bounding rectangle for sets of geographic objects.

A one-pass algorithm that performs region expansion in images represented by quadtrees is presented. The algorithm changes to black those white pixels within a specified distance of any black mode in the image. The algorithm yields a significant improvement over previous approaches by reducing both the number of black nodes that must be considered for expansion and the number of nodes that must be inserted as a result of the expansion. The reductions are achieved by introducing the concepts of a merging cluster and a vertex set. Empirical tests show that the execution time of this algorithm generally decreases as the radius of expansion increases, whereas in previous approaches the execution time generally increased with the radius of expansion.>

As part of the Multiple Autonomous Underwater Vehicle Project, a spatial mapping system has been developed to provide a model of the underwater environment suitable for autonomous navigation. The system is composed of multiresolution depth maps designed to integrate sensor data with an a priori model, an object/attribute database for storing information about detected objects, and a set of flags to monitor abnormal or emergency conditions in the environment. The structure of the mapping system and the algorithms used to map terrain and obstacles detected by acoustic sonar are described.>

A natural byproduct of the tree-like nature of the quadtree is that many basic image processing operations can be implemented as tree traversals which differ in the nature of the computation that is performed at each node. Some of these computations involve the inspection of a node's adjacent neighbors (termed neighbor finding). A new model is developed for images represented by quadtrees, and it is used to analyze various neighbor-finding techniques. The model's predicted costs for neighbor finding correlate very closely with empirical results and it is superior to the model that was used previously.

Results of a study are summarized in which quadtrees were used to encode the regions in three map overlays representing a small area in northern California. Programs were then written to perform various analysis and manipulation tasks on the quadtree-encoded regions. Data is provided on the compactness of the encodings and the efficiency of the programs.