The Experts below are selected from a list of 3756 Experts worldwide ranked by ideXlab platform

Chunchia Wang - One of the best experts on this subject based on the ideXlab platform.

Chi-ming Chung - One of the best experts on this subject based on the ideXlab platform.

Timothy K Shih - One of the best experts on this subject based on the ideXlab platform.

Murray Wood - One of the best experts on this subject based on the ideXlab platform.

  • an analysis of Inheritance Hierarchy evolution
    Evaluation and Assessment in Software Engineering, 2019
    Co-Authors: Murray Wood, Lyubomir Ivanov, Zenon Lamprou
    Abstract:

    This research investigates the evolution of object-oriented Inheritance hierarchies in open source, Java systems. The paper contributes an understanding of how hierarchies, particularly large complex hierarchies, evolve in 'real world' systems. It informs object-oriented design practices that aim to control or avoid these complicated design structures. The study is based on a detailed analysis of 665 Inheritance hierarchies drawn from a total of 262 versions of 10 open source systems. The research contributions include that: i) the majority of Inheritance hierarchies are 'simple' in structure and remain that way throughout their lifetimes ii) the majority of hierarchies are stable in terms of size and shape throughout their lifetimes iii) there is a minority of large, complex, branching 'Subtree' hierarchies that continue to grow ever more complicated as the systems evolve iv) a detailed analysis of some of these larger hierarchies finds evidence of 'good' object-oriented design practices being used but also highlights the significant challenges involved in understanding and refactoring these complex structures. There is clear evidence that some of the complex hierarchies are emphasising reuse while others appear focused on type Inheritance.

  • EASE - An Analysis of Inheritance Hierarchy Evolution
    Proceedings of the Evaluation and Assessment on Software Engineering, 2019
    Co-Authors: Murray Wood, Lyubomir Ivanov, Zenon Lamprou
    Abstract:

    This research investigates the evolution of object-oriented Inheritance hierarchies in open source, Java systems. The paper contributes an understanding of how hierarchies, particularly large complex hierarchies, evolve in 'real world' systems. It informs object-oriented design practices that aim to control or avoid these complicated design structures. The study is based on a detailed analysis of 665 Inheritance hierarchies drawn from a total of 262 versions of 10 open source systems. The research contributions include that: i) the majority of Inheritance hierarchies are 'simple' in structure and remain that way throughout their lifetimes ii) the majority of hierarchies are stable in terms of size and shape throughout their lifetimes iii) there is a minority of large, complex, branching 'Subtree' hierarchies that continue to grow ever more complicated as the systems evolve iv) a detailed analysis of some of these larger hierarchies finds evidence of 'good' object-oriented design practices being used but also highlights the significant challenges involved in understanding and refactoring these complex structures. There is clear evidence that some of the complex hierarchies are emphasising reuse while others appear focused on type Inheritance.

  • ICSE - Inheritance usage patterns in open-source systems
    Proceedings of the 40th International Conference on Software Engineering, 2018
    Co-Authors: Jamie Stevenson, Murray Wood
    Abstract:

    This research investigates how object-oriented Inheritance is actually used in practice. The aim is to close the gap between Inheritance guidance and Inheritance practice. It is based on detailed analyses of 2440 Inheritance hierarchies drawn from 14 open-source systems. The original contributions made by this paper concern pragmatic assessment of Inheritance Hierarchy design quality. The findings show that Inheritance is very widely used but that most of the usage patterns that occur in practice are simple in structure. They are so simple that they may not require much Inheritance-specific design consideration. On the other hand, the majority of classes defined using Inheritance actually appear within a relatively small number of large, complex hierarchies. While some of these large hierarchies appear to have a consistent structure, often based on a problem domain model or a design pattern, others do not. Another contribution is that the quality of hierarchies, especially the large problematic ones, may be assessed in practice based on size, shape, and the definition and invocation of novel methods - all properties that can be detected automatically.

  • Evaluating Inheritance depth on the maintainability of object-oriented software
    Empirical Software Engineering, 1996
    Co-Authors: John Daly, Andrew Brooks, James Miller, Marc Roper, Murray Wood
    Abstract:

    This empirical research was undertaken as part of a multi-method programme of research to investigate unsupported claims made of object-oriented technology. A series of subject-based laboratory experiments, including an internal replication, tested the effect of Inheritance depth on the maintainability of object-oriented software. Subjects were timed performing identical maintenance tasks on object-oriented software with a Hierarchy of three levels of Inheritance depth and equivalent object-based software with no Inheritance. This was then replicated with more experienced subjects. In a second experiment of similar design, subjects were timed performing identical maintenance tasks on object-oriented software with a Hierarchy of five levels of Inheritance depth and the equivalent object-based software. The collected data showed that subjects maintaining object-oriented software with three levels of Inheritance depth performed the maintenance tasks significantly quicker than those maintaining equivalent object-based software with no Inheritance. In contrast, subjects maintaining the object-oriented software with five levels of Inheritance depth took longer, on average, than the subjects maintaining the equivalent object-based software (although statistical significance was not obtained). Subjects' source code solutions and debriefing questionnaires provided some evidence suggesting subjects began to experience difficulties with the deeper Inheritance Hierarchy. It is not at all obvious that object-oriented software is going to be more maintainable in the long run. These findings are sufficiently important that attempts to verify the results should be made by independent researchers.

Michele Missikoff - One of the best experts on this subject based on the ideXlab platform.

  • Inheritance Hierarchy design in object-oriented databases
    Data & Knowledge Engineering, 1999
    Co-Authors: Catriel Beeri, Anna Formica, Michele Missikoff
    Abstract:

    Abstract Object-oriented database schema design is still mostly an art. One of the difficulties encountered during design is typing conflicts induced by multiple Inheritance. In this paper, we propose a method for treating such a kind of conflicts. Our approach to Inheritance conflict solving consists of several ingredients. First, we rely on branding, to introduce ‘type equivalence by name’, thus allowing a designer to distinguish between structurally similar but se-mantically different types. However, we offer a heuristic that does not require a designer to explicitly state branding declarations. Second, we describe various kinds of conflicts, and we offer a set of procedures that analyze a schema to discover such conflicts, classify them, offering potential solutions, if possible. The procedures have been conceived for a design system that allows a designer maximum flexibility, while guiding him/her to a correct design.

  • Object-oriented database schema analysis and Inheritance processing: a graph-theoretic approach
    Data & Knowledge Engineering, 1997
    Co-Authors: Anna Formica, H. D. Groger, Michele Missikoff
    Abstract:

    Abstract In this paper we address the Inheritance process in the context of strongly typed Object-oriented database (OODB) systems, allowing multiple Inheritance and overriding. For such powerful systems, it is important to analyse the Inheritance Hierarchy to identify a number of significant properties. The first, schema consistency , is connected to the Inheritance conflicts . In the presence of an unsolvable Inheritance conflict there is a contradiction in the schema. The second property is related to the termination of the Inheritance process. We expect that all the subtypes in the schema, if consistent, can be rewritten in expanded form, after Inheritance, in a finite time. Schemas that guarantee these two formal properties will be referred to as correct schemas. In the paper a graph-theoretic method is provided, aimed at supporting the designer in checking the correctness and deriving the expanded form of a schema. Furthermore, from the analysis of the complexity of the Inheritance process, a third formal property has been defined, concerning the degree of compactness achievable in a schema, by using Inheritance hierarchies. In particular, a class of schemas has been defined, referred to as logarithmic schemas, whose expanded forms, after Inheritance, become exponential in the size of the original schemas.