• Documents
  • Authors
  • Tables
  • Log in
  • Sign up
  • MetaCart
  • DMCA
  • Donate

CiteSeerX logo

Advanced Search Include Citations
Advanced Search Include Citations | Disambiguate

Data Abstraction and Hierarchy

by Barbara Liskov
Add To MetaCart

Tools

Sorted by:
Results 1 - 10 of 157
Next 10 →

Object-oriented Analysis and Design with Applications

by Grady Booch - 2ND EDITION, THE BENJAMIN/CUMMINGS PUBLISHING COMPANY, INC , 1994
"... ..."
Abstract - Cited by 1237 (0 self) - Add to MetaCart
Abstract not found
(Show Context)

Citation Context

...one level of abstraction are shielded fromsimplementation details at lower levels of abstraction.sLiskov goes as far as to suggest that "for abstraction to work, implementations must besencapsulated" =-=[53]-=-. In practice, this means that each class must have two parts: an interfacesand an implementation. The interface of a class captures only its outside view, encompassingsour abstraction of the behavior...

Refactoring Object-Oriented Frameworks

by William F. Opdyke , 1992
"... This thesis defines a set of program restructuring operations (refactorings) that support the design, evolution and reuse of object-oriented application frameworks. The focus of the thesis is on automating the refactorings in a way that preserves the behavior of a program. The refactorings are defin ..."
Abstract - Cited by 489 (4 self) - Add to MetaCart
This thesis defines a set of program restructuring operations (refactorings) that support the design, evolution and reuse of object-oriented application frameworks. The focus of the thesis is on automating the refactorings in a way that preserves the behavior of a program. The refactorings are defined to be behavior preserving, provided that their preconditions are met. Most of the refactorings are simple to implement and it is almost trivial to show that they are behavior preserving. However, for a few refactorings, one or more of their preconditions are in general undecidable. Fortunately, for some cases it can be determined whether these refactorings can be applied safely. Three of the most complex refactorings are defined in detail: generalizing the inheritance hierarchy, specializing the inheritance hierarchy and using aggregations to model the relationships among classes. These operations are decomposed into more primitive parts, and the power of these operations is discussed from the perspectives of automatability and usefulness in supporting design. Two design constraints needed in refactoring are class invariants and exclusive components. These constraints are needed to ensure that behavior is preserved across some refactorings. This thesis gives some conservative algorithms for determining whether a program satisfies these constraints, and describes how to use this design information to refactor a program.
(Show Context)

Citation Context

...ing is most frequently used to model conceptual hierarchies. When used in this way, a subtype describes a type that is more specific than a supertype; the subtype is a specialization of the supertype =-=[53, 74]-=-. 5MS-DOS is a trademark of Microsoft Corporation. 15 Inheritance can be used in several ways; some clarify the design of a framework while others can make a framework more difficult to understand. On...

Specification Matching of Software Components

by Amy Moormann Zaremski, Jeannette M. Wing - ACM Transactions on Software Engineering and Methodology , 1996
"... Specification matching is a way to compare two software components based on descriptions of the components' behaviors. In the context of software reuse and library retrieval, it can help determine whether one component can be substituted for another or how one can be modified to fit the requ ..."
Abstract - Cited by 358 (4 self) - Add to MetaCart
Specification matching is a way to compare two software components based on descriptions of the components' behaviors. In the context of software reuse and library retrieval, it can help determine whether one component can be substituted for another or how one can be modified to fit the requirements of the other. In the context of object-oriented programming, it can help determine when one type is a behavioral subtype of another. We use formal specifications to describe the behavior of software components, and hence, to determine whether two components match. We give precise definitions of not just exact match, but more relevantly, various flavors of relaxed match. These definitions capture the notions of generalization, specialization, and substitutability of software components. Since our formal specifications are pre- and post-conditions written as predicates in firstorder logic, we rely on theorem proving to determine match and mismatch. We give examples from our impleme...
(Show Context)

Citation Context

... object o 1 of type S there is an objectso 2 of type T such that for all programs P defined in terms of T , the behavior of P is unchanged when o 1 is substituted for o 2 , then S is a subtype of T . =-=[14]-=-. Behavioral notions of subtyping that attempt to capture this substitutability property have since been defined by many, including America [1], Leavens and his colleagues [12, 13, 3], Meyer [18], and...

Software Reuse

