Agile coding with design patterns and SOLID principles
As every developer knows, requirements are subject to change. But when you build adaptability into your code, you can respond to change more easily and avoid disruptive rework. Focusing on Agile programming, this book describes the best practices, principles, and patterns that enable you to create flexible, adaptive code--and deliver better business value.
Expert guidance to bridge the gap between theory and practice
- Get grounded in Scrum: artifacts, roles, metrics, phases
- Organize and manage architectural dependencies
- Review best practices for patterns and anti-patterns
- Master SOLID principles: single-responsibility, open/closed, Liskov substitution
- Manage the versatility of interfaces for adaptive code
- Perform unit testing and refactoring in tandem
- See how delegation and abstraction impact code adaptability
- Learn best ways to implement dependency interjection
- Apply what you learn to a pragmatic, agile coding project
Get code samples at:
About the Author
Most Helpful Customer Reviews
The title of the book “Adaptive Code via C#” describes the book very well. It is all about writing adaptive code and using C# as the programming language. Throughout my career as Software Engineer in past 10+ years, I maintained a lot of bad code and wrote some too. Most experienced programmers know the programming language quite well. They also know about software design and design pattern. However, they failed to apply them in practice. This book is a practical guideline to show you how we could use design patterns and SOLID in real projects. Part 1 is a quick review of software development processes and practices. I found it extremely useful. As an experienced programmer, I think that I already know about dependency, design patterns and unit test, etc. But I still learned a lot of from there. It also focuses on how to apply these techniques in C# language. It mentioned some anti-patterns which I and my colleagues made too. Part 2 is about SOLID. It presents SOLID in a very simple and easy to understand way. It used a lot of example to explain why and how we should apply these principles, instead of just telling you the theory. Many experienced programmers may already read the well-known Design Patterns book by GoF. But I think GoF’s book is bit too hard for many programmers. This book describes some widely used patterns in more practical way. I hope it could have more design patterns mentioned which covers different situations and need. After reading this part, I realized that I made some mistake in my previous projects and understand what mistakes I had made. I hope I can read this book earlier such that I could avoid these mistakes. Part 3 is examples on how to apply all these in practice. A lot of books tell you about some principles and give you a simple example. But they failed to show you how to apply all principles into a single project. This book put all these together and applies them step by step in the project. It is extremely handy for those who are new in agile development team. Overall, I highly recommend intermediate level programmers to read this book, especially who is working in a project that clients have new requirements very often. Even for programmers who have 10+ experiences like me, you will still find a lot of useful technique and recap your software design skills. For junior programmers, you may found this book a bit difficult and may not fully understand why such technique was used. But after reading this, you will have the idea why your senior colleagues design the software in that way. If you are really newbie, you can simple leave this book at the moment.
Before I go any further, let me say I really like this book. I do have some criticisms, but overall I think this is a book much like the famous CODE COMPLETE by Steve McConnell, that every developer should read at some point. PART 1 ("An Agile Foundation") covers a definition of SCRUM and a comparison with waterfall, then moves on to code dependencies, code organisation, interfaces and design patterns, concluding with unit testing and refactoring. This was, I thought, the weakest area of the book. It, very ambitiously, attempts to cover a LOT of ground. While it does a very good job of touching on each area, I think it could have benefited from a slight reorganisation and a little more depth in some areas. First, I think the discussion on Agile should be separated into its own section providing a clear separation of methodology from coding practices. The coverage of agile practices is thorough but I would have liked to see some discussion of digital SCRUM tools. I felt the section on problems with SCRUM and Agile is misnamed as the issues that are addressed were all code-related issues that can be disruptive to SCRUM/Agile methodologies, but not directly related to SCRUM. The section on Design Patterns was extremely light, though Part 2 does discuss other design patterns in some depth. I would also like to see a brief discussion of static-analysis tools. Overall, a very good introduction. PART 2 ("Writing SOLID code") is where each of the SOLID principles is covered in quite significant depth. Each section begins with a clear definition of the key ideas, a clear definition, and a concise code example which is refactored with a discussion that walks the reader through the thought-process involved in understanding the problem each principle addresses. Code-smells and anti-patterns are also discussed. This is a most complete discussion of the SOLID principles and the author succeeds admirably. Although this book targets C#, the author has kept the code generic enough that the book should be easily accessible to developers working with other OOP languages such as Java. PART 3 ("Adaptive Sample") ties the first two parts of the book together with a fictional product being developed by a fictional company, written as a dialog between multiple developers who work through the process of building a backlog, task breakdown and estimation for a chat application. Once the backlog has been built, we move directly into sprint #1 where we work through a planning session and the subsequent code development. Each story, idea and proposed code is discussed among the team members, enabling the reader to follow the thought process behind the code presented and the application of the principles discussed earlier in the book. At sprint end, the progress is demoed, feedback gathered and a retrospective performed, before moving into sprint #2 Overall, I’m very impressed with this book. It’s not a difficult book to read but covers a lot of ground and will be useful as a reference book for years to come. Highly recommended.