Of Object-oriented Research Articles

Staying DRY with OO and FP

We discuss the coding principle Don’t Repeat Yourself (DRY) and compare various tactics to achieve DRY code, both in the context of object-oriented (OO) programming and functional programming (FP). Neither OO nor FP play a significant role in the International Olympiad in Informatics (IOI), but these paradigms are highly relevant in industry. This article aims to make clear that they offer useful computational insights that should appeal to talented students and that could somehow make their appearance in the IOI. We conclude with an AHA insight and some WET advice for talent development and programming contests.

Identification of latent variables using, factor analysis and multiple linear regression for software fault prediction

Software practitioners develop models by considering the process of software fault prediction in the early stage of the software development life cycle in order to detect faulty modules. Various statistical and machine learning techniques are examined in the past for fault prediction. In this study, we have performed an empirical analysis of object-oriented (OO) metrics with a review of studies from the year 1996 to 2018 in the literature considering the statistical and machine learning techniques for software fault prediction. In this research, the concept of factor analysis and its sub-measures with regression are used to assess the capabilities for fault-proneness. The authors have also grouped the significant predictors i.e. CK and OO metrics using the factor analysis. In this paper, we have identified significant factor’s in five software’s datasets. The model is using the factor analysis with regression technique for estimating software fault-proneness. The results calculated prove the potential and capabilities of factor analysis for grouping important factors and using regression to identify the significant predictors. The experimental results obtained prove the ability of factor analysis with regression for predicting the susceptibility of software towards, the grouping of the components and effective use of the concept researchers and software practitioners. However, the significance and the application of the factor analysis with regression in software fault prediction are still limited and focus on these studies should be considered in order to generalize the results. On the basis of the results obtained, researchers are provided with future guidelines in this research work.

A review of object-oriented approach for test case prioritization

<p>The most essential phase in regression testing is Test Case Prioritization (TCP), with its primary objective to increase the fault detection rate at different stages during testing. Prior to achieving the objective, existing evidence of techniques in TCP must be synthesized and analyzed. At present, fault detection for TCP based on object-oriented features only consider statement, module, and class level. The important features of object-oriented (OO) programming like inheritance and polymorphism have not been fully explored for fault detection in TCP. Such OO concepts are important for test case selection and in turn for ranking the test cases (prioritization). This paper reviews various test case prioritization techniques specific to OO systems. This review is hoped to highlight the importance and usage of TCP in relation to object-oriented software development lifecycle.</p>

Threshold-based empirical validation of object-oriented metrics on different severity levels

Software metrics has become desideratum for the fault-proneness, reusability and effort prediction. To enhance and intensify the sufficiency of object-oriented (OO) metrics, it is crucial to perceive the relationship between OO metrics and fault-proneness at distinct severity levels. This paper characterise on the investigation of the software parts with higher probability of occurrence of faults. We examined the effect of thresholds on the OO metrics and build the predictive model based on those threshold values. This paper also instanced on the empirical validation of threshold values calculated for the OO metrics for predicting faults at different severity levels and builds the statistical model using logistic regression. This paper depicts the detection of fault-proneness by extracting the relevant OO metrics and focus on those projects that falls outside the specified risk level for allocating the more resources to them. We presented the effects of threshold values at different risk levels and also validated results on the KC1 dataset using machine learning and different classifiers.

Threshold-based empirical validation of object-oriented metrics on different severity levels

Software metrics has become desideratum for the fault-proneness, reusability and effort prediction. To enhance and intensify the sufficiency of object-oriented (OO) metrics, it is crucial to perceive the relationship between OO metrics and fault-proneness at distinct severity levels. This paper characterise on the investigation of the software parts with higher probability of occurrence of faults. We examined the effect of thresholds on the OO metrics and build the predictive model based on those threshold values. This paper also instanced on the empirical validation of threshold values calculated for the OO metrics for predicting faults at different severity levels and builds the statistical model using logistic regression. This paper depicts the detection of fault-proneness by extracting the relevant OO metrics and focus on those projects that falls outside the specified risk level for allocating the more resources to them. We presented the effects of threshold values at different risk levels and also validated results on the KC1 dataset using machine learning and different classifiers.

A Suite of Object Oriented Cognitive Complexity Metrics

