[Book Review] Code Writing Guide
This review was written with a copy of the book provided by the publisher, and this did not influence the content or evaluation of the review.
Overview
What makes code easy to review?
The Guide to Writing Readable and Review-Friendly Code is a book written by a current LINE developer based on their experiences. It thoroughly covers various methods and principles to enhance code readability.
Personally, I think it's an excellent introductory book on code conventions. Let me explain why.
Pros
Practical Examples
The examples in the book are detailed and reflect real-world scenarios. While some examples might seem lengthy, taking the time to go through them allows for a deep understanding of the details.
Appropriate Guidelines
While the author of 'Clean Code' sometimes makes extreme claims towards the end, this book provides realistic and relatable guidelines from start to finish.
Content Not Bound by Language
Although the book primarily focuses on Java and Kotlin, developers using other languages can also understand and apply the concepts.
Diverse Approaches
Instead of presenting a single solution to a problem, the book explains multiple options, offering readers a variety of choices, which feels considerate.
Cons
Lack of Intuition in Some Examples
Some examples are not very intuitive. Particularly in sections dealing with Android code, prior knowledge of mobile application structure might be necessary.
The lack of intuition in examples might be natural when explaining anti-patterns, but if the examples were intuitive from the start, they wouldn't be introduced as anti-patterns, right? Still, there's a lingering feeling that more relatable examples could have been prepared.
So, Who Should Read This Book
This book is a valuable guide for any developer looking to improve code readability. I especially recommend it to junior developers. It is filled with practical content on naming conventions, writing comments, function separation, and dependency management that can be immediately applied in the workplace. Additionally, it includes guidance on code reviews, which will be beneficial for collaboration with team members.
However, it's not just useful for junior-level developers.
If I were a junior, I would frequently refer to this book, pondering "What is clean code?" During those overwhelming and daunting moments early in my development career, reading a page from this book could provide a small guiding light. This book portrays "good code" not as a mere ideal but as something concrete and achievable.
If I were a mid-level developer, I would likely use this book with my team during code reviews. By examining different solutions to the same problem, we could discuss "Why is this method good?" or "Could we solve it differently?" Through such discussions and reflections, we could experience the joy of growing together.
If I were a senior (though I'm not yet a senior 😂), I would emphasize certain parts of this book to my team. With the message "Readable code is truly good code," I would instill the belief that the guidelines presented in the book could improve the team's code. Helping the entire team write clean and efficient code, beyond individual capabilities, is the role of a senior (nod).
Conclusion
This book will resonate differently depending on your career stage.
For juniors learning to code, it serves as a friendly guide; for mid-level developers aiming to grow with their team, it provides material for discussion; and for seniors leading a team, it acts as a compass. Ultimately, the message this book conveys is simple yet powerful:
"Clean and readable code is good code."