—Course Overview
1m 38s
Attaining Extensibility with Object-oriented Code
- 18m 28s
—What Makes Code Object-oriented?
7m 22s
—What Follows in This Course
2m 22s
—An Example that Lacks Objects
4m 24s
—Putting Objects Where It Doesn’t Seem to Be Possible
3m 23s
—Summary
0m 54s
Rendering Branching Over Boolean Tests Obsolete
- 39m 33s
—Introducing the Problem in Code
3m 32s
—Recognizing the Problem
5m 40s
—Turning Branching into a Function
6m 13s
—Turning Function into a State
7m 49s
—Moving All State-related Code into States
9m 40s
—Assessing Improvement
5m 1s
—Summary
1m 34s
Keeping the Focus on Domain Logic with Sequences
- 26m 15s
—Understanding the Problem
4m 32s
—Outlining the Desired Solution
4m 18s
—Aggregating the Sequence
6m 23s
—Improving the Readability
4m 56s
—Improving Performance of Infrastructural Operations
4m 5s
—Summary
1m 59s
Untangling Structure from Operations on Business Data
- 45m 7s
—Identifying the Problem of Selecting an Object
3m 0s
—Identifying the Problem of Synthesizing an Object
7m 43s
—Understanding the Problems
3m 57s
—Treating Collection of Objects as an Object
5m 4s
—Implementing the Collection of Objects
5m 41s
—Introducing the Compositional Function Idea
8m 55s
—Generalized Composition Function
9m 4s
—Summary
1m 40s
Turning Algorithms into Strategy Objects
- 33m 1s
—Identifying the Problem of a Varying Algorithm
5m 19s
—Dissecting the Algorithm
5m 21s
—Identifying the Moving Parts of the Algorithm
6m 38s
—Analysis of the Template Method with Strategy Object
3m 1s
—Externalizing Strategy to a Separate Class
5m 8s
—Implementing a Concrete Strategy Class
5m 51s
—Summary
1m 40s
Using Immutable Objects When Possible
- 53m 6s
—Causing a Bug That Comes from a Mutable Object
5m 48s
—Discovering the Aliasing Bug
6m 19s
—Fixing the Aliasing Bug
1m 53s
—Understanding Value Objects
3m 48s
—Implementing Reference Type as a Value Type
6m 38s
—Consuming the Immutable Class
3m 48s
—Turning Immutable Objects into Value Objects
7m 1s
—Supporting Hash Tables
5m 13s
—Completing the Equality Tests
4m 11s
—Mutable vs. Immutable vs. Value Object
6m 36s
—Summary
1m 47s
Leveraging Special Case Objects to Remove Null Checks
- 36m 37s
—Understanding the Problem of Null
5m 34s
—Outlining the Design Without Null References
2m 9s
—How to Never Return Null
7m 21s
—Demonstrating the Power of Null Objects
6m 28s
—Introducing Special Cases
3m 30s
—Turning Boolean Query Methods into Real Operations
5m 18s
—Substituting Objects at Run Time
4m 33s
—Summary
1m 40s
Turning Optional Calls into Calls on Optional Objects
- 43m 37s
—Complicating the Requirements That Lead to Use of Nulls
4m 1s
—Identifying the Problem of a Nonexistent Objects
6m 35s
—Representing Optional Object as a Collection
5m 44s
—Wrapping a Collection into an Option Type
6m 30s
—Improving Readability of the Client Code
1m 25s
—Adding Pattern Matching to Options
3m 36s
—Heavyweight Implementation of Options with Pattern Matching
7m 36s
—Demonstrating the Use of Heavyweight Option Type
6m 21s
—Summary
1m 45s
Increasing Flexibility by Avoiding Switch Statements
- 40m 42s
—Adding Requirements that Lead to Multiway Branching
6m 8s
—Using the Old-fashioned Switch Instruction and an Enum
5m 33s
—Encapsulating Representation in a Separate Class
5m 48s
—Using Encapsulated Representation as the Key
8m 56s
—Turning Multiway Branching into a Dictionary Object
3m 47s
—Substituting the Multiway Branching Object at Runtime
8m 11s
—Summary
2m 16s
Turning Chained Branching into the Chain of Rule Objects
- 40m 0s
—Implementing Classical Chain of If-Then-Elses
5m 55s
—Proposing an Object-oriented Design
4m 27s
—Implementing Concrete Rules
6m 27s
—Simplifying Implementation Through Refactoring
5m 38s
—Combining Primitive Rules into Complex Ones
6m 58s
—Demonstrating the Flexibility of the Chain of Rules
8m 25s
—Summary
2m 6s
Refactoring to Bind It All Together
- 46m 43s
—Introducing an Example
3m 53s
—Analyzing Initial Implementation
4m 28s
—Recognizing Infrastructural Code
5m 35s
—Making Infrastructure Explicit
2m 51s
—Removing All Infrastructure from Implementation
6m 11s
—Where to Go with Infrastructural Code?
6m 56s
—Making Profit on Flexibility of Object-oriented Code
9m 0s
—Summary
1m 52s
—Course Summary
5m 53s
