shopping cart
Call us:  800-878-7323 HELP
McAfee SECURE helps keep you safe from identity theft, credit card fraud, spyware, spam, viruses and online scams.
Interviews | June 19, 2009

All posts by Dave Jim Lynch Makes Landscape Art... Out of Text

If Carl Hiaasen set one of his novels on a residential stretch of boundary line between British Columbia and Washington, or if Richard Russo's characters had relatives in the Pacific Northwest, the result might be something like Jim Lynch's Border Songs. Continue »


  1. $18.16 Sale Hardcover add to wish list

    Border Songs

    Jim Lynch

$59.80
List price: $64.99
HARDCOVER, NEW
Ships in 1 to 3 days
Add to Wishlist
available for shipping or prepaid pickup only
Available for In-store Pickup
in 7 to 12 days
Qty Store Section
1 Partner Warehouse Software Engineering- Object Oriented Programming


Object-oriented Design Through Heuristics (96 Edition)

by Arthur Riel

Object-oriented Design Through Heuristics (96 Edition) Cover
  1. This particular item is stocked in a Partner Warehouse and will ship separately from other items in your shopping cart.

Synopses & Reviews

Publisher Comments:

020163385XB04062001

Synopsis:

This object-oriented development book provides specific experience-based guidelines to help developers make the right design decisions. It uses heuristics to show programmers under what conditions to apply patterns and offers the next step for those who know the basics of object-oriented design.

About the Author

Arthur J. Riel has more than twelve years of experience programming in C and C++ and currently teaches more than forty courses per year in both corporate and academic environments. He has participated in the development of many large systems, working with AT&T Bell Laboratories, Draper Laboratories, IBM, and Northeastern University. He has written numerous articles for publications including the Journal of Object-Oriented Programming, the C++ Insider, and the C/C++ Gazette. He is also a frequent lecturer at leading conferences including OOPSLA, Object Expo, SCOOP, and C++ World.

020163385XAB04062001

Table of Contents

Preface.

Acknowledgments.

1. The Motivation for Object-Oriented Programming.

Revolutionists, Evolutionists, and the Object-Oriented Paradigm.

Accidental Versus Essential Complexity à la Frederick Brooks.

The Waterfall Model.

The Iterative Model.

Same- Versus Different-Language Prototyping.

Software Reusability.

Corporate Hierarchies of Good Designers.

2. Classes and Objects: The Building Blocks of the Object-Oriented Paradigm.

Introduction to Classes and Object.

Messages and Methods.

Class Coupling and Cohesion.

Dynamic Semantics.

Abstract Classes.

Roles Versus Classes.

3. Topologies of Action-Oriented Versus Object-Oriented Applications.

Differences in Application Topologies.

When the Action-Oriented Paradigm Goes Right.

The God Class Problem (Behavioral Form).

Another Example of Poor System Intelligence Distribution.

The God Class Problem (Data Form).

The Proliferation of Classes Problem.

The Role of Agent Classes.

Examining the Use of Separate Entity and Controller Classes.

4. The Relationships Between Classes and Objects.

Introduction to Class and Object Relationships.

The Uses Relationship.

Six Different Ways to Implement the Uses Relationship.

Heuristics for the Uses Relationship.

Refining the Amount of Collaboration Between Two Classes.

The Containment Relationship.

Semantic Constraints Between Classes.

Attributes Versus Contained Classes.

More Containment Heuristics.

A Relationship Between Uses and Containment?

Containment by Value Versus Containment by Reference.

5. The Inheritance Relationship.

Introduction to the Inheritance Relationship.

Overriding Base Class Methods in Derived Classes.

The Use of the Protected Section of a Base Class.

The Width and Depth of Inheritance Hierarchies.

Private, Protected, and Public Inheritance à la C++.

A Real-World Example of Specialization.

Heuristics That Trade Off Design Complexity and Flexibility.

A Real-World Example of Generalization.

The Mechanism of Polymorphism.

A Problem with the Use of Inheritance as a Reusability Mechanism.

An Inheritance Solution to an Interrupt-Driven Architecture.

