Paul Gestwicki

Methodology and architecture of JIVE

A novel approach to the runtime visualization and analysis of object-oriented programs is presented and illustrated through a prototype system called JIVE: Java Interactive Visualization Environment. The main contributions of JIVE are: multiple concurrent representations of program state and execution history; support for forward and reverse execution; and graphical queries over program execution. This model facilitates program understanding and interactive debugging. Our visualization of runtime states clarifies the important point that objects are environments of execution. The history of object interaction is displayed via sequence diagrams, and in this way we help close the loop between design-time and run-time representations. Interactive execution is made possible by maintaining a runtime history database, which may be queried for information on variable behavior, method executions, and object interactions. We illustrate the capabilities of this system through examples. JIVE is implemented using the Java Platform Debugger Architecture and supports the Java language and libraries, including multithreaded and GUI applications.

Teaching Design Patterns Through Computer Game Development

We present an approach for teaching design patterns that emphasizes object-orientation and patterns integration. The context of computer game development is used to engage and motivate students, and it is additionally rich with design patterns. A case study is presented based on EEClone, an arcade-style computer game implemented in Java. Our students analyzed various design patterns within EEClone, and from this experience, learned how to apply design patterns in their own game software. The six principal patterns of EEClone are described in detail, followed by a description of our teaching methodology, assessment techniques, and results.

Computer games as motivation for design patterns

We present a computer game case study that can be used to motivate the need for design patterns. Design patterns are often misunderstood, but good examples can motivate students to work at understanding patterns. Computer games are used in many books and online resources to teach programming concepts, but these examples are usually simplified or non-object-oriented. We present a simple game that exhibits functionality found in commercial games (animation, collision detection, etc.) and show how it can be used as a case study for design patterns. Specifically, we illustrate how the state, facade, observer, strategy, and visitor patterns can replace procedural approaches for implenting the logic and animation of game written in Java.

JIVE: java interactive visualization environment

Jive represents a novel approach to runtime visualization and analysis of Java programs. It facilitates program understanding and interactive debugging, featuring: multiple, customizable views of object structure; representation of execution history via sequence diagrams; interactive queries on runtime behavior; forward and reverse interactive execution. JIVE uses standard JVM and compilers.

Novel approaches to CS 0 with app inventor for android

1. SUMMARY Googles App Inventor for Android (AIA) is a visual programming environment for creating mobile phone applications that is designed to be accessible and appealing to college nonmajors taking introductory courses in computer science. Specifically, AIA provides a development environment similar to StarLogo TNG [7], Scratch [5], and Alice [2] but enabling users to create mobile applications incorporating social networking, location awareness, and Web-based services for Googles Android platform [1].

Interactive visualization of Java programs

The design and implementation of a novel visual interactive execution environment for Java is described. This system displays both the run-time object structure as well as the internal details of object and method activations. The representation of the execution state is based upon a novel yet simple representation technique which clarifies the important fact that objects are environments. All major Java features, including inheritance, inner classes, static methods, exceptions, etc., are supported. The GUI components built from Javas Swing or AWT libraries can be visualized in juxtaposition with the underlying execution state. We also include a reverse-execution mechanism that allows a user to rollback to previous states of an execution. A notable characteristic of the visualization system is that it employs the existing Java virtual machine; no new Java interpreter is needed. A novel preprocessor (source-to-source transformation) is employed in conjunction with a run-time mediator written in Java, which carries out the visualization. A prototype of these ideas was completed to validate the entire approach.

Work in progress - curriculum visualization

CurricVis is a work-in-progress curriculum visualization application. The structure of a curriculum is modeled as a directed graph whose nodes represent courses and whose edges represent relationships between courses. Various graphical styles are used to encode details such as co-requisites and electives. Diagrams are automatically generated based on a curricular knowledge base. This approach has many benefits over manually-created visualizations: they require less maintenance and promote visual exploration of curriculum modifications. The CurricVis prototype has been used to generate visualizations of Computer Science curricula, including degree programs for majors and minors. The resulting visualizations have been valuable in advising current students as well as explaining the curriculum to prospective students. They have also been used to facilitate curriculum discussion in departmental committees. More user-friendly data entry and visualization generation interfaces are currently under development. Future work includes integration with Web-based course catalogs and student transcripts, path highlighting for computer-assisted advising, and the integration of more advanced information visualization techniques for large-scale curriculum visualization.

Learning analytics for collaborative writing: a prototype and case study

This paper explores the ways in which participants in writing intensive environments might use learning analytics to make productive interventions during, rather than after, the collaborative construction of written artifacts. Specifically, our work considered how university students learning in a knowledge work model---one that is collaborative, project-based, and that relies on consistent peer-to-peer interaction and feedback---might leverage learning analytics as formative assessment to foster metacognition and improve final deliverables. We describe Uatu, a system designed to visualize the real time contribution and edit history of collaboratively written documents. After briefly describing the technical details of this system, we offer initial findings from a fifteen week qualitative case study of 8 computer science students who used Uatu in conjunction with Google Docs while collaborating on a variety of writing and programming tasks. These findings indicate both the challenges and promise of delivering useful metrics for collaborative writing scenarios in academe and industry.

Studio-based learning and app inventor for android in an introductory CS course for non-majors

In this study, an experimental introductory CS course was implemented focusing on two pedagogic factors: the use of App Inventor for Android (AIA), a visual blocks programming environment for creating smart phone applications; and the adoption of studio-based learning (SBL) as the main teaching methodology. Participants included 18 non-CS major undergraduates. The Motivated Strategies for Learning Questionnaire (MSLQ) was implemented at several stages. With the exception of the Peer Learning scale in the mid-MSLQ, all participants scored in the high range in the three MSLQs. Results indicated that participants were comfortable collaborating with peers and asking questions. Additional data were collected from entry and exit interviews as well as student-created mind maps. The study revealed positive student response to the pedagogic factors and positive attitudes towards CS, and the subjects also demonstrated significant academic achievement. The experimental approach was found to have a positive effect on students motivation, creativity, achievement, and attitude towards CS.

Interactive visualization of object-oriented programs

We describe a novel approach to runtime visualization of object-oriented programs. Our approach features: visualizations of execution state and history; forward and reverse execution; interactive queries during program execution; and advanced drawing capabilities involving a combination of compile-time and runtime-analysis. Our methodology is realized in a software tool called <i>JIVE</i>, for <i>Java Interactive Visualization Environment</i>.