by Charles W. Krueger - ACM Computing Surveys , 1992
"... Software reuse is the process ofcreating software systems from existing software rather than building software systems from scratch. ‘l’his simple yet powerful vision was introduced in 1968. Software reuse has, however, failed to become a standard software engineering practice. In an attempt to unde ..."
Abstract - Cited by 307 (2 self) - Add to MetaCart
Software reuse is the process ofcreating software systems from existing software rather than building software systems from scratch. ‘l’his simple yet powerful vision was introduced in 1968. Software reuse has, however, failed to become a standard software engineering practice. In an attempt to understand why, researchers have renewed their interest in software reuse and in the obstacles to implementing it. This paper surveys the different approaches to software reuse found in the research literature. It uses a taxonomy to describe and compare the different approaches and make generalizations about the field of software reuse. The taxonomy characterizes each reuse approach interms of its reusable artifacts and the way these artifacts are abstracted, selected, speciahzed, and integrated. Abstraction plays a central role in software reuse. Concise and expressive abstractions are essential if software artifacts are to be effectively reused. The effectiveness of a reuse technique can be evaluatedin terms of cognztzue dwtance-an intuitive gauge of the intellectual effort required to use the technique. Cognitive distance isreduced in two ways: (l) Higher level abstractions ina reuse technique

A Paradigmatic Object-Oriented Programming Language: Design, Static Typing and Semantics

by Kim B. Bruce - Journal of Functional Programming , 1993
"... In order to illuminate the fundamental concepts involved in object-oriented programming languages, we describe the design of TOOPL, a paradigmatic, statically-typed, functional, object-oriented programming language which supports classes, objects, methods, hidden instance variables, subtypes, and in ..."
Abstract - Cited by 119 (9 self) - Add to MetaCart
In order to illuminate the fundamental concepts involved in object-oriented programming languages, we describe the design of TOOPL, a paradigmatic, statically-typed, functional, object-oriented programming language which supports classes, objects, methods, hidden instance variables, subtypes, and inheritance. It has proven to be quite difficult to design such a language which has a secure type system. A particular problem with statically type checking object-oriented languages is designing type-checking rules which ensure that methods provided in a superclass will continue to be type correct when inherited in a subclass. The type-checking rules for TOOPL have this feature, enabling library suppliers to provide only the interfaces of classes with actual executable code, while still allowing users to safely create subclasses. In order to achieve greater expressibility while retaining type-safety, we choose to separate the inheritance and subtyping hierarchy in the language. The design of...
(Show Context)

Citation Context

...as possible. Inheritance has clear advantages in prototyping systems. However there appear to be real dangers of excessive complexity when long subclass chains are left in large systems. Others (see (=-=Liskov, 1988-=-; Snyder, 1986), for example) have cautioned about the dangers of loss of encapsulation in inheritance. A related problem is that minor changes in a superclass can invalidate method definitions lower ...

An Empirical Investigation of an Object-Oriented Software System

by Michelle Cartwright, Martin Shepperd - IEEE Transactions on Software Engineering , 1997
"... This paper describes an empirical investigation into an industrial object-oriented (OO) system comprising 133,000 lines of C++. The system was a sub system of a telecommunications product and was developed using the Shlaer-Mellor method. ..."
Abstract - Cited by 73 (0 self) - Add to MetaCart
This paper describes an empirical investigation into an industrial object-oriented (OO) system comprising 133,000 lines of C++. The system was a sub system of a telecommunications product and was developed using the Shlaer-Mellor method.
(Show Context)

Citation Context

... that the system was built over a period 1993 to 1994, when far less guidance was available with regard to "good" or "proper" use of inheritance. Research work such as Liskov's substitution principle =-=[18]-=- had not permeated into standard practice and design heuristics such as [19] were not published until OO software was more established. Second, the classes with the highest defect densities were found...

ICC++ -- A C++ Dialect for High Performance Parallel Computing

by A. A. Chien, U. S. Reddy, Chien Reddy Plevyak, J. Dolby - In Proceedings of the 2nd International Symposium on Object Technologies for Advanced Software , 1996
"... ICC++ is a new C++ concurrent dialect which allows sequential/parallel program versions to be maintained with single source, the construction of concurrent data abstractions, convenient expression of irregular and fine-grained concurrency, and supports high performance implementations. ICC++ prov ..."
Abstract - Cited by 62 (11 self) - Add to MetaCart
ICC++ is a new C++ concurrent dialect which allows sequential/parallel program versions to be maintained with single source, the construction of concurrent data abstractions, convenient expression of irregular and fine-grained concurrency, and supports high performance implementations. ICC++ provides annotations for potential concurrency, facilitating both sharing source with sequential programs and grain size tuning for efficient execution. ICC++ has a notion of object consistency which can be extended structurally and procedurally to implement larger data abstractions. Finally, ICC++ integrates arrays into the object system and hence the concurrency model. In short, ICC++ addresses concurrency and its relation to abstractions -- whether they are implemented by single objects, several objects, or object collections. The design of the language, its rationale, and current status are all described. Keywords concurrent object-oriented programming, concurrent languages, parallel...
(Show Context)

