Improve Relevancy of Object Oriented Class Cohesion Metrics with Inheritance

Cohesion is a very important quality attribute in software. As we know that there are number of cohesion metrics are proposed in the literature to measure the cohesion of software systems. These metrics gives undefined values for a large number of classes which comes under special cases. Because of this reason, these metrics became non-applicable for these classes as they are unable to give cohesion values for these classes. In this paper, a value assignment criterion would be used to make cohesion metrics applicable and the concept of inheritance would be included for these special cases. Study the effect of including or excluding the inherited elements i.e., methods and attributes

A new cohesion metric and restructuring technique for object oriented paradigm

When software systems grow large during maintenance, they may lose their quality and become complex to read, understood and maintained. Developing a software system usually requires teams of developers working in concert to provide a finished product in a reasonable amount of time. What that means is many people may read each component of the software system such as a class in object oriented programming environment

Identifying Extract Class and Extract Method Refactoring Opportunities Through Analysis of Variable Declarations and Uses

For small software systems, with perhaps a few thousand lines of code, software structure is largely an esthetic issue. When software systems grow large, including perhaps a million or more lines of source code, their structures become much more important. Developing a large system requires teams of developers working in concert to provide a finished product in a reasonable amount of time. That means that many people will read each component to use, test or modify towards accomplishing new features. In the software development life cycle, the maintenance phase is a dominant stage that impacts production cost of the system dramatically. This is mainly because, for a successful system, the maintenance phase lasts until the system\u27s retirement and includes crucial operations such as enhancing performance, fixing newly discovered bugs and adopting/expending the software to meet new user requirements. Moreover, a software component may be modified or fixed by someone who is not the original author of that component. In this case, all the operations conducted during maintenance or initial development may lead to insertion of code into a unit that may be unrelated to the original design concept of that unit. As software systems become large and complex they grow too long to read and understand completely by a single person. After their initial implementations, maintenance operations tend to make the system even less maintainable, increasing the time and effort needed for future maintenance. In this research, we are interested in finding ways to successfully detect code defects and propose solutions to increase the overall maintainability of software systems that are larger than any one person can completely comprehend from its code alone. This process of refactoring software impacts the total production cost of the system positively by improving the quality of software code such as its comprehensibility and readability. To reduce the total development cost for a system, we suggest three main re-factorings. These novel forms of refactoring techniques aim to eliminate code defects such as large classes and long methods. The main goal of these re-factorings is to create smaller and cohesive software units with clear intentions to improve the maintainability of software. We provide analysis and visualization tools to help a user identify candidate code fragments to be extracted as separate unites. With these automation tools, developers do not have to manually inspect a foreign code base to detect possible refactoring opportunities. Through the visual representations we provide, one can observe all suggested re-factorings effectively on large scale software systems and decide whether a particular refactoring needs to be applied. To show the effectiveness of our techniques, we also provide some experiments conducted using these tools and techniques both on our own project\u27s source code and other open-source projects

Cohesion Metrics for Improving Software Quality

Abstract Software product metrics aim at measuring the quality of software. Modu- larity is an essential factor in software quality. In this work, metrics related to modularity and especially cohesion of the modules, are considered. The existing metrics are evaluated, and several new alternatives are proposed. The idea of cohesion of modules is that a module or a class should consist of related parts. The closely related principle of coupling says that the relationships between modules should be minimized. First, internal cohesion metrics are considered. The relations that are internal to classes are shown to be useless for quality measurement. Second, we consider external relationships for cohesion. A detailed analysis using design patterns and refactorings confirms that external cohesion is a better quality indicator than internal. Third, motivated by the successes (and problems) of external cohesion metrics, another kind of metric is proposed that represents the quality of modularity of software. This metric can be applied to refactorings related to classes, resulting in a refactoring suggestion system. To describe the metrics formally, a notation for programs is developed. Because of the recursive nature of programming languages, the properties of programs are most compactly represented using grammars and formal lan- guages. Also the tools that were used for metrics calculation are described.Siirretty Doriast