Senthil Mani

AUSUM: approach for unsupervised bug report summarization

In most software projects, resolved bugs are archived for future reference. These bug reports contain valuable information on the reported problem, investigation and resolution. When bug triaging, developers look for how similar problems were resolved in the past. Search over bug repository gives the developer a set of recommended bugs to look into. However, the developer still needs to manually peruse the contents of the recommended bugs which might vary in size from a couple of lines to thousands. Automatic summarization of bug reports is one way to reduce the amount of data a developer might need to go through. Prior work has presented learning based approaches for bug summarization. These approaches have the disadvantage of requiring large training set and being biased towards the data on which the model was learnt. In fact, maximum efficacy was reported when the model was trained and tested on bug reports from the same project. In this paper, we present the results of applying four unsupervised summarization techniques for bug summarization. Industrial bug reports typically contain a large amount of noise---email dump, chat transcripts, core-dump---useless sentences from the perspective of summarization. These derail the unsupervised approaches, which are optimized to work on more well-formed documents. We present an approach for noise reduction, which helps to improve the precision of summarization over the base technique (4% to 24% across subjects and base techniques). Importantly, by applying noise reduction, two of the unsupervised techniques became scalable for large sized bug reports.

User-centered design and business process modeling: cross road in rapid prototyping tools

Fast production of a solution is a necessity in the world of competitive IT consulting business today. In engagements where early user interface design mock-ups are needed to visualize proposed business processes, the need to quickly create UI becomes prominent very early in the process. Our work aims to speed up the UI design process, enabling rapid creation of low-fidelity UI design with traditional user-centered design thinking but different tooling concepts. This paper explains the approach and the rationale behind our model and tools. One key focal point is in leveraging business process models as a starting point of the UI design process. The other focal point is on using a model-driven approach with designer-centered tools to eliminate some design overheads, to help manage a large design space, and to cope with changes in requirements. We used examples from a real business engagement to derive and strengthen this work.

Regression testing in the presence of non-code changes

Regression testing is an important activity performed to validate modified software, and one of its key tasks is regression test selection (RTS) -- selecting a subset of existing test cases to run on the modified software. Most existing RTS techniques focus on changes made to code components and completely ignore non-code elements, such as configuration files and databases, which can also change and affect the system behavior. To address this issue, we present a new RTS technique that performs accurate test selection in the presence of changes to non-code components. To do this, our technique computes traceability between test cases and the external data accessed by an application, and uses this information to perform RTS in the presence of changes to non-code elements. We present our technique, a prototype implementation of our technique, and a set of preliminary empirical results that illustrate the feasibility, effectiveness, and potential usefulness of our approach.

Entering the circle of trust: developer initiation as committers in open-source projects

The success of an open-source project depends to a large degree on the proactive and constructive participation by the developer community. An important role that developers play in a project is that of a code committer. However, code-commit privilege is typically restricted to the core group of a project. In this paper, we study the phenomenon of the induction of external developers as code committers. The trustworthiness of an external developer is one of the key factors that determines the granting of commit privileges. Therefore, we formulate different hypotheses to explain how the trust is established in practice. To investigate our hypotheses, we developed an automated approach based on mining code repositories and bug-tracking systems. We implemented the approach and performed an empirical study, using the Eclipse projects, to test the hypotheses. Our results indicate that, most frequently, developers establish trust and credibility in a project by contributing to the project in a non-committer role. Moreover, the employing organization of a developer is another factor--although a less significant one--that influences trust.

Debugging model-transformation failures using dynamic tainting

Model-to-text (M2T) transforms are a class of software applications that translate a structured input into text output. The input models to such transforms are complex, and faults in the models that cause an M2T transform to generate an incorrect or incomplete output can be hard to debug. We present an approach based on dynamic tainting to assist transform users in debugging input models. The approach instruments the transform code to associate taint marks with the input-model elements, and propagate the marks to the output text. The taint marks identify the input-model elements that either contribute to an output string, or cause potentially incorrect paths to be executed through the transform, which results in an incorrect or a missing string in the output. We implemented our approach for XSL-based transforms and conducted empirical studies. Our results illustrate that the approach can significantly reduce the fault search space and, in many cases, precisely identify the input-model faults. The main benefit of our approach is that it automates, with a high degree of accuracy, a debugging task that can be tedious to perform manually.

