You are previewing Object Thinking.
O'Reilly logo
Object Thinking

Book Description

In OBJECT THINKING, esteemed object technologist David West contends that the mindset makes the programmer—not the tools and techniques. Delving into the history, philosophy, and even politics of object-oriented programming, West reveals how the best programmers rely on analysis and conceptualization—on thinking—rather than formal process and methods. Both provocative and pragmatic, this book gives form to what’s primarily been an oral tradition among the field’s revolutionary thinkers—and it illustrates specific object-behavior practices that you can adopt for true object design and superior results.

Gain an in-depth understanding of:

  • Prerequisites and principles of object thinking.

  • Object knowledge implicit in eXtreme Programming (XP) and Agile software development.

  • Object conceptualization and modeling.

  • Metaphors, vocabulary, and design for object development.

  • Learn viable techniques for:

  • Decomposing complex domains in terms of objects.

  • Identifying object relationships, interactions, and constraints.

  • Relating object behavior to internal structure and implementation design.

  • Incorporating object thinking into XP and Agile practice.

  • Table of Contents

    1. Object Thinking
    2. Acknowledgments
    3. Preface
      1. A Different (and Possibly Controversial) Kind of Software Book
      2. Paths and Destinations
      3. Who Should Read This Book
      4. How This Book Is Organized
    4. Introduction
      1. Curiosities
      2. The "People Issue"
        1. The Need for Better Developers
        2. Producing Better Developers
      3. Object Thinking
      4. XP and Object Thinking
    5. 1. Object Thinking
      1. Observing the Object Difference
      2. Object Thinking = Think Like an Object
      3. Problem = Solution
      4. Object Thinking and Agile Development Practices
        1. Values
          1. Communication
          2. Simplicity
          3. Feedback
          4. Courage
        2. Selected Practices
          1. Metaphor
          2. Simple Design
          3. Refactoring
          4. On-Site Customer
          5. Coding Standards
      5. Thinking Is Key
        1. Software Development Is a Cultural Activity
      6. Onward
    6. 2. Philosophical Context
      1. Philosophy Made Manifest—Dueling Languages
        1. SIMULA
        2. C++
        3. Smalltalk
      2. Formalism and Hermeneutics
      3. Postmodern Critiques
    7. 3. From Philosophy to Culture
      1. Four Presuppositions
        1. One: Everything is an object.
        2. Two: Simulation of a problem domain drives object discovery and definition.
        3. Three: Objects must be composable.
        4. Four: Distributed cooperation and communication must replace hierarchical centralized control as an organizational paradigm.
      2. Object Principles—Software Principles
      3. Cooperating Cultures
    8. 4. Metaphor: Bridge to the Unfamiliar
      1. The Lego Brick Metaphor
      2. The Object-as-Person Metaphor
      3. Software as Theater; Programmers as Directors
      4. Ants, Not Autocrats
      5. Two Human-Derived Metaphors
        1. Inheritance
        2. Responsibility
      6. Thinking Like an Object
    9. 5. Vocabulary: Words to Think With
      1. Essential Terms
        1. Object
        2. Responsibility
          1. Maintain and supply on request one or more units of information.
          2. Perform a computational task.
          3. Report on or update the state of the object.
          4. Coordinate other objects.
        3. Message
        4. Interface (Protocol)
      2. Extension Terms
        1. Collaboration and Collaborator
        2. Class
        3. Class Hierarchy (Library)
        4. Abstract/Concrete
        5. Inheritance
        6. Delegation
        7. Polymorphism
        8. Encapsulation
        9. Component
        10. Framework
        11. Pattern
      3. Implementation Terms
        1. Method
        2. Variable
        3. Late/Dynamic Binding
      4. Auxiliary Concepts
        1. Domain
        2. Business Requirement
        3. Business Process Reengineering
        4. Application
    10. 6. Method, Process, and Models
      1. Two Decades of Object Methodology
      2. Purpose and Use of Method
      3. A Syncretic Approach
      4. Models
        1. Semantic Net
        2. Object Cubes
        3. Interaction Diagram
        4. Static Relation Diagram
        5. Object State Chart
    11. 7. Discovery
      1. Domain Understanding
        1. Domain Anthropology
      2. Object Definition
        1. Heuristics
          1. Heuristic: Let objects assume responsibility for tasks that are wholly or completely delegated to other objects in cases in which the responsibility reflects natural communication patterns in the domain.
          2. Heuristic: Delegate responsibilities to get a better distribution and increase reusability.
          3. Heuristic: Use anthropomorphization and foreshadowing to determine whether an object should assume a given responsibility.
          4. Heuristic: Responsibilities should be distributed among the community of objects in a balanced manner.
          5. Heuristic: Always state responsibilities in an active voice describing a service to be performed.
          6. Heuristic: Avoid responsibilities that are characteristic specific, that focus on providing a potential user with the value of a single characteristic of the object.
          7. Heuristic: Create proxies for objects outside your domain that are sources of information required by objects within your domain.
          8. Heuristic: Look for components.
    12. 8. Thinking Toward Design
      1. Object Internals
        1. Knowledge Required
        2. Message Protocol
        3. Message Contracts
        4. State Change Notification
      2. Object Appearance
        1. Occasions Requiring an Appearance
      3. Object State, Object Constraints
    13. 9. All the World’s a Stage
      1. Static Relationships
        1. Is-a-Kind-of Relationship
        2. Collaborates-with Relationship
        3. Situational Relationship
          1. Static Relationship Model
          2. Collective Memory Map
          3. Architecture
      2. Dynamic Relationships
        1. Scripts
        2. Event Dispatching
          1. State Modeling
      3. Constraints
        1. Self-Evaluating Rules
          1. Structural Abstraction of a Self-Evaluating Rule
          2. Behavioral Abstraction
        2. Implementation
        3. Methods
        4. Knowledge Maintenance Objects
      4. Development at the Speed of Thought
    14. 10. Wrapping Up
      1. Vexations
        1. The Impedance Mismatch Problem
        2. A Problem with GUIs
      2. Extensions
        1. Frameworks
          1. Composable Document
          2. Object Routing and Tracking
          3. Resource Allocation and Scheduling
        2. Object-Based Evocative Architecture
      3. Provocation—The Future of Objects
    15. Bibliography
    16. About the Author
    17. Index
    18. About the Author
    19. Copyright