A Comparative Study on the Effect of Multiple Inheritance Mechanism in Java, C++, and Python on Complexity and Reusability of Code

Component Based Software Engineering (CBSE) constructs a quality software system by reusing existing components. For the construction of high-quality software system, reusability plays an important role. Software component should be designed and implemented in such a way that many different programs can reuse them. Reuse of software can increase the productivity and quality of software by reducing effort, time and cost which was elapsed in designing and developing reusable software component. In this paper, a Neuro-fuzzy model has been proposed that uses software component design patterns for analysis and Chidamber and Kemerer (CK) metric for evaluation, optimization and categorization of reusability for component based software. The work is divided into 2 phases. In the first phase, analysis and optimization of reusability are empirically evaluated with high precision value using CK metric and unsupervised Self Organizing Map (SOM) Neural Network. In the second phase, reusability is categorized as very low, low, medium, high and very high using a supervised Back propagation Neural Network (BPNN) and fuzzy inference rules applied on CK metric values. The proposed model may help a software designer to evaluate and optimize the reusability of components while designing software to make quality software system.

There is no software metrics based on object-oriented programming languages (OOPLs) developed to help object-oriented software development. A graph-theoretical complexity metric to measure object-oriented software complexity is described. It shows that inheritance has a close relation with the object-oriented software complexity, and reveals that misuse of repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors. An algorithm to support this software metric is presented. Its time complexity is O(n/sup 3/). >

Type-preserving compilation can improve software reliability by generating code that can be verified independently of the compiler. Practical type preserving compilation does not exist for languages with multiple inheritance. This paper presents Emi, the first typed intermediate language to support practical compilation of a programming language with fully general multiple inheritance. The paper demonstrates the practicality of Emi by showing that Emi can be used to faithfully model standard implementation strategies of multiple inheritance for C++, the most widely-used programming language with general multiple inheritance.

Inheritance is one of the key elements of Object oriented programming. Inheritance is characterized as single or multiple depending on the number of classes a class can inherit from. Single inheritance is simple but restrictive. Multiple inheritance on the other hand is complex but allows a more natural definition of relationships between classes. There has been a significant amount of discussion on the value of multiple inheritance over single inheritance considering the complexity multiple inheritance adds. This paper reviews the two types of inheritance and examines their benefits. The paper then examines the issues and objections that have been raised on the two inheritance mechanisms. Graph, Linear, and Tree oriented implementations of multiple inheritance are reviewed to see how multiple inheritance issues are handled by various object oriented languages.

In object-oriented systems, assessing reusability plays a key role in reducing a cost and improving the quality of the software. Objectoriented programming helps in achieving the concept of reusability through different types of inheritance programs, which further help in developing reusable software modules. And object-oriented metrics identify the effectiveness of each reuse strategy. Software reusability has considerable effect on software quality. Software quality increases as reuse of software components increases. But software quality improvement cannot be understood unless it is measured. This paper focuses on an empirical evaluation of object-oriented metrics in C++ using three different object-oriented features. Three programs have been considered as input for the study -- the first program uses multilevel inheritance, the second program uses multiple inheritance and the third program uses hierarchical inheritance. We have found that multilevel inheritance has more impact on reusability among these three features.

Software reuse significantly reduce the costs of software production in the field of open-source software (OSS) development and lead to produce more reliable software systems. Software metrics have been proposed as indicators of software quality factors such as reusability. However, few empirical research papers have validated the relationship between components reusability and software metrics. This research aims to validate Chidamber and Kemerer (CK) metrics as predictors of software reusability. In order to achieve this goal, an empirical study is conducted to validate metrics in classifying two groups of components: library (reuse-prone) and non-library (less reuseprone). A nearest neighbor’s technique is used to classify library and application components using object-oriented software metrics. The approach is applied to a number of library and application systems available online. The conducted nearest neighbors models have produced acceptable classification. The results provide evidence of using metrics as surrogates of software reusability when models are evaluated using Fmeasure. CK metrics can be used to measure component reuse-proneness and can be used to differentiate between library and application components. A nearest neighbor’s technique can be used to identify the reuse-prone components in open-source application.

