Two-directional record layout for multiple inheritance

Two of the fundamental uses of generalization in object-oriented software development are the reusability of code and better structuring of the description of objects. Multiple inheritance is one of the important features of object-oriented methodologies which enables developers to combine concepts and increase the reusability of the resulting software. However, multiple inheritance is implemented differently in commonly used programming languages. In this paper, we use Chidamber and Kemerer (CK) metrics to study the complexity and reusability of multiple inheritance as implemented in Python, Java, and C++. The analysis of results suggests that out of the three languages investigated Python and C++ offer better reusability of software when using multiple inheritance, whereas Java has major deficiencies when implementing multiple inheritance resulting in poor structure of objects.

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.

It is by now widely accepted that a number of tasks in natural language understanding (NLU) require the storage of and reasoning with a vast amount of background (commonsense) knowledge. While several efforts have been made to build such ontologies, a consensus on a scientific methodology for ontological design is yet to emerge. In this paper we suggest an approach to building a commonsense ontology for language understanding using language itself as a design guide. The idea is rooted in Frege's conception of compositional semantics and is related to the idea of type inferences in strongly-typed, polymorphic programming languages. The method proposed seems to (i) resolve the problem of multiple inheritance; (ii) suggest an explanation for polysemy and metaphor; and (iii) provide a step towards establishing a systematic approach to ontological design.

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.

I want to spend the first portion of my presentation giving you a brief summary of some of the features of the Polymorphic Programming Language.

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 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.

Currently available programming and database systems are insufficient for engineering applications. The authors contend that a logical progression from a formal conceptual model of the engineering domain to a computational model will lead to new programming paradigms capable of directly supporting engineering applications in a rigorous, concise manner. A formal domain model devised by the authors, theHybrid Model (HM) of design information, is briefly introduced. It is an extension of axiomatic set theory and is discussed in detail elsewhere. HM forms the basis ofDesigner, a prototype-based object-oriented programming language supporting a signature-based canonical message-passing mechanism and multiple inheritance. Designer is implemented using the Scheme programming language. Because Designer satisfies a formal conceptual model, and because it is based on a formally specified language, its robustness and logical validity are superior to those of other languages not founded on formal principles. Designer combines concepts of functional and object-oriented programming to provide the formal rigor and flexibility to capture the complex and strongly interrelated information that designers use. Examples demonstrate how Designer represents design information. The results of the authors' research indicate that Designer can capture design information (including aspects of functional requirements and design intent) effectively and efficiently.

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/). >

Inheritance is a powerful concept employed in computer science, especially in artificial intelligence (AI), object-oriented programming (OOP), and object-oriented databases (OODB). In the field of AI, inheritance has been primarily used as a concise and effective means of representing and reasoning with common-sense knowledge (Thirunarayan, 1995). In programming languages and databases, inheritance has been used for the purpose of sharing data and methods, and for enabling modularity of software (re)use and maintenance (Lakshmanan & Thirunarayan, 1998). In this chapter, we present various design choices for incorporating inheritance into programming languages from an application programmer’s perspective. In contrast with the language of mathematics, which is mature and well-understood, the embodiment of object-oriented concepts and constructs in a concrete programming language is neither fixed nor universally accepted. We exhibit programs with similar syntax in different languages that have very different semantics, and different looking programs that are equivalent. We compare and contrast method inheritance, interaction of type system with method binding, constructs for method redefinition, and their implementation in widely used languages such as C++ (Stroustrup, 1997), Java (Arnold, Gosling, & Holmes, 2005), and C# (Hejlsberg, Wiltamuth, & Golde, 2006), to illustrate subtle issues of interest to programmers. Finally, we discuss multiple inheritance briefly.

Existing schemes for object layout and dispatch in the presence of multiple inheritance and separate compilation waste space and are slower than systems with single inheritance. This paper describes the bidirectional object layout, a new scheme for object layout that produces smaller objects and faster method invocations than existing schemes by automatically optimizing particular uses of multiple inheritance. The bidirectional object layout is used for the programming language Theta, and is applicable to languages like C++. This paper also demonstrates how to efficiently implement method dispatch when method signatures are allowed to change in subclasses. Most current statically compiled languages require identical signatures for efficiency.

chapter 1 - Introducing C# and .NET

Scala is a new programming language developed at EPFL and incorporating the most important concepts of object-oriented and functional languages. It aims at integrating well with the Java and .NET platforms: their respective libraries are accessible without glue code, and the compiler can produce programs for both virtual machines. This thesis focuses on the compilation of two important concepts of Scala : mixin inheritance and run time types. The compilation techniques are presented in the context of the Java virtual machine, but could be adapted easily to other similar environments. Mixin inheritance is a relatively recent form of inheritance, offering new capabilities compared to single inheritance, without the complexity of multiple inheritance. We propose two implementation techniques for mixin inheritance: code copying and delegation. The implementation used in the Scala compiler is then presented and justified. Run time types make it possible for a program to examine the type of its values during execution. This possibility is interesting in itself, offering new capabilities to the programmer. Furthermore, run time types are also required to implement other high level concepts, like pattern matching, type-safe serialisation and reflection. We propose an implementation technique based on the representation of types as values, and show how to use the run time types of the underlying virtual machine to implement those of Scala. The techniques presented in this thesis have been implemented in our Scala compiler, scalac. This enabled us to evaluate these techniques, in particular their impact on the performances of programs. This evaluation was performed on several real, non-trivial programs.

The original Ada language, designed in the early 1980s was object-based but not fully object-oriented; it supported encapsulation and data abstraction but not inheritance, polymorphism or dynamic binding. A language revision effort culminating in IS0 standardization in 1995 has filled this gap. After summarizing Ada's main features, this tutorial explores the language's approach to Object Orientation.The presentation develops an example to motivate and illustrate the key semantic and stylistic points, compares Ada with other 00 languages (C++, Eiffel, Java), and explains the rationale for major language design decisions. Topics include: Why Ada realizes the class concept through both a data type facility and a modularization construct, and the effects of this design decision Implications of explicit versus implicit pointers for polymorphism Interactions between encapsulation (visibility control) and OOP How Ada models multiple inheritance How the developer can define class-specific operations for storage management and assignment Why object creation presents pitfalls for effective de-centralized 00 style, and how to avoid these pitfalls How to write applets in AdaAfter attending this tutorial, the student will understand Ada's 00 model, but will also see the underpinnings of OOP in a way that leads to more effective 00 styles with other programming languages.

15 - Why Use C++?