Book
Clean Code
A Handbook of Agile Software Craftsmanship
Robert C. Martin
Summary
Robert C. Martin distilled this from decades as a programming consultant, working with colleagues at Object Mentor to turn their day-to-day practice of cleaning up code into a teachable set of habits. The first thirteen chapters treat naming, functions, error handling, and testing as separate disciplines; three case-study chapters then apply them by refactoring real code, including a chapter dissecting JUnit's internals and one reworking the SerialDate class from the JCommon library. A closing chapter distills the smells and heuristics gathered along the way into a single reference list. Martin's premise is blunt: messy code slows a team down long before anyone calls it technical debt, and cleaning it up is a skill separate from writing it in the first place.
Editor's Note
Best for intermediate developers first systematizing code discipline. A great pick once you've finished basic syntax and want criteria for readable code; it offers many principles, so choose what fits rather than applying all of them.
Target Readers
- Developers who can already make code work and want a vocabulary for judging whether it's also readable
- Programmers heading into a code review who want to know which naming and function-size complaints are worth raising
- Teams refactoring a legacy class who want a worked example of turning messy code into something they'd approve in review
Tags
Colophon
- Publisher
- KADOKAWA
- ISBN
- 978-4048930598
- Published
- Dec 2017
- List price
- ¥4,180incl. taxMay differ from the actual selling price on Amazon
Get this book
* The link above is an advertisement via Amazon Associates.Related Books
Prerequisites
- Recommended
Sukkiri Wakaru Java Nyumon (A Clear Introduction to Java)
Kiyotaka Nakayama, Daigo Kunimoto
Reason: Once you can write basic Java syntax, the next step is to raise your sights from merely working code to code that is readable and easy to change. Clean Code provides principles for naming, function decomposition, and comments—building the sense of quality that is hard to acquire on your own.
- Recommended
The Art of Readable Code
Simple and Practical Techniques for Writing Better Code
Dustin Boswell, Trevor Foucher
Reason: After grasping the basics of readability such as naming and function decomposition, you move on to binding them into principles of why. Clean Code connects individual techniques into a coherent system of craftsmanship and design principles.
- Recommended
The Pragmatic Programmer
your journey to mastery, 20th Anniversary Edition
David Thomas, Andrew Hunt
Reason: After adopting the pragmatic mindset of keeping code healthy, you ground those attitudes in concrete quality standards at the function and class level. Clean Code systematizes what good code is through principles and worked examples.
Next Books
- Recommended
Java Gengo de Manabu Design Pattern Nyumon (An Introduction to Design Patterns Learned in the Java Language)
Hiroshi Yuki
Reason: Once you can write clean functions and classes, it's time to learn design patterns—named solutions to recurring design problems—through Java code. This book lets you experience the 23 GoF patterns in Java implementations, building a vocabulary of reusable designs and the ability to compose relationships between classes with clear intent.
- Recommended
Refactoring
Improving the Design of Existing Code, 2nd Edition
Martin Fowler
Reason: Once you know what good code looks like, you need techniques to safely move existing code toward that standard. Refactoring offers a systematic way to improve structure without changing behavior, guided by code smells.
- Recommended
Test-Driven Development
Kent Beck
Reason: To keep writing clean code, you need a foundation that lets you change it without fear. Test-driven development instills the discipline of growing clean, working code in small cycles, turning quality into a habit.
- Recommended
Clean Architecture
A Craftsman's Guide to Software Structure and Design
Robert C. Martin
Reason: Once quality at the function and class level is second nature, the next step is to design the direction of dependencies and boundaries across the whole system. Clean Architecture provides the principle of pushing details outward and keeping business rules at the core.
- Recommended
Domain-Driven Design: Tackling Complexity in the Heart of Software
Eric Evans
Reason: Once you have quality standards at the code level, you point that expressiveness toward the language of the domain. Meaningful names become a ubiquitous language that bridges business and code, making the model speakable in code.
- Related
Web API: The Good Parts
Takaaki Mizuno
Reason: A sense for good code carries over from the inside of functions and classes to the design of the APIs you expose. The Clean Code principles of naming, consistency, and predictability extend naturally to URIs and response design—the 'public names' of an API.