Inheritance Hierarchies Versus Attributes.

The Confusion of the Need for Inheritance Versus an Object's Dynamic Semantics.

Using Inheritance to Hide the Representation of a Class.

Mistaking Objects for Derived Classes.

Mistaking Object Generalization for the Need to Build Classes at Runtime.

The Attempt to NOP a Base Class Method in Its DerivedClass(es).

The Implementation of Optional Parts of Objects.

A Problem with No Optimal Solution.

Reusing Components Versus Reusing Frameworks.

6. Multiple Inheritance.

Introduction to Multiple Inheritance.

The Common Misuse of Multiple Inheritance.

A Valid Use of Multiple Inheritance.

Accidental Complexity In Languages That Do Not Support Multiple Inheritance.

Frameworks That Incorporate Multiple Inheritance.

The Use of Multiple Inheritance in the Design of Mixins.

DAG Multiple Inheritance.

Accidental DAG Multiple Inheritance via Poor Implementation of Optional Containment.

7. The Association Relationship.

Introduction to Associations.

Associations Implemented Through a Referential Attribute.

Associations Implemented Through a Third-Party Class.

Deciding Between a Containment and an Association Relationship.

8. Class-Specific Data and Behavior.

Introduction to Class-Specific Versus Object-Specific Data and Behavior.

Using Metaclasses to Capture Class-Specific Data and Behavior.

Using Language-Level Keywords to Implement Class- Versus Object-Specific Data and Behavior.

Metaclasses à la C++.

A Useful Abstract Class That Is Not a Base Class?

9. Physical Object-Oriented Design.

The Role of Logical and Physical Object-Oriented Design.

The Construction of Object-Oriented Wrappers.

Persistence in an Object-Oriented System.

Memory Management Issues in an Object-Oriented Application.

Minimal Public Interfaces for Reusable Components.

Implementing Safe Shallow Copies.

Concurrent Object-Oriented Programming.

Implementing Object-Oriented Designs in Nonobject-Oriented Languages.

10. The Relationship Between Heuristics and Patterns.

Heuristics Versus Patterns.

Transitivity Among Design Transformation Patterns.

The Reflexive Property of Design Transformation Patterns.

Other Design Transformation Patterns.

Future Research.

11. The Use of Heuristics in Object-Oriented Design.

The ATM Problem.

Choosing a Methodology.

A First Attempt at Producing an Object Model for the ATM.

Adding Behavior to Our Object Model.

Explicit Case Analysis Due to Accidental Complexity.

Messaging Objects in Different Address Spaces.

The Processing of the Transaction.

Returning to the Domain of the ATM.

Other Miscellaneous Issues.

Conclusion.

A. Heuristics Summary.

B. Memory Leakage in C++.

C. Selected C++ Examples.

Bibliography.

Index. 020163385XT04062001


Product Details

ISBN:
9780201633856
Author:
Riel, Arthur J.
Publisher:
Addison-Wesley Professional
Author:
Riel, Arthur J.
Location:
Reading, Mass. :
Subject:
Programming - General
Subject:
Programming - Object Oriented Programming
Subject:
Object-oriented programming (computer science
Subject:
Programming / Object Oriented
Subject:
Object-oriented pro
Publication Date:
April 1996
Binding:
Hardcover
Grade Level:
Professional and scholarly
Language:
English
Illustrations:
Yes
Pages:
379
Dimensions:
9.50x7.60x1.28 in. 2.19 lbs.

Other books you might like

  1. $35.00 Used Hardcover add to wish list
  2. $67.25 New Trade Paper add to wish list
  3. $56.95 New Trade Paper add to wish list
  4. $69.99 New Hardcover add to wish list
  5. $4.95 Used Mass Market add to wish list
  6. $5.75 Used Hardcover add to wish list

Related Aisles

  • back to top

Powell's City of Books is an independent bookstore in Portland, Oregon, that fills a whole city block with more than a million new, used, and out of print books. Shop those shelves — plus literally millions more books, DVDs, and eBooks — here at Powells.com.