Citation Context

...s perform logically atomic updates to the abstraction's state; and each operation must maintain the consistency of that state. Support for such abstractions in sequential languages is well understood =-=[30, 34]-=-, but the situation is more complex for concurrent languages [1, 43, 17, 2, 4, 9, 24, 22]. Concurrency allows only a partial order on state updates, complicating the notion of consistency. Any concurr...

On the Separation of Concerns in Program Families

by Adrian Colyer, Awais Rashid, Gordon Blair , 2004
"... Aspect-orientation can help to separate concerns in software. One of the goals of this separation is to promote flexibility and configurability; this is especially true when constructing program families (and product-lines). This paper introduces a set of principles that instruct in the creation of ..."
Abstract - Cited by 52 (0 self) - Add to MetaCart
Aspect-orientation can help to separate concerns in software. One of the goals of this separation is to promote flexibility and configurability; this is especially true when constructing program families (and product-lines). This paper introduces a set of principles that instruct in the creation of flexible, configurable, aspect-oriented systems. We illustrate the principles through their application to a software product-line. The principle of dependency alignment serves as a guideline for structuring concern implementation in modules, eliminating unwarranted dependencies between concerns. The principles of orthogonal and weakly orthogonal aspects instruct in the design of aspects that are included in some system configurations, but not in others. We show how these principles scale to larger systems and larger concern implementations.
(Show Context)

Citation Context

... in on individual aspects, and the design guidelines that enable the inclusion or exclusion of an aspect to be made a configurable option in a software system. Barbara Liskov’s substitution principl=-=e [13] g-=-ives the conditions under which a derived class can be considered a genuine subtype of its super-type. The principle is stated as follows: “If for each object o1 of type S there is an object o2 of t...

Enhancing modular OO verification with separation logic

by Wei-ngan Chin, Cristina David, Huu Hai Nguyen, Shengchao Qin - In Proceedings of POPL , 2008
"... chinwn,davidcri,nguyenh2© Conventional specifications for object-oriented (OO) programs must adhere to behavioral subtyping in support of class inheritance and method overriding. However, this requirement inherently weakens the specifications of overridden methods in superclasses, leading to impreci ..."
Abstract - Cited by 46 (4 self) - Add to MetaCart
chinwn,davidcri,nguyenh2© Conventional specifications for object-oriented (OO) programs must adhere to behavioral subtyping in support of class inheritance and method overriding. However, this requirement inherently weakens the specifications of overridden methods in superclasses, leading to imprecision during program reasoning. To address this, we advocate a fresh approach to OO verification that focuses on the distinction and relation between specifications that cater to calls with static dispatching from those for calls with dynamic dispatching. We formulate a novel specification subsumption that can avoid code re-verification, where possible. Using a predicate mechanism, we propose a flexible scheme for supporting class invariant and lossless casting. Our aim is to lay the foundation for a practical verification system that is precise, concise and modular for sequential OO programs. We exploit the separation logic formalism to achieve this.
(Show Context)

Citation Context

...ject types in the class hierarchy, including any class invariant that may be imposed. From the point of conformance to OO semantics, most analysis techniques uphold Liskov’s Substitutivity Principle (=-=Liskov 1988-=-) on behavioral subtyping. Under Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distrib...

Design of class hierarchies based on concept (Galois) lattices

by Robert Godin, Hafedh Mili, Guy W. Mineau, Rokia Missaoui, Amina Arfi, Thuy-tien Chau , 1998
"... Building and maintaining the class hierarchy has been recognized as an important but one of the most difficult activities of object-oriented design. Concept (or Galois) lattices and related structures are presented as a framework for dealing with the design and maintenance of class hierarchies. Beca ..."
Abstract - Cited by 36 (1 self) - Add to MetaCart
Building and maintaining the class hierarchy has been recognized as an important but one of the most difficult activities of object-oriented design. Concept (or Galois) lattices and related structures are presented as a framework for dealing with the design and maintenance of class hierarchies. Because the design of class hierarchies is inherently an iterative and incremental process, we designed incremental algorithms that update existing Galois lattices as the result of adding, removing, or modifying class specifications. A prototype tool incorporating this and other algorithms has been developed as part of the IGLOO project, which is a large object-oriented software engineering joint research project involving academic and industrial partners. The tool can generate either the concept lattice or several variant structures incrementally by incorporating new classes one by one. The resulting hierarchies can be interactively explored and refined using a graphical browser. In addition, s...
Powered by: Apache Solr
  • About CiteSeerX
  • Submit and Index Documents
  • Privacy Policy
  • Help
  • Data
  • Source
  • Contact Us

Developed at and hosted by The College of Information Sciences and Technology

© 2007-2019 The Pennsylvania State University