In this paper, we describe our experiences using dynamic program visualizations in our Java-based CS1 and CS2 courses during the spring semester 2013. The visualizations were constructed by both faculty and students using the new viewer canvas in jGRASP. A public beta version was downloaded and installed in our computer labs and on student and faculty machines. Program visualizations were used in the classroom as well as in lab activities and programming projects. Since the viewers had already been evaluated in controlled experiments, our focus was on ease of use of the viewer canvas by the students and the utility of the program visualizations in helping students understand their programs. Direct observations in the lab and individual meetings with students to discuss their work indicated that students could indeed build dynamic visualizations that, in conjunction with the debugger, helped them understand and correct bugs in their programs much more effectively than using the debugger alone.

This workshop will focus on using the new jGRASP viewer canvas which provides an exciting new dimension to dynamic program visualization. The canvas allows students and instructors to organize dynamic viewers of multiple objects and primitives to quickly form coherent program visualizations. Students can quickly build and save visualizations of their own programs, and faculty can create visualizations and provide them to students with example programs. "Playing" a program in canvas mode brings the visualization to life as objects come into scope and the canvas is updated automatically. All educators who teach Java will benefit from this workshop. It will be especially suitable for instructors who teach CS1 (introduction to programming), CS2 (introduction to data structures), and CS3 (introduction to algorithms), as well as for instructors of AP courses in high schools. jGRASP is a freely available educational IDE (http://www.jgrasp.org/); no prior experience with jGRASP is expected. Laptop required.

This BOF is related to the Special Session Transforming the CS Classroom with Studio-Based Learning (SBL). SBL promotes learning in a collaborative context by having students construct, present, review and refine their work with the guidance of peers and teachers. A team of CS educators and education experts have been implementing and evaluating SBL in CS courses over the past five years. The BOF will introduce SBL to the SIGCSE audience, and engage them in a discussion of the potential of, evidence for, and practical advice regarding SBL as an instructional approach that can motivate as well as teach students. Discussions will include "war stories" from teachers who have adopted the approach in their courses and hands-on activities to help participants apply SBL to their courses.

The studio-based learning (SBL) model aims to promote learning in a social and collaborative context by having learners construct, iteratively refine, and critically review design artifacts under the guidance of instructors and disciplinary experts. Recognizing the potential of SBL to foster the development of not only technical design skills, but also increasingly-coveted communication and collaboration skills, we have been adapting the approach for computing education, implementing it in various courses, and evaluating its impact over the past 5 years. This effort now involves 26 computing courses at 15 institutions in seven states. To our knowledge, this represents the most systematic implementation and evaluation of a pedagogy for computing education to date. This special session will introduce SBL to the SIGCSE community and facilitate a discussion and exchange of ideas. In addition to oral and poster presentations of the SBL model and its evaluation results, the session will feature "war stories" from teachers who have applied the model to their courses and hands-on activities to help attendees apply SBL to their courses.

Dynamic program viewing is a form of visual verification in which a student executes one or more statements in a program and interactively observes the behavior in basic viewers (e.g., an object with its fields) and/or conceptual viewers (e.g., the structural display of binary search tree). This activity can be extremely useful from a program understanding perspective as well as a debugging perspective. In contrast, testing (e.g., with JUnit) provides a way to create persistent test cases and then run and re-run them in an efficient way. We have observed that dynamic program viewing and testing are quite complementary. When test cases are written and executed, dynamic program viewing becomes a valuable aid in traditional debugging as well. Since most test cases are written at the functional level (e.g., did a method return the expected value?), dynamically viewing test methods as they execute can provide students with a deeper level of understanding. The jGRASP IDE has been extended to allow students to combine dynamic program viewing with JUnit testing. In this paper, we discuss both the technical success of this effort and several examples that demonstrate the potential for student use in early computing courses.

This paper presents an experience in designing, implementing, and evaluating a studio-based learning model for CS2. Adapted from architecture and art education, as well as from collaborative problem-solving pedagogies, studio-based learning has shown great promise for computing education. Key elements of studio-based learning include exploring multiple solutions to a problem, justifying the choice of one solution, and being subject to, as well as providing, peer reviews. We describe the design, implementation, and revision of a studio model for CS2, and then present the results of an evaluation of the model when compared to traditional instruction in CS2.

jGRASP has three integrated approaches for interacting with its dynamic viewers for data structures: debugger, workbench, and text-based interactions that allow individual Java statements and expressions to be executed/evaluated. These approaches can be used together to provide a complementary set of interactions with the dynamic viewers. Data structure identification and rendering were tested by examining examples from 20 data structure textbooks. Controlled experiments with CS2 students indicate that the viewers can have a significant positive impact on student performance. The overall result is a flexible environment for interacting with effective dynamic data structure visualizations generated by a robust structure identifier.

Inheritance and polymorphism are important OOP topics in CS1 and CS2. While these concepts are generally straightforward, there are subtleties that may leave students confused. For example, accessibility of a field in an object is generally determined by the declaring type and access modifiers of the field, and the context in the executing program from which the field is referenced. The dynamic object viewers in jGRASP have been expanded to allow the user to: (1) change the declared type of the object reference to any compatible type and (2) change the accessibility context of the object reference. These options enable the user to explore accessibility and visibility relationships by experimenting with any object on the workbench or in the debugger. Symbols, color, and text are used in the viewer to indicate inheritance relationships, accessibility, and visibility of fields and methods. Initial classroom use has demonstrated the potential for these new viewer features as an aid to students who are learning about inheritance and polymorphism.

The jGRASP lightweight IDE has been extended to provide object viewers that automatically generate dynamic, state-based visualizations of data structures in Java. These viewers provide multiple synchronized visualizations of data structures as the user steps through the source code in either debug or workbench mode. This tight integration in a lightweight IDE provides a unique and promising environment for learning data structures. Initial classroom use has demonstrated the object viewers' potential as an aid to students who are learning to write and modify classes representing data structures. Recently completed controlled experiments with CS2 students indicate that these viewers can have a significant positive impact on student performance.

The jGRASP lightweight IDE provides object viewers that automatically generate dynamic, state-based visualizations of objects and primitive variables in Java. Multiple synchronized visualizations of an object, including complex data structures, are immediately available to users from the jGRASP debugger window or object workbench. Initial use has demonstrated the object viewers' potential as an aid to understanding and debugging

This paper describes a software engineering project course for freshman. The course has been designed to engage and motivate software engineering students at the beginning of their matriculation, while at the same time providing solid software engineering content. Student teams use a simple software process based on extreme programming to complete a semester-long project in computer animation. Course motivation, structure, and implementation are described

The jGRASP IDE provides new object viewers that automatically generate dynamic, state-based visualizations of objects and primitive variables in Java. Multiple synchronized visualizations of an object, including complex data structures, are immediately available to users from the jGRASP debugger window or object workbench. Initial classroom use has demonstrated the object viewers' potential as an aid to student learning, while future research will explore their utility through controlled experiments.

A framework for producing dynamic data structure visualizations within the context of a lightweight IDE is described. Multiple synchronized visualizations of a data structure can be created with minimal coding through the use of an external viewer model. The framework supplies a customizable viewer template as well as high-level APIs to a graph drawing library and the Java Debugger Interface. Initial classroom use has demonstrated the framework's ease of use as well as its potential to as an aid to student learning.

Recently, the first two in a series of planned comprehension experiments were performed to measure the effect of the control structure diagram (CSD) on program comprehensibility. Upper- and lower-division computer science and software engineering students were asked to respond to questions regarding the structure and execution of one source code module of a public domain graphics library. The time taken for each response and the correctness of each response was recorded. Statistical analysis of the data collected from these two experiments revealed that the CSD was highly significant in enhancing the subjects' performance in this program comprehension task. The results of these initial experiments promise to shed light on fundamental questions regarding the effect of software visualizations on program comprehensibility.

Recently, the first in a series of planned comprehension experiments was performed to measure the effect of the control structure diagram (CSD) on program comprehensibility. Upper-division computer science students were asked to respond to questions regarding the structure and execution of a source code module written in Java. Statistical analysis of the data collected from this experiment revealed that the CSD was highly significant in enhancing the subjects' performance in this program comprehension task. The results of this initial experiment along with the planned follow-on experiments promise to shed light on fundamental questions regarding the effect of software visualizations on program comprehensibility.

Although a computer science curriculum may use a single language as its "core" language, many curricula require students to learn and use multiple languages for course or practicum work. Students benefit from the exposure to other languages and other language models. However, a problem arising from the multi-lingual nature of a curriculum is the necessity to learn and use different development environments and language front-ends. GRASP (Graphical Representations of Algorithms, Structures, and Processes) is a software engineering tool currently being successfully utilized as a common development environment for the multi-lingual computer science curriculum at Auburn University. Besides providing a common front-end for different languages, GRASP also provides automated visualization of source code in the form of the control structure diagram and the complexity profile graph. This paper describes GRASP and its current use in the computer science curriculum. GRASP is freely available via the Internet at the following URL: http://www.eng.auburn.edu/grasp