Clean code : a handbook of agile software craftsmanship / Robert C. Martin ; [with] Michael C. Feathers ... [et al.].
Material type: TextSeries: Feathers, Michael C ; Publication details: Upper Saddle River, NJ : Prentice Hall, c2009.Description: xxix, 431 p. : ill. ; 24 cmISBN:- 0132350882 (pbk. : alk. paper)
- 9780132350884 (pbk. : alk. paper)
- 005.1 MAR
Item type | Current library | Call number | Copy number | Status | Date due | Barcode | |
---|---|---|---|---|---|---|---|
Standard Loan | Moylish Library Main Collection | 005.1 MAR (Browse shelf(Opens below)) | 1 | Available | 39002100348110 |
Enhanced descriptions from Syndetics:
Even bad code can function. But if code isn't clean, it can bring a development organization to its knees. Every year, countless hours and significant resources are lost because of poorly written code. But it doesn't have to be that way.
Noted software expert Robert C. Martin presents a revolutionary paradigm with Clean Code: A Handbook of Agile Software Craftsmanship . Martin has teamed up with his colleagues from Object Mentor to distill their best agile practice of cleaning code "on the fly" into a book that will instill within you the values of a software craftsman and make you a better programmer--but only if you work at it.
What kind of work will you be doing? You'll be reading code--lots of code. And you will be challenged to think about what's right about that code, and what's wrong with it. More importantly, you will be challenged to reassess your professional values and your commitment to your craft.
Clean Code is divided into three parts. The first describes the principles, patterns, and practices of writing clean code. The second part consists of several case studies of increasing complexity. Each case study is an exercise in cleaning up code--of transforming a code base that has some problems into one that is sound and efficient. The third part is the payoff: a single chapter containing a list of heuristics and "smells" gathered while creating the case studies. The result is a knowledge base that describes the way we think when we write, read, and clean code.
Readers will come away from this book understanding
How to tell the difference between good and bad code How to write good code and how to transform bad code into good code How to create good names, good functions, good objects, and good classes How to format code for maximum readability How to implement complete error handling without obscuring code logic How to unit test and practice test-driven development This book is a must for any developer, software engineer, project manager, team lead, or systems analyst with an interest in producing better code.
Includes bibliographical references and index.
Clean code -- Meaningful names -- Functions -- Comments -- Formatting -- Objects and data structures -- Error handling -- Boundaries -- Unit tests -- Classes -- Systems -- Emergence -- Concurrency -- Successive refinement -- JUnit internals -- Refactoring serialdate -- Smells and heuristics -- Appendix A: Concurrency II -- Appendix B: Org.jfree.date.serialdate -- Appendix C: Cross references of heuristics -- Epilogue.
Table of contents provided by Syndetics
- Foreword (p. xix)
- Introduction (p. xxv)
- On the Cover (p. xxix)
- Chapter 1 Clean Code (p. 1)
- There Will Be Code (p. 2)
- Bad Code (p. 3)
- The Total Cost of Owning a Mess (p. 4)
- Schools of Thought (p. 12)
- We Are Authors (p. 13)
- The Boy Scout Rule (p. 14)
- Prequel and Principles (p. 15)
- Conclusion (p. 15)
- Bibliography (p. 15)
- Chapter 2 Meaningful Names (p. 17)
- Introduction (p. 17)
- Use Intention-Revealing Names (p. 18)
- Avoid Disinformation (p. 19)
- Make Meaningful Distinctions (p. 20)
- Use Pronounceable Names (p. 21)
- Use Searchable Names (p. 22)
- Avoid Encodings (p. 23)
- Avoid Mental Mapping (p. 25)
- Class Names (p. 25)
- Method Names (p. 25)
- Don't Be Cute (p. 26)
- Pick One Word per Concept (p. 26)
- Don't Pun (p. 26)
- Use Solution Domain Names (p. 27)
- Use Problem Domain Names (p. 27)
- Add Meaningful Context (p. 27)
- Don't Add Gratuitous Context (p. 29)
- Final Words (p. 30)
- Chapter 3 Functions (p. 31)
- Small! (p. 34)
- Do One Thing (p. 35)
- One Level of Abstraction per Function (p. 36)
- Switch Statements (p. 37)
- Use Descriptive Names (p. 39)
- Function Arguments (p. 40)
- Have No Side Effects (p. 44)
- Command Query Separation (p. 45)
- Prefer Exceptions to Returning Error Codes (p. 46)
- Don't Repeat Yourself (p. 48)
- Structured Programming (p. 48)
- How Do You Write Functions Like This? (p. 49)
- Conclusion (p. 49)
- SetupTeardownIncluder (p. 50)
- Bibliography (p. 52)
- Chapter 4 Comments (p. 53)
- Comments Do Not Make Up for Bad Code (p. 55)
- Explain Yourself in Code (p. 55)
- Good Comments (p. 55)
- Bad Comments (p. 59)
- Bibliography (p. 74)
- Chapter 5 Formatting (p. 75)
- The Purpose of Formatting (p. 76)
- Vertical Formatting (p. 76)
- Horizontal Formatting (p. 85)
- Team Rules (p. 90)
- Uncle Bob's Formatting Rules (p. 90)
- Chapter 6 Objects and Data Structures (p. 93)
- Data Abstraction (p. 93)
- Data/Object Anti-Symmetry (p. 95)
- The Law of Demeter (p. 97)
- Data Transfer Objects (p. 100)
- Conclusion (p. 101)
- Bibliography (p. 101)
- Chapter 7 Error Handling (p. 103)
- Use Exceptions Rather Than Return Codes (p. 104)
- Write Your Try-Catch-Finally Statement First (p. 105)
- Use Unchecked Exceptions (p. 106)
- Provide Context with Exceptions (p. 107)
- Define Exception Classes in Terms of a Caller's Needs (p. 107)
- Define the Normal Flow (p. 109)
- Don't Return Null (p. 110)
- Don't Pass Null (p. 111)
- Conclusion (p. 112)
- Bibliography (p. 112)
- Chapter 8 Boundaries (p. 113)
- Using Third-Party Code (p. 114)
- Exploring and Learning Boundaries (p. 116)
- Learning log4j (p. 116)
- Learning Tests Are Better Than Free (p. 118)
- Using Code That Does Not Yet Exist (p. 118)
- Clean Boundaries (p. 120)
- Bibliography (p. 120)
- Chapter 9 Unit Tests (p. 121)
- The Three Laws of TDD (p. 122)
- Keeping Tests Clean (p. 123)
- Clean Tests (p. 124)
- One Assert per Test (p. 130)
- F.I.R.S.T (p. 132)
- Conclusion (p. 133)
- Bibliography (p. 133)
- Chapter 10 Classes (p. 135)
- Class Organization (p. 136)
- Classes Should Be Small! (p. 136)
- Organizing for Change (p. 147)
- Bibliography (p. 151)
- Chapter 11 Systems (p. 153)
- How Would You Build a City? (p. 154)
- Separate Constructing a System from Using It (p. 154)
- Scaling Up (p. 157)
- Java Proxies (p. 161)
- Pure Java AOP Frameworks (p. 163)
- AspectJ Aspects (p. 166)
- Test Drive the System Architecture (p. 166)
- Optimize Decision Making (p. 167)
- Use Standards Wisely, When They Add Demonstrable Value (p. 168)
- Systems Need Domain-Specific Languages (p. 168)
- Conclusion (p. 169)
- Bibliography (p. 169)
- Chapter 12 Emergence (p. 171)
- Getting Clean via Emergent Design (p. 171)
- Simple Design Rule 1: Runs All the Tests (p. 172)
- Simple Design Rules 2-4: Refactoring (p. 172)
- No Duplication (p. 173)
- Expressive (p. 175)
- Minimal Classes and Methods (p. 176)
- Conclusion (p. 176)
- Bibliography (p. 176)
- Chapter 13 Concurrency (p. 177)
- Why Concurrency? (p. 178)
- Challenges (p. 180)
- Concurrency Defense Principles (p. 180)
- Know Your Library (p. 182)
- Know Your Execution Models (p. 183)
- Beware Dependencies Between Synchronized Methods (p. 185)
- Keep Synchronized Sections Small (p. 185)
- Writing Correct Shut-Down Code Is Hard (p. 186)
- Testing Threaded Code (p. 186)
- Conclusion (p. 190)
- Bibliography (p. 191)
- Chapter 14 Successive Refinement (p. 193)