design patterns and test driven development...tests are what ensure your code’s value you can do...
TRANSCRIPT
![Page 1: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/1.jpg)
Design Patterns and Test Driven Development
Jorg Faschingbauer
www.faschingbauer.co.at
1 / 138
![Page 2: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/2.jpg)
Table of Contents
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
2 / 138
![Page 3: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/3.jpg)
Introduction
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
3 / 138
![Page 4: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/4.jpg)
Introduction Literature
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
4 / 138
![Page 5: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/5.jpg)
Introduction Literature
The Book on Patterns: Gang of Four (GoF)
Groundbreaking in 1995,until today
Collection ofthen-existing patterns
... only giving themnames
Concise and to the point
Well-structured
(Relatively) easy to read
... provided youunderstand theproblems
5 / 138
![Page 6: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/6.jpg)
Introduction Literature
The Other Books on Patterns
6 / 138
![Page 7: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/7.jpg)
Introduction Literature
The Book on Test Driven Development
Groundbreaking in 2003
Revolutionary thoughsimple (has only 200pages)
“New” methodologies
Test-first developmentRefactoring, guidedby automatic tests...
Basis for all agilesoftware developmentprocesses
7 / 138
![Page 8: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/8.jpg)
Introduction Design Patterns
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
8 / 138
![Page 9: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/9.jpg)
Introduction Design Patterns
Design Patterns: What?
What is a design pattern?
A solution to a design problem
Beware: there is no solution without a problem
“Design” means Object Oriented Design
Inheritance and polymorphism aren’t patterns — at least not in OO
There are many different problems
Object creation: objects are not always created directlyStructure: who knows who, and what does he look like?Behavior : how do my objects talk to each other?
9 / 138
![Page 10: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/10.jpg)
Introduction Design Patterns
Design Patterns: Why?
Why use design patterns?
Code is a solution to a problem
Solution/code needs to be readable and understandableSolutions to similar problems tend to be similar... at least, should!
Design patterns ...
Give names to solutions → important in communicationEncourage solution similarityAre well understood → documentation need only give the pattern’snameSolutions become obvious
10 / 138
![Page 11: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/11.jpg)
Introduction Design Patterns
Non-Obvious Problem
Gsellmann’s Weltmaschine
11 / 138
![Page 12: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/12.jpg)
Introduction Design Patterns
Non-Obvious Solution
12 / 138
![Page 13: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/13.jpg)
Introduction Design Patterns
Design Patterns: Caveats
Design patterns are no silver bullet
Overengineering : artificial/unnecessary code complexity
Solution without a problemNot easy to understand — not at all obvious what’s being solvedOne of the biggest mistakes in software designIt’s like the pest
Pattern usage does not automatically ensure sound OO design
What is sound design?
Nobody knows
... but fortunately there is Test Driven Development
13 / 138
![Page 14: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/14.jpg)
Introduction Test Driven Development
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
14 / 138
![Page 15: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/15.jpg)
Introduction Test Driven Development
Test Driven Development
A simple idea ... but first the problem ...
New code is written and tested since ages
Bugs are fixed until it worksTesting mainly done manuallyStandalone test programs, or ...... mostly the entire target application
Existing code breaks once it is modified (law of nature)
Breakage not easily detectedFear!=⇒ nobody ever modifies existing code=⇒ software starts to rot once it has been written
15 / 138
![Page 16: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/16.jpg)
Introduction Test Driven Development
Development — Traditional Approach
Traditional Approach
Think about the design
Come up with a decision
Code it
See if it works
Fix
(etc.)
16 / 138
![Page 17: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/17.jpg)
Introduction Test Driven Development
Traditional Approach — Problems
So what are the core problems?
Before a modification ...
How do I know my solution will be ok?How will it feel? Will it be usable?Am I (and others) comfortable with it?
After a modification ...
It is impossible to decide if everything still worksWhat is the definition of everything?What is the definition of works?What are the costs to decide that?What are the costs if we do only manual testing?What is the state of the code? What about refactoring?
After the release ...
We curse at the testers that they do a bad job!
17 / 138
![Page 18: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/18.jpg)
Introduction Test Driven Development
Test Driven Development — Principles (1)
What if we were able to test everything automatically?
Modifications could be done without any fear
“Regression”: new term for that kind of bugSomething that worked before a modification but doesn’t afterwards
Ongoing refactoring possible → no code smells
New features would bring new tests
The Everything grows over time
But: the Everything is now defined as ...
Production code
Test code
18 / 138
![Page 19: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/19.jpg)
Introduction Test Driven Development
Test Driven Development — Principles (2)
Test Driven Development
New “development process”
Tests come first
→ “Requirements phase”
Have you ever read a requirementsdocument after coding was done?
→ Tests fail initially
19 / 138
![Page 20: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/20.jpg)
Introduction Test Driven Development
Test Driven Development — Benefits? Caveats?
What does it bring, what does it cost?
More work initially — so much for sure
Investment into the future
More code can be done
Not at all easy to convince people of it
Big caveat
Tests belong to the code
No way moving on without!
=⇒ Have to take care of the tests
20 / 138
![Page 21: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/21.jpg)
Test Driven Development
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
21 / 138
![Page 22: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/22.jpg)
Test Driven Development xUnit — How it Works
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
22 / 138
![Page 23: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/23.jpg)
Test Driven Development xUnit — How it Works
Origins
Unittest frameworks — where they come from
SUnit, 1998. By Kent Beck in Smalltalk.
JUnit, 2001. Ported from Smalltalk to Java, by Kent Beck and ErichGamma.
Gained wide popularity by Kent Beck’s book
From then on ported to almost every language — commonly knownas xUnit
Python: PyUnit, then became part of the Python library, moduleunittest
C++: Boost.Test, CppUnit, Google Test, ...All the newer languages: Ruby, Rust, Go, ...COBOL
23 / 138
![Page 24: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/24.jpg)
Test Driven Development xUnit — How it Works
xUnit Structure — Overview
TestCase: one test that is written. Here’s the most code.
TestSuite: composition of many test cases, for structural purposes.
Fixture: defined environment of a TestCase
TestRunner: runs a Test (Suite or Case), collects and presentsresults.
24 / 138
![Page 25: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/25.jpg)
Test Driven Development xUnit — How it Works
xUnit: TestCase and TestSuite
Suites: recursive test structure
Derive from TestCase to implement tests
Use TestSuite objects to structure tests hierarchically
Run a subset of all tests
The Composite Pattern in use ...
Not available in every xUnit incarnation
25 / 138
![Page 26: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/26.jpg)
Test Driven Development xUnit — How it Works
xUnit: TestCase and Fixture
Fixture: defined test environment
Multiple tests start from the same state → common Fixture
Method setUp() — establishes known state to start tests from.Examples: well-known/required database content, files have to bepresent, ...
Method tearDown() — deallocates resources. For example: cleanupdatabase, remove files, ...
Implementation:
Python: class thatcontains test methods
C/C++: weird macrosto setup objects andassociations
26 / 138
![Page 27: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/27.jpg)
Test Driven Development xUnit — How it Works
xUnit: TestCase and Assertions
Test code checks for failure: Assertions
Varying multitude of assertions to draw from
Records test failure in some test result, for later reporting
Abort the test case → failure
Variation: non-fatal assertions
container.insert(100)
container.insert(200)
self.assertEqual(len(container), 2)
self.assertAlmostEqual(1/3, 0.333, 2)
27 / 138
![Page 28: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/28.jpg)
Test Driven Development xUnit — How it Works
xUnit: TestRunner
Running all tests: TestRunner
TestRunner usually instantiated in main programs
During running a test ...
Fixtures are prepared (setup(), tearDown())Results are collectedFailure or success
After all tests have run ...
The result has to be presented
(Sidenote: do you know the Strategy Pattern?)
28 / 138
![Page 29: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/29.jpg)
Test Driven Development Test Driven Development
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
29 / 138
![Page 30: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/30.jpg)
Test Driven Development Test Driven Development
The “Process”
Test Driven Development is ... well ...
Not a full process
The basis of all “agile” processes
Anybody doing Scrum these days?
It’s Software done right
It’s about continuous investment andtaking out
30 / 138
![Page 31: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/31.jpg)
Test Driven Development Test Driven Development
The “Requirements Phase”, New Code
Writing new code in a test driven way ...
Nothing is clear from the beginning
... not even the problem
To get hold of the problem ...
Write code that wouldn’t compile(there’s no solution yet)
... but gives you an impression of how asolution could look like
Talk to people about proposed solution
→ “Finding the interface”
This is the first test
“Test First Development”
31 / 138
![Page 32: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/32.jpg)
Test Driven Development Test Driven Development
The “Requirements Phase”, Existing Code
Modifying existing code, to add features or change behavior ...
Find the test suite for the module in question
→ structure is important
Add a new test for the new feature, making clear exactly what iswanted
The new test naturally fails, as always
Modify code
Run all tests
Repeat
32 / 138
![Page 33: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/33.jpg)
Test Driven Development Test Driven Development
Caveats (1)
Take care of your tests! If your tests are suddenly gone, your code isalone ...
33 / 138
![Page 34: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/34.jpg)
Test Driven Development Test Driven Development
Caveats (2)
Tests are what ensure your code’s value
You can do more valuable code with tests and TDD
Test code is no different from “real” code
→ Subject to bitrot
“Lost Tests Syndrome”: keep your hands off manual test suitearrangement
→ Varying support from frameworks
34 / 138
![Page 35: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/35.jpg)
Test Driven Development Test Driven Development
Caveats (3)
But:
Nobody tests the tests
false impression: “it’s only tests”
Structure is important
Easy running is important — everybody has to know how
Easy running : avoid big dependencies — nobody will want to setupdatabase infrastructure
35 / 138
![Page 36: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/36.jpg)
OO Basics
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
36 / 138
![Page 37: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/37.jpg)
OO Basics
Object Oriented Programming and Design (1)
“Perfection is attained not when there is nothing more to add, but whenthere is nothing more to remove”
Antoine de Saint-Exupery
To adhere to this principle is possible even in assembly code
... it’s just that it’s a bit harder
37 / 138
![Page 38: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/38.jpg)
OO Basics
Object Oriented Programming and Design (2)
What OO does for us:
Things can be programmed like we talk about them
Enforces encapsulation
Members (private)Methods
Lets us separate out dependencies
InterfacesInheritance
38 / 138
![Page 39: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/39.jpg)
OO Basics Members and Methods
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
39 / 138
![Page 40: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/40.jpg)
OO Basics Members and Methods
Example: Members and Methods
Encoding and decoding: the Julius Caesar “Encryption” method
UML C++ Code
class JuliusCaesarCodec
{
public:
string encode(string data);
string decode(string data);
private:
int shift;
};
40 / 138
![Page 41: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/41.jpg)
OO Basics Members and Methods
Example: Constructor and Destructor
Constructor (and Destructor): controlled initialization
There’s only one way to do it — unlike in C
struct initialization
Explicit assignment
Define a function init jc codec(int shift)
(literally hundreds more)
C++ Code
class JuliusCaesarCodec
{
public:
JuliusCaesarCodec(int shift);
~JuliusCaesarCodec();
// ...
};
41 / 138
![Page 42: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/42.jpg)
OO Basics Inheritance
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
42 / 138
![Page 43: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/43.jpg)
OO Basics Inheritance
Motivation: Interfaces
What if ...
There were multiple such codecs available (Base64?)
I don’t care which one I am using
I want to write code that just makes use of any codec
Solution: Interfaces
Define the interface of an entire set of implementations
Implementations implement interfaces
User code is then written against interfaces rather than concreteimplementations
43 / 138
![Page 44: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/44.jpg)
OO Basics Inheritance
Example: Interfaces (1)
Interfaces ...
Don’t implement anything
Only force implementors into a corset for uniform usage
UML
44 / 138
![Page 45: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/45.jpg)
OO Basics Inheritance
Example: Interfaces (2)
Interfaces don’t implement ...
C++: no dedicated interface keyword (as there is in Java)
Abstract Methods
Codec Interface: C++ Code
class Codec
{
public:
virtual ~Codec() {}
virtual string encode(string data) = 0;
virtual string decode(string data) = 0;
};
45 / 138
![Page 46: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/46.jpg)
OO Basics Inheritance
Example: Interfaces (3)
Concrete code implements ...
C++: no dedicated implements keyword (as there is in Java)
Plain inheritance
Implementing an Interface: C++ Code
class JuliusCaesarCodec : public Codec
{
public:
// ...
virtual string encode(string data);
virtual string decode(string data);
};
46 / 138
![Page 47: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/47.jpg)
OO Principles — SOLID
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
47 / 138
![Page 48: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/48.jpg)
OO Principles — SOLID
Design Principles
Principle vs. Dogma
Every handcraft has rules, on every single level, which everybodyagrees upon
Our handcraft is no exception
On the design level : Design Principles
Single ResponsibilityOpen/ClosedLiskov SubstitutionInterface SegregationDependency Inversion
→ SOLID (for people who find it hard to remember rules)
Antipattern: a pattern that violates any of these principles
48 / 138
![Page 49: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/49.jpg)
OO Principles — SOLID Single Responsibility
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
49 / 138
![Page 50: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/50.jpg)
OO Principles — SOLID Single Responsibility
Single Responsibility Principle
“Every class must have responsibility over a single part of the program”
Robert C. Martin, at around 2000
“Every class must do one thing and should do that well.”
Jorg Faschingbauer, all the time
Consequences:
Defining/writing tests is easier
Documenting is easier
Understanding is easier
50 / 138
![Page 51: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/51.jpg)
OO Principles — SOLID Open/Closed
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
51 / 138
![Page 52: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/52.jpg)
OO Principles — SOLID Open/Closed
Open/Closed Principle
“Software entities must be open for extension, but closed formodification.”
Bertrand Meyer, 1988
Interpretations/consequences:
Adding functionality not by modifying but by adding (e.g. “plugins”)
Heavy use of an interface
52 / 138
![Page 53: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/53.jpg)
OO Principles — SOLID Liskov Substitution
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
53 / 138
![Page 54: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/54.jpg)
OO Principles — SOLID Liskov Substitution
Liskov Substitution Principle (1)
“It must be possible in a program to exchange two implementations of aninterface without compromising the correctness of the program.”
Barbara Liskov, 1995
Is this true for our Codec “design”?
54 / 138
![Page 55: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/55.jpg)
OO Principles — SOLID Liskov Substitution
Liskov Substitution Principle (2)
Classical violation of Liskow’s principle: square/rectangle
A rectangle is defined as a pair (width, height), each of which ismodifiable separately
Can a square be seen as a rectangle then?
Consequences:
No special cases in user code
Polished interfaces
55 / 138
![Page 56: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/56.jpg)
OO Principles — SOLID Interface Segregation
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
56 / 138
![Page 57: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/57.jpg)
OO Principles — SOLID Interface Segregation
Interface Segregation Principle
“No client of an interface should be forced to depend on methods it doesnot use.”
Robert C. Martin (again), at around 2000
57 / 138
![Page 58: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/58.jpg)
OO Principles — SOLID Dependency Inversion
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
58 / 138
![Page 59: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/59.jpg)
OO Principles — SOLID Dependency Inversion
Dependency Inversion Principle (1)
1 High-level modules should not depend on low-level modules. Bothshould depend on abstractions.
2 Abstractions should not depend upon details. Details should dependupon abstractions.
Robert C. Martin (again), at around 2000
59 / 138
![Page 60: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/60.jpg)
OO Principles — SOLID Dependency Inversion
Dependency Inversion Principle (2)
Bad Good
Does that really pay off?
There is only one concrete implementation
With dependency inversion applied there’s one more class
Not easily readable
60 / 138
![Page 61: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/61.jpg)
OO Principles — SOLID Dependency Inversion
Dependency Inversion Principle (3)
Really Bad
Typical scenario: longif-else-if-... chains
Each association usedbased on, say, the valueof an integer variable
Really Good
Shorter code — no longchains
(Ideally) does exactlyone thing, and delegatesencoding
Does anybody know the Strategy Pattern?
61 / 138
![Page 62: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/62.jpg)
Design Patterns
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
62 / 138
![Page 63: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/63.jpg)
Design Patterns
Design Patterns — The Legend
“Each pattern describes a problem which occurs over and over again inour environment, and then describes the core of the solution to that
problem, in such a way that you can use this solution a million times over,without ever doing it the same way twice.”
Christopher Alexander, 1977
Christopher Alexander is an architect
Gang of Four got heavily inspired by his work
63 / 138
![Page 64: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/64.jpg)
Design Patterns
Design Patterns — Definition
A Design Pattern has the following attributes:
Name. We use it to identify and talk about problems and theirsolutions.
Problem. A pattern is a solution, and there is no solution without aproblem. The problem must be clearly defined.
Solution. A description of the solution — design, responsibilities,collaborations, ...
Consequences. Benefits, trade-offs. Needed for evaluation/selection.
64 / 138
![Page 65: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/65.jpg)
Design Patterns
Design Patterns — The Book
Creational Patterns
Factory Method
Abstract Factory
Builder
Prototype
Singleton
Structural Patterns
Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy
Behavioral Patterns
Interpreter
TemplateMethod
Chain ofResponsibility
Command
Iterator
Mediator
Memento
Observer
State
Strategy
Visitor65 / 138
![Page 66: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/66.jpg)
Creational Patterns
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
66 / 138
![Page 67: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/67.jpg)
Creational Patterns
Creational Patterns — What for? (1)
Direct object creation ...
Using concrete type
void use_codec(JuliusCaesarCodec *codec) { /*...*/ }
JuliusCaesarCodec *codec = new JuliusCaesarCodec(5);
use_codec(codec);
Hard dependency on JuliusCaesarCodec, introduced by1 codec being of concrete type2 Instantiation of concrete type
Is it necessary to use concrete type?
Does use codec() care?
67 / 138
![Page 68: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/68.jpg)
Creational Patterns
Creational Patterns — What for? (2)
Using interface type
void use_codec(Codec *codec) { /*...*/ }
Codec *codec = new JuliusCaesarCodec(5);
use_codec(codec);
Still hard dependency on JuliusCaesarCodec, introduced by1 Instantiation of concrete type
68 / 138
![Page 69: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/69.jpg)
Creational Patterns
Creational Patterns — What for? (3)
Naive solution: external function
Codec *create_codec();
void use_codec(Codec *codec) { /*...*/ }
Codec *codec = create_codec();
use_codec(codec);
Dependency has been moved to create codec()
We don’t care which Codec incarnation we use → LiskowSubstitution Principle
Decided externally, by the implementation of create codec()
69 / 138
![Page 70: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/70.jpg)
Creational Patterns
Creational Patterns — What for? (4)
Now how could create codec() look like?
enum CodecType {
JULIUS_CAESAR,
BASE64
};
int jc_shift = 5;
// modify if you want different type
CodecType type_instantiated = BASE64;
Codec *create_codec() {
switch (type_instantiated) {
case JULIUS_CAESAR: return new JuliusCaesarCodec(jc_shift);
case BASE64: return new Base64Codec;
}
}
70 / 138
![Page 71: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/71.jpg)
Creational Patterns
Creational Patterns — What for? (5)
There are prettier solutions!→ Creational Patterns
71 / 138
![Page 72: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/72.jpg)
Creational Patterns Abstract Factory
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
72 / 138
![Page 73: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/73.jpg)
Creational Patterns Abstract Factory
Abstract Factory
Setup (near main() function?)
codec_factory = new JuliusCaesarCodecFactory(5);
Usage
Codec *codec = codec_factory->create();
use_codec(codec);
73 / 138
![Page 74: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/74.jpg)
Creational Patterns Abstract Factory
Abstract Factory — Discussion
How does using (instantiating) code get to the factory?
Pass factory in
Explicit: everyone can see that module makes use of it→ Dependency is obvious
Global Variable → bad smell
Hidden dependency
Singleton ...
Pass via Constructor
class SomeCodecUser
{
public:
SomeCodecUser(CodecFactory *codec_factory);
};
74 / 138
![Page 75: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/75.jpg)
Creational Patterns Singleton
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
75 / 138
![Page 76: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/76.jpg)
Creational Patterns Singleton
Singleton
Ensure a class has only one instance,and provide a global access point to it.
get instance() is not calledon an instance
C++, Java: static
76 / 138
![Page 77: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/77.jpg)
Creational Patterns Singleton
Singleton — Example
Example: Base64Codec ...
Everybody needs it
Email attachmentsHTTP transport...
There need not be multiple instances
It has no data of its ownOnly the algorithm (encode(), decode())
77 / 138
![Page 78: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/78.jpg)
Creational Patterns Singleton
Singleton — Example, Class Definition (1)
base64.h
class Base64Codec
{
public:
// return (and on-demand instantiate)
// the only Base64Codec object in the world
static Base64Codec &get_instance();
string encode(string data);
string decode(string data);
private:
...
};
78 / 138
![Page 79: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/79.jpg)
Creational Patterns Singleton
Singleton — Example, Class Definition (2)
base64.h
class Base64Codec
{
public:
...
private:
// THE object
static Base64Codec *instance;
// inhibit public instantiation
Base64Codec();
};
79 / 138
![Page 80: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/80.jpg)
Creational Patterns Singleton
Singleton — Example, Class Implementation
base64.cc
Base64Codec *Base64Codec::instance;
Base64Codec &Base64Codec::get_instance()
{
if (instance == NULL)
instance = new Base64Codec;
return *instance;
}
80 / 138
![Page 81: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/81.jpg)
Creational Patterns Singleton
Singleton — Example, User Code
user.cc
string binary_data = ...;
string email_attachment =
Base64Codec::get_instance().encode(binary_data);
81 / 138
![Page 82: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/82.jpg)
Creational Patterns Singleton
Singleton — Discussion
Singleton: Pros
Nicely encapsulates global data
Saves one from passing parameters instead
Singleton: Cons
Nicely encapsulates global data
Saves one from passing parameters instead
It’s still global
Unit testing?
Makes the design less obvious
Singleton access hidden deep in implementationHidden dependency!
Anti-Pattern?
82 / 138
![Page 83: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/83.jpg)
Structural Patterns
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
83 / 138
![Page 84: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/84.jpg)
Structural Patterns
Structural Patterns — What for?
Any non-trivial program has an object structure ...
Multiple objects are combined → structure
Some structures and motivations are immediately obvious
... others aren’t
There are no billions of different motivations
→ A handful of Patterns is sufficient to describe most
84 / 138
![Page 85: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/85.jpg)
Structural Patterns
Combining Objects — Multiple Inheritance (1)
Issues:
CombinedClass is a union of both of its bases
Contains boths methods and data, without “namespace” qualification
ConflictsAmbiguitiesProne to bugs
Situation very similar to global variable usage
85 / 138
![Page 86: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/86.jpg)
Structural Patterns
Combining Objects — Multiple Inheritance (2)
Massacre in C++
class CombinedClass : public SomeClass, public AnotherClass
{
public:
void combinedOperation() {
attr = SomeClass::attr + AnotherClass::attr;
operationA();
SomeClass::operationB();
AnotherClass::operationB();
operationC();
}
private:
int attr;
};
86 / 138
![Page 87: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/87.jpg)
Structural Patterns
Combining Objects — Composition (1)
Better, because ...
Relationships are more obvious
No ambiguities
Speech is clear: “Uses SomeClass and AnotherClass toimplement its operations” (if anybody cares at all)
And not: “Is both a SomeClass and a AnotherClass, and adds alittle to both”
87 / 138
![Page 88: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/88.jpg)
Structural Patterns
Combining Objects — Composition (2)
class CombinedClass
{
public:
void combinedOperation() {
attr = Some.attr + another.attr;
some.operationA();
some.operationB();
another.operationB();
another.operationC();
}
private:
SomeClass some;
AnotherClass another;
int attr;
};
88 / 138
![Page 89: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/89.jpg)
Structural Patterns
Combining Objects — There’s More To It
So much for trivial object combinations→ Structural Patterns
89 / 138
![Page 90: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/90.jpg)
Structural Patterns Adapter
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
90 / 138
![Page 91: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/91.jpg)
Structural Patterns Adapter
Adapter — Sample Problem
Sample Problem: Base64Codec (again) ...
I have an implementation based on C++ iostream
Want to implement C++ string based interface
... as dictated by interface Codec
class Base64Codec
: public Codec
{
public:
string encode(string);
string decode(string);
};
class IOBase64Codec
{
public:
static void encode(
istream&, ostream&);
static void decode(
istream&, ostream&);
};
91 / 138
![Page 92: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/92.jpg)
Structural Patterns Adapter
Adapter — Motivation
Pattern: apply ultralight glue ...
Interfaces are similar
It is obvious that their intention is the same
Interfaces are incompatible, compiler-wise
Adapt the iostream implementation into our string based Codec
hierarchy
Fortunately there’s C++’s istringstream and ostringstream
which turns a string into a stream and back
92 / 138
![Page 93: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/93.jpg)
Structural Patterns Adapter
Adapter — Graphics
93 / 138
![Page 94: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/94.jpg)
Structural Patterns Adapter
Adapter — Implementation
A typical adapter implementation ...
Usually very short, to the point, obvious
Inlineable in most cases
No big deal — it’s the name that is important for communication
string Base64Codec::encode(string in)
{
istringstream sin(in);
ostringstream sout;
IOBase64Codec::encode(sin, sout);
return sout.str();
}
94 / 138
![Page 95: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/95.jpg)
Structural Patterns Bridge
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
95 / 138
![Page 96: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/96.jpg)
Structural Patterns Bridge
Bridge — Example: String (1)
Straightforward bridge example: String
Goal: transparent sharing of objects
User code has an innocent looking object → bridge
Handle to the real stuff... possibly augmented with some additional higher level methods
E.g. a naive String class
Implementation: reference counting, low level memory managementBridge: cute methods find, cut, splice, ...
96 / 138
![Page 97: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/97.jpg)
Structural Patterns Bridge
Bridge — Example: String (2)
String: Object Diagram
String: Class Diagram
97 / 138
![Page 98: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/98.jpg)
Structural Patterns Bridge
Bridge — Definition
Bridge: GoF Definition
Decouple an abstraction from its implementation so that the two can varyindependently.
So what could that mean?
String is an easy application of the Bridge pattern
String is an abstraction: nobody sees low level memory issues, butrather useful methods
Definition leaves much more room for interpretation
Abstraction side can varyImplementation side can vary
98 / 138
![Page 99: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/99.jpg)
Structural Patterns Bridge
Bridge — General Case
Focus is more on independent evolution of both sides
Abstract Factory can be used to setup bridges
As for the String example ...
Abstractions: ASCIIString, UTF8String, ...
Implementations: StringImpMalloc, StringImpChunked
99 / 138
![Page 100: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/100.jpg)
Structural Patterns Composite
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
100 / 138
![Page 101: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/101.jpg)
Structural Patterns Composite
Composite — Example: Unix Filesystem (1)
101 / 138
![Page 102: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/102.jpg)
Structural Patterns Composite
Composite — Example: Unix Filesystem (2)
Hierarchy is in place with this design
But there is more which is lacking from this example
Directory is differentApplication (tar, tree, ...) needs to know the concrete types→ Complexity
102 / 138
![Page 103: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/103.jpg)
Structural Patterns Composite
Composite — Example: Graphics
Common interface
Composite Graphic draws all it contains
Recursive: Graphic can contain Graphic can contain ...
103 / 138
![Page 104: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/104.jpg)
Structural Patterns Composite
Composite — Example: Thermometer
AveragingThermometer: average out of several temperatures
Design variation: weighted average
104 / 138
![Page 105: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/105.jpg)
Structural Patterns Composite
Composite — Example: Boolean Expression
Abstract SyntaxTrees (AST)
Simple AST:BooleanExpression
Evaluating(executing) ASTsis a differentstory
InterpreterPattern
Object Structure
Class Diagram
105 / 138
![Page 106: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/106.jpg)
Structural Patterns Proxy
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
106 / 138
![Page 107: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/107.jpg)
Structural Patterns Proxy
Proxy — Definition
GoF Definition
Provide a surrogate or placeholder for another object to control access toit.
GoF Diagram
A-ha ...
107 / 138
![Page 108: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/108.jpg)
Structural Patterns Proxy
Proxy — GoF Example: Image in Text
Image should not beloaded/calculated whennot in visible area
→ Demand loading
ImageProxy::draw()
{
if (image == NULL)
image = Image(filename);
image->draw();
}
108 / 138
![Page 109: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/109.jpg)
Structural Patterns Proxy
Proxy — Example: Plugin Interface
Loading code from a file ...
Unix/Linux: dlopen(), dlsym()
Windows: LoadLibraryEx(), GetProcAddress()
Defining a plugin scheme: Codec ...
A plugin (DLL, sharded library) brings one Codec object
Well defined name: the object
We only know the interface (implementation buried in plugin)
Proxy Codec ...
Load libraryUse dlsym() to find the object
Use that as RealSubject
109 / 138
![Page 110: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/110.jpg)
Structural Patterns Proxy
Proxy — Remoting (1)
The word Proxy as everybody knows it ...
110 / 138
![Page 111: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/111.jpg)
Structural Patterns Proxy
Proxy — Remoting (2)
Distributed applications ...
Use a remote object as if it were remote
Local Proxy object — satisfying the interface
Remote concrete implementation
Wire protocol in between
DBusThermometer
111 / 138
![Page 112: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/112.jpg)
Structural Patterns Proxy
Proxy — Remoting (3)
Distributed Application
112 / 138
![Page 113: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/113.jpg)
Behavioral Patterns
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
113 / 138
![Page 114: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/114.jpg)
Behavioral Patterns
Behavioral Patterns
Structure versus Functionality
Structure implies functionality (sometimes)
Composite: boolean expressions
Structure implies only little functionality (sometimes)
AdapterBridge
Functionality implies structure (mostly)
Behavioral Patterns:
Focus on object interactions
Parameters, return values
→ Semantics
114 / 138
![Page 115: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/115.jpg)
Behavioral Patterns Command
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
115 / 138
![Page 116: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/116.jpg)
Behavioral Patterns Command
Command
Command: the problem ...
Imagine a large framework, passing and executing requests of somesort
Requests are not fixed, but rather extensible/anonymous
Request ⇐⇒ functioncall
Variable parameters
→ Encapsulateparameters in object
116 / 138
![Page 117: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/117.jpg)
Behavioral Patterns Command
Command — Example: Remote Requests
Large framework, handling remote requests ...
Which pattern is used for RequestParser?
Command’s execution maximally decoupled from the rest
→ Highly dynamic
117 / 138
![Page 118: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/118.jpg)
Behavioral Patterns Command
Command — Problems
Command has problems (as everything) ...
Non-uniform return value — Hello, Spool, JobStatus are quitedifferent
How is that serialized back onto the line?→ Probably not appropriate!
Command classes are largely unrelated (→ structural problems)
Many Command classes
Command implementation tend to become complex
Gets unhandy really soon if applied unapproprately → watch out, andchange!
118 / 138
![Page 119: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/119.jpg)
Behavioral Patterns Command
Command — Example: Shell
UNIX Shell: parsing and executing user’s command line ...
Uniform outcome (exit status) → perfect!
GoF example: menu items (no outcome at all)
119 / 138
![Page 120: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/120.jpg)
Behavioral Patterns Interpreter
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
120 / 138
![Page 121: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/121.jpg)
Behavioral Patterns Interpreter
Interpreter — Example: Boolean Expression (1)
Composite structure
Evaluation is not so simple
Storage of variable’s values → Context
121 / 138
![Page 122: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/122.jpg)
Behavioral Patterns Interpreter
Interpreter — Example: Boolean Expression (2)
Interpreter vs. Composite: hard to tell the difference ...
Languages are bestrepresented by trees
Trees are bestrepresented usingComposite
=⇒ Interpreter likely isComposite
Not necessarily vice versa
class Context {
public:
bool lookup_value(string);
};
class Expression
{
public:
virtual bool
evaluate(Context&) = 0;
};
122 / 138
![Page 123: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/123.jpg)
Behavioral Patterns Interpreter
Interpreter — Discussion
Ups
Grammar is easy to extend
Easily implemented
Downs
Complex grammars hard to maintain
→ Parser generators probably a better alternative
See also
Visitor pattern, to extend functionality
123 / 138
![Page 124: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/124.jpg)
Behavioral Patterns Observer
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
124 / 138
![Page 125: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/125.jpg)
Behavioral Patterns Observer
Observer — Model-View-Controller (MVC) (1)
Model-View-Controller: revolution in GUI design in the late 70s
Model : application data, business logic
View : visible representation
observes the model → callback
Controller : specifies actions tomanipulate the model
Triggered by button clicks, for example
125 / 138
![Page 126: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/126.jpg)
Behavioral Patterns Observer
Observer — Model-View-Controller (MVC) (2)
MVC is not among the GoF patterns ...
Subdivided into more generalized patterns
MVC was discovered for GUI designIntegrated into SmalltalkAdopted by Apple for their GUIs
Controller → Strategy
“Do something!”, and not caring what
View → Composite
Recursive decomposition of graphics
Interaction (notification) between Model and View → Observer
126 / 138
![Page 127: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/127.jpg)
Behavioral Patterns Observer
Observer — Collaborations (1)
Subject has zero ormore Observersregistered
On modification, all ofthem are notified
On notifications, theyupdate their ... whatever
127 / 138
![Page 128: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/128.jpg)
Behavioral Patterns Observer
Observer — Collaborations (2)
128 / 138
![Page 129: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/129.jpg)
Behavioral Patterns Observer
Observer — Discussion (1)
Observing multiple subjects
update() needs to pass a reference to changed subject
When is the update triggered?
Every single modification?→ Inconsistent state“Transactional integrity”?
Who triggers the update?
User after he is done? → unhandySubject? Transactional integrity?→ Be careful during design! Change if smell detected!
129 / 138
![Page 130: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/130.jpg)
Behavioral Patterns Observer
Observer — Discussion (2)
Push versus pull
Does subject push modification information?Or does observer query for it?
Multithreading
pull has to lock into subject→ Deadlock danger during callback (?)
130 / 138
![Page 131: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/131.jpg)
Behavioral Patterns Strategy
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
131 / 138
![Page 132: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/132.jpg)
Behavioral Patterns Strategy
Strategy — Example: TestRunner (1)
The Template Method pattern, as applied to xUnit ...
Template Method doesn’t scale (as everybody knows)
It is a straightforward solution to long if-else chainsOne dimension of variability (here, format()) is manageable)Number of implementors grows exponentially with the number ofvariationsExtension is not reusable
Different solution necessary
132 / 138
![Page 133: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/133.jpg)
Behavioral Patterns Strategy
Strategy — Example: TestRunner (2)
Consequences ...
TestRunner instances are parameterizeable
TestRunner is a concrete classReceives a Formatter during construction (or at runtime, or ...)
Formatting is Unit-testable without prior test run
133 / 138
![Page 134: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/134.jpg)
Behavioral Patterns Strategy
Strategy — Final Words
Strategy is one of the most important patterns, because ...
Delegation is perfectly/clearly/cleanly expressed
Runtime parameterization possible
Delegee need not be passed to constructor — can also be donedynamically
Perfect alternative to most long if-else chains where functionalityis chosen
134 / 138
![Page 135: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/135.jpg)
Behavioral Patterns Visitor
Overview
1 IntroductionLiteratureDesign PatternsTest DrivenDevelopment
2 Test Driven DevelopmentxUnit — How it Works
Test DrivenDevelopment
3 OO BasicsMembers and MethodsInheritance
4 OO Principles — SOLIDSingle ResponsibilityOpen/ClosedLiskov Substitution
Interface SegregationDependency Inversion
5 Design Patterns6 Creational Patterns
Abstract FactorySingleton
7 Structural PatternsAdapterBridge
CompositeProxy
8 Behavioral PatternsCommandInterpreterObserverStrategyVisitor
135 / 138
![Page 136: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/136.jpg)
Behavioral Patterns Visitor
Visitor — Extending Boolean Expressions (1)
Main method:evaluate()
What aboutprettyprint()?
What aboutmyfavoritemethod()?
Add all to Expression?
→ Unhandiness,uncovered by theInterface SegregationPrinciple
136 / 138
![Page 137: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/137.jpg)
Behavioral Patterns Visitor
Visitor — Extending Boolean Expressions (2)
Add visit() toExpression
Nodes: enter(), walkchildren, leave()
Leaves: enter(),leave()
... or so
137 / 138
![Page 138: Design Patterns and Test Driven Development...Tests are what ensure your code’s value You can do more valuable code with tests and TDD Test code is no di erent from \real" code!](https://reader036.vdocuments.mx/reader036/viewer/2022071509/612d694d1ecc515869422c0c/html5/thumbnails/138.jpg)
Behavioral Patterns Visitor
Notes
138 / 138