Class Inheritance Research Articles

Of love and fur: grandmothers, class, and pre-mortem inheritance in a southern Polish city

This article analyses the pre-mortem alternate-generation inheritance of fur clothing in Krakow: a practice that speaks to the conventions of grandmother-granddaughter relationships and also to the connection between inheritance and social class. The perception of fur as a symbolically loaded material enhances its suitability for being ‘kept in the family’. Clothing inheritance fosters bourgeois belonging over multiple generations, encouraging the patronage of selected spaces and services (including furriers). In the shorter term, however, generational differences within amicable grandmother-granddaughter pairs are amplified in part through the way pre-mortem inheritance practices highlight granddaughters' non-reciprocable debt to their grandmothers. A focus on fur as a particular kind of object highlights the significance of certain inheritance practices and their links to the affective ties in the reproduction of class in Poland. The article also contributes to a broader understanding of the reproduction of class by analysing the interconnections between taste, the body, and memory.

Study of Control Strategy and Software Architecture Based on Flat Type Small Parts Assembly

For different sizes of flat type small parts assembly problems, the assembly control strategy and software architecture are analyzed and machine vision is introduced into the micro-assembly work. Proposeing "Look and move + Visual servo" micro-assembly control mode, adopted by the interfacial layer, data layer and logic layer composed of layered software architecture, we designed a vision-based vacuum adsorption micro-assembly platform, and it can achieve different sizes of small parts precision assembly. The real-time of software and framework class inheritance, using object-oriented applications programming methods and integrate Halcon vision algorithm library is analyzed, eventually the process control system design is completed. By five flat type small parts consisting of micro components, a series of eight assembly experiment and precision measurements of its key indicators are conducted, It is shown that:The error of micro component concentricity and parallelism basically meet the accuracy requirements of assembly. The proposed control method can effectively for other micro-assembly system, and has a good real-time performance, reusability and human-computer interaction.

EVL: A framework for multi-methods in C++

Multi-methods are functions whose calls at runtime are resolved depending on the dynamic types of more than one argument. They are useful for common programming problems. However, while many languages provide different mechanisms to implement them in one way or another, there is still, to the best of our knowledge, no library or language feature that handles them in a general and flexible way. In this paper, we present the EVL (Extended Virtual function Library) framework which provides a set of classes in C++ aiming at solving this problem.The EVL framework provides a generalization of virtual function dispatch through the number of dimensions and the selection of the function to invoke using a so-called Function Comparison Operator. Our library provides both symmetric and asymmetric dispatch algorithms that can be refined by the programmer to include criteria other than class inheritance. For instance, the EVL framework provides multi-methods with predicate dispatch by defining a dedicated FCO based not only on the dynamic types of the arguments but also on their values. This flexibility greatly helps to resolve ambiguities without having to define new functions. Our multi-methods also unify dispatch tables and caching by introducing cache strategies for which the implementation is a balance between memory and speed.To define multi-methods in C++, we implement a non-intrusive reflection library providing fast dynamic casting and supporting dynamic class loading. Our multi-methods are policy-based class templates that support virtual but not repeated inheritance. They check the type compatibility of functions at compile-time, preserve type-safety and resolve function calls at runtime by invoking the cache or updating it by computing the selected function for the requested tuple of types. By default, our multi-methods handle dispatch errors at runtime by throwing exceptions but an error-code strategy can be set up by defining a dedicated policy class. Performance of our multi-methods is comparable with that of standard virtual functions when configured with fast cache.

연구데이터 관리 및 검색을 위한 스키마 클래스 상속 모델

최근 연구데이터가 국가자산이라는 인식의 확산으로 원시데이터 관리 및 재사용의 필요성이 이슈이다. 본 연구에서는 데이터의 체계적인 관리를 위해, 스키마 클래스를 상속하는 방식의 메타데이터 설계 모델과 상속을 통해 생성된 스키마 객체들을 대상으로 메타데이터 통합 검색 모델을 제안하였다. 스키마 클래스를 상속한 스키마 객체가 데이터 컬렉션에 1대1의 관계를 갖도록 데이터 아키텍처를 설계하였으며, 제안된 모델의 검증을 위해서 가상 스키마 클래스 및 객체가 시스템적으로 구현 가능함을 증명하였다. 본 연구에서 제안하는 스키마 클래스 상속 및 통합검색 모델은 일반적으로 사용되는 ‘하향식 계층 모델’의 단점을 극복하는 모델로서, 정부 기관에서 생산되는 데이터를 독립적으로 관리하는데 활용될 수 있다고 사료된다.

