Object-Oriented Design Choices
1st Edition
Published on 19. January 2021
Book
Hardback
348 pages
978-0-367-82081-7 (ISBN)
Description
Do modern programming languages, IDEs, and libraries make coding easy? Maybe, but coding is not design. Large-scale or expensive apps clearly require evaluation of design choices. Still, software design directly impacts code reuse and longevity even for small-scale apps with limited overhead. This text evaluates and contrasts common object-oriented designs.
A given problem may have many solutions. A developer may employ different design techniques - composition, inheritance, dependency injection, delegation, etc. - to solve a particular problem. A skilled developer can determine the costs and benefits of different design responses, even amid competing concerns. A responsible developer documents design choices as a contract with the client, delineating external and internal responsibilities. To promote effective software design, this book examines contractual, object-oriented designs for immediate and sustained use as well as code reuse. The intent of identifying design variants is to recognize and manage conflicting goals such as short versus long-term utility, stability versus flexibility, and storage versus computation. Many examples are given to evaluate and contrast different solutions and to compare C# and C++ effects. No one has a crystal ball; however, deliberate design promotes software longevity. With the prominence of legacy OO code, a clear understanding of different object-oriented designs is essential.
Design questions abound. Is code reuse better with inheritance or composition? Should composition rely on complete encapsulation? Design choices impact flexibility, efficiency, stability, longevity, and reuse, yet compilers do not enforce design and syntax does not necessarily illustrate design. Through deliberate design, or redesign when refactoring, developers construct sustainable, efficient code.
A given problem may have many solutions. A developer may employ different design techniques - composition, inheritance, dependency injection, delegation, etc. - to solve a particular problem. A skilled developer can determine the costs and benefits of different design responses, even amid competing concerns. A responsible developer documents design choices as a contract with the client, delineating external and internal responsibilities. To promote effective software design, this book examines contractual, object-oriented designs for immediate and sustained use as well as code reuse. The intent of identifying design variants is to recognize and manage conflicting goals such as short versus long-term utility, stability versus flexibility, and storage versus computation. Many examples are given to evaluate and contrast different solutions and to compare C# and C++ effects. No one has a crystal ball; however, deliberate design promotes software longevity. With the prominence of legacy OO code, a clear understanding of different object-oriented designs is essential.
Design questions abound. Is code reuse better with inheritance or composition? Should composition rely on complete encapsulation? Design choices impact flexibility, efficiency, stability, longevity, and reuse, yet compilers do not enforce design and syntax does not necessarily illustrate design. Through deliberate design, or redesign when refactoring, developers construct sustainable, efficient code.
Reviews / Votes
"The introduction of object-oriented programming was a pivotal moment in software engineering, leading to a new way of creating systems by modelling their constituents independently and linking them through shared interfaces. Object orientation allows for the creation of more complex systems, better focus on a small subset of components at any given time, and a greater level of component independence; it even facilitates the creation of software product lines. Designing a system using object orientation requires the mastery of several interdependent concepts, such as abstraction, inheritance, composition, and polymorphism. Dingle (Seattle Univ.) provides a cohesive framework for learning object-oriented design from a practical point of view. Concepts are introduced hierarchically, starting from the idea of encapsulation and design as a contract and drilling down to specifics such as virtual function tables and abstract classes. This approach results in an incremental experience of learning object-oriented design that is rarely found in computer science courses, but that is essential for software engineers who wish to harness the power of object-oriented programming languages in practice. Although no book can fully replace hands-on bench experience, this compact guide can ensure that one's practical efforts will be optimally targeted.--L. Benedicenti, University of New Brunswick
Review in April 2022 Issue of CHOICE
More details
Language
English
Place of publication
Oxford
United Kingdom
Publishing group
Taylor & Francis Ltd
Target group
Professional and scholarly
Academic and Professional Practice & Development
Illustrations
14 s/w Abbildungen, 21 s/w Tabellen
21 Tables, black and white; 14 Illustrations, black and white
Dimensions
Height: 240 mm
Width: 161 mm
Thickness: 23 mm
Weight
690 gr
ISBN-13
978-0-367-82081-7 (9780367820817)
Copyright in bibliographic data and cover images is held by Nielsen Book Services Limited or by the publishers or by their respective licensors: all rights reserved.
Schweitzer Classification
Other editions
Additional editions
Adair Dingle
Object-Oriented Design Choices
Book
01/2021
1st Edition
Chapman & Hall/CRC
€83.30
Shipment within 15-20 days
Adair Dingle
Object-Oriented Design Choices
E-Book
01/2021
1st Edition
Chapman & Hall/CRC
€81.99
Available for download
Adair Dingle
Object-Oriented Design Choices
E-Book
01/2021
1st Edition
Chapman & Hall/CRC
€81.99
Available for download
Person
Adair Dingle, PhD, is a professor of computer science at Seattle University, Washington, USA whose previous text, Software Essentials: Design and Construction, received the 2015 Alpha Sigma Nu Book Award. Teaching and research interests focus on algorithms and software design including efficient memory management, patterns, refactoring and tools for software development and education.
Content
Preface
Detailed Book Outline
Section I: Stable Type Desig
Contractual Design and the Class Construct
Encapsulation
Explicit Design and Constraints
Class (Type) Functionality
Constructors
Accessors and Mutators
Utility and Public Methods
Destructors
Design as a Contract
Error Handling
Published Assumptions
Invariants
Programming by Contract Example
Contractual Expectations
OO Design Principle
Summary
Design Exercises
Ownership - Abstracted but Tracked
The Abstraction of Memory
Heap Memory
Ownership of Heap Objects
Array Allocation
Design Intervention
Persistent Data
Class Design
Memory Reclamation
C++ Explicit Deallocation
Garbage Collection
Reference Counting
Design: Storage vs Computation
OO Design Principle
Summary
Design Exercise
Data Integrity
Data Corruption
Copying
Shallow versus Deep Copying
C++ Copying of Internal Heap Memory
Unseen Aliasing
C# Cloning to Avoid Aliasing
Move semantics
Handle: C++ Smart Pointers
unique_ptr
shared_ptr
weak_ptr
usage
OO Design Principle
Summary
Design Exercises
Section II: Strategic Type Coupling
Composition
Object-oriented Relationships
Containment (Holds-A)
Composition (Has-A)
Modification
Replacement
Postponed instantiation
Echoing an Interface
Interfaces for Design Consistency
Wrappers and Delegates
Dependency Injection
Constructor Injection
Property (Setter) Injection
Method Injection
Dependency Injection Costs and Benefits
OO Design Principle
Summary
Design Exercises
Inheritance
Automate Type Checking
Polymorphism
Overloading
Generics
Subtype polymorphism
Function inlining
Costs and Benefits of Polymorphism
Dynamic Binding
whoami() type identification
Keywords for dynamic binding
Heterogeneous Collections
Virtual Function table
Abstract Classes
Inheritance designs
OO Design Principle
Summary
Design Exercises
Inheritance vs Composition
Constrained Inheritance
When Only Composition is Viable
When Inheritance Leaks Memory: C++ destructors
Inconsistent Access:
C++ accessibility and binding
Code Reuse
Class Design: Has-a or Is-a?
Inheritance with and without Composition
5Software Maintainability
OO Design Principle
Summary
Design Exercises
Section III: Effective Type Reuse
Design Longevity
Software Evolution
Disassembler Example
Virtual Function Table
Type Extraction
Problematic Type Extension
Multiple Inheritance and its Simulation
Design difficulties
Single inheritance with composition
Simulation without inheritance
Class Hierarchies Cross-Products
OO Design Principle
Summary
Design Exercises
Operator Overloading
Operators represent functions
Overloading Addition in C++
Client Expectations
Operator Overloading in C#
Operators Overloaded only in C++
Indexing support
I/O via the stream operators
Type conversion
Transparent access
OO Design Principle
Summary
Design Exercise
Appendix A: The Pointer Construct
Pointer definition
Dereferencing pointers
Inappropriate use of pointers
Transient versus persistent memory
References
The this pointer
Arrays
Summary
Appendix B: Design Examples
Contractual Design
Ownership: C++ class memory management
Copying
Composition
Inheritance
Appendix C: Comparative Design Examples
Composition versus Inheritance
Design longevity
Operator overloading
Glossary
References
Detailed Book Outline
Section I: Stable Type Desig
Contractual Design and the Class Construct
Encapsulation
Explicit Design and Constraints
Class (Type) Functionality
Constructors
Accessors and Mutators
Utility and Public Methods
Destructors
Design as a Contract
Error Handling
Published Assumptions
Invariants
Programming by Contract Example
Contractual Expectations
OO Design Principle
Summary
Design Exercises
Ownership - Abstracted but Tracked
The Abstraction of Memory
Heap Memory
Ownership of Heap Objects
Array Allocation
Design Intervention
Persistent Data
Class Design
Memory Reclamation
C++ Explicit Deallocation
Garbage Collection
Reference Counting
Design: Storage vs Computation
OO Design Principle
Summary
Design Exercise
Data Integrity
Data Corruption
Copying
Shallow versus Deep Copying
C++ Copying of Internal Heap Memory
Unseen Aliasing
C# Cloning to Avoid Aliasing
Move semantics
Handle: C++ Smart Pointers
unique_ptr
shared_ptr
weak_ptr
usage
OO Design Principle
Summary
Design Exercises
Section II: Strategic Type Coupling
Composition
Object-oriented Relationships
Containment (Holds-A)
Composition (Has-A)
Modification
Replacement
Postponed instantiation
Echoing an Interface
Interfaces for Design Consistency
Wrappers and Delegates
Dependency Injection
Constructor Injection
Property (Setter) Injection
Method Injection
Dependency Injection Costs and Benefits
OO Design Principle
Summary
Design Exercises
Inheritance
Automate Type Checking
Polymorphism
Overloading
Generics
Subtype polymorphism
Function inlining
Costs and Benefits of Polymorphism
Dynamic Binding
whoami() type identification
Keywords for dynamic binding
Heterogeneous Collections
Virtual Function table
Abstract Classes
Inheritance designs
OO Design Principle
Summary
Design Exercises
Inheritance vs Composition
Constrained Inheritance
When Only Composition is Viable
When Inheritance Leaks Memory: C++ destructors
Inconsistent Access:
C++ accessibility and binding
Code Reuse
Class Design: Has-a or Is-a?
Inheritance with and without Composition
5Software Maintainability
OO Design Principle
Summary
Design Exercises
Section III: Effective Type Reuse
Design Longevity
Software Evolution
Disassembler Example
Virtual Function Table
Type Extraction
Problematic Type Extension
Multiple Inheritance and its Simulation
Design difficulties
Single inheritance with composition
Simulation without inheritance
Class Hierarchies Cross-Products
OO Design Principle
Summary
Design Exercises
Operator Overloading
Operators represent functions
Overloading Addition in C++
Client Expectations
Operator Overloading in C#
Operators Overloaded only in C++
Indexing support
I/O via the stream operators
Type conversion
Transparent access
OO Design Principle
Summary
Design Exercise
Appendix A: The Pointer Construct
Pointer definition
Dereferencing pointers
Inappropriate use of pointers
Transient versus persistent memory
References
The this pointer
Arrays
Summary
Appendix B: Design Examples
Contractual Design
Ownership: C++ class memory management
Copying
Composition
Inheritance
Appendix C: Comparative Design Examples
Composition versus Inheritance
Design longevity
Operator overloading
Glossary
References