Object sensitivity analysis is a well-known form of context-sensitive points-to analysis. This analysis is parameterized by a bound on the names of symbolic objects associated with each allocation site. In this paper, we propose a novel approach based on object sensitivity analysis that takes as input a set of client queries, and tries to answer them using an initial round of inexpensive object sensitivity analysis that uses a low object-name length bound at all allocation sites. For the queries that are answered unsatisfactorily, the approach then pin points "bad" points-to facts, which are the ones that are responsible for the imprecision. It then employs a form of program slicing to identify allocation sites that are potentially causing these bad points-to facts to be generated. The approach then runs object sensitivity analysis once again, this time using longer names for just these allocation sites, with the objective of resolving the imprecision in this round. We describe our approach formally, prove its completeness, and describe a Datalog-based implementation of it on top of the Petablox framework. Our evaluation of our approach on a set of large Java benchmarks, using two separate clients, reveals that our approach is more precise than the baseline object sensitivity approach, by around 29% for one of the clients and by around 19% for the other client. Our approach is also more precise on most large benchmarks than a recently proposed approach that uses SAT solvers to identify allocation sites to refine.

A common need of refactorings that involve object allocations is to determine precisely the program points at which objects allocated at a given allocation site become fully initialized. In this paper we formalize the notion of full initialization points (FIPs) of allocation sites, and present a static analysis to determine precisely these program points. While this analysis can benefit several allocation-site refactorings, to demonstrate its usefulness we select two specific refactorings in this paper - object sharing refactoring and immutability refactoring. By introducing code to cache and share objects at the FIPs suggested by our analysis, object-sharing refactoring was able to obtain a mean memory savings of 11.4% on a set of real Java benchmarks. Immutability refactoring guided by our analysis achieved a mean runtime speedup of 1.6X compared to performing the same refactoring using a baseline approach.

In this age of collaborative software development, the importance of usable APIs is well recognized. There already exists a rich body of literature that addresses issues ranging from how to design usable APIs to assessing qualitatively the usability of a given API. However, there does not yet exist a set of general-purpose metrics that can be pressed into service for a more quantitative assessment of API usability. The goal of this paper is to remedy this shortcoming in the literature. Our work presents a set of formulas that examine the API method declarations from the perspective of several commonly held beliefs regarding what makes APIs difficult to use. We validate the numerical characterizations of API usability as produced by our metrics through the APIs of several software systems. Copyright © 2013 John Wiley & Sons, Ltd.

Creation of large numbers of co-existing long-lived isomorphic objects increases the memory footprint of applications significantly. In this paper we propose a dynamic-analysis based approach that detects allocation sites that create large numbers of long-lived isomorphic objects, estimates quantitatively the memory savings to be obtained by sharing isomorphic objects created at these sites, and also checks whether certain necessary conditions for safely employing object sharing hold. We have implemented our approach as a tool, and have conducted experiments on several real-life Java benchmarks. The results from our experiments indicate that in real benchmarks a significant amount of heap memory, ranging up to 37% in some benchmarks, can be saved by employing object sharing. We have also validated the precision of estimates from our tool by comparing these with actual savings obtained upon introducing object-sharing at selected sites in the real benchmarks.

There exist a number of large legacy systems that still undergo continuous maintenance and enhancement. Due to the sheer size and complexity of the software systems and limited resources, managers are confronted with crucial decisions regarding allocation and training of new engineers, intelligent allocation of testing personnel, assessment of release readiness of the software and so on. While the area of bug prediction by mining software repositories holds promise, and is a worthwhile endeavor, the current state of the art techniques are not accurate enough in predicting bugs and hence are of limited usefulness to managers. So instead of predicting files as buggy or not we take a different viewpoint and focus on providing decision support for managers. In this paper we present a set of metrics to guide the managers in taking these decisions. These metrics are evaluated using 4 open source systems and 2 proprietary systems.

While the advent of open source code search tools have made the source code of thousands of open source software (OSS) readily accessible, thereby increasing legitimate reuse, it has also opened up the possibility of unconscientious employees plagiarizing code from OSS repositories. Plagiarism in proprietary software would not only lead to costly lawsuits, but also undermine the credibility of the organization. Hence detecting plagiarism in proprietary software is an urgent need. Though there exist a number of techniques for detecting plagiarism in student project assignments, they do not scale well in the case of large proprietary software. Especially when code snippets are plagiarized from the large number of available open source software. In this paper we propose a novel approach that applies Mining Software Repositories (MSR) based techniques to the problem of plagiarism detection. We create a programming style profile for each maintenance engineer by mining the version history and use that to detect source code commits that are likely to be plagiarized. Such suspected code fragments can be analyzed using any of the existing plagiarism detection techniques to confirm the plagiarism and ascertain the original code.

