Today, many of the research innovations in software visualization and comprehension are evaluated on small-scale programs in a way that avoids actual human evaluation, despite the fact that these techniques are designed to help programmers develop and understand large and complex software. The investments required to perform such human studies often outweigh the need to publish. As such, the goal of this work (and toolkit) is to enable the evaluation of software visualizations of real-life software systems by its actual developers, as well as to understand the factors that influence adoption. The approach is to directly assist practicing software developers with visualizations through open and online collaboration tools. The mechanism by which we accomplish this goal is an online service that is linked through the projects' revision-control and build systems. We are calling this system Spider SENSE, and it includes web-based visualizations for software exploration that is supported by tools for mirroring development activities, automatic building and testing, and automatic instrumentation to gather dynamic-analysis data. In the future, we envision the system and toolkit to become a framework on which further visualizations and analyses are developed. Spider SENSE is open-source and publicly available for download and collaborative development.
[paper] [website]

Software engineers organize source code into a dominant hierarchy of components and modules that may emphasize various characteristics over runtime behavior. In this way, runtime features may involve cross-cutting aspects of code from multiple components, and some of these features may be emergent in nature, rather than designed. Although source-code modularization assists software engineers to organize and find components, identifying such cross-cutting feature sets can be more difficult. This work presents a visualization that includes a static (i.e., compile-time) representation of source code that gives prominence to clusters of cooperating source-code instructions to identify dynamic (i.e., runtime) features and constituent behaviors within executions of the software. In addition, the visualization animates software executions to reveal which feature clusters are executed and in what order. The result has revealed the principal behaviors of software executions, and those behaviors were revealed to be (in some cases) cohesive, modular source-code structures and (in other cases) cross-cutting, emergent behaviors that involve multiple modules. In this paper, we describe our system (Cerebro), envisage the uses to which it can be put, and evaluate its ability to reveal emergent runtime features and internal constituent behaviors of execution. We found that: (1) the visualization revealed emergent and commonly occuring functionalities that cross-cut the structural decomposition of the system; (2) four independent judges generally agreed in their interpretations of the code clusters, especially when informed only by our visualization; and (3) interacting with the external interface of an application while simultaneously observing the internal execution facilitated localization of code that implements the features and functionality evoked externally.
[paper] [website]

VISSFOT 2015 was held in Bremen, Germany this year and it turned out to be an interesting time there for me! I presented two works around novel visualizations and software research, and got some great appreciation and feedback for it! Despite being a young community, I found the conference engaging and I am evermore enthusiastic about the role of visualizations in the area of software engineering and research. The two papers on Cerebro and Spider SENSE, can be found here and here respectively. As I participated (far right) in a panel discussion on visualizing software runtime after my talk on Cerebro: And like with every conference, I do like to take a walk around a foreign town. :) The architecture in Bremen’s old town is beautiful: And the Cathedral in Bremen, Germany … is breathtaking:

I spent a set of 12 amazing weeks this summer at Redmond, Washington, where I worked as an engineering intern with the Word engineering team at Microsoft. Aside from the challenging work, it was nice to work and have fun with a great set of people! And it was not just work, but I also had a time of my life while enjoying great Washington weather, a Marron 5 rock concert, a hike upto 6,800 ft. along the slope of Mount Rainier, a visit to the original Starbucks store and numerous walks through the lovely streets of Seattle! It has been a time to remember.

The PL241-Compiler is an SSA-based optimizing compiler that supports copy propagation, common subexpression elimination, constant folding, register allocation and code generation for the DLX (pronounced ‘Deluxe’) RISC processor architecture. I wrote the compiler as a part of a graduate course at UC Irvine. It was both a challenging and extremely useful course and compiler to work on. In fact, I ended up borrowing ideas like value-numbering that are pivotal to the SSA-form for my own research projects. I would highly recommend this course to anyone who might be interested in, or is working on program analysis. Essentially, I decided to open source the code of my implementation and continue working on it during my free time — yes, it is that interesting and addictive! Code: https://bitbucket.org/vpalepu/pl241-compiler

I am happy to report that I have passed the Advancement to Candidacy exam, the second milestone towards my PhD. Still a long way to go, but there is now one less thing to worry about! Also it seems, that now I get to call my self a Ph.D. Candidate at UC Irvine. The Advancement to Candidacy exam is the second milestone for a Ph.D. student in the Software Engineering Program at UC Irvine. It requires the student to write a journal length/style research paper pertaining to an area of software engineering. This paper is then submitted to a review panel of three experienced software engineering researchers who provide detailed feedback on the paper and research. The student is then required to turn in a revised version of this paper to the reviewing committee who then either accept or reject the revised paper. Upon acceptance, the student is allowed to present his/her research in an oral defense to a committee of five experienced software engineering researchers many of whom are facult ...