Efficient Testing of Service-Oriented Applications Using Semantic Service Stubs

Service-oriented applications can be expensive to test because services are hosted remotely, are potentially shared among many users, and may have costs associated with their invocation. In this paper, we present an approach for reducing the costs of testing such applications. The key observation underlying our approach is that certain aspects of an application can be tested using locally deployed semantic service stubs, instead of actual remote services.A semantic service stub incorporates some of the service functionality, such as verifying preconditions and generating output messages based on post conditions. We illustrate how semantic stubs can enable the client test suite to be partitioned into subsets, some of which need not be executed using remote services. We also present a case study that demonstrates the feasibility of the approach, and potential cost savings for testing. The main benefits of our approach are that it can (1) reduce the number of test cases that need to be run to invoke remote services, (2) ensure that certain aspects of application functionality are well-tested before service integration occurs.

Model-driven approach for managing human interface design life cycle

Designing a large application user interface is an iterative process. Commonly used tools lack models to support this iterative process. Research on model-driven UI design has over the years focused on modeling UI at a higher level of abstraction but lacked support during in the iteration process. This paper briefly presents the context of our research - transforming a business model into a base UI model for further customization. Specifically, we present a feature that helps reflect changes from the business model in the user interface design tool. We designed it so that the human designers can choose to react to these changes as they see appropriate. The technique is one of our attempts to apply the model-drive approach to better support design iteration through requirement changes.

Automated support for repairing input-model faults

Model transforms are a class of applications that convert a model to another model or text. The inputs to such transforms are often large and complex; therefore, faults in the models that cause a transformation to generate incorrect output can be difficult to identify and fix. In previous work, we presented an approach that uses dynamic tainting to help locate input-model faults. In this paper, we present techniques to assist with repairing input-model faults. Our approach collects runtime information for the failing transformation, and computes repair actions that are targeted toward fixing the immediate cause of the failure. In many cases, these repair actions result in the generation of the correct output. In other cases, the initial fix can be incomplete, with the input model requiring further repairs. To address this, we present a pattern-analysis technique that identifies correct output fragments that are similar to the incorrect fragment and, based on the taint information associated with such fragments, computes additional repair actions. We present the results of empirical studies, conducted using real model transforms, which illustrate the applicability and effectiveness of our approach for repairing different types of faults.

Using User Interface Design to Enhance Service Identification

User interface (UI) design is an integral part of the software design process. The UI design not only outlines the look and feel of the system, but also helps in flushing out the requirements - by identifying what data is visible to and processed by different users. However, in any SOA methodology, UI design is typically considered out of scope. In this paper, we highlight the importance of UI design specification in the SOA landscape, from a service- identification perspective. Service identification, which is a key activity in any SOA-based development, involves specification of business requirements as a set of granular service definitions. We propose an approach for harvesting the UI design specification to define service requirements for the intended system; more specifically in terms of information and business service requirements. Our approach consists of the following steps: (1) capture user interface design in a format amenable to automated analysis, with appropriate references to data and process models, (2) identify requirements for information services from data that is displayed in the user interface, and (3) identify business service requirements from the UI navigation flow and the links between the UI and the business process model. To illustrate our approach, we present a case study using the Amazon associate Web services. The study demonstrates how the use of UI designs can lead to better service identification. The proposed approach can complement any existing SOA methodology that follows a top-down approach to identify services.

Consultant assistant: a tool for collaborative requirements gathering and business process documentation

In this paper we present Consultant Assistant (CA), a tool to assist business consultants in collaborative requirements gathering and business process documentation. CA is a web tool that uses a model-based approach to capture the requirements. CA allows users to select relevant components of industry-specific process hierarchies, reuse documents from past engagements, collaboratively author requirements, and publish these requirements in a document based format. These documents can further be published to an asset repository for future reuse.