We present Fril++ an object-oriented extension to Fril. This new programming language supports the modelling of fuzzy applications by integrating a fuzzy logic programming language with the object-oriented paradigm. Fril++ includes the concept of fuzzy objects as an explicit construction in the language. Fuzzy objects are naturally related with multiple inheritance, and so we allow both of these in the language. The multiple inheritance gives us more flexibility, and in any case, the associated ambiguities are not so much of a problem in logic programming as they are in other paradigms. We also exploit the fact that information is expressed by the hierarchy itself. A Fril++ program can explicitly use the hierarchy by means of special constructions integrated into the language. Fril++ provides support for user decisions when there are several answers for a message by having a library of defuzzification methods.

Object-oriented software development is a subject area difficult to teach, especially to beginners. They face a lot of abstraction and (from a beginners point of view) isolated topics, such as the syntax and semantics of a programming language, the functionality of a software development environment and basic object-oriented concepts. Although many professionals in education believe in the object approach as the best method of introducing object-oriented concepts, there is no common agreement on how to start such courses. Current study programs often begin by teaching a programming language, instead of focusing on the basics of object-oriented concepts.In the last years a learning environment was developed based on a visual programming language to abstract away from details. It assists teaching step-by-step object-oriented concepts and the syntax and semantics of a programming language in secondary schools and first year university courses. Our goal is to port this learning environment to the widely used IDE Eclipse.

Implementing Programming Languages (PLs) has always been a challenge for various reasons. One reason is the excess of routine tasks to be redone on every implementation cycle. This is despite the remarkable fraction of syntax and semantics usually shared between successive cycles. In this paper, we present a component-based approach to avoid reimplementation of shared PL fractions. We provide two sets of reusable components; one for syntax implementation and another for semantics. Our syntax and semantics components correspond to syntactic categories and semantics rules of a PL specification, respectively. We show how, in addition to their service to reusability in syntax and semantics, our components can cater reusable implementation of PL analyses.Our current level of experimentation suggests that this approach is applicable wherever the following two features are available or can be simulated: Type Constraints and Multiple Inheritance. Implementing a PL using our approach, however, requires some modest programming discipline that we will explain throughout the text.KeywordsOperational SemanticSyntactic CategoryDerivation TreeExpression TraitType ConstraintThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The object-oriented metrics suite proposed by Chidamber and Kemerer (CK) is a measurement approach towards improved object-oriented design and development practices. However, existing studies evide...

chapter 7 - Advanced Types, Polymorphism, and Accessors

Much recent work in polymorphic programming languages allows subtyping and multiple inheritance for records. In such systems, we would like to extract a field from a record with the same efficiency as if we were not making use of subtyping and multiple inheritance. Methods currently used make field extraction 3-5 times slower, which can produce a significant overall performance slowdown.

One of the modern paradigms to develop an application is object oriented analysis and design. In this paradigm, there are several objects and each object plays some specific roles in applications. In an application, we must distinguish between procedural semantics and declarative semantics for their implementation in a specific programming language. For the procedural semantics, we can write a set of instructions that must be executed sequentially. The declarative semantics declare a set of facts and rules. They do not specify the sequence of steps for doing the processing. In this paper, we present four taxonomies for the rules in object-oriented paradigm and discuss how the paradigm can be extended to support declarative semantic of applications. Then, the rules in the taxonomies are evaluated in four case studies. After that, an approach is recommended for finding and implementation of declarative semantics, based on some practical experience obtained from the evaluation.

The increasing importance of software measurement has led to design and development of new software measures. As the development of object-oriented software is rising, more and more metrics are being defined for object-oriented programming languages. But there is a little understanding of comparative application of many of these measures to different programming languages. As a consequence, it is very difficult for software managers and developers to select suitable measures and programming languages for object-oriented systems. In this paper, we investigate 23 object-oriented metrics proposed by various researchers. The metrics are applied to same set of 15 programs coded in C++ and Java in an attempt to make comparative study of these two prominent object-oriented programming languages. The work done here reveals that these object-oriented metrics can be applied successfully to both Java and C++. But, Java proves to be more object-oriented than C++ as per intuition. However, counting rules defined for computation of these metrics should be framed more carefully.

The programming language concepts which ought to be presented in the comparative programming languages course (either graduate or undergraduate) are all covered by choosing C++, Java, Perl, and Python as the languages to be compared. These include dynamic typing, object orientation, multiple inheritance, interpreters and compilers, keyword and default parameters, generics, operator overloading, complex numbers, universal hierarchies, exceptions, and garbage collection. We describe such a course, which we have given.