The document outlines 9 steps or "rules" for improving object-oriented code through a technique called "Object Calisthenics". The rules promote code that is more readable, reusable, testable and maintainable by focusing on practices like reducing indentation levels, avoiding else blocks, wrapping primitive types, limiting accessor methods, and keeping classes and methods small. Applying these rules to a new code project and analyzing the results can help customize the rules and determine how well they improve code quality.

1. Object Calisthenics
9 steps to better OO code

2. Agenda
Learn how to make our code more:
readable
reusable
testable
maintainable

3. Calisthenics

4. Cal • is • then • ics - /ˌkaləsˈTHeniks/

5. "Calisthenics are exercises consisting of a
variety of gross motor movements; often
rhythmical and generally without equipment
or apparatus."
Wikipedia

6. Object Calisthenics
Jeff Bay

7. Written for Java

8. Why bother?

9. Code is read more
than it's written

10. Rule #1
Only one level of
indentation per method

11. class Board {
public function __construct(array $data) {
$buf = '';
// 0
for ($i=0; $i<10; $i++) {
// 1
for ($j=0; $j<10; $j++) {
// 2
$buf .= $data[$i][$j]
}
}
return $buf;
}
}

12. class Board {
public function __construct(array $data) {
$buf = '';
collectRows($buf);
return $buf;
}
private function collectRows($buf) {
for ($i=0; $i<10; $i++) {
collectRow($buf, $i);
}
}
private function collectRow($buf, $row) {
for ($i=0; $i<10; $i++) {
$buf .= $data[$row][$i];
}
}
}

13. Benefits
Single responsibility
Better naming
Shorter methods
Reusable methods

14. Rule #2
Do not use else keyword

15. if (...) {
...
} elseif (...) {
...
} elseif (...) {
...
} elseif (...) {
...
} elseif (...) {
...
} elseif (...) {
...
} else {
...
}

16. public function login($username, $password) {
if ($this->userRepository->isValid($username, $password)) {
redirect("homepage");
} else {
addFlash("error", "Bad credentials");
redirect("login");
}
}

17. public function login($username, $password) {
if ($this->userRepository->isValid($username, $password)) {
return redirect("homepage");
}
addFlash("error", "Bad credentials");
return redirect("login");
}

19. Extract code

20. Default value

21. Polymorphism

22. Strategy pattern

23. State pattern

24. Benefits
Avoids code duplication
Lower complexity
Readability

25. Rule #3
Wrap primitive types if it
has behaviour

26. Value Object in DDD

27. public function checkDate(int $year, int $month, int $day)
{
...
}
// 10th of December or 12th of October?
$validator->checkDate(2016, 10, 12);

28. public function checkDate(Year $year,
Month $month,
Day $day)
{
...
}
$validator->checkDate(new Year(2016),
new Month(10),
new Day(12)
);

29. Benefits
Encapsulation
Type hinting
Attracts similar behaviour

30. Rule #4
Only one -> per line

31. OK: Fluent interface

32. $validator->addFilter(new EmailFilter())
->addFilter(new NotEmptyFilter());

33. Not OK: getter chain

34. $token = $this->getService(Service::AUTH)
->authUser($user, $password)
->getResult()
->getToken();
// 1. What if non object is returned?
// 2. How about exceptions handling?

35. class Location {
/** @var Piece */
public current;
}
class Piece {
/** @var string */
public representation;
}
class Board {
public function boardRepresentation(array $board) {
$buf = '';
foreach ($board as $field) {
$buf .= substring($field->current->representation, 0, 1);
}
return $buf;
}
}

36. class Location {
/** @var Piece */
private $current;
public function addTo($buf) {
return $this->current->addTo($buf);
}
}
class Piece {
/** @var string */
private $representation;
public function character() {
return substring(representation, 0, 1);
}
public function addTo($buf) {
return $buf . $this->character();
}
}
class Board {
public function boardRepresentation(array $board) {
$buf = '';
/** @var Location $field */
foreach ($board as $field) {
$field->addTo($buf);
}
return $buf;

37. Benefits
Encapsulation
Demeter's law
Open/Closed Principle

38. Rule #5
Do not abbreviate

39. Why abbreviate?

40. Name too long?

41. Too many responsibilities

42. Split & extract

43. Duplicated code?

44. Refactor!

45. Benefits
Clear intentions
Indicate underlying problems

46. Rule #6
Keep your classes small

47. What is small class?
15-20 lines per method
50 lines per class
10 classes per module

48. 200 lines per class

49. 10 methods per class

50. 15 classes per namespace

51. Benefits
Single Responsibility
Smaller namespaces

52. Rule #7
No more than 2 5 instance
variable per class

53. Class should handle single
variable state

54. In some cases it might be
two variables

56. class CartService {
private $userService;
private $logger;
private $cart;
private $translationService;
private $entityManager;
private $authService;
// ...
}

57. Benefits
High cohesion
Encapsulation
Fewer dependencies

58. Rule #8
First class collections

59. Doctrine's ArrayCollection

60. Benefits
Single Responsibility

61. Rule #9
Do not use setters/getters

62. Accessors are fine

63. Don't make decisions
outside of class

64. Let class do it's job

65. Tell, don't ask

66. class Game {
/** @var int */
private score;
public function setScore(score) {
$this->score = score;
}
public function getScore() {
return $this->score;
}
}
// Usage
$game->setScore($game->getScore() + ENEMY_DESTROYED_SCORE);

67. class Game {
/** @var int */
private score;
public function addScore($delta) {
$this->score += $delta;
}
}
// Usage
$game->addScore(ENEMY_DESTROYED_SCORE);

68. Benefits
Open/Closed Principle

69. Catch 'em all!
1. Only one level of indentation per method,
2. Do not use else keyword,
3. Wrap primitive types if it has behavior,
4. Only one dot per line,
5. Don’t abbreviate,
6. Keep your entities small,
7. No more than two instance variable per class,
8. First Class Collections,
9. Do not use accessors
10. ???
11. PROFIT!

70. Homework

71. Create new project up to
1000 lines long

72. Apply presented rules as
strictly as possible

73. Draw conculsions

74. Customize these rules

75. Final thoughts

76. These are not best practices

77. These are just guidelines

78. Use with caution!

79. Thank you!