Learn Object Thinking from David West: The Book that Revolutionized Object-Oriented Programming
Object Thinking: A Book Review
If you are a programmer who wants to improve your skills and understanding of object-oriented programming, you may want to read Object Thinking by David West. This book is not a typical technical book that teaches you how to use a specific language or tool. Rather, it is a book that challenges you to think differently about software development. It is a book that explores the history, philosophy, and culture of object thinking.
object thinking david west ebook 11
But what is object thinking? According to West, object thinking is a mindset that guides programmers to think in terms of objects rather than procedures or data structures. Objects are entities that have identity, state, and behavior. They communicate with each other by sending messages. They are autonomous and responsible for their own actions. They are composable and adaptable to changing requirements. They are the building blocks of software systems.
West is an esteemed object technologist who has been involved in object-oriented programming since its early days. He has worked with pioneers such as Alan Kay, Grady Booch, Kent Beck, Ward Cunningham, and others. He has taught courses on object-oriented analysis and design at various universities and companies. He has also written several books and articles on the topic.
The main argument and purpose of this book is to show that the mindset makes the programmernot the tools and techniques. West contends that many programmers fail to grasp the essence of object-oriented programming because they focus too much on the syntax or semantics of a language or the steps or diagrams of a method. They miss the bigger picture of what objects are and how they should behave. They do not think like objects.
This book aims to help programmers develop an in-depth understanding of object thinking by delving into its historical and philosophical roots, its values and principles, its metaphors and vocabulary, its methods and models, its techniques and practices. It also illustrates specific object-behavior practices that programmers can adopt for true object design and superior results.
In this article, I will provide a summary of each chapter of the book, followed by an evaluation of its strengths and weaknesses. I will then conclude with my personal opinion and rating of the book.
Summary of the book
Chapter 1: Object Thinking
This chapter introduces the concept of object thinking and contrasts it with traditional software engineering approaches. West argues that traditional software engineering is based on a mechanistic worldview that views software as a machine composed of parts that perform functions on data. This worldview leads to software development practices that emphasize formal processes, methods, models, data structures, algorithms, etc.
Object thinking, on the other hand, is based on an organic worldview that views software as a society composed of objects that have identity, state, and behavior. This worldview leads to software development practices that emphasize discovery, exploration, conceptualization, metaphor, vocabulary, communication, Chapter 2: Philosophical Context
This chapter traces the historical and philosophical origins of object thinking and how they influenced the development of object-oriented programming languages and methods. West discusses the contributions of philosophers such as Plato, Aristotle, Kant, Hegel, Wittgenstein, Heidegger, and others to the understanding of objects and their relations.
West also examines the contrast between two philosophical schools that have shaped software development: formalism and hermeneutics. Formalism is the view that reality can be represented by formal systems of logic, mathematics, and symbols. Hermeneutics is the view that reality can only be interpreted by human understanding and context. West argues that object thinking is more aligned with hermeneutics than formalism.
Finally, West critiques postmodernism and its implications for software development. Postmodernism is the view that reality is subjective, relative, and constructed by language and power. West contends that postmodernism undermines the validity and value of object thinking by denying the existence and meaning of objects.
Chapter 3: From Philosophy to Culture
This chapter explains the four presuppositions of object thinking and how they lead to object principles that guide software development. The four presuppositions are:
Everything is an object.
Simulation of a problem domain drives object discovery and definition.
Objects must be composable.
Distributed cooperation and communication must replace hierarchical centralized control as an organizational paradigm.
From these presuppositions, West derives several object principles that reflect the values and goals of object thinking. Some of these principles are:
Objects are responsible for themselves.
Objects have state-dependent behavior.
Objects communicate by sending messages.
Objects are specified by their interfaces.
Objects conform to protocols.
Objects are created by other objects.
West also discusses the cultural shift required for adopting object thinking in software development. He argues that traditional software engineering culture is based on a hierarchical, centralized, bureaucratic, and mechanistic model that hinders creativity and collaboration. He proposes a new software culture based on a distributed, cooperative, democratic, and organic model that fosters innovation and communication.
Chapter 4: Metaphor: Bridge to the Unfamiliar
This chapter explores the role of metaphors in object thinking and how they help programmers to bridge the gap between the problem domain and the software domain. West defines a metaphor as a way of understanding one thing in terms of another. He argues that metaphors are essential for object thinking because they enable programmers to conceptualize objects and their behaviors in familiar terms.
West provides several examples of metaphors that have been used for object thinking, such as Lego bricks, objects as persons, software as theater, and ants as objects. He explains how these metaphors capture some aspects of object thinking, such as identity, state, behavior, communication, composition, etc. He also acknowledges the limitations and pitfalls of these metaphors, such as oversimplification, ambiguity, inconsistency, etc.
West also offers some guidelines for choosing and using metaphors effectively for object thinking. Some of these guidelines are:
Select metaphors that are appropriate for the problem domain and the intended audience.
Use multiple metaphors to capture different perspectives and dimensions of objects.
Avoid mixing metaphors that may cause confusion or contradiction.
Evaluate metaphors for their accuracy, completeness, clarity, and usefulness.
Refine or replace metaphors as needed to reflect new insights or changes in requirements.
Chapter 5: Vocabulary: Words to Think With
This chapter introduces the essential terms and concepts of object thinking and how they help programmers to communicate and understand objects and their behaviors. West argues that vocabulary is important for object thinking because it provides a common language for describing and reasoning about objects. He also warns that vocabulary can be misleading or misused if not defined or applied correctly.
West defines and explains some of the key terms and concepts of object thinking, such as:
Object: An entity that has identity, state, and behavior.
Responsibility: A contract or obligation that an object has to perform a certain action or provide a certain service.
Message: A request or command that an object sends to another object to invoke its behavior.
Class: A description or template that defines the common state and behavior of a group of objects.
Inheritance: A mechanism that allows a class to inherit the state and behavior of another class.
Polymorphism: A mechanism that allows an object to behave differently depending on the context or the message it receives.
Encapsulation: A mechanism that hides the internal structure and implementation of an object from other objects.
Abstraction: A mechanism that simplifies or generalizes the state and behavior of an object by ignoring irrelevant details.
Composition: A mechanism that combines objects to form larger or more complex objects.
West also provides some examples and exercises to illustrate and practice these terms and concepts in various scenarios and languages.
Chapter 6: Method: Process and Models
This chapter critiques the traditional software engineering methods and models that are based on a formalistic and mechanistic worldview. West argues that these methods and models are incompatible with object thinking because they impose rigid and predefined processes, structures, and notations that constrain the creativity and flexibility of programmers. He also points out the limitations and failures of these methods and models in dealing with complex and dynamic domains.
West proposes an alternative approach to software development that is based on object thinking. This approach is characterized by discovery, exploration, conceptualization, metaphor, vocabulary, communication, etc. It does not prescribe a fixed or universal process or model, but rather adapts to the specific needs and context of each project. It does not rely on formal or graphical notations, but rather uses informal and textual tools that facilitate understanding and dialogue.
West introduces some of the tools that support object thinking, such as:
CRC cards: A technique that uses index cards to represent classes, their responsibilities, and their collaborators.
Interaction diagrams: A technique that uses simple diagrams to show the messages exchanged among objects in a scenario.
State diagrams: A technique that uses simple diagrams to show the states and transitions of an object in response to events.
Class diagrams: A technique that uses simple diagrams to show the classes, their attributes, their methods, and their relationships in a system.
West also provides some examples and exercises to demonstrate and practice these tools in various scenarios and languages.
Chapter 7: Discovery
This chapter describes the process of discovering objects from problem domains. West argues that object discovery is the most important and challenging part of object thinking because it requires programmers to understand the essence and behavior of objects in their natural context. He also warns that object discovery is not a straightforward or deterministic process, but rather an iterative and exploratory process that involves trial and error, feedback, and refinement.
West presents some of the techniques that can help programmers to discover objects, such as:
Brainstorming: A technique that involves generating as many ideas as possible without judging or filtering them.
Storyboarding: A technique that involves creating a sequence of sketches or pictures that illustrate how objects interact in a scenario.
Role-playing: A technique that involves acting out the roles and behaviors of objects in a scenario.
Prototyping: A technique that involves creating a simplified or partial version of an object or a system to test its functionality and usability.
Testing: A technique that involves verifying the correctness and quality of an object or a system by applying various inputs and checking the outputs.
West also discusses some of the challenges and pitfalls of object discovery, such as:
Bias: The tendency to favor certain ideas or solutions based on personal preferences or assumptions.
Inconsistency: The lack of coherence or alignment among different objects or aspects of a system.
Ambiguity: The presence of multiple or unclear meanings or interpretations of an object or a system.
Complexity: The difficulty or impossibility of comprehending or managing all the details or interactions of an object or a system.
Change: The variation or evolution of an object or a system over time or across contexts.
Chapter 8: Thinking Toward Design
This chapter explains the transition from discovery to design in object thinking. West argues that object design is not a separate or final phase of software development, but rather a continuous and iterative process that involves evaluating and improving object designs based on various criteria and heuristics. He also emphasizes that object design is not a purely technical or rational activity, but rather a creative and subjective activity that requires intuition and judgment.
West presents some of the criteria and heuristics that can help programmers to evaluate and improve object designs, such as:
Cohesion: The degree to which an object has a single and well-defined responsibility.
Coupling: The degree to which an object depends on or interacts with other objects.
Granularity: The level of detail or abstraction of an object.
Encapsulation: The degree to which an object hides its internal structure and implementation from other objects.
Abstraction: The degree to which an object simplifies or generalizes its state and behavior by ignoring irrelevant details.
Composition: The degree to which an object is composed of other objects.
West also provides some examples and exercises to apply these criteria and heuristics to real-world problems, such as designing a vending machine, a bank account, a text editor, etc.
Chapter 9: All the World's a Stage
This chapter introduces the metaphor of software as theater for object design. West argues that this metaphor is useful for object thinking because it captures the dynamic and interactive nature of objects and their behaviors. He also shows how this metaphor can help programmers to address some of the common challenges and issues in object design, such as inheritance, polymorphism, concurrency, distribution, etc.
West explains how the elements of theater can serve as analogies for software objects, such as:
Actor: An object that has identity, state, and behavior.
Role: A responsibility or function that an actor performs in a scenario.
Script: A sequence of actions or messages that an actor follows in a scenario.
Scene: A context or situation in which actors interact in a scenario.
Prop: An object that supports or enhances the behavior of an actor in a scenario.
Cue: An event or signal that triggers or coordinates the behavior of an actor in a scenario.
West also discusses the benefits and limitations of this metaphor for object design. Some of the benefits are:
It helps programmers to focus on the behavior rather than the structure of objects.
It allows programmers to reuse or modify objects by changing their roles or scripts.
It enables programmers to model complex and dynamic domains in terms of scenarios and interactions.
It fosters creativity and innovation by encouraging programmers to explore different possibilities and solutions.
Some of the limitations are:
It may not be suitable or intuitive for every problem domain or software project.
It may not be compatible or consistent with other metaphors or models used for object design.
It may not address all the technical or practical aspects of object design, such as performance, security, reliability, etc.
Chapter 10: Wrapping Up
This chapter summarizes and concludes the main points and arguments of the book. West reviews the definition and importance of object thinking for programmers. He also recaps the main topics covered in each chapter, such as philosophy, culture, metaphor, vocabulary, method, discovery, design, etc. He also provides some recommendations for further reading and learning about object thinking from various sources and perspectives.
West also invites feedback and dialogue with the readers. He encourages readers to share their opinions, questions, comments, criticisms, suggestions, etc. with him via email or website. He also expresses his gratitude and appreciation to the readers for their interest and attention to his book.
Evaluation of the book
The book has several strengths that make it a valuable and enjoyable read for programmers who want to improve their skills and understanding of object-oriented programming. Some of these strengths are:
It provides a comprehensive and coherent overview of object thinking, covering its historical and philosophical roots, its values and principles, its metaphors and vocabulary, its methods and models, its techniques and practices.
It challenges conventional wisdom and offers fresh perspectives on software development, questioning the validity and usefulness of traditional software engineering approaches and proposing alternative approaches based on object thinking.
It combines theory and practice with clear examples and exercises, illustrating how object thinking can be applied to various scenarios and languages, and how it can lead to better object design and superior results.
The book also has some weaknesses that may limit its appeal or usefulness for some readers or situations. Some of these weaknesses are:
It assumes prior knowledge and experience with object-oriented programming, using terms and concepts that may not be familiar or clear to beginners or novices.
It sometimes becomes too abstract or philosophical for practical purposes, delving into topics that may not be directly relevant or applicable to software development.
It occasionally becomes biased or opinionated in favor of certain languages or methods, dismissing or criticizing others without sufficient evidence or justification.
In conclusion, Object Thinking by David West is a book that aims to show that the mindset makes the programmernot the tools and techniques. It is a book that explores the history, philosophy, and culture of object thinking. It is a book that helps programmers to think in terms of objects rather than procedures or data structures. It is a book that challenges programmers to discover, conceptualize, model, design, and communicate objects and their behaviors.
The main takeaways and implications for programmers from this book are:
Object thinking is a mindset that guides programmers to think in terms of objects rather than procedures or data structures.
Object thinking is based on an organic worldview that views software as a society composed of objects that have identity, state, and behavior.
Object thinking requires a shift in mindset and culture from traditional software engineering approaches that focus on processes, methods, models, data structure