◎ Introduction: Programming Paradigms
01 The Era of Paradigms
02 Programming Paradigm

◎ Chapter 1: Objects, Design
01.
Implementing a Ticket Sales Application
02.
What's the problem
___code that deviates from expectations
Code vulnerable to ___ changes
03.
Improving the design
Let's increase ___autonomy
___What has been improved
___How did you do it?
___Encapsulation and Cohesion
___Procedural and object-oriented
___Shift of responsibility
___can be improved further
___Yeah, that's a lie!
04.
object-oriented design
Why is ___design necessary?
___object-oriented design

◎ Chapter 2: Object-Oriented Programming
01.
Movie ticket reservation system
___ Review the requirements
02.
Towards Object-Oriented Programming
___ collaboration, object, class
Program structure that follows the structure of the ___ domain
Implementing the ___ class
___ a community of cooperating objects
___ A Short Story About Collaboration
03.
Get a discounted rate
___ Start working together to calculate discount rates
___ Discount policy and discount conditions
___ Configure a discount policy
04.
Inheritance and polymorphism
___ Compile-time dependencies and run-time dependencies
Programming by ___ Difference
___ Inheritance and Interfaces
___ polymorphism
___ Interfaces and Polymorphism
05.
Abstraction and Flexibility
___ The Power of Abstraction
___ Flexible design
___ Abstract Classes and Interfaces Tradeoffs
___ Code Reuse
___ inheritance
___ synthesis

◎ Chapter 3: Roles, Responsibilities, and Cooperation
01.
cooperation
___ A look back at the movie ticket reservation system
___ cooperation
___ Collaboration determines the context for design
02.
responsibility
What is ___ responsibility?
___ Assignment of Responsibilities
___ Responsibility-Driven Design
___ message determines the object
___ actions determine status
03.
role
___ Roles and Collaboration
___ Flexible and reusable collaboration
___ Objects vs. Roles
___ Roles and Abstractions
___ actors and roles

◎ Chapter 4: Design Quality and Tradeoffs
01.
Data-driven movie ticket reservation system
Let's prepare the ___ data
Let's reserve tickets to the ___ movie
02.
Design Tradeoffs
___ encapsulation
___ Cohesion and coupling
03.
The Problems with Data-Driven Movie Ticketing Systems
___ Encapsulation Violation
___ high coupling
___ low cohesion
___ Keep the encapsulation
04.
Towards autonomous objects
___ Objects that are responsible for their own data
___ Encapsulation Violation
05.
But it's still not enough
___ high coupling
___ low cohesion
___ Data-driven design focuses on the state of objects rather than their behavior.
06.
The Challenges of Data-Driven Design
___ Data-centric design forces you to define operations on objects in isolation.

Chapter 5: Assigning Responsibilities
01.
Towards Responsibility-Driven Design
___ Decide on action before data
___ Determine responsibility within the context of collaboration
___ Responsibility-Driven Design
02.
GRASP Pattern for Responsibility Assignment
Starting from the concept of ___ domain
___ Assign responsibility to information professionals
___ high cohesion and low coupling
___ Assign object creation responsibility to the creator
03.
Verification through implementation
___ Improve Discount Condition
Separate ___ types
___ Separation through polymorphism
___Protect from changes
___ Improving the Movie class
___ Change and Flexibility
04.
Alternatives to Responsibility-Driven Design
___ method cohesion
Let's make ___ objects autonomous

◎ Chapter 6: Messages and Interfaces
01.
Collaboration and Messages
___ client-server model
___ Messages and Message Transmission
___ messages and methods
___ Public Interface and Operations
___ Signature
02.
Interface and design quality
___ Don't ask, just order
___ An interface that reveals intent
___ Putting it all together
03.
The trap of principles
___ The Demeter Rule is not a rule that forces one dot (.)
___ Conflict between coupling and cohesion
04.
Command-Query Separation Principle
___ Separating commands and queries from recurring schedules
___ Command-query separation and referential transparency
___ Focus on responsibility

◎ Chapter 7: Object Decomposition
01.
Procedure abstraction and data abstraction
02.
Procedural abstraction and functional decomposition
___ System as a main function
___ Payroll Management System
___ Implementing a payroll management system
___ Problems with top-down functional decomposition
___ When is top-down decomposition useful?
03.
module
___ Information Hiding and Modules
Advantages and limitations of the ___ module
04.
Data abstraction and abstract data types
___ abstract data type
05.
class
Is the ___ class an abstract data type?
___ Converting from an abstract data type to a class
Choose based on ___ changes
___ cooperation is important

Chapter 8: Managing Dependencies
01.
Understanding Dependencies
___ Changes and Dependencies
___ Dependency Transition
___ Runtime dependencies and compile-time dependencies
___ context independence
Resolving ___ dependencies
02.
Flexible design
___ Dependency and Coupling
___ Knowledge creates union
___ Rely on abstractions
___ explicit dependencies
___ new is harmful
___ Sometimes it's okay to create
___ Reliance on standard classes is not harmful
___ Expand the context
___ combinable actions

◎ Chapter 9: Flexible Design
01.
Open-closed principle
___ Fix compile-time dependencies and change runtime dependencies
___ Abstraction is key
02.
Separate creation and use
Add ___ FACTORY
___ Assign responsibility to pure artifacts
03.
Dependency Injection
___ Hidden dependencies are bad
04.
Dependency Inversion Principle
___ Abstraction and Dependency Inversion
___ Dependency Inversion Principle and Packages
05.
Advice on flexibility
___ Flexible design is only right when flexibility is needed.
___Cooperation and responsibility are important

