Agile Software Development, Principles, Patterns, and Practices

by Robert C. Martin

Written by a software developer for software developers, this book is a unique collection of the latest software development methods. The author includes OOD, UML, Design Patterns, Agile and XP methods with a detailed description of a complete software design for reusable programs in C++ and Java. Using a practical, problem-solving approach, it shows how to develop an object-oriented application--from the early stages of analysis, through the low-level design and into the implementation. Walks readers through the designer's thoughts -- showing the errors, blind alleys, and creative insights that occur throughout the software design process. The book covers: Statics and Dynamics; Principles of Class Design; Complexity Management; Principles of Package Design; Analysis and Design; Patterns and Paradigm Crossings. Explains the principles of OOD, one by one, and then demonstrates them with numerous examples, completely worked-through designs, and case studies. Covers traps, pitfalls, and work arounds in the application of C++ and OOD and then shows how Agile methods can be used. Discusses the methods for designing and developing big software in detail. Features a three-chapter, in-depth, single case study of a building security system. For Software Engineers, Programmers, and Analysts who want to understand how to design object oriented software with state of the art methods.

Genres: Programming, Technology, Software, Computer Science, Technical, Nonfiction, Coding

552 pages, Hardcover

First published October 25, 2002

About the author

Robert Cecil Martin, commonly called Uncle Bob, is a software engineer, advocate of Agile development methods, and President of Object Mentor Inc. Martin and his team of software consultants use Object-Oriented Design, Patterns, UML, Agile Methodologies, and eXtreme Programming with worldwide clients.

He was Editor in Chief of the C++ Report from 1996 to 1999. He is a featured speaker at international conferences and trade shows.

Reviews

[Rod Hilton · Rating 5 out of 5]

This book covers a great deal of material: Martin talks about the basic practices of agile software development, the principles of good object-oriented design, and common OO design patterns.

This book is, in my opinion, a career-changer. Having a single book that teaches what it essentially means to move from being a programmer to a real software craftsman is invaluable. I'd recommend this for any experienced programmer who wants to transition to a more professional approach to writing high quality, maintainable code.

In this book, Martin avoids a problem that plagued Clean Code - most of the code examples here are short, making it less problematic that they lack any kind of formatting to aid readability. My main problem with the book was that I personally don't think C++ code ever "looks" good, so examples that illustrated how to clean C++ code weren't as impactful for me as the Java examples. I think I would have preferred the C-based code to be in C# instead.

Overall, this is an excellent book that really helped me grow into a software craftsman. Occasionally, some of the code examples drag on a bit long, and occasionally the examples look overengineered (a common problem when using code short enough to illustrate a single thing), but the book is so good otherwise that it's worth slogging through the occasional rough patches.

[Vitor · Rating 5 out of 5]

A must-read for developers willing to build maintainable, testable and scalable software. It teaches you the basics for agile "software development", TDD, SOLID principles, design patterns and much more. Also, you really need to try out the patterns and practices presented in this book so you can feel how it is to create a "Clean Architecture". On the other hand, the reader might need some programming experience before trying to understand all the reasons and solutions proposed in this book.

[Zahra Dashti · Rating 3 out of 5]

بلاخره تموم شد! یک انتخاب نادرست برای این زمان! یک کتاب سخت خوان و انگیزه کم کن، حداقل برای کسی مثل من که هنوز در ابتدای راه دیزاین هست. اصلا توصیه نمی کنم اگر هنوز به درک نسبتا خوبی از مفاهیم پایه نرسیدید این کتاب رو بخونید. چون به نظرم سخت نوشته شده و خسته و گیجتون می کنه. بعدها، شاید وقتی مفاهیم برام بیشتر جا افتاد، به عنوان یک کتاب که از تجارب واقعی نوشته شده، باز این کتاب رو بخونم.

[Marshall · Rating 3 out of 5]

This book alternates between incredibly useful and frustratingly complex. Its explanations of the practical use of software design patterns as well as various principles of object-oriented design are so clear and pragmatic that I can safely say this book has shaped my programming practices. For that, I want to give it 5 stars. Then suddenly comes one of these monster case studies in which he describes in painful detail some programming problem in the most convoluted way possible, including UML diagrams that look like a jigsaw puzzle and pages of code that are both unnecessary and unhelpful. For that, I want to give it 1 star. I'm left with no choice but to settle for an average of 3 stars. My advice: Read the chapters about design patterns and object-oriented principles, and skip the mind-numbing case studies.

[Olha · Rating 5 out of 5]

I've read it for 1.5 years. 🙄 Just because I've overestimated its complexity.
The book actually consists of SOLID principles, bunch of GoF patterns with fancy modifications, and a chapter on packaging. There are a lot of case studies here.

The style is very good, while sometimes too verbose. I liked that some decisions are explained so many times that I've understood 😀.

So, having a paperback copy of a classic book is a good idea.

[Bill · Rating 4 out of 5]

This book is a great overview of patterns & workflows for writing code in an agile process. There isn't a lot of new information in the book, as most of it can be found in more detail elsewhere, but if you're looking for a consolidated overview or refresher, I highly recommend it. It's also great for the case studies, which are well-written examples of how to do some of this stuff in real-world scenarios.

[Ricardo Cavalcanti · Rating 5 out of 5]

I completely agree with Vitor's Review.

[Ihsan Nurul iman · Rating 3 out of 5]

The first chapters of the book explain a little bit about Agile and its methodologies, practices, and background. The subsequences are all about reviews of refactoring, design patterns, testing, and related stuff. Also, there are some study cases at the end of each topic.

