Clean Code

Robert C. “Uncle Bob” Martin has been a software professional since 1970 and an international software consultant since 1990. He is founder and president of Object Mentor, Inc., a team of experienced consultants who mentor their clients worldwide in the fields of C++, Java, C#, Ruby, OO, Design Patterns, UML, Agile Methodologies, and eXtreme programming.

• Foreword                      xixIntroduction              xxvOn the Cover                     xxix Chapter 1: Clean Code                    1 There Will Be Code                        2 Bad Code                           3 The Total Cost of Owning a Mess                 4 Schools of Thought                        12 We Are Authors                      13 The Boy Scout Rule                     14 Prequel and Principles                   15 Conclusion                        15 Bibliography                  15 Chapter 2: Meaningful Names                     17 Introduction               17 Use Intention-Revealing Names                     18 Avoid Disinformation                         19 Make Meaningful Distinctions                20 Use Pronounceable Names                            21 Use Searchable Names                                22 Avoid Encodings                          23 Avoid Mental Mapping                    25 Class Names                    25 Method Names                              25 Don’t Be Cute                    26 Pick One Word per Concept                 26 Don’t Pun                    26 Use Solution Domain Names                    27 Use Problem Domain Names                   27 Add Meaningful Context                       27 Don’t Add Gratuitous Context                    29 Final Words                        30 Chapter 3: Functions                                           31 Small!                               34 Do One Thing                         35 One Level of Abstraction per Function                           36 Switch Statements                     37 Use Descriptive Names                      39 Function Arguments                          40 Have No Side Effects                          44 Command Query Separation                           45 Prefer Exceptions to Returning Error Codes              46 Don’t Repeat Yourself                          48 Structured Programming                   48 How Do You Write Functions Like This?                49 Conclusion                          49 SetupTeardownIncluder                        50 Bibliography                                       52 Chapter 4: Comments                                                  53 Comments Do Not Make Up for Bad Code                   55 Explain Yourself in Code                        55 Good Comments                              55 Bad Comments                          59 Bibliography                          74 Chapter 5: Formatting                                           75 The Purpose of Formatting                     76 Vertical Formatting                         76 Horizontal Formatting                         85 Team Rules                      90 Uncle Bob’s Formatting Rules                  90 Chapter 6: Objects and Data Structures                      93 Data Abstraction                     93 Data/Object Anti-Symmetry                        95 The Law of Demeter                         97 Data Transfer Objects                     100 Conclusion                       101 Bibliography                           101 Chapter 7: Error Handling                           103 Use Exceptions Rather Than Return Codes                  104 Write Your Try-Catch-Finally Statement First                    105 Use Unchecked Exceptions                         106 Provide Context with Exceptions                      107 Define Exception Classes in Terms of a Caller’s Needs                107 Define the Normal Flow                  109 Don’t Return Null                        110 Don’t Pass Null                       111 Conclusion                           112 Bibliography                                 112 Chapter 8: Boundaries                                                            113 Using Third-Party Code                               114 Exploring and Learning Boundaries                      116 Learning log4j                         116 Learning Tests Are Better Than Free                      118 Using Code That Does Not Yet Exist                     118 Clean Boundaries                           120 Bibliography                           120 Chapter 9: Unit Tests                                    121 The Three Laws of TDD                   122 Keeping Tests Clean                          123 Clean Tests                        124 One Assert per Test                        130 F.I.R.S.T.                      132 Conclusion                       133 Bibliography                        133 Chapter 10: Classes                         135 Class Organization                  136 Classes Should Be Small!                 136 Organizing for Change                   147 Bibliography                     151 Chapter 11: Systems                                                  153 How Would You Build a City?                     154 Separate Constructing a System from Using It                      154 Scaling Up                            157 Java Proxies                        161 Pure Java AOP Frameworks                     163 AspectJ Aspects                     166 Test Drive the System Architecture                      166 Optimize Decision Making                       167 Use Standards Wisely, When They Add Demonstrable Value                168 Systems Need Domain-Specific Languages                   168 Conclusion                    169 Bibliography                      169 Chapter 12: Emergence                        171 Getting Clean via Emergent Design                171 Simple Design Rule 1: Runs All the Tests                  172 Simple Design Rules 2–4: Refactoring                        172 No Duplication                      173 Expressive                        175 Minimal Classes and Methods               176 Conclusion                   176 Bibliography                     176 Chapter 13: Concurrency                         177 Why Concurrency?                    178 Challenges                        180 Concurrency Defense Principles                   180 Know Your Library                    182 Know Your Execution Models                       183 Beware Dependencies Between Synchronized Methods            185 Keep Synchronized Sections Small                  185 Writing Correct Shut-Down Code Is Hard                 186 Testing Threaded Code                     186 Conclusion                      190 Bibliography                         191 Chapter 14: Successive Refinement                     193 Args Implementation                          194 Args: The Rough Draft                       201 String Arguments                   214 Conclusion                       250 Chapter 15: JUnit Internals                                    251 The JUnit Framework                    252 Conclusion                 265 Chapter 16: Refactoring SerialDate                         267 First, Make It Work                     268 Then Make It Right                    270 Conclusion                      284 Bibliography                     284 Chapter 17: Smells and Heuristics                         285 Comments                           286 Environment                       287 Functions                            288 General                               288 Java                                     307 Names                                 309 Tests                                    313 Conclusion                         314 Bibliography                      315 Appendix A: Concurrency II                              317 Client/Server Example                           317 Possible Paths of Execution                    321 Knowing Your Library                      326 Dependencies Between Methods Can Break Concurrent Code         329 Increasing Throughput                  333 Deadlock                    335 Testing Multithreaded Code                   339 Tool Support for Testing Thread-Based Code                    342 Conclusion                    342 Tutorial: Full Code Examples                    343 Appendix B: org.jfree.date.SerialDate                             349 Appendix C: Cross References of Heuristics                  409 Epilogue                           411Index                                  413

