The document discusses the SOLID principles of object-oriented design. It uses an example of parsing encrypted messages from an RSS feed to demonstrate how to apply the SOLID principles. Specifically, it shows refactoring the code to have single responsibility, follow the open/closed principle by allowing extension, use Liskov substitution, separate interfaces, and depend on abstractions rather than concretions. This makes the code more maintainable and able to adapt to changing requirements over time such as different encryption methods or data sources.

1. SOLID OO
Design
Tudor Pavel
1 / 46

2. Change is inevitable.
2 / 46

3. Design prepares you for it.
3 / 46

4. Design Stamina Hypothesis
http://martinfowler.com/bliki/DesignStaminaHypothesis.html
4 / 46

5. Principles
Single Responsibility (SRP)
Open/Closed (OCP)
Liskov Substitution (LSP)
Interface Segregation (ISP)
Dependency Inversion (DIP)
5 / 46

6. Single Responsibility
A class/method should serve a single purpose.
There should never be more than one reason for a class/method to change.
6 / 46

7. Open/Closed
A class/method should be open for extension but closed for modification.
7 / 46

8. Liskov Substitution
Subclasses should be substitutable for their base classes.
8 / 46

9. Interface Segregation
Many client-specific interfaces are better than one general-purpose interface.
9 / 46

10. Dependency Inversion
Depend upon abstractions. Do not depend upon concretions.
10 / 46

11. Design is all about
dependencies.
11 / 46

12. When you know something,
you depend on it.
12 / 46

13. If it changes,
you might change.
13 / 46

14. Example App
14 / 46

15. Requirements
We are the FBI and our buddies from the NSA
post some encrypted messages for us in a
secret RSS feed.
Our job is to parse the messages from the feed
and store them in clear text in our DB, since we
don't understand encryption.
15 / 46

16. Encryption
The NSA are slightly better than us at
encryption, so they've used e Caesar Cipher to
encrypt the messages.
16 / 46

17. Message model
class Message < ActiveRecord::Base
end
17 / 46

18. Public interface
class RSSMessagesParser
def execute
messages = fetch_messages
messages.each { |m| Message.create(text: decrypt(m)) }
end
private
def fetch_messages
# ...
end
def decrypt(message)
# ...
end
end
18 / 46

19. Fetching messages
require 'rss'
class RSSMessagesParser
def execute
messages = fetch_messages
messages.each { |m| Message.create(text: decrypt(m)) }
end
private
def fetch_messages
RSS::Parser.parse(open('http://secret.nsa.gov/rss').read).items
end
def decrypt(message)
# ...
end
end
19 / 46

20. Entire class
require 'rss'
class RSSMessagesParser
def execute
messages = fetch_messages
messages.each { |m| Message.create(text: decrypt(m)) }
end
private
def fetch_messages
RSS::Parser.parse(open('http://secret.nsa.gov/rss').read).items
end
def decrypt(message)
message.split('').map(&:ord).map { |a| a - 3 }.map(&:chr).join
end
end
20 / 46

21. But what if...
the "secret" URL changes?
the encryption method changes?
reading other RSS feeds is required?
21 / 46

22. Knowing when to refactor
Is it DRY?
Does it have a single responsibility?
Does everything in it change at the same
rate?
Does it depend on more stable things?
! The answer needs to be YES for all of them to move on.
22 / 46

23. Is it DRY?
23 / 46

24. Does it have a single
responsibility?
24 / 46

25. What does RSSMessagesParser do?
Fetches messages and decrypts them and saves them to the DB.
Words like and and or are design smells suggesting a violation of SRP. This class
is doing too much!
25 / 46

26. Extracting responsibilities
class MessagesParser
def initialize
@cipher = NSACipher.new
@rss = RSSMessages.new
end
def execute
messages = @rss.fetch
messages.each { |m| Message.create(text: @cipher.decrypt(m)) }
end
end
26 / 46

27. SRP should be applied to
methods too
class MessagesParser
def initialize
@cipher = NSACipher.new
@rss = RSSMessages.new
end
def execute
messages = @rss.fetch
messages.each { |m| parse(m) }
end
private
def parse(message)
Message.create(text: @cipher.decrypt(m))
end
end
27 / 46

28. The NSACipher
class NSACipher
def decrypt(message)
message.split('').map(&:ord).map { |a| a - 3 }.map(&:chr).join
end
end
28 / 46

29. The RSSMessages class
require 'rss'
class RSSMessages
def fetch
RSS::Parser.parse(open('http://secret.nsa.gov/rss').read).items
end
end
29 / 46

30. Is it DRY?
30 / 46

31. Does it have a single
responsibility?
31 / 46

32. Does everything in it change
at the same rate?
32 / 46

33. The RSS URL and the Cipher step
can change more often than the
classes, because the NSA want to
stay at least ahead of the novice
hackers by changing them
periodically.
33 / 46

34. Using Open/Close Principle
class NSACipher
def initialize(step=3)
@step = step
end
def decrypt(message)
message.split('').map(&:ord).map { |a| a - @step }.map(&:chr).join
end
end
Add default step to simplify current calls
The class is now open for extension and reusability.
NSACipher is essentially a generic Caesar cipher that can be used to decrypt
messages, it has nothing to do with NSA, so we can rename it.
34 / 46

35. Reusable CaesarCipher
class CaesarCipher
def initialize(step=3)
@step = step
end
def decrypt(message)
message.split('').map(&:ord).map { |a| a - @step }.map(&:chr).join
end
end
35 / 46

36. The same with RSSFetcher
require 'rss'
class RSSFetcher
def initialize(url='http://secret.nsa.gov/rss')
@url = url
end
def fetch
RSS::Parser.parse(open(@url).read).items
end
end
36 / 46

37. Since we're using Rails 4.1 and the
two defaults are secret values, we
can move them to secrets.yml.
development:
default_caesar_step: 3
default_rss_url: 'http://secret.nsa.gov/rss'
def initialize(url=Rails.application.secrets.default_rss_url)
def initialize(step=Rails.application.secrets.default_caesar_step)
37 / 46

38. MessagesParser class
class MessagesParser
def initialize
@cipher = CaesarCipher.new
@rss = RSSFetcher.new
end
def execute
messages = @rss.fetch
messages.each { |m| parse(m) }
end
private
def parse(message)
Message.create(text: @cipher.decrypt(m))
end
end
38 / 46

39. Does it depend on more
stable things?
39 / 46

40. Using Dependency Inversion
class MessagesParser
def initialize(cipher, fetcher)
@cipher = cipher
@fetcher = fetcher
end
def execute
messages = @fetcher.fetch
messages.each { |m| parse(m) }
end
private
def parse(message)
Message.create(text: @cipher.decrypt(m))
end
end
MessagesParser now depends upon abstractions being injected by callers
40 / 46

41. Alternative ciphers now
supported
AES
DES
...
41 / 46

42. Alternative fetchers now
supported
Files
Twitter :)
...
42 / 46

43. Conclusions
The App is easily adaptable to future
changes because of SOLID Design
Beautiful and abstract class designs, even
Design Patterns (next), were discovered by
refactoring and following basic rules and
principles
Learn to trust your nose and to be prepared
for the inevitable changes that are coming
43 / 46

44. References
SOLID Object-Oriented Design, Sandi Metz,
https://speakerdeck.com/skmetz/solid-object-oriented-
design
44 / 46

45. Bonus
To make sure the concept of SRP sinks in:
http://youtu.be/vlN17gMhnEk
(get ready for British English and humour)
45 / 46

46. Questions?
46 / 46