Chapter 10: Inheritance and Code Reuse
01.
Inheritance and Duplicate Code
___ DRY principle
___ Duplication and Change
___ Eliminate duplicate code using inheritance
___ Strongly coupled Phone and NightlyDiscountPhone
02.
Vulnerable base class problem
___ Unnecessary interface inheritance problem
___ Method Overriding's Misbehavior Problem
___ Problem with simultaneous modification of parent and child classes
03.
Take a look at your phone again
Let's rely on ___ abstraction
___ Extract the difference with a method
___ Move duplicate code to the parent class
___ Abstraction is key
___ Choose a name that reveals your intentions
Add ___ tax
04.
Programming by Difference

Chapter 11: Synthesis and Flexible Design
01.
Change inheritance to composition
___ Unnecessary interface inheritance problem: java.util.Properties and java.util.Stack
___ Method Overriding Misbehavior Problem: InstrumentedHashSet
___ Problem with simultaneous modification of parent and child classes: PersonalPlaylist
02.
Explosive increase in combinations due to inheritance
___ Combining basic and additional policies
___ Implementing basic policies using inheritance
___ Combine tax policies with basic policies
___ Combine the basic rate discount policy with the basic policy
___ Fall into the trap of duplicate code
03.
Change to composite relationship
___ Synthesize basic policies
Apply ___ additional policies
___ Synthesize basic and additional policies
___ Add a new policy
___ Object composition is a better approach than class inheritance
04.
mix-in
___ Implementing basic policies
Implementing additional policies with ___ traits
___ Add-on Policy Trait Mix-in
___ stackable changes

◎ Chapter 12: Polymorphism
01.
polymorphism
02.
The duality of inheritance
___ Lecture Evaluation Using Inheritance
___ Inheritance of data perspective
___ Inheritance of behavioral perspective
03.
Upcasting and dynamic binding
___ Same message, different method
___ Upcasting
___ dynamic binding
04.
Dynamic method exploration and polymorphism
___ Automatic message delegation
___ dynamic context
___ Incomprehensible message
___ self vs. super
05.
Inheritance vs. Delegation
___ Delegation and self references
___ prototype-based object-oriented language

◎ Chapter 13: Subclassing and Subtyping
01.
Type
___ type of concept perspective
___ Types from a programming language perspective
___ Type from the object-oriented paradigm perspective
02.
Type hierarchy
Inclusion relationship between ___ types
___ Object-Oriented Programming and Type Hierarchy
03.
Subclassing and subtyping
___ When should I use inheritance?
___ is-a relationship
___ Behavioral Compatibility
___ Separate layers according to client expectations
___ Subclassing and Subtyping
04.
Liskov substitution principle
___ Client and Substitutability
Revisiting the ___ is-a relationship
___ The Liskov Substitution Principle is the foundation of flexible design.
___ Type Hierarchy and the Liskov Substitution Principle
05.
Design and subtyping by contract
Contract with ___ subtype

◎ Chapter 14: Consistent Cooperation
01.
Changing your mobile phone billing system
___ Basic Policy Extension
___ Implementing a fixed-rate system
Implementing a time-based approach
Implementing a ___-day-of-the-week method
Implementing the ___ section-by-section method
02.
Bringing consistency to your design
___ Conditional logic vs. object navigation
___ Revisiting Encapsulation
03.
Implementing consistent baseline policies
___ Separate changes
___ Encapsulate changes
___ Designing Collaboration Patterns
Implementing collaboration patterns at the ___ level of abstraction
___ Implementing concrete cooperation
___ Fit into the collaboration pattern
___ Find the pattern

◎ Chapter 15: Design Patterns and Frameworks
01.
Design Patterns and Design Reuse
___ software pattern
___ pattern classification
___ Patterns and Responsibility-Driven Design
___ Encapsulation and Design Patterns
___ pattern is the starting point
02.
Frameworks and code reuse
___ Code Reuse vs. Design Reuse
___ Separate packages into parent and child policies
___ Control Inversion Principle

◎ In conclusion: Moving forward

◎ Appendix A: Design by Contract
01.
Cooperation and Contract
___ side effects explicitly
___ contract
02.
Design by contract
___Prerequisites
___ postcondition
___ invariant
03.
Design and subtyping by contract
___ Contract Rules
___ Variability Rule
___ Function Types and Subtyping

◎ Appendix B: Implementation of the type hierarchy
Implementing a type hierarchy using ___ classes
Implementing type hierarchy using ___ interfaces
___ Implementing type hierarchy using abstract classes
___ Abstract classes and interfaces? Combining them
Using ___ Duck Typing
___ Mixins and Type Hierarchies

◎ Appendix C: Dynamic Collaboration, Static Code
01.
Dynamic and static models
___ actions determine the code
Consider ___ changes
02.
Domain Model and Implementation
About the ___ domain model
___ Designing Monsters
___ Domain model considering behavior and change
___ Analysis model, design model, and implementation model

◎ Appendix D: References
___ References

This book covers the following topics:

◎ How to design and implement object-oriented programs based on roles, responsibilities, and collaboration
◎ How to trade off design using cohesion and coupling
◎ Various dependency management techniques that make design flexible
◎ The concept of inheritance for type hierarchy and composition for code reuse
◎ Various design principles and design patterns