Object Calisthenics: 9 regras que vão mudar sua forma de programar 🇧🇷

Escrever bom software é difícil, não se iluda, e geralmente passamos mais tempo lendo código que escrevendo código. Para escrever bons códigos você precisa ler bons códigos, isso é um hábito, e vem com o tempo, não adianta correr. Uma boa dica para melhorar sua escrita é utilizar de Object Calisthenics, que são 9 regras para "enxugar" suas classes, tornando-as muito mais fáceis de serem entendidas. A partir daí, é só correr pro abraço!

Transcript

1. OBJECT CALISTHENICS 9 regras que vão mudar sua forma de programar
2. Sou Junior Grossi twitter.com/junior_grossi github.com/jgrossi
3. Paciência!
4. https://github.com/corcel/corcel
6. ◽ 2004 php ◽ 2016 ◽
7. https://www.glofox.com/careers
8. QUALIDADE DE CÓDIGO
9. CLEAN CODE / SOLID
10. Você realmente escreve códigos 100% SOLID? #sinceridade
11. SOBRE SOLID: É um objetivo muito ousado Exige muitos conceitos de OOP Envolve muita experiência em abstração Exige um time muito "Maduro "
12. SOLID não é um processo SOLID é o objetivo final... ...de um processo muito longo
13. COMO COMEÇAR O PROCESSO?
14. É impossível aplicar SOLID em uma classe "gorda"
16. Sua classe precisa de uma dieta
17. OBJECT CALISTHENICS ❤
18. Jeff Bay, 2008 The Thoughtworks Anthology
19. 9 REGRAS/EXERCÍCIOS para deixar seus objetos em forma
20. ATENÇÃO Não se engane Algumas regras são bem difíceis Aplique com cautela Não seja um extremista Invista tempo em cada regra Algumas regras são dependentes
21. REGRA 1 Apenas um nível de indentação por método
22. MOTIVOS Evitar efeito hadouken Facilitar leitura do código Promover SRP (Single Responsibility Principle)
23. public function notify(DateInterval $dateInterval): void { $posts = $this­>postsRepository ­>findByDateInterval($dateInterval); foreach ($posts as $post) { $totals = $this­>report­>calculateTotals($post); foreach ($post­>authors() as $author) { $this­>message­>sendTo($author, $totals); } } } 1 2 3 4 5 6 7 8 9 10 11 12
24. $totals = $this­>report­>calculateTotals($post); foreach ($post­>authors() as $author) { $this­>message­>sendTo($author, $totals); } public function notify(DateInterval $dateInterval): void 1 { 2 $posts = $this­>postsRepository 3 ­>findByDateInterval($dateInterval); 4 5 foreach ($posts as $post) { 6 7 8 9 10 } 11 } 12
25. $this­>notifyAuthors($post); private function notifyAuthors(Post $post): void { $totals = $this­>report ­>calculateTotals($post); foreach ($post­>authors() as $author) { $this­>message ­>sendTo($author, $totals); } } public function notify(DateInterval $dateInterval): void 1 { 2 $posts = $this­>postsRepository 3 ­>findByDateInterval($dateInterval); 4 5 foreach ($posts as $post) { 6 7 } 8 } 9 10 11 12 13 14 15 16 17 18 19 20
26. REGRA 2 Não use ELSE
27. MOTIVOS Porque else não serve para nada Porque você não precisa do else Na verdade você nunca precisou do else
28. private function authorizeUser(User $user): bool { if ($user­>isAdmin()) { $result = true; } else { $result = false; } return $result; } private function authorizeUser(User $user): bool { if ($user­>isAdmin()) { return true; } return false; // Ou só return $user­>isAdmin() }
29. private function response(Request $request): Response { if ($request­>expectsJson()) { $response = $this­>createJsonResponse(); } else { $response = $this­>createHtmlResponse(); } return $this­>formatResponse($response); }
30. private function response(Request $request): Response { $response = $this­>buildFromRequest($request); return $this­>formatResponse($response); } private function buildFromRequest(Request $request): Response { if ($request­>expectsJson()) { return $this­>createJsonResponse(); } return $this­>createHtmlResponse(); }
31. REGRA 3 Envolva seus tipos primitivos
32. MOTIVOS Tipos primitivos são muito permissivos Não possuem nenhum significado/comportamento Encapsulamento Value Objects em DDD
33. public function charge(int $amount, string $currency): string { $this­>paymentProvider­>chargeUser( $this­>user­>id(), $amount, $currency ); return $this­>paymentProvider ­>confirmationNumber(); }
34. class Money { private int $amount; private Currency $currency; public function __construct(int $amount, string $currency) { $this­>amount = $amount; $this­>currency = new Currency($currency); } public function amount(): int { return $this­>amount; } public function currencyAbbreviation(): string { return $this­>currency ­>abbreviation(); } }
35. class Currency { private string $abbreviation; public function __construct(string $abbreviation) { if (!$this­>abbreviationIsValid($abbreviation)) { throw new InvalidCurrencyAbbreviationException; } $this­>abbreviation = strtoupper($abbreviation); } public function abbreviation(): string { return $this­>abbreviation; } // Code }
36. public function charge(Money $price): string { $this­>paymentProvider­>chargeUser( $this­>user­>id(), $price­>amount(), $price­>currencyAbbreviation(), ); return $this­>paymentProvider ­>confirmationNumber(); }
37. REGRA 4 Envolva suas collections em classes
38. MOTIVOS Te força a usar SRP Agrupa ações semelhantes na mesma classe
39. CONCEITO Manipular objectos similares em um só lugar Somente uma propriedade por classe collection Métodos realizam ações no conjunto de objectos
40. class ActiveUsersCollection implement Iterator { private array $users = []; public function __construct(array $users) { $this­>users = $users; } public function filterByActivationProcess(): self { // Code } }
41. REGRA 5 Use apenas um ponto (­>) por linha
42. MOTIVOS Facilita a leitura Lei de Demeter (fale com amigos) Reforça o Open-close principle
43. EXCEÇÕES Fluent Interfaces / Chaining Pattern $builder­>where(...)­>order(...)­>limit(...)­>get()
44. class RemoteCompany { private CountriesCollection $countries; public function addCountries(EmployeesCollection $employees): void { foreach ($employees as $employee) { $this­>countries­>add( $employee­>address­>country­>code(); ) } } } 1 2 3 4 5 6 7 8 9 10 11 12 13
45. class Employee { public function addToCollection(CountriesCollection $countries): void { $countries­>add( $this ­>address ­>addToCollection($countries) ); } }
46. class RemoteCompany { private CountriesCollection $countries; public function addCountries(EmployeesCollection $employees): void { foreach ($employees as $employee) { $employee­>addToCollection( $this­>countries ); } } } 1 2 3 4 5 6 7 8 9 10 11 12 13
47. REGRA 6 Não abrevie
48. MOTIVOS Aumentar entendimento do contexto Porque abreviação é uma merda Porque eu não sou obrigado a entender
50. EXEMPLOS $cfClient quer dizer $cloudflareClient $rsp quer dizer $requestServiceProvider $mgSrv quer dizer $mongoService
51. DICA MAROTA TRILEGAL Nomes estão ficando muito grandes? Reveja SRP! Sua classe/método pode estar fazendo coisa demais
52. REGRA 7 Mantenha todas as classes pequenas
53. MOTIVOS Mais fáceis de manter SRP Porque classe grande é uma merda
54. REGRINHAS Classes com até 50 linhas 150 linhas (PHP) Pacotes com no máximo 10 arquivos
55. REGRA 8 Não tenha mais que duas variáveis de instância em sua classe
57. MOTIVOS SRP Porque classe grande é uma merda
59. class Customer { private Name $name; private int $customerId; } class Name { private string $firstName; private string $lastName; }
60. Não seja um extremista! para lógica de domínio para representação de dados (Entity)
61. REGRA 9 Não use getters ou setters A galera de Java pira
63. MOTIVOS Podem ferir SRP / Encapsulamento Regra: Tell, don't ask! Não possuem significado algum "Immutable classes" pra accessors (sem tomada de decisão)
64. class Company { private EmployeesCollection $employees; public function setEmployees(EmployeesCollection $employees): void { $this­>employees = $employees; } }
65. class Company { private EmployeesCollection $employees; public function hireEmployee(Employee $employee): void { $this­>employees­>add($employee) } }
66. class Exam { private int $total; public function setTotal(int $total): void { $this­>total = $total; } }
67. class Exam { private int $total; public function addCorrectQuestion(Question $question): void { $this­>total += $question­>total(); } }
68. Getters/Setters. Evil. Period. Yegor Bugayenko https://www.yegor256.com/2014/09/16/getters-and-setters-are-evil.html
69. ALGUMAS VERDADES Lemos mais código que escrevemos Escrever bem é difícil Exige prática Requer tempo
70. Você escreve para outro dev ler Você pode ser esse outro dev Devs são burros preguiçosos Incluindo eu e você Previna problemas com devs
71. Extremely Defensive PHP - Marco Pivetta (@Ocramius) PHPSW: Coding Practices, June 2015 https://youtu.be/8d2AtAGJPno
72. Próximos Passos Hexagonal Architecture / DDD (abstrações) ⬇ SOLID / Clean Code
73. Domain-Driven Design in PHP Carlos Buenosvinos, Christian Soronellas, and Keyvan Akbary https://leanpub.com/ddd-in-php
74. OBRIGADO Perguntas? Dúvidas? Críticas? Sugestões? twitter.com/junior_grossi github.com/jgrossi grossi.dev