Object orientation has gained a wide adoption in the software development community. To this end, different metrics that can be utilized in measuring and improving the quality of object-oriented (OO) software have been proposed, by providing insight into the maintainability and reliability of the system. Some of these software metrics are based on cognitive weight and are referred to as cognitive complexity metrics. It is our objective in this paper to present a suite of cognitive complexity metrics that can be used to evaluate OO software projects. The present suite of metrics includes method complexity, message complexity, attribute complexity, weighted class complexity, and code complexity. The metrics suite was evaluated theoretically using measurement theory and Weyuker’s properties, practically using Kaner’s framework and empirically using thirty projects.

Understanding the interplay between the logical and structural coupling of software classes

Abstract During the lifetime of object-Oriented (OO) software systems, new classes are added to increase functionality, also increasing the inter-dependencies between classes. Logical coupling depicts the change dependencies between classes, while structural coupling measures source code dependencies induced via the system architecture. The relationship or dependency between logical and structural coupling have been debated in the past, but no large study has confirmed yet their interplay. In this study, we have analysed 79 open-source software projects of different sizes to investigate the interplay between the two types of coupling. First, we quantified the overlapping or intersection of structural and logical class dependencies. Second, we statistically computed the correlation between the strengths of logical and structural dependencies. Third, we propose a simple technique to determine the stability of OO software systems, by clustering the pairs of classes as “stable” or “unstable”, based on their co-change pattern. The results from our statistical analysis show that although there is no strong evidence of a linear correlation between the strengths of the coupling types, there is substantial evidence to conclude that structurally coupled class pairs usually include logical dependencies. However, not all co-changed class pairs are also linked by structural dependencies. Finally, we identified that only a low proportion of structural coupling shows excessive instability in the studied OSS projects.

Evolutionary Analysis of Software Structure Based on Software Networks

Evolution is one of the essential characteristics of software system. Understanding their evolutions can lead to better software engineering practices. The existing work usually concerns on the simple statistics such as number of versions, software scale and the number of modules, neglecting the analysis of the evolutionary characteristics of software systems as a whole. This paper introduces the theory and methodology in complex networks to analyze the evolution of object-oriented (OO) software from a whole perspective. It uses the software class network to represent the OO software, and analyzes the evolutionary laws of OO software from the number of nodes and edges, average degree, degree distribution and small-world phenomenon. Empirical results on real-world OO software systems uncover some underlying evolution characteristics which give a better understanding of the complexity of the evolution of object-oriented software systems and are also important inspirations to software evolution modeling.

Benefits of object-oriented models and ModeliChart: modern tools and methods for the interdisciplinary research on smart biomedical technology.

Computational models of biophysical systems generally constitute an essential component in the realization of smart biomedical technological applications. Typically, the development process of such models is characterized by a great extent of collaboration between different interdisciplinary parties. Furthermore, due to the fact that many underlying mechanisms and the necessary degree of abstraction of biophysical system models are unknown beforehand, the steps of the development process of the application are iteratively repeated when the model is refined. This paper presents some methods and tools to facilitate the development process. First, the principle of object-oriented (OO) modeling is presented and the advantages over classical signal-oriented modeling are emphasized. Second, our self-developed simulation tool ModeliChart is presented. ModeliChart was designed specifically for clinical users and allows independently performing in silico studies in real time including intuitive interaction with the model. Furthermore, ModeliChart is capable of interacting with hardware such as sensors and actuators. Finally, it is presented how optimal control methods in combination with OO models can be used to realize clinically motivated control applications. All methods presented are illustrated on an exemplary clinically oriented use case of the artificial perfusion of the systemic circulation.

XML jako formát vyjádření objektových Petriho sítí

A number of object-oriented (OO) variants have so far been devised for Petri Nets (PN). However, none of these variants has ever been described using an open, independent format – such as XML. This article suggests several possibilities and advantages of such a description. The outlined XML language definition for the description of object-oriented Petri Nets (OOPN) is based on XMI (description of UML object-oriented models), SOX (simple description of general OO systems) and PNML (an XML-based language used for the description of structured and modular PN). For OOPN, the XML form of description represents a standard format for storing as well as for transfer between various OOPN-processing (analysis, simulation, ...) tools.

A Comparative Study on State Programming: Hierarchical State Machine (HSM) Pattern and State Pattern