Dynamic slicing is an analysis that operates on program execution models (e.g., dynamic dependence graphs) to sup- port the interpreation of program-execution traces. Given an execution event of interest (i.e., the slicing criterion), it solves for all instruction-execution events that either affect or are affected by that slicing criterion, and thereby reduces the search space to find influences within execution traces. Unfortunately, the resulting dynamic slices are still often prohibitively large for many uses. Despite this reduction search space, the dynamic slices are often still prohibitively large for many uses, and moreover, are provided without guidance of which and to what degree those influences are exerted. In this work, we present a novel approach to quan- tify the relevance of each instruction-execution event within a dynamic slice by its degree of relative influence on the slicing criterion. As such, we augment the dynamic slice with dynamic-relevance measures for each event in the slice, which can be used to guide and prioritize inspection of the events in the slice.
[paper] [slides]

New Ideas Paper accepted at ASE 2014

— Vijay Krishna Palepu (@vkrishnapalepu)

The Phase 2 exam is the first milestone for a Ph.D. student in the Software Engineering Program at UC Irvine. It entails the reading of 62 research papers from all fields of software engineering and finally a 6 hour long essay-based exam that tests the examinees about the different aspects of software engineering as a field of practice and research, how it has progressed over the years, the major spheres of innovation within and what the future looks like for practitioners and researchers alike. I am happy to report that I have passed it in my first attempt and thus have completed the first official milestone towards my PhD. Still a long way to go, but there is now one less thing to worry about!

Technical Research Talk at ASE 2013

— Vijay Krishna Palepu (@vkrishnapalepu)

{Distracted by thinking of alternate ways of saying things that like “Moreover” and “Therefore”, in your scientific writing? Don’t be! You can now focus on the stuff that really matters and leave the burden of figuring out the new ways to say some common place words with this latex package. Code: https://github.com/VijayKrishna/latex-random-conjunctions

This is a product of being a big fan of F.R.I.E.N.D.S. and a software engineer. :) I want to see if i can find something interesting by running some basic text analysis and statistics on the transcripts of the episodes. questions that i am trying to answer: Who speaks the most? Summaries of individual episodes? Summaries of what each F.R.I.E.N.D.S. said? Code: https://github.com/VijayKrishna/friends_analysis

Modern applications make heavy use of third-party libraries and components, which poses new challenges for efficient dynamic analysis. To perform such analyses, transitive dependent components at all layers of the call stack must be monitored and analyzed, and as such may be prohibitively expensive for systems with large libraries and components. As an approach to address such expenses, we record, summarize, and reuse dynamic dataflows between inputs and outputs of components, based on dynamic control and data traces. These summarized dataflows are computed at a fine-grained instruction level; the result of which, we call “dynamic dependence summaries.” Although static summaries have been proposed, to the best of our knowledge, this work presents the first technique for dynamic dependence summaries. The benefits to efficiency of such summarization may be afforded with losses of accuracy. As such, we evaluate the degree of accuracy loss and the degree of efficiency gain when using dynamic dependence summaries of library methods. On five large programs from the DaCapo benchmark (for which no existing whole-program dynamic dependence analyses have been shown to scale) and 21 versions of NANOXML, the summarized dependence analysis provided 90% accuracy and a speed-up of 100% (i.e., ×2), on average, when compared to traditional exhaustive dynamic dependence analysis.
[paper] [slides]

My paper with Prof. Xu and Prof Jones, titled: “Improving Efficiency of Dynamic Analysis with Dynamic Dependence Summaries”, was accepted at the technical research track at ASE 2013! This work describes a novel technique to summarize the API method behavior in terms of the dynamic dependence relations observed therein.

In this New Ideas and Emerging Results paper, we present a novel visualization, THE BRAIN, that reveals clusters of source code that co-execute to produce behavioral features of the program throughout and within executions. We created a clustered visualization of source-code that is informed by dynamic control flow of multiple executions; each cluster represents commonly interacting logic that composes software features. In addition, we render individual executions atop the clustered multiple-execution visualization as user-controlled animations to reveal characteristics of specific executions—these animations may provide exemplars for the clustered features and provide chronology for those behavioral features, or they may reveal anomalous behaviors that do not fit with the overall operational profile of most executions. Both the clustered multiple-execution view and the animated individual-execution view provide insights for the constituent behaviors within executions that compose behaviors of whole executions. Inspired by neural imaging of human brains of people who were subjected to various external stimuli, we designed and implemented THE BRAIN to reveal program activity during execution. The result has revealed the principal behaviors of execution, and those behaviors were revealed to be (in some cases) cohesive, modular source-code structures and (in other cases) cross-cutting, emergent behaviors that involve multiple modules. In this paper, we describe THE BRAIN and envisage the uses to which it can be put, and we provide two example usage scenarios to demonstrate its utility.
[paper] [vimeo]

Our paper titled: “Visualizing Constituent Behaviors within Executions”, that describes the visulization behind the early prototype that we created called THE BRAIN, was accepted at the NIER paper track at VISSOFT 2013! A draft version of the paper is available here.

