Author
Girish Maskeri Rama
Other affiliations: University of Southern California
Bio: Girish Maskeri Rama is an academic researcher from Infosys. The author has contributed to research in topics: Software system & Source code. The author has an hindex of 11, co-authored 26 publications receiving 530 citations. Previous affiliations of Girish Maskeri Rama include University of Southern California.
Papers
More filters
TL;DR: A new set of metrics that measure the quality of modularization of a non-object-oriented software system are presented and proposed, based on information-theoretic principles.
Abstract: 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
111 citations
TL;DR: A set of metrics that characterize the quality of modularization with respect to the APIs of the modules and such object-oriented inter-module dependencies as caused by inheritance, associational relationships, state access violations, fragile base-class design, etc are provided.
Abstract: 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.
97 citations
Patent•
15 Dec 2006TL;DR: In this article, a history of changes in modularization is kept such that the degree to which given source code is well-modularized can be determined over time, and the changes made to the code by individual programmers may be kept, such that their coding enhanced or harmed modularization may be tracked.
Abstract: Quality of modularization of source code is tested using different perspectives such as a structural modularity perspective, an architectural modularity perspective, a size perspective, and a similarity of purpose perspective. A history of changes in modularization may be kept such that the degree to which given source code is well-modularized can be determined over time. The changes made to the code by individual programmers may be kept, such that the degree to which their coding enhanced or harmed modularization may be tracked.
59 citations
Patent•
13 Dec 2006TL;DR: In this article, a history of changes in modularization is kept such that the degree to which given source code is well-modularized can be determined over time, and the changes made to the code by individual programmers may be kept, such that their coding enhanced or harmed modularization may be tracked.
Abstract: Quality of modularization of source code is tested using different perspectives such as a structural modularity perspective, an architectural modularity perspective, a size perspective, and a similarity of purpose perspective. A history of changes in modularization may be kept such that the degree to which given source code is well-modularized can be determined over time. The changes made to the code by individual programmers may be kept, such that the degree to which their coding enhanced or harmed modularization may be tracked.
35 citations
TL;DR: This 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, and validate the numerical characterizations of API usability as produced by the metrics through the APIs of several software systems.
Abstract: 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.
33 citations
Cited by
More filters
TL;DR: This paper presents a survey of techniques and technologies proposed over the years either to prevent architecture erosion or to detect and restore architectures that have been eroded, and argues that no single strategy can address the problem of erosion.
175 citations
TL;DR: The definitions of smells, their causes as well as effects, and their detection mechanisms presented in the current literature are explored, and existing smell detection methods are classified into five groups — metrics, rules/heuristics, history, machine learning, and optimization-based detection.
173 citations
TL;DR: This presentation explains how human-centered design can make application programming interfaces easier for developers to use and how this approach can be applied to the design of mobile devices.
Abstract: Human-centered design can make application programming interfaces easier for developers to use.
155 citations
TL;DR: A novel SDP approach which takes advantages of SDAEs and ensemble learning, namely the proposed two-stage ensemble (TSE), which concludes that deep representations are promising for SDP compared with traditional software metrics and TSE is more effective for addressing the class-imbalance problem in SDP.
Abstract: Context Software defect prediction (SDP) plays an important role in allocating testing resources reasonably, reducing testing costs, and ensuring software quality. However, software metrics used for SDP are almost entirely traditional features compared with deep representations (DPs) from deep learning. Although stacked denoising autoencoders (SDAEs) are powerful for feature learning and have been successfully applied in other fields, to the best of our knowledge, it has not been investigated in the field of SDP. Meanwhile, class-imbalance is still a pressing problem needing to be addressed. Objective In this paper, we propose a novel SDP approach, SDAEsTSE, which takes advantages of SDAEs and ensemble learning, namely the proposed two-stage ensemble (TSE). Method Our method mainly includes two phases: the deep learning phase and two-stage ensemble (TSE) phase. We first use SDAEs to extract the DPs from the traditional software metrics, and then a novel ensemble learning approach, TSE, is proposed to address the class-imbalance problem. Results Experiments are performed on 12 NASA datasets to demonstrate the effectiveness of DPs, the proposed TSE, and SDAEsTSE, respectively. The performance is evaluated in terms of F-measure, the area under the curve (AUC), and Matthews correlation coefficient (MCC). Generally, DPs, TSE, and SDAEsTSE contribute to significantly higher performance compared with corresponding traditional metrics, classic ensemble methods, and benchmark SDP models. Conclusions It can be concluded that (1) deep representations are promising for SDP compared with traditional software metrics, (2) TSE is more effective for addressing the class-imbalance problem in SDP compared with classic ensemble learning methods, and (3) the proposed SDAEsTSE is significantly effective for SDP.
141 citations
TL;DR: Two formal specifications of the metamodel for an object-oriented modeling language are presented, and it is shown how to use these specifications for model conformance and multiview consistency checking.
Abstract: Model-driven development, using languages such as UML and BON, often makes use of multiple diagrams (e.g., class and sequence diagrams) when modeling systems. These diagrams, presenting different views of a system of interest, may be inconsistent. A metamodel provides a unifying framework in which to ensure and check consistency, while at the same time providing the means to distinguish between valid and invalid models, that is, conformance. Two formal specifications of the metamodel for an object-oriented modeling language are presented, and it is shown how to use these specifications for model conformance and multiview consistency checking. Comparisons are made in terms of completeness and the level of automation each provide for checking multiview consistency and model conformance. The lessons learned from applying formal techniques to the problems of metamodeling, model conformance, and multiview consistency checking are summarized.
129 citations