A short introduction to a powerful Design by Contract technique and its implementation in ruby contracts.ruby. Design by Contract allows one to do defensive programming in very elegant fashion, allows to set contracts on methods (expectations on input - arguments; and on output - return result) and invariants on classes. This allows to reason about code much much better.

1. DESIGN BY CONTRACT
IN RUBY
by Alexey Fedorov

2. CLASSICAL DEFENSIVE PROGRAMMING

3. def add(a, b)
a + b
end

4. def add(a, b)
raise "a should be Fixnum or Float" unless a.is_a?(Fixnum) ||
a.is_a?(Float)
raise "b should be Fixnum or Float" unless b.is_a?(Fixnum) ||
b.is_a?(Float)
result = a + b
raise "result should be Fixnum or Float" unless result.is_a?(Fixnum) ||
result.is_a?(Float)
result
end

5. GEM "CONTRACTS"

6. Contract Num, Num => Num
def add(a, b)
a + b
end

7. DESIGN BY CONTRACT

8. Answers following questions:
What does it expect?
What does it guarantee?
What does it maintain?

9. BENEFITS

10. Clients can be confident using its public APIs
Service itself can be confident in its own operations

11. ASSERTON STEROIDS. AND IT IS NOT ONLY
ABOUT TYPES

12. Contract ActiveUser => Rating
def rating_for(active_user)
# calculate rating for active user
end
class ActiveUser
def self.valid?(user)
# check that user is active
end
end

13. VERY USEFUL CONTRACT VIOLATION ERROR
MESSAGES

14. ContractError: Contract violation for argument 1 of 1:
Expected: ActiveUser,
Actual: #<User:0x00000101059540> {last_activity=27.11.2014}
Value guarded in: Object::rating_for
With Contract: ActiveUser => Rating
At: (irb):10
... backtrace ...

15. PATTERN MATCHING, SORTA..

16. Contract 1 => 1
def factorial(_)
1
end
Contract Num => Num
def factorial(number)
number * factorial(number ­ 1)
end

17. SOMETHING USEFUL

18. # Handles successful responses
Contract 200, JsonString => JsonString
def handle_response(status, response)
transform_response(response)
end
# Handles failures by forwarding them
Contract Num, String => String
def handle_response(status, response)
response
end

19. LIMITLESS BENEFITS

20. Consistency of input
Consistency of data flows inside the system
Consistency of state of the system
Consistency of output
Blow up loudly on any logical error in the system

21. CAVEATS

22. Performance?

23. PERFORMANCE

24. Benchmark Slowdown
a+b 900% slowdown
production system with network IO 5-10% slowdown
NO_CONTRACTS=1 0% slowdown
No loud blowing up with NO_CONTRACTS=1in production

25. LINKS
Github: github.com/egonSchiele/contracts.ruby
Nice tutorial: egonschiele.github.io/contracts.ruby
Creator: github.com/egonSchiele
Me, co-maintainer: github.com/waterlink

26. THANKS
Q & A