This document discusses the importance of clean code and naming conventions. It argues that naming everything properly, including namespaces, classes, functions and variables, is crucial because people will read code far more than they write it. Descriptive names communicate intent and enable code to be understood without comments. Common naming issues like 'Util' classes and generic names are addressed. The document emphasizes that functions should be named for what they do, with boolean functions starting with 'has' or 'is'. Setters should not return anything other than the object or null.

1. Stop wasting time through clean code #phpnw11 Volker Dusch / @__edorian

2. So stop wasting time!Why are we here? 2 Introduction

3. Why are we hereto talk code and coding! 3 Introduction

4. });});}); 4 Introduction

5. Me? 5 Introduction

6. Volker Dusch@__edorian 6 Introduction

7. PHP for around 9 years 7 Introduction

8. I’m currently into TDD, CI, Clean Code and shipping 8 Introduction …amongst other stuff

9. 9 Introduction Just go and buy those *Book covers used under fair use

10. Get in touchTwitter: @__edorianXing / G+: Volker DuschStackoverflow:(visit us at http://chat.stackoverflow.com/rooms/11/phpIRC: edorianMail: php@wallbash.com 10 Introduction

11. Ask questions at any time! 11 Introduction First question gets an elePHPant Another question gets one too!

12. Why try to save time? 12 Motivation

13. Because we are professionals 13 Motivation

14. Even so our field is quite young 14 Motivation

15. Do you know how expensive it is to have you people around? 15 Motivation

16. 16 Motivation German numbers, ymmv €, £, Approx.. values You get around 50k a year 50.000 / Year Adding non-wage labor costs of around 60% 80.000 / Year Office space, water, hardware, coffee, plants, cleaning, drugs, travels, training 100.000 / Year 250 Days without weekends and holidays and your 30 holidays => 220 days 455 / Day When working 8 hours a day 55 Bucks per Hour! Your employer expects you to contribute over 100.000 Bucks in business value per year!

17. Wait why are we here again? 17 Motivation

18. To get things done, fast!Delivering is fun! 18 Motivation

20. Scrum,

21. Kanban,

22. Organizational structures

23. Sane hardware

24. Sane working environments

26. 21 Time! It matters! Not programming Changing Planning Thinking Creating Growing/Building Asking Typing Reviewing Reading

28. Reading

29. Processing

30. Writing

31. Going to 10

35. Unclear requirements?

36. Customers?

37. Schedules?

39. Rushing out stuff to make people happy“Well I’d go back and fix it but I can’t because $x”Is that comfortable? 28 Clean Code?

43. Simple

44. Just get it done as fast as possible

45. Nobody cares how you do it

47. If you can go faster when writing tests it is your responsibility to do that!

50. Just do it. It’s not magic, don’t fear doing it!

51. Practice before you do it at work!

52. Tools? You don‘t need tools to get started!

54. Your tests should run REALLY fast

55. If you can‘t do that now use --filter

57. You need to practice

58. It‘s just like any other tool and concept

59. Actually – Unit testing is really easy…

61. What to focus on?Is there anything we can base our decisions on? 38 Enough! Code! Now!

62. 39 I <2 off by one errors "There are only two hard problems in Computer Science: cache invalidation, naming things, and off-by-one errors.“ - Phil Karlton

63. 40 Naming things!

64. We name everythingWe might want to get that right 41 Naming matters

65. The purpose of a name is to reveal intent 42 Naming matters

66. A good name tells you everything you need to know! 43 Examples! class User { public function getId() {…} public function getName() {…} /** Calculate Body-Mass-Index @link … */ public function getBMI() {…} /** @param float $kg Weight in Kilogramm */ public function setWeight($kg) {…}

67. You shouldn’t need comments 44 Code! Finally! class User { public function getUserId() {…} public function getFirst/Last/DisplayName() {…} /** @link … */ public function getBodyMassIndex() {…} /** @param float $kilogramm */ public function setWeight($kilogramm) {…}

68. Names already arecompliable documentation 45 Naming matters

69. Another example 46 Code! class Calendar { public function getMonth($shortened = false) {…} } class Calendar { public function getMonthNames() {…} public function getShortendMonthNames() {…} }

71. They enable us to understand what‘s up

73. Before we startnaming things 49 Let’s go!

75. If you have long methods you might be interested in types 100 lines later

77. Classes

78. Functions

80. Namespaces gave us the ability to get pretty class names

82. Is that a good idea?

83. Harder to change folder structure

84. Duplicate information

85. Just do it anyways. It’s the expected layout

87. Using generic names throws that away!

89. Single responsibility principle!

91. By always asking if stuff fits we can ‘discover’ new classes in our applications

93. You depend on way to much other stuff

94. Usually tightly coupled

95. You can extend from those classes and chances are you can’t swap out ether

97. Composite? 60 Another logger interface interface Logger { public function log($logMessage); public function setOutputFormat($format); public function activate(); public function deactivate(); public function flush(); public function setIncludeTimestamp($format); public function addLogger(Logger $logger); }

99. They exist to act as early warning signs

102. If you name stuff like a design pattern you’d better implement that pattern!

103. Factory, DataMapper, Visitor, Composite, Strategy, Builder

105. Functions are where the action is

106. For a long time functions where all we had!

110. Setters modify internal state

111. Both should not modify anything else

113. Return codes for ugly IFs onto consumersif(!$config->set("key", "value")) { } if(!$config->has("key")) { $config->set("key", "value"); }

114. No boolean parameters 69 $user->setInactive(false); If you don’t have a very good reason! $user->setAdminStatus(false); $user->setAdminStatus(true); vs $user->revokeAdminRights(); $user->grantAdminRights();

115. Classes are nounsFunctions start with verbs! 70 $title->show(); ->createStuff(); ->deleteStuff() ->dispatchCall(); ->subscribeUser(); But never $user->admin(); or $user->bag(); $list->subscription();

116. Agree on verbs for actions 71 Don’t $dir->expunge(); Can you tell me the difference between $directory->delete($entry); And $directory->remove($entry); $router->dispatch/delegate($call); $list->add/append($user);

118. Usually those functions get created for “doing the same thing with different side effects but not wanting to call it that”

120. But you want long privates$user->setUserNameOrThrowAnbr />ExceptionIfNotPossible(); $logger->logMessageButDontDoAnythingbr />IfYouCantWriteToTheBackend($message); Not even: $logger->logMessage($message);

122. Precise names help a lot to create readable client code

124. Lots of small descripte methods

127. Then you call it

128. Then it does work

131. Do you like reading functions that are:

132. Over 100?

133. Over 20?

138. Long functions are where classes hide!

140. And we wrapped them in classes

141. That’s good for read/write access!

143. It is _easy_ to write big functions!

144. But the first change makes it all worth!

146. Descriptive function parameters

147. Big scope: long name

152. Our constants are in hash maps

153. Our variables are stored in hash maps

154. Our arrays are hash maps

155. We’d like to foreach over EVERYTHING!

158. You can create them everywhere, no DI!

159. Identity is based on state! Think dates

160. Lots of getters and setters. If you really miss arrays you can implement ArrayAccess too

161. http://misko.hevery.com/2008/09/30/to-new-or-not-to-new/

163. Value objects! 94 New them everywhere! classMonthlyValuesimplementsIteratorAggregate { protected $values = array(); publicfunction __construct(array $values) { if(count($values) != 12) { thrownnewInvalidArgumentException('...'); } $this->values = $values; } publicfunctionget($monthNumber) { return $this->values[$monthNumber]; } // ... publicfunctiongetIterator() ...

165. Additional Resources:

166. http://edorian.posterous.com/they-told-you-to-document-everything-they-lie

169. Just use exceptions in favor of return codes

171. Creating small functions saves time!

172. Only tested code can stay clean

173. You can only fix what you can reproduce!

175. Recommended Reads 100 Rate my talk please! Clean Code Management Professionalism ^ Best book in 2011 ^ In my humble opinion *Book covers used under fair use More: https://www.google.com/bookmarks/l#!threadID=GU46RJYjEsMU%2FBDcqV3woQ8eH4sOcl