The document discusses the Open/Closed Principle (OCP), which states that software entities should be open for extension but closed for modification. It provides an example of an OCP kata using a bowling scoring problem. Programmers are instructed to write tests, then refactor the code by changing the object composite returned by a factory to make each new test pass without modifying existing code. The document also provides credits to people involved in developing and promoting OCP and related katas.

1. SOLID
The Open/Closed Principle
Dependency Inversion
Paul Blundell
@Blundell_apps
www.blundellapps.com

2. Five basic principles of object-orientated programming.
“The principles when applied together intend to make it more likely that a
programmer will create a system that is easy to maintain and extend
over time”
S ?
O ?
L ?
I ?
D ?
SOLID

3. Five basic principles of object-orientated programming.
“The principles when applied together intend to make it more likely that a
programmer will create a system that is easy to maintain and extend
over time”
Single Responsibility Principle
Open / Closed Principle
Liskov’s Substitution
Interface Segregation
Dependency Inversion
SOLID

4. Five basic principles of object-orientated programming.
“The principles when applied together intend to make it more likely that a
programmer will create a system that is easy to maintain and extend
over time”
Single Responsibility Principle
Open / Closed Principle
Liskov’s Substitution
Interface Segregation
Dependency Inversion
SOLID

5. Open / Closed Principle
?
SOLID

6. Open / Closed Principle
“Software entities (classes, modules,
methods etc) should be open for extension
but closed for modification”
That is such an entity can allow its behaviour
to be changed without altering its source
code.
SOLID

7. Open Closed Principle

8. Open Closed Principle

9. Dependency Inversion

10. The aim of the OCP kata is to use the Open
Closed Principle to design a maintainable
and extensible code base.
Think about:
- How to compose functionality out of existing
objects
- How to avoid reworking existing code
OCP Kata

11. Write the first failing test
Then write a factory that returns an object or
a composed object that makes the test
pass.
Rules:
- the factory should be limited to creating and
linking objects
- no conditionals allowed in the factory
OCP Kata

12. @Test
public void scoreZeroForGutterGame() {
// First test
}
@Test
public void scoreTwentyForAllOnesGame() {
// Second test
}
// Continue
Bowling OCP Kata

13. Write the next failing test
Can you make this test pass by just changing
the factory and object composite?
Yes - Great do it!
No - Refactor until you can
The refactoring should be the system to a state where it’s possible to
implement the next test just by changing the composite of objects that
is returned by the factory. Do not implement new functionality when
refactoring the current test must still fail.
OCP Kata

14. Fork / Clone this repo:
git@github.com:novoda/dojos.git
Goto this folder:
github.com/novoda/dojos/tree/master/ocpBowling
Make a copy of this folder (rename default with a team name):
github.com/novoda/dojos/tree/master/ocpBowling/20130918-default
Rules are in the repo here:
ocpBowling/20130918-default/src/main/java/com/bowling/bowling_rules.txt
Start!
OCP Kata

15. Matteo Vaccari
- invented the OCP Kata
- http://matteo.vaccari.name/blog/archives/293
David Nicolette
- created the OCP jigsaw diagram
Uncle Bob
- Creator of the original bowling Kata
- http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata
Kevin Rutherford
- guided me in the art of Kata’s
- http://silkandspinach.net/
Jonas Gauffin
- for the meme
- http://blog.gauffin.org/2012/05/solid-principles-with-real-world-examples/#.UjWDy9K_s2k
Credits
Paul Blundell
@Blundell_apps
www.blundellapps.com