Large, multinational software development organizations face a number of issues in supporting software design and modeling by geographically distributed architects. To address these issues, we present CoDesign, an extensible, collaborative, event-based software modeling framework developed in a distributed, collaborative setting by our two organizations. CoDesign's core capabilities include real-time model synchronization between geographically distributed architects, as well as detection and resolution of a range of modeling conflicts via several off-the-shelf conflict detection engines.

A number of companies are trying to migrate large monolithic software systems to Service Oriented Architectures. A common approach to do this is to first identify and describe desired services (i.e., create a model), and then to locate portions of code within the existing system that implement the described services. In this paper we describe a detailed case study we undertook to match a model to an open-source business application. We describe the systematic methodology we used, the results of the exercise, as well as several observations that throw light on the nature of this problem. We also suggest and validate heuristics that are likely to be useful in partially automating the process of matching service descriptions to implementations.

There exists a number of large business critical software systems written in newer languages such as C and Java that are fast becoming legacy and increasingly difficult to maintain. Unlike older monolithic systems, where modularization primarily involves splitting the monolithic code base into modules, for such newer systems which already have some basic modular structure, code decomposition is only one of the many possible activities. Even though the area of software modularization has received considerable attention over these past years, there are hardly any case studies documented in literature on modularizing large C and Java systems. We still do not fully comprehend the activities experienced developers perform when they have to modularize such newer systems. The goal of this paper is to learn from past software modularization projects and identify common recurring patterns. This paper formalizes 6 such patterns, which we term as modularization operators, that are likely to be the basic building blocks of any software modularization activity. The operators presented in this paper are validated using modularization case studies of open source software systems and a proprietary software system and several observations and insights are presented.

The metrics formulated to date for characterizing the modularization quality of object-oriented software have considered module and class to be synonymous concepts. But a typical class in object oriented programming exists at too low a level of granularity in large object-oriented software consisting of millions of lines of code. A typical module (sometimes referred to as a superpackage) in a large object-oriented software system will typically consist of a large number of classes. Even when the access discipline encoded in each class makes for "clean" class-level partitioning of the code, the intermodule dependencies created by associational, inheritance-based, and method invocations may still make it difficult to maintain and extend the software. The goal of this paper is to provide a set of metrics that characterize large object-oriented software systems with regard to such dependencies. Our metrics characterize the quality of modularization with respect to the APIs of the modules, on the one hand, and, on the other, with respect to such object-oriented inter-module dependencies as caused by inheritance, associational relationships, state access violations, fragile base-class design, etc. Using a two-pronged approach, we validate the metrics by applying them to popular open-source software systems.

We present in this paper a new set of metrics that measure the quality of modularization of a non-object-oriented software system. We have proposed a set of design principles to capture the notion of modularity and defined metrics centered around these principles. These metrics characterize the software from a variety of perspectives: structural, architectural, and notions such as the similarity of purpose and commonality of goals. (By structural, we are referring to intermodule coupling-based notions, and by architectural, we mean the horizontal layering of modules in large software systems.) We employ the notion of API (application programming interface) as the basis for our structural metrics. The rest of the metrics we present are in support of those that are based on API. Some of the important support metrics include those that characterize each module on the basis of the similarity of purpose of the services offered by the module. These metrics are based on information-theoretic principles. We tested our metrics on some popular open-source systems and some large legacy-code business applications. To validate the metrics, we compared the results obtained on human-modularized versions of the software (as created by the developers of the software) with those obtained on randomized versions of the code. For randomized versions, the assignment of the individual functions to modules was randomized

The layered architecture pattern has been widely adopted by the developer community in order to build large software systems. The layered organization of software modules offers a number of benefits such as reusability, changeability and portability to those who are involved in the development and maintenance of such software systems. But in reality as the system evolves over time, rarely does the actual source code of the system conform to the conceptual horizontal layering of modules. This in turn results in a significant degradation of system maintainability. In order to re-factor such a system to improve its maintainability, it is very important to discover, analyze and measure violations of layered architecture pattern. In this paper we propose a technique to discover such violations in the source code and quantitatively measure the amount of non-conformance to the conceptual layering. The proposed approach evaluates the extent to which the module dependencies across layers violate the layered architecture pattern. In order to evaluate the accuracy of our approach, we have applied this technique to discover and analyze such violations to a set of open source applications and a proprietary business application by taking the help of domain experts wherever possible.