State machines can be implemented by using several methods. Although state pattern (SP) implementation is one of the most popular methods, nowadays usage of hierarchical state machine (HSM) pattern is increasing. In this paper our motivation is making a metric based comparison between HSM and SP pattern. In addition, effect of increase in usage of inheritance in HSM pattern is analyzed. SP and HSM pattern belongs to different software methodologies, thus usage of object-oriented (OO) metrics is not applicable. However, both patterns implement state machines. For this reason, a new metric suit for state machines is proposed. As a result of this study, it is shown that using inheritance effectively in HSM pattern increases software quality. In addition, it is shown that HSM pattern handles enter/exit actions more effectively than SP. event e with the same transition a. Both states go to the same state; S3, with event e. S1 and S2 can be grouped under S12. By doing so, the number of events and transitions is reduced with the help of inheritance.

Integrating Evolutionary Testing with Reinforcement Learning for Automated Test Generation of Object‐Oriented Software

Recent advances in evolutionary test generation greatly facilitate the testing of Object-oriented (OO) software. Existing test generation approaches are still limited when the Software under test (SUT) includes Inherited class hierarchies (ICH) and Non-public methods (NPM). This paper presents an approach to generate test cases for OO software via integrating evolutionary testing with reinforcement learning. For OO software with ICH and NPM, two kinds of particular isomorphous substitution actions are presented and a Q-value matrix is maintained to assist the evolutionary test generation. A prototype called EvoQ is developed based on this approach and is applied to generate test cases for actual Java programs. Empirical results show that EvoQ can efficiently generate test cases for SUT with ICH and NPMand achieves higher branch coverage than two state-of-the-art test generation approaches within the same time budget.

RECODE: SOFTWARE PACKAGE REFACTORING VIA COMMUNITY DETECTION IN BIPARTITE SOFTWARE NETWORKS

It is an intrinsic property of real-world software to evolve, which is usually accompanied by the increase of software complexity and deterioration of software quality. So successful software has to be reconditioned from time to time. Though many refactoring approaches have been proposed, only a few of them are performed at the package level. In this paper, we present a novel approach to refactor the package structure of object-oriented (OO) software. It uses weighted bipartite software networks to represent classes, packages, and their dependencies; it proposes a guidance community detection algorithm (GUIDA) to obtain the optimized package structure; and it finally provides a list of classes as refactoring candidates by comparing the optimized package structure with the real package structure. Through a set of experiments we have shown that the proposed approach is able to identify a majority of classes that experts recognize as refactoring candidates, and the benefits of our approach are illustrated in comparison with other two approaches.

An efficient prediction model for software reusability for Java-based object-oriented systems

Software reuse is the process of creating new software systems with a likelihood of using existing software artefacts to add new functionalities with slight or no modification. It promises significant improvements in software quality and productivity by reducing implementation and testing time (with a consideration that prior testing and use has eliminated bugs) thereby making it cost effective. In this paper, we present an automation model for the identification and evaluation of reusable software to measure the software reusability levels (low, medium and high) of procedure-based object-oriented software systems. The presented approach uses a metric framework to compute functional analysis of object-oriented (OO)-based software components which take into account maintainability index to target essential attributes to predict reusability levels for reusability measurement. The presented approach works at the functional level rather than at the structural level. The performance of the presented automation model is recorded using criteria like precision, recall, accuracy and classification error. The model is implemented as a tool (JRM2I) in Java and results indicate that the model can be efficiently used as an economic model for the identification and prediction of procedure-based reusable components from the existing software reservoir.

Extension of Object-Oriented Metrics Suite for Software Maintenance

Software developers require information to understand the characteristics of systems, such as complexity and maintainability. In order to further understand and determine characteristics of object-oriented (OO) systems, this paper describes research that identifies attributes that are valuable in determining the difficulty in implementing changes during maintenance, as well as the possible effects that such changes may produce. A set of metrics are proposed to quantify and measure these attributes. The proposed complexity metrics are used to determine the difficulty in implementing changes through the measurement of method complexity, method diversity, and complexity density. The paper establishes impact metrics to determine the potential effects of making changes to a class and dependence metrics that are used to measure the potential effects on a given class resulting from changes in other classes. The case study shows that the proposed metrics provide additional information not sufficiently provided by the related existing OO metrics. The metrics are also found to be useful in the investigation of large systems, correlating with project outcomes.

ONTOLOGICAL FRAMEWORK FOR OBJECT-ORIENTED ANALYSIS AND DESIGN

