My research lies at the intersection of human-computer interaction (HCI) and software engineering (SE): I apply theories and methods from HCI to problems in SE. My Ph.D research explores the applicability of Information Foraging Theory when there are multiple variants (or versions) of information.

My recent projects are:

  1. Variations foraging
  2. Usage of software history and version control systems
  3. Understanding novice programmers

Variations foraging for exploratory programming

For ill-defined problems, people explore multiple solutions and alternatives. Programmers also do this. For example, one programmer explored multiple color schemes and score options for a game. He saved these alternatives “just in case” or for comparisons. But, notice the variants are all very similar, and there can be too many of them. This makes working with such alternatives or variants hard. 



The goal of my research is to understand how programmers work with variants, so that we can build better tools for their exploration. I use Information Foraging Theory (IFT) to guide my research.

  1. User study: We conducted a user study to investigate how programmers reuse code from prior variants.  Our key results indicate that IFT applies to working with similar variants. But programmers’ foraging involved a lot of comparison operations and building stories, both of which are new phenomena to IFT.  Paper (a CHI’16 best paper)Preprint, Talk.
  2. Cognitive modeling: To systematically use IFT to understand how programmers navigate among variants and what their mental models are, we build a cognitive model called PFIS-V. The model sheds light into programmers’ mental models about code variants: they cared about was identical, what was similar and and what had “moved” across variants. This paper also calls for models to look beyond just source code. Paper, Preprint, TalkSource code.
  3. I recently built a new and much better model, but I can’t write about it as yet. There’s a paper under review.

Since my research is based on theoretical foundations, some of my results are also generalizable to variants in other exploratory domains, such as graphic design, writing documents, or presentation decks (like I once found):


Usage of version control systems

Version control systems (VCS) are one of developers’ most useful tools and have been around for a while. But I believe we can do much better with their information design. Software history is one place where developers often dig for information, but we don’t know the whats, hows and whys of such information seeking. And without thus characterizing developer usage, we can’t improve the history tools for developers.

So, we explored developers’ usage of software history.

  1. We used mixed methods: We used interviews (qualitative) for rich data and conducted a survey (quantitative) to complement the interviews. An ICSME’15 Best Paper. Preprint.
  2. What we’re really talking about here is information foraging in VCS. So we brought an Information Foraging Theory perspective to interpret the data from the interviews and surveys. We found some cool stuff, which I wrote up as my Masters thesis (provided upon request).

Understanding novice programmers

Recently, I started collaborating with Daniel Lin on understanding novice programmers.

  1. We found some cool stuff on novice programmers’ web search behaviors. A paper is under review.