A Terse String-Embedded Language for Tree Searching and Replacing

Treepace is a new library and a domain specific language for tree pattern matching and replacing, implemented in Python. Selected concepts resemble the well-known application programing interface (API) for string regular expressions. The language is terse since it is possible to write a simple transformation consisting of a pattern and a replacement in one row. Objects of any types can be used as node values. Calling host language constructs, e.g., functions, in the embedded language is straightforward. Node class inheritance allows for mapping tree nodes to external objects like GUI (graphical user interface) components.

Software Engineering Based on Object Management Petri Net

Object management Petri net technique is developed to integrate analysis, design and implementation for applications of management information system. Not only object concept is adopted to describe tokens in places, but also class inheritance and composition, user interface and complicate algorithm are represented by expanded transitions. Three kinds of work modes of object management Petri net are introduced to fulfill development, execution, and simulation of the net system.

Narrar la ambivalencia desde el cuerpo: diálogo sobre nuestras propias experiencias en torno a la “no-maternidad”

article, we share a dialogue about our personal decision-making processes regarding motherhood, the convergence of institutionalized motherhood and compulsory heterosexuality, and the possibility of actively choosing non-motherhood. We claim that our resistances to the mandate of hetero-patriarchal motherhood -as well as the ambivalences present in our decision-making processes- are forms of embodied transgression and rebellion. We find it relevant to rescue our testimonies as feminists living in the decades of 1990 and 2000 because we believe that by rendering political our own experiences anchored in our bodies, our social class, ethnic origin and cultural inheritance, we become part of a political collective and we build theory that serves as a ground to think about ourselves and about our gendered society. Thus, our testimonies contribute to the processes of making personal decisions, sustaining political struggles and defining the subjects of feminisms.

New Quality Inheritance Metrics for Object-Oriented Design

Metrics are used to help a software engineer in quantitative analysis to assess the quality of the design before a system is built. Object-Oriented (OO) design is becoming more popular in software development environment and OO design metrics are essential parts of software environment. The primary purpose of this paper is to analytically evaluate against the Weyuker’s property and empirically validate, a proposed inheritance metrics (against a three versions of the same project) that can be used to measure the quality (especially focus on the quality factors “Reuse” and “Design Complexity”) of an OO systems in terms of the using class inheritance tree.

Verifying traits: an incremental proof system for fine-grained reuse

Abstract Traits have been proposed as a more flexible mechanism than class inheritance for structuring code in object-oriented programming, to achieve fine-grained code reuse. A trait originally developed for one purpose can be adapted and reused in a completely different context. Formalizations of traits have been extensively studied, and implementations of traits have started to appear in programming languages. So far, work on formally establishing properties of trait-based programs has mostly concentrated on type systems. This paper presents the first deductive proof system for a trait-based object-oriented language. If a specification of a trait can be given a priori, covering all actual usage of that trait, our proof system is modular as each trait is analyzed only once. However, imposing such a restriction may in many cases unnecessarily limit traits as a mechanism for flexible code reuse. In order to reflect the flexible reuse potential of traits, our proof system additionally allows new specifications to be added to a trait in an incremental way which does not violate established proofs. We formalize and show the soundness of the proof system.

Predicting object-oriented class reuse-proneness using internal quality attributes