1. 5/5

   Klassiker som är alla utvecklare borde läsa

   Den här är en riktig klassiker som i mångt och mycket lär ut en filosofi eller sätt att tänka kring kod som är oerhört värdefulla. Man kan diskutera detaljerna, men på det stora hela är tankarna i den här boken något jag drar nytta av varje dag.

   Christian H

   07 maj 2021
2. 5/5

   Refererar ofta till denna

   Varje dag ser jag kod som inte följer denna boken... och varje dag önskar jag att den hade gjort det. Tipsen och idéerna som presenteras i denna bok känns väldigt rätt efter att ha läst dem och det som presenteras är i sig nästan värt att ta till sig i livet i allmänt. Boken går bl.a. igenom hur kod kan struktureras för att bli lättläst, varför vi behöver ha den lättläst, hur den kan struktureras för att bli prydligare och lättare att återanvända. Allt detta är fundamentala delar för varje programmerare. Jag skulle rekommendera den till varje programmerare!

   Sebastian L

   13 januari 2015
3. 5/5

   Borde vara obligatorisk läsning för utvecklare.

   Tänk om alla utvecklare följde åtminstone några av riktlinjerna i den här boken. Vad mycket enklare allting skulle bli. Boken är proppfull med värdefulla, genomtänkta och handfasta tips med potential att lyfta dig som utvecklare till en helt ny nivå. Rekommenderas starkt!!

   Markus B

   03 november 2014
4. 4/5

   Den här boken borde alla programmerare ha!

   Det är inte alltid man har tid att skapa Clean Code men det här är guiden som man alltid återkommer till.

   Henrik Å

   07 augusti 2014
5. 5/5

   Du blir en bättre programmerare

   Den här boken lär dig hur du skriver kod som är lättare att läsa för dig om 3 månader eller om någon annan utvecklare ska ta över din kod. Det handlar alltså om att gå igenom saker som kanske kan verka självklara såssom att namnge variabler, funktioner och klasser på ett tydligt sätt men som i verkligheten inte görs så bra som man kanske skulle önska. Jag har ännu inte kommit egenom hela boken men det jag har läst än så länge sätter denna bok i samma klass som klassiker såsom The pragmatic programmer och The mythical man month.

   Martin K

   11 april 2014
6. 4/5

   I would recommend reading The Clean Coder prior to this book, since it will bring you the understanding and feeling for why TDD is so powerful. This book guides you through the main principles of what a clean code should look like. Some things you will not agree with, some will be too good to be true, but what this book will make you do is to start thinking about your code and begin writing code that is easy to read, understand, and re-use. Once you read it, you will never be the same. The code in this book is in Java.

   Tridy

   07 maj 2013