Download Object Thinking by David West PDF: The Ultimate Resource for Object-Oriented Software Development
Object Thinking David West Pdf Download
If you are a software developer who wants to learn how to think in terms of objects, you might be interested in reading Object Thinking by David West. This book is a comprehensive guide to the history, principles, practice, benefits, and challenges of object thinking. In this article, we will give you an overview of what this book is about and how you can download it as a PDF file.
Object Thinking David West Pdf Download
The History of Object Thinking
Object thinking is not a new idea. It has been around since the early days of computing. However, it has evolved over time as different programmers and researchers have contributed to its development. In this section, we will trace the origins and evolution of object thinking from its roots in object-oriented programming to its current state in object-oriented methodologies.
The Origins of Object-Oriented Programming
The term "object-oriented programming" was coined by Alan Kay in the late 1960s. Kay was one of the pioneers of personal computing at Xerox PARC (Palo Alto Research Center). He was inspired by the work of Ivan Sutherland, who created Sketchpad, one of the first graphical user interfaces (GUIs) that allowed users to manipulate graphical objects on a screen. Kay wanted to create a programming language that would enable programmers to create interactive graphical applications using objects as the basic building blocks. He also wanted to make programming more accessible and fun for children and non-experts.
Kay and his colleagues at Xerox PARC developed Smalltalk, the first pure object-oriented programming language. Smalltalk was based on the idea that everything is an object, and objects communicate with each other by sending and receiving messages. Smalltalk also introduced the concept of classes, which are templates for creating objects with common attributes and behaviors. Classes can inherit from other classes, forming a hierarchy of abstraction. Smalltalk also supported dynamic typing, which means that objects can change their type at runtime depending on the messages they receive.
The Influence of Smalltalk and Simula
Smalltalk had a profound influence on the development of object-oriented programming. Many of the features and concepts of Smalltalk were adopted by other languages such as Objective-C, Ruby, Python, and Java. However, Smalltalk was not the only language that contributed to object-oriented programming. Another important language was Simula, developed by Ole-Johan Dahl and Kristen Nygaard in Norway in the 1960s. Simula was designed for simulating complex systems using objects as discrete entities that interact with each other. Simula introduced the concept of subclasses, which are classes that extend the functionality of existing classes without modifying them. Subclasses can override the methods of their superclasses, providing polymorphism, which means that different objects can respond differently to the same message depending on their type.
The Evolution of Object-Oriented Methodologies
As object-oriented programming became more popular and widely used, programmers and researchers realized that they needed a systematic way of analyzing, designing, and implementing object-oriented systems. This led to the emergence of various object-oriented methodologies, which are sets of guidelines, techniques, and tools for applying object-oriented principles to software development. Some of the most influential object-oriented methodologies are:
Object-Oriented Analysis and Design (OOAD), proposed by Grady Booch in the 1980s. OOAD focuses on identifying the objects, classes, relationships, and behaviors in a problem domain and mapping them to a software solution.
Object Modeling Technique (OMT), developed by James Rumbaugh and his team in the 1980s. OMT uses graphical notation to represent the static structure, dynamic behavior, and functional requirements of an object-oriented system.
Objectory, created by Ivar Jacobson in the 1980s. Objectory emphasizes the use of use cases, which are scenarios that describe how users interact with a system to achieve their goals.
Unified Modeling Language (UML), introduced by Booch, Rumbaugh, and Jacobson in the 1990s. UML is a standard notation for modeling object-oriented systems using diagrams that show different aspects of a system such as structure, behavior, interaction, and deployment.
Unified Process (UP), developed by Booch, Rumbaugh, Jacobson, and others in the 1990s. UP is a framework for managing software projects using an iterative and incremental approach that adapts to changing requirements and feedback.
Extreme Programming (XP), proposed by Kent Beck in the late 1990s. XP is an agile methodology that emphasizes customer collaboration, frequent delivery, continuous testing, code quality, and team work.
The Principles of Object Thinking
Object thinking is not just about using a particular language or methodology. It is also about adopting a mindset that views software development as a process of creating and manipulating objects that represent real-world entities and concepts. In this section, we will explain some of the key principles of object thinking that underlie object-oriented programming and methodologies.
Objects as Abstractions
An object is an abstraction that encapsulates state and behavior. State refers to the data or attributes that an object has at any given time. Behavior refers to the actions or methods that an object can perform or respond to. For example, a car is an object that has state (such as color, model, speed) and behavior (such as start, stop, accelerate). An abstraction is a simplified representation of something complex or detailed. Abstraction helps us to focus on the essential features of something while ignoring irrelevant details. For example, when we think about a car as an object, we don't need to know how its engine works or what its VIN number is. We only need to know what it can do and what it looks like.
Objects as Collaborators
Objects as Adaptable and Evolvable
Objects are not static or fixed. They can adapt and evolve according to changing circumstances and needs. Objects can change their state and behavior dynamically by modifying their attributes and methods. For example, a car can change its color, model, speed, or even its type by adding or removing parts or features. Objects can also inherit from other objects, creating new subclasses that extend or modify the functionality of existing classes. For example, a truck can inherit from a car, but add a cargo bed and a towing capacity. Objects can also delegate some of their responsibilities to other objects, creating composite objects that consist of smaller objects working together. For example, a car can delegate its steering, braking, and accelerating functions to a driver object.
The Practice of Object Thinking
Object thinking is not only a theoretical concept. It is also a practical skill that can be applied to software development. In this section, we will explain some of the key steps and techniques involved in applying object thinking to software development. These steps are: object discovery and definition, object design and implementation, and object testing and refactoring.
Object Discovery and Definition
The first step in applying object thinking to software development is to discover and define the objects that are relevant to the problem domain. The problem domain is the area of interest or concern that the software system is intended to address or solve. For example, if we are developing a software system for managing a library, the problem domain would include books, patrons, librarians, loans, reservations, etc.
To discover and define objects in a problem domain, we can use various heuristics and patterns. Heuristics are rules of thumb or guidelines that help us make decisions or judgments. Patterns are reusable solutions or templates that have been proven to work in similar situations. Some of the common heuristics and patterns for object discovery and definition are:
Nouns: Identify the nouns in the problem statement or description and consider them as potential objects. For example, in the sentence "A patron can borrow up to three books from the library for two weeks", we can identify four nouns: patron, book, library, and week.
Responsibilities: Assign responsibilities to each potential object based on what it knows (information) and what it does (action). For example, a book object knows its title, author, genre, etc., and does nothing. A patron object knows its name, address, phone number, etc., and can borrow books.
Collaborations: Identify the collaborations between objects based on how they interact with each other through messages. For example, a patron object collaborates with a library object by sending it a message to borrow a book.
Abstraction: Group similar objects into classes based on their common attributes and behaviors. For example, we can group all book objects into a class called Book.
Inheritance: Organize classes into hierarchies based on their specialization and generalization relationships. For example, we can create subclasses of Book such as FictionBook and NonfictionBook that inherit from Book but have additional attributes or behaviors.
Encapsulation: Hide the internal details of each class from other classes and expose only the public interface that defines how other classes can interact with it. For example, we can hide the implementation details of how a book object stores its title and author from other objects and only expose methods such as getTitle() and getAuthor() that return these values.
Object Design and Implementation
The next step in applying object thinking to software development is to design and implement the objects that we have discovered and defined in the previous step. Designing an object involves deciding how it will store its state (attributes) and perform its behavior (methods). Implementing an object involves writing code in an object-oriented programming language such as Java or Python that follows the design specifications.
To design and implement objects effectively, we need to consider three aspects of each object: its internal structure, its message protocol, and its appearance.
Internal Structure
Message Protocol
The message protocol of an object refers to how it communicates with other objects through messages. A message consists of a name and a list of arguments that specify the information or action that is requested or performed. For example, a message named borrow with an argument book can be sent from a patron object to a library object to request borrowing a book.
To design and implement the message protocol of an object, we need to consider the following aspects:
Message names: Choose descriptive and consistent names for messages that reflect their purpose and meaning. For example, use borrow instead of b or getBook.
Message arguments: Choose appropriate types and numbers of arguments for messages that provide enough information for the receiver to process the message. For example, use book as an argument for borrow instead of title or author.
Message contracts: Define the preconditions and postconditions for each message that specify what must be true before and after the message is sent or received. For example, a precondition for borrow could be that the patron has not exceeded the maximum number of books allowed, and a postcondition could be that the book is marked as borrowed by the patron.
Message responses: Decide what type of response each message should return to the sender, such as a value, an acknowledgment, an exception, or nothing. For example, borrow could return a boolean value indicating whether the borrowing was successful or not.
Appearance
The appearance of an object refers to how it presents itself to other objects or users through its interface. An interface is a set of public messages that an object supports and exposes to other objects or users. For example, a library object could have an interface that includes messages such as borrow, return, reserve, search, etc.
To design and implement the appearance of an object, we need to consider the following aspects:
Interface design: Design an interface that is clear, consistent, complete, and minimal. A clear interface provides meaningful and unambiguous messages. A consistent interface follows conventions and standards for naming and organizing messages. A complete interface provides all the necessary messages for interacting with the object. A minimal interface provides only the essential messages and avoids redundancy and complexity.
Interface documentation: Document the interface using comments or annotations that describe the purpose, parameters, return values, exceptions, and contracts of each message. For example, we can use JavaDoc comments in Java or Docstrings in Python to document the interface of an object.
Interface testing: Test the interface using unit tests or interactive tools that verify the correctness and functionality of each message. For example, we can use JUnit in Java or unittest in Python to write unit tests for testing the interface of an object.
Object Testing and Refactoring
The final step in applying object thinking to software development is to test and refactor the objects that we have designed and implemented in the previous steps. Testing involves checking whether the objects work as expected and meet the requirements and specifications of the problem domain. Refactoring involves improving the quality and structure of the code without changing its functionality or behavior.
To test and refactor objects effectively, we need to use various techniques and tools such as:
Unit testing: Write and run tests for each individual object or class that check whether it performs its intended behavior correctly. For example, we can use JUnit in Java or unittest in Python to write unit tests for testing objects.
Debugging: Identify and fix errors or bugs in the code that cause unexpected or incorrect behavior. For example, we can use Eclipse in Java or PyCharm in Python to debug code using breakpoints, watches, and step-by-step execution.
Code analysis: Analyze the code using tools that can detect and report potential errors, vulnerabilities, code smells, style issues, and other quality indicators. For example, we can use SonarQube or Veracode to perform code analysis on various languages and platforms.
Code refactoring: Refactor the code using techniques that can improve its readability, maintainability, reusability, and extensibility without changing its functionality or behavior. For example, we can use Extract Method, Rename Variable, Replace Magic Number with Symbolic Constant, and other refactoring techniques to improve the code.
The Benefits of Object Thinking
Object thinking can bring many benefits to software development. In this section, we will explain some of the main benefits of object thinking in relation to agile development, software quality, and software innovation.
Object Thinking and Agile Development
Agile development is a software development approach that values individuals and interactions over processes and tools, working software over comprehensive documentation, customer collaboration over contract negotiation, and responding to change over following a plan. Agile development follows principles such as delivering working software frequently, welcoming changing requirements, collaborating with customers and stakeholders, self-organizing teams, continuous improvement, and technical excellence.
Object thinking supports agile development by enabling the following:
Incremental and iterative development: Objects can be developed incrementally and iteratively by adding new features or modifying existing ones in small batches. Objects can also be integrated and tested continuously using automated tools.
User-centric design: Objects can be designed from the user's perspective by focusing on their needs, goals, and expectations. Objects can also be validated and verified by involving users in feedback loops and user testing sessions.
Collaborative teamwork: Objects can be developed collaboratively by teams of developers who share a common vision and understanding of the problem domain. Objects can also be communicated effectively using common terminology and notation.
Adaptive planning: Objects can be planned adaptively by prioritizing the most important or valuable features or requirements. Objects can also be adjusted easily to accommodate changing needs or circumstances.
Object Thinking and Software Quality
Software quality is a measure of how well a software system meets the expectations and requirements of its users and stakeholders. Software quality can be evaluated using various attributes such as functionality, reliability, usability, efficiency, maintainability, and portability.
Object thinking enhances software quality by improving the following attributes:
Functionality: Objects can provide functionality that meets the specified requirements and satisfies the intended purpose. Objects can also provide functionality that is consistent, accurate, secure, and compliant.
Reliability: Objects can provide reliability that ensures the software system performs correctly under normal and abnormal conditions. Objects can also provide reliability that prevents or recovers from failures, errors, or faults.
Efficiency: Objects can provide efficiency that optimizes the use of resources such as time, space, memory, and energy. Objects can also provide efficiency that minimizes the overhead and complexity of the software system.
Maintainability: Objects can provide maintainability that facilitates the modification and evolution of the software system. Objects can also provide maintainability that supports the verification and validation of the software system.
Portability: Objects can provide portability that enables the software system to run on different platforms or environments. Objects can also provide portability that allows the software system to interoperate with other systems or components.
Object Thinking and Software Innovation
Software innovation is the process of creating new or improved software products or services that meet the needs or expectations of users or stakeholders. Software innovation can be driven by various factors such as market demand, customer feedback, technological advancement, competitive advantage, or social impact.
Object thinking fosters software innovation by enabling the following:
Experimentation: Objects can enable experimentation by allowing developers to try out different ideas or solutions quickly and easily. Objects can also enable experimentation by providing feedback and results that can be measured and evaluated.
Exploration: Objects can enable exploration by allowing developers to discover new possibilities or opportunities in the problem domain. Objects can also enable exploration by providing abstraction and encapsulation that can hide irrelevant details and expose relevant features.
Creativity: Objects can enable creativity by allowing developers to express their vision or i