Class reuse-proneness is the likelihood that a class can be reused and is a key quality characteristic in object-oriented design. Because it is clearly impossible to know with certainty when, where, how, and how often a class will be reused, this likelihood can only be estimated when a class is developed. At that stage, the internal quality attributes of a class such as cohesion, coupling, and size can be measured. In this paper, we empirically study the ability of 29 internal class quality measures, individually and in combination, to estimate class reuse-proneness. Specifically, we take into account both class inheritance and class instantiation, which are two ways in which a class can be reused. Our results show that most of the considered measures are predictors for the considered reuse-proneness attributes to some degree. The capability of the considered internal quality measures to predict class reuse-proneness is enhanced when the measures are combined using an optimized multivariate statistical model. The results also show that the size and coupling attributes of a class have positive impacts on its reuse-proneness via inheritance and instantiation. The cohesion of a class has a negative impact on its inheritance reuse-proneness and a positive impact on its instantiation reuse-proneness. The overall results of the empirical study show that software developers can use a number of predictors to assess the reuse-proneness of classes and possibly improve the reuse-proneness of the classes by controlling their internal quality attributes. Our results contribute to the evaluation of the quality of a class, but a comprehensive evaluation of the quality of a class should take into account many more qualities. Also, not all classes in a software system are built with reuse-proneness in mind, so our results should be applied only to those that are designed and implemented to be reusable.

New Proposed Inheritance Metrics to Measure the Software Complexity

Inheritance is an important aspect of object-oriented paradigm during software development. Inheritance supports the class hierarchy design and relation between classes and inheritance also has an impact on the complexity of software. Complexity of software increases the testing and maintenance efforts. So researchers and developer always try to reduce the software complexity because low software complexity reduce testing and maintainability. In this study, we propose two new inheritance metrics based on level of methods like CCDIT (Class Complexity due to Depth of Inheritance Tree) and CCNOC (Class Complexity due to Number of Children) to measure the complexity of methods in classes. Firstly we present the Chidamber & Kemerer (C & K) metrics for class inheritance and related work. Secondly we measure and investigate the software complexity by generating UML diagram of software. Lastly we present comparison of newly proposed metrics with other inheritance metrics proposed by other researchers. General Terms:

Object-oriented programming with gradual abstraction

We describe an experimental object-oriented programming language, ASL2, that supports program development by means of a series of abstraction steps. The language allows immediate object construction, and it is possible to use the constructed objects for concrete problem solving tasks. Classes and class hierarchies can be derived from the objects - via gradual abstraction steps. We introduce two levels of object classification, called weak and strong object classification. Strong object classification relies on conventional classes, whereas weak object classification is looser, and less restrictive. As a central mechanism, weakly classified objects are allowed to borrow methods from each other. ASL2 supports class generalization, as a counterpart to class specialization and inheritance in mainstream object-oriented programming languages. The final abstraction step discussed in this paper is a syntactical abstraction step that derives a source file with a syntactical class form.

Refactoring and representation independence for class hierarchies

Refactoring transformations are important for productivity and quality in software evolution. Modular reasoning about semantics preserving transformations is difficult even in typed class-based languages because transformations can change the internal representations for multiple interdependent classes and because encapsulation can be violated by pointers to mutable objects. In this paper, an existing theory of representation independence for a single class, based on a simple notion of ownership confinement, is generalized to a hierarchy of classes and used to prove refactoring rules that embody transformations of complete class trees. This allows us to formalize refactorings that inherently involve class inheritance, such as Pull Up or Push Down Field; moreover, this makes it possible to generalize refactorings previously restricted to change of data representation of private attributes (like Extract Class and Encapsulate Field) to address data refinement of protected attributes, dealing with the impact that the corresponding transformations may cause in the subclasses. The utility of the proposed rules is shown in a relatively extensive case study. Shortcomings of the theory are described as a challenge to other approaches to heap encapsulation and relational reasoning for classes.

PyOpt: a Python-based object-oriented framework for nonlinear constrained optimization

We present pyOpt, an object-oriented framework for formulating and solving nonlinear constrained optimization problems in an efficient, reusable and portable manner. The framework uses object-oriented concepts, such as class inheritance and operator overloading, to maintain a distinct separation between the problem formulation and the optimization approach used to solve the problem. This creates a common interface in a flexible environment where both practitioners and developers alike can solve their optimization problems or develop and benchmark their own optimization algorithms. The framework is developed in the Python programming language, which allows for easy integration of optimization software programmed in Fortran, C, C+?+, and other languages. A variety of optimization algorithms are integrated in pyOpt and are accessible through the common interface. We solve a number of problems of increasing complexity to demonstrate how a given problem is formulated using this framework, and how the framework can be used to benchmark the various optimization algorithms.