Live demo: http://www.ics.uci.edu/~vpalepu/205project The purpose of this interactive narrative-based tutorial on statistical methods is to establish a simplified way for students to learn statistical concepts (specifically Hypothesis testing with t-tests) that are grounded in real-life examples. In addition to a narrative, an interface in presented that allows students to interact with data sets that are accessible on-line. The goal is to give students interested in doing research a fun way to quickly and clearly understand critical concepts in statistics, needed to continue to experiment with their own data sets (or on-line ones) so they can interpret future data sets they work with in meaningful and statistically sound ways. IMPORTANT: This project was done as a part of a class project in collaboration with Sonny Lin and Dahlia Hegab, at UC Irvine, CA.

Attending the ISR Forum 2013

— Vijay Krishna Palepu (@vkrishnapalepu)

Attending the ISR Forum 2013

— Vijay Krishna Palepu (@vkrishnapalepu)

Attending ICSE 2013

— Vijay Krishna Palepu (@vkrishnapalepu)

Studying vast volumes of bug and issue discussions can give an understanding of what the community has been most concerned about, however the magnitude of documents can overload the analyst. We present an approach to analyze the development of the Android open source project by observing trends in the bug discussions in the Android open source project public issue tracker. This informs us of the features or parts of the project that are more problematic at any given point of time. In turn, this can be used to aid resource allocation (such as time and man power) to parts or features. We support these ideas by presenting the results of issue topic distributions over time using statistical analysis of the bug descriptions and comments for the Android open source project. Furthermore, we show relationships between those time distributions and major development releases of the Android OS.
[paper] [slides]

Attending ICSE and MSR 2012

— Vijay Krishna Palepu (@vkrishnapalepu)

Attending the ISR Forum 2012

— Vijay Krishna Palepu (@vkrishnapalepu)

So this was a cool class project that I worked on where we were to implement a lambda calculus interpreter in any language of our choice. It just seemed too natural to do this in Scheme. :) It attempts to implement both alpha and beta reductions. The following code for the interpreter is also available as a gist, with test cases: https://gist.github.com/VijayKrishna/5180292.js ;;UCI Class Project - INF212 Analysis of Programming Languages ;;Nicholas DiGiuseppe and Vijay Krishna Palepu ;;1.interpreter is not case sensitive. ;;2.interpreter lives in the world of symbols and lists. ;;3.interpreter requires proper parenthesis. ;;4.does not work with numbers such as 1 2 3... ;;reference: http://matt.might.net/articles/implementing-a-programming-language/ ;;original 7 lines ; eval takes an expression and an environment to a value (define (eval e env) (display "evaluating ") (display e) (display " with ") (display env) (newline) (cond ((symbol? e) (begin ( ...

Studying vast volumes of bug and issue discussions can give an understanding of what the community has been most concerned about, however the magnitude of documents can overload the analyst. We present an approach to analyze the development of the Android open source project by observing trends in the bug discussions in the Android open source project public issue tracker. This informs us of the features or parts of the project that are more problematic at any given point of time. In turn, this can be used to aid resource allocation (such as time and man power) to parts or features. We support these ideas by presenting the results of issue topic distributions over time using statistical analysis of the bug descriptions and comments for the Android open source project. Furthermore, we show relationships between those time distributions and major development releases of the Android OS. Martie, Lee; Palepu, Vijay Krishna; Sajnani, Hitesh; Lopes, Cristina; , “Trendy bugs: Topic trends ...

Developed a set of Plug & Play Models for Video Game systems. These models were developed with the aim of assisting game designers and engineers to identify the baseline requirements in their games which they can then modify to the specific requirements of the game that they are developing. The fact that there exists a common feature set across all games that are or may exist, is leveraged in this approach.

Developed a framework for dynamic program analysis for Java byte code using ASM. The framework instruments the bytecode for a given Java system/project and performs analysis to detect the data and control dependencies between statements of source code.

Trendy Bugs accepted at MSR Challenge 2012

— Vijay Krishna Palepu (@vkrishnapalepu)

Accepted at UCI for the Software Engineering Ph.D.

— Vijay Krishna Palepu (@vkrishnapalepu)

Developed wireframe of a web based user interface of an existing board game based on the U.S. Presidential Elections as a part of a 6 man team. Conducted Cognitive Walkthroughs and Heuristic Evaluations for the wireframes developed. The scope of the wireframes was limited to the first two phases, i.e. the Primaries and Conventions. The objective of the project was to take the first steps in designing the user interface of a Web based game version of an existing US presidential elections board game created by Jean-Claude Falmagne. The detailed project report can be found here: report; and the screen shots of the mockups can be found here: wireframes.

Developed an Eclipse Plug-in to statically reverse engineer a selected Java code snippet, to corresponding Sequence Diagram. Recursive parsing of Abstract Syntax Tree of code was done to derive chronological ordering of method invocations, thus accurately depicting Program Flow.

Developed the software design, with a working prototype, for electoral voting via a seamless integration of both web and cellular technologies. Objective was to solve the toughest problems of mankind using technology. Involved intensive requirement analysis and research of target users, to identify a system required to meet that objective. Interviewed user groups from urban and rural backgrounds to understand socio-economic conditions of citizens. Concluded that transparent governance and hence a strong electoral process as basic requirements for solving large scale socio-economic issues.