Even though this book is not a breakthrough--there isn't something new--but the depth of the reviews makes the book worth reading. You'll recall many topics like Refactoring, XP, TTD, etc etc. You'll learn it more deeply because the author gives different perspectives on how to use certain techniques.

What bothers me a lot about this book is the author's word selection. Bob is a Sesquipedalian: he likes using big words. Some selections cause the book to be unreadable.

Also, some explanations are just too shallow. Sometimes, the author likes to assume that the readers have an understanding of the prerequisites, so he didn't give so much time explaining it or explaining it in a vague way. This is frustrating. I had to skip two case studies because of their lack of explanations. I'd tried it hard, seriously, but I don't think I would ever understand with that level of unclarity.

[Razvan Matei · Rating 5 out of 5]

I've read up this book up to the Packaging the Payroll System, right before starting the ETS Study Case. The reason for this abandon is that this book is very large (at least for me, a novice in reading technical books).

It is a great book for learning Design Patterns. Also, it is a nice read as the author has a good sense of humor, and inserts funny stuff here and there.

[Per Flitig · Rating 3 out of 5]

It’s a bit dated but the book provides a lot of useful information on making software projects successful. It’s the kind of book I wish I read a long time ago at the beginning of my career. Still, it’s valuable to revisit these concepts once in a while.
I would categorize this book as recommended reading for budding software engineers.

[Fiils · Rating 5 out of 5]

As there is now a lot of literature that is useful, but to find something you need that you can use later, in practice. I read this book and gladly recommended it to my friend who is a programmer working for the IT company SCAND I always mark such literature and keep it and advise everyone.

[Jess Hamilton · Rating 5 out of 5]

Very good book, my friend who works at a custom software development company recommended this book to me. The book covers all of the basics that you need to know as a beginner that are typically overlooked in other books for beginners. All of this information is presented in an easy-to-understand format with lots of examples along the way.

[Rodrigo Almeida · Rating 5 out of 5]

Excelent book. Every developer must read this book, at least, once in your professional life. It hasn't just talking about design patterns, but how to get there and when and if makes sense. Give you a critical vision about design patterns, refactoring, TDD and process development.

[Sigit Hadi · Rating 5 out of 5]

book that you should read .

[Ivan Ković · Rating 5 out of 5]

Nice explanation of SOLID principles. Some of the stuff is outdated but conveys the message good enough

[Rafalp · Rating 1 out of 5]

Outdated

[Tianyao (Till) Chen · Rating 3 out of 5]

The first few chapters until SOLID and design patterns are more relevant to Agile.

[Boogie · Rating 4 out of 5]

Clench your teeth or you will not finish this magnificent piece of art. It's packed with C++ and Java snippets, UMLs, case studies, etc. It's more like having a job than reading a book.

[Marcin · Rating 5 out of 5]

It was big changer in my career. It teached me how to be a developer. Not just a coder.

[Jose Ernesto · Rating 5 out of 5]

a must read for a software developer

[David Greenbaum · Rating 5 out of 5]

This is the most influential software engineering book in my library.

[Farzin]

[]

[Huralnyk Alexey · Rating 4 out of 5]

I need to reread it. Several times.

[S · Rating 5 out of 5]

I think it's the best book to get deep in OOP.

[Arvind Balasubramaniam · Rating 4 out of 5]

Pretty much a bible on Agile development and design including the "SOLID" principles. The examples on design patterns are also well written, with much detail going into the evolution of the patterns. The author tends to work from first principles while designing, so it mimicks real life development and is a good reference point for the inexperience developer. I docked one point because some of the code examples (especially, the code walkthrough chapters) were way too long-winded and some of the design pattern chapters could have been easily condensed to 50% of their length while not removing much of the core content.

[John Doe · Rating 5 out of 5]

The authoritative work on modern software development.

To anyone who bought this book as a reference to SOLID: please, please read the whole thing. Especially the Package Principles are extremely undervalued.

To anyone not using the OO paradigm (eg. applying functional programming), please don't discard this book for the parts biased towards it. Many of Uncle Bob's insights are paradigm agnostic, despite OO developers focusing on SOLID in the context of OO when referencing this book.

An absolute must read for everyone in software development.

[David Espley · Rating 5 out of 5]

Having finished this book for the second time, I am struck by what a profound influence the material contained has had on my career. Quite simply this is the very best book on programming I have ever read. If you can follow the SOLID principles contained within you will write high quality, compact and maintainable code.

I am currently encouraging a group of about 20 developers to study this book and share their experiences

[Vito · Rating 3 out of 5]

This has a lot of great advice. The advice is ageless but the delivery is dated. I recommend some of Uncle Bob's newer books:

http://www.amazon.com/Clean-Code-Hand...

http://www.amazon.com/The-Clean-Coder...

[Nick · Rating 4 out of 5]

Some of the code examples are dated in the late 2000s/early 2010s, but the concepts are rock solid. The chapters on software packaging and calculating package metrics with the Main Sequence and Stable Abstraction Principle is a fairly significant, under-researched contribution to the software engineering research space. Worth a read,cover-to-cover.

[Raghu Hudli · Rating 5 out of 5]

One of the best books on design principles. The source for SOLID design design principles. Robert Martin takes the focus away from notation and focusses on design problems - the most important one of achieving loose coupling - required for any scalable and extensible system.

I found it a great source for some of my training programs on object-oriented design.