Comparison of Class Inheritance and Interface Usage in Object Oriented Programming through Complexity Measures

It is widely acknowledged that in software engineering, the usage of metrics at the initial phases of the object oriented software can help designers to make better decisions. The quality of class diagrams could be a major determinant for the quality of the software product that is finally delivered. Quantitative measurements are useful to assess class diagram quality. Following this innovative thinking, two UML class diagrams are taken to measure the complexity and size. A set of metrics of complexity measures are used to measure the class diagrams. Seven known complexity measures are evaluated and compared for inheritance and interface usage in object oriented programming. Two UML class diagrams are introduced with possible interfaces and measured the complexity metrics and a comparison has been made between the class inheritance and class interface usage through complexity measurements.

Inheritance Metrics for Object-Oriented Design

The inheritance metrics give us information about the inheritance tree of the system. Inheritance is a key feature of the Object-Oriented (OO) paradigm. This mechanism supports the class hierarchy design and captures the IS-A relationship between a super class and its subclass. Several OO inheritance metrics have been proposed and their reviews are available in the literature. Among the various measurements we focus on the metrics of class inheritance hierarchies. In this paper we consider the inheritance metrics of F.T. Sheldon et al (2002) and Henderson Seller's (1996) for comparison with proposed inheritance metric suites. In doing so, an attempt has been made to define empirical relationship between the proposed inheritance metric suites with considered existing inheritance metrics and the focus was on which how the inheritance metric suites were correlated with the existing ones. Data for several C++ classes has been collected from various sources.

Delegation by object composition

Class inheritance and method overriding, as provided by standard class-based languages, are often not flexible enough to represent objects with some dynamic behavior. In this respect, object composition equipped with different forms of method body lookup is often advocated as a more flexible alternative to class inheritance since it takes place at run time, thus permitting the behavior of objects to be specialized dynamically. In this paper, we illustrate Incomplete Featherweight Java (IFJ), an extension of Featherweight Java with a novel linguistic construct, the incomplete object. Incomplete objects require some missing methods which can be provided at run time by composition with another (complete) object. Furthermore, we present two mechanisms for the method body lookup on (composed) objects, one based on delegation and the other based on consultation. Thanks to the design of the language, the consultation-based lookup is a simple extension of the delegation-based one. Both mechanisms are disciplined by static typing, therefore the language enjoys type safety (which implies no “message-not-understood” run-time errors) and avoids possible accidental overrides due to method name clashes.

Nonlinear Finite-Element Analysis Software Architecture Using Object Composition

Object composition offers significant advantages over class inheritance to develop a flexible software architecture for finite-element analysis. Using this approach, separate classes encapsulate fu...

Coping with abstraction in object orientation with a special focus on interface classes

One of the subjects that undergraduate students learning Object Oriented (OO) design find hard to apply is the construction of class hierarchies in general, and the use of interface classes in particular. The design process requires decomposition and reconstruction of problems in order to model software classes. The common attributes and behaviors are usually modeled using class inheritance except when the common behaviors do not belong to the same class hierarchy; in such case, an interface class is preferred. In order to be able to properly design, the designer has to demonstrate the abstraction abilities on various levels. In this study, we aimed at examining the students' demonstration of abstraction levels during design of class hierarchy in general, and whether or not they use interface classes in particular. The results of the study reveal that a majority of students were able to build a reasonable class hierarchy; however, many of them did not use interface classes as a tool for expressing common behaviors. Nevertheless, all of them could identify and choose the best solution for a particular problem among four different solutions, which included the use of interface class.

Development of a Multidisciplinary Collaborative Design System

A new product modeling method for product multidisciplinary collaborative design (MCD) is put forward. The method uses a flexible product model which can be extended transversely and lengthwise by multiple levels’ inheritance and new attribute classes’ addition and a class inheritance mechanism under network environment which allows each discipline to build own view model of a product. An open and flexible system architecture supporting the product MCD effectively is put forward, and prototype system implementation is introduced.