Regardless of the large number of Object-Oriented (OO) modeling languages currently being used in the Information Systems (IS) modeling process, unavailability of an OO modeling language that can be used in both the analysis and design phases disintegrates the two phases. The problem is, such disintegration can lead to a high level of missing information in the real world system from the analysis phase to the design phase. The approach of this study is to propose a framework to produce design phase models from analysis phase models using ontology based Unified Modeling Language (UML), thereby integrating the two phases. The results obtained from the porposed framework involve: a consructed language which can be used in generating the analysis phase scripts; and the development of script files based on the UML constructs at the analysis and design phases to automatically generate the UML scripts for those two phases. Since this study is a part of an ongoing research study, it can be concluded that, at the end of this study (1) both analysis and design phases would be able to integrate using a common OO modeling language (2) the manual work involved in the current analysis and design modeling would be reduced (3) the complexities and difficulties faced by the modelers (By modelers we mean the analysts and designers who are doing the analysis and design phase modeling) in using UML modeling tools would be reduced.

Multi-granularity evolution analysis of software using complex network theory

Software systems are a typical kind of man-made complex systems. Understanding their evolutions can lead to better software engineering practices. In this paper, the authors use complex network theory as a tool to analyze the evolution of object-oriented (OO) software from a multigranularity perspective. First, a multi-granularity software networks model is proposed to represent the topological structures of a multi-version software system from three levels of granularity. Then, some parameters widely used in complex network theory are applied to characterize the software networks. By tracing the parameters’ values in consecutive software systems, we have a better understanding about software evolution. A case study is conducted on an open source OO project, Azureus, as an example to illustrate our approach, and some underlying evolution characteristics are uncovered. These results provide a different dimension to our understanding of software evolutions and also are very useful for the design and development of OO software systems.

An inheritance complexity metric for object-oriented code: A cognitive approach

Software metrics should be used in order to improve the productivity and quality of software, because they provide critical information about reliability and maintainability of the system. In this paper, we propose a cognitive complexity metric for evaluating design of object-oriented (OO) code. The proposed metric is based on an important feature of the OO systems: Inheritance. It calculates the complexity at method level considering internal structure of methods, and also considers inheritance to calculate the complexity of class hierarchies. The proposed metric is validated both theoretically and empirically. For theoretical validation, principles of measurement theory are applied since the measurement theory has been proposed and extensively used in the literature as a means to evaluate the software engineering metrics. We applied our metric on a real project for empirical validation and compared it with Chidamber and Kemerer (CK) metrics suite. The theoretical, practical and empirical validations and the comparative study prove the robustness of the measure.

CLIPS–OWL: A framework for providing object-oriented extensional ontology queries in a production rule engine

In this paper, we define a framework, namely CLIPS–OWL, for enabling the CLIPS production rule engine to represent the extensional results of DL reasoning on OWL ontologies in the form of Object-Oriented (OO) models. The purpose of this transformation is to allow CLIPS to use these OO models as static query models that are able to answer extensional ontology queries directly by the RETE reasoning engine during the development of custom CLIPS production rule programs, without interfacing at runtime the external DL reasoner. In that way, any CLIPS-based application may enhance its functionality by incorporating ontological knowledge without modifying the architecture of the CLIPS rule engine. CLIPS–OWL has been implemented using the Pellet DL reasoner and the CLIPS Object-Oriented Language (COOL).

Mutation testing on an object-oriented framework: An experience report

Context The increasing presence of Object-Oriented (OO) programs in industrial systems is progressively drawing the attention of mutation researchers toward this paradigm. However, while the number of research contributions in this topic is plentiful, the number of empirical results is still marginal and mostly provided by researchers rather than practitioners. Objective This article reports our experience using mutation testing to measure the effectiveness of an automated test data generator from a user perspective. Method In our study, we applied both traditional and class-level mutation operators to FaMa, an open source Java framework currently being used for research and commercial purposes. We also compared and contrasted our results with the data obtained from some motivating faults found in the literature and two real tools for the analysis of feature models, FaMa and SPLOT. Results Our results are summarized in a number of lessons learned supporting previous isolated results as well as new findings that hopefully will motivate further research in the field. Conclusion We conclude that mutation testing is an effective and affordable technique to measure the effectiveness of test mechanisms in OO systems. We found, however, several practical limitations in current tool support that should be addressed to facilitate the work of testers. We also missed specific techniques and tools to apply mutation testing at the system level.