Commit Bubbles

Our paper, Commit Bubbles, has been accepted to ICSE 2015: New Ideas and Emerging Results.

Commit Bubbles Interface

The abstract of the paper follows:

Developers who use version control are expected to produce systematic commit histories that show well-defined steps with logical forward progress. Existing version control tools assume that developers also write code systematically. Unfortunately, the process by which developers write source code is often evolutionary, or as-needed, rather than systematic. Our contribution is a fragment-oriented concept called Commit Bubbles that will allow developers to construct systematic commit histories that adhere to version control best practices with less cognitive effort, and in a way that integrates with their as-needed coding workflows.

In other words, Commit Bubbles aims to alleviate the “tangled commit” and “non-descriptive commit message” dilemmas that developers routinely encounter when constructing version control commit histories:

Git Commit (xkcd)

Hadoop 2.6.0 Windows 64-bit Binaries

Hadoop

The official release of Apache Hadoop 2.6.0 does not include the required binaries (e.g., winutils.exe) necessary to run hadoop. In order to use Hadoop on Windows, it must be compiled from source. This takes a bit of effort, so I’ve provided a pre-compiled, unofficial distribution below:

I compiled the source using:

Then, using the Windows SDK 7.1 Command Prompt or Visual Studio Command Prompt (2010):

set JAVA_HOME=C:\PROGRA~1\Java\jdk1.7.0_71
set Platform=x64

The build system requires that you use the 8.3 short filename for JAVA_HOME (no spaces!). The environment variables (Platform) are also case sensitive. Finally:

mvn package -Pdist -DskipTests -Dtar

The binaries will be available in hadoop-dist/target.

How Developers Visualize Compiler Messages

Explanatory Visualization for Ambiguous Reference

Our paper, How Developers Visualize Compiler Messages: A Foundational Approach to Notification Construction, has been accepted to the 2nd IEEE Working Conference on Software Visualization (VISSOFT 2014).

The abstract of the paper follows:

Self-explanation is one cognitive strategy through which developers comprehend error notifications. Self-explanation, when left solely to developers, can result in a significant loss of productivity because humans are imperfect and bounded in their cognitive abilities. We argue that modern IDEs offer limited visual affordances for aiding developers with self-explanation, because compilers do not reveal their reasoning about the causes of errors to the developer.

The contribution of our paper is a foundational set of visual annotations that aid developers in better comprehending error messages when compilers expose their internal reasoning. We demonstrate through a user study of 28 undergraduate Software Engineering students that our annotations align with the way in which developers self-explain error notifications. We show that these annotations allow developers to give significantly better self-explanations when compared against today’s dominant visualization paradigm, and that better self-explanations yield better mental models of notifications.

The results of our work suggest that the diagrammatic techniques developers use to explain problems can serve as an effective foundation for how IDEs should visually communicate to developers.

Improving Error Notification Comprehension through Visual Overlays in IDEs

My graduate consortium submission, Improving Error Notification Comprehension through Visual Overlays in IDEs has been accepted to the IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC) in Melbourne, Australia. The abstract of the paper follows:

Error notifications, as presented by modern integrated development environments, are cryptic and confusing to developers. My dissertation research will demonstrate that modifying production compilers to expose detailed semantics about compilation errors is feasible, and that these semantics can be leveraged through diagrammatic representations using visual overlays on the source code to significantly improve compiler error notification comprehension.

Google Internship Redux

Google

I’m returning to Mountain View, California this summer to intern for Google, from June 16 to September 5. This time around, I will be working with the Knowledge: Translate team on interactive visualizations applied to the domain of machine learning.

Compiler Error Notifications Revisited

Our paper, Compiler Error Notifications Revisited: An Interaction-First Approach for Helping Developers More Effectively Comprehend and Resolve Error Notifications, has been accepted to ICSE 2014: New Ideas and Emerging Results.

Interaction Framework

The abstract of the paper follows:

Error notifications and their resolutions, as presented by modern IDEs, are still cryptic and confusing to developers. We propose an interaction-first approach to help developers more effectively comprehend and resolve compiler error notifications through a conceptual interaction framework. We propose novel taxonomies that can serve as controlled vocabularies for compiler notifications and their resolutions. We use preliminary taxonomies to demonstrate, through a prototype IDE, how the taxonomies make notifications and their resolutions more consistent and unified.

Frontiers in Education

Frontiers in Education
This week I attended the Frontiers in Education conference (October 23-26) in Oklahoma City, Oklahoma, where I presented my work on A Community College Blended Learning Classroom Experience through Artificial Intelligence in Games. This is my first Computer Science Education paper.

The paper reports on the experience of teaching an industry-validated course on Artificial Intelligence in Computer Games within the Simulation and Game Design department at a two-year community college during a 16-week semester. The course format used a blended learning just-in-time teaching approach, which included active learning programming exercises and one-on-one student interactions.

ACT-R Models of the Concentration Game

Concentration
Our paper on Speed/Accuracy Tradeoff in ACT-R Models of the Concentration Game Game has appeared in the 2013 International Conference on Cognitive Modeling.

This paper describes the development of subsymbolic ACT-R models for the Concentration game. Performance data is taken from an experiment in which participants played the game under two conditions: minimizing the number of mismatches/turns during a game, and minimizing the time to complete a game. Conflict resolution and parameter tuning are used to implement an accuracy model and a speed model that capture the differences for the two conditions. Visual attention drives exploration of the game board in the models. Modeling results are generally consistent with human performance, though some systematic differences can be seen. Modeling decisions, model limitations, and open issues are discussed.