--- product_id: 7513025 title: "Adaptive Code via C#: Agile coding with design patterns and SOLID principles" price: "£43.40" currency: GBP in_stock: true reviews_count: 13 url: https://www.desertcart.co.uk/products/7513025-adaptive-code-via-c-agile-coding-with-design-patterns-solid store_origin: GB region: United Kingdom --- # Adaptive Code via C#: Agile coding with design patterns and SOLID principles **Price:** £43.40 **Availability:** ✅ In Stock ## Quick Answers - **What is this?** Adaptive Code via C#: Agile coding with design patterns and SOLID principles - **How much does it cost?** £43.40 with free shipping - **Is it available?** Yes, in stock and ready to ship - **Where can I buy it?** [www.desertcart.co.uk](https://www.desertcart.co.uk/products/7513025-adaptive-code-via-c-agile-coding-with-design-patterns-solid) ## Best For - Customers looking for quality international products ## Why This Product - Free international shipping included - Worldwide delivery with tracking - 15-day hassle-free returns ## Description 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: http://github.com/garymclean/AdaptiveCode Review: Required reading for all professional C# developers - Holy cow. This is essential reading for every professional C# developer who works in Agile-Scrum teams, or who wants to. In fact I think this should be required reading for every professional C# developer. I dare say perhaps employers should filter their candidates based on whether they have already read this book. Ultimately this book boils down everything that every company that has been tinkering with Agile or formally using Agile has been most consistently using as its set of core guidelines for project management and SOLID principles as its core set of coding guidelines. It summarizes the software industry's most popular "best practices". This book will teach you at a high level how software in an Agile (Scrum/XP) environment is managed. It will teach you how the code architecture is or should be layered. It will teach you how to write testable code. Ultimately it will teach you how to write code that can adapt to changes--changes including late-discovered new features, realization of bad design, reprioritization of themes, replaced team members, and so on. Every project has changes. This book doesn't teach agile code. It teaches agile *coding*, the process of writing adaptive code, which goes beyond the code itself, and should be embraced by an entire team, otherwise only portions of the concepts are usable. This is true of any agile development book. Mind you, this book also reinforces the *basic* formulation of formal software engineering patterns and practices in the 2000s (now mid-2010s). I have seen teams exercise these "best practices" when their budget or skillset did not afford it. Agile code requires up front investment for long-term savings and sanity. For small projects, if up-front investment cannot be afforded at all but for a quick-and-dirty prototype, management may favor the easier implementation and deployment--the shameful but functional prototype working in production. Personally I think such outputs are occasionally appropriate, as long as they are formally recognized as serious technical debt. I've seen projects go both ways--formal projects abandoning all Scrum/XP (or in some cases any) project management methodologies and unit tests and ending up with a mess of hardly maintainable code, and informal projects going hardcore TDD but missing too many Scrum-XP components and ultimately they never get built--mini-projects that perhaps should never have been formalized with Agile-Scrum, because to do it successfully requires that everyone on board understands the value of every part of the process. But there are still a huge number of excellent habits the quick-and-dirty cowboy developer can still pick up by reading from this book and exercising much of what it suggests. One can still maximize code quality and adaptability following some basic conventions, and these conventions introduce a little extra cost but, exercised conservatively, the immediate tangible benefits outweigh the costs even for the quick-and-dirty prototypes. In such cases, while the entirety of this book is not useful, much of it still is. But this book runs the gamut of development in professional team environments, so it's a good read on the whole because every developer's career goes through what every project must go through: changes in his career. Be prepared. I've come across a few books produced in the previous decade that took too long to explain the principles or were otherwise so completely dry that I honestly could not read them. Gary McLean Hall writes very readable text. It is concise without being distractingly dry and doesn't litter the book with overzealous humor to keep it interesting as it doesn't need to. It is, simply, pointed yet approachable. There are plenty of examples in the book to demonstrate or illustrate his points. And he is surprisingly complete in combining SOLID principles and Agile project methodologies into one book. I'm still surprised by how thick this book *isn't*. It doesn't waste a lot of time. There's a lot to learn. And I'm still reading it; this review will be updated when I'm done, but these are my first impressions. Review: Take your code to the next level - I highly recommend this book. It’s not for the absolute beginner, but if you’re an intermediate or even senior programmer I think you’ll find this book very helpful. The book starts with a summary of Scrum, and I think it makes a good quick reference. For a more in-depth description of Scrum, see the book Scrum: The Art of Doing Twice the Work in Half the Time, which I also recommend (I actually listened to the audiobook). The chapter on dependencies and layering was an excellent discussion on organizing projects in Visual Studio solutions. The idea is to minimize dependencies between your code and external APIs. This helps to untangle your code and keep its components isolated, which makes it easier to maintain them. I applied this concept to one of my projects and I immediately saw the benefits. The book has a chapter on unit testing, but it’s more of a refresher. If you really want to understand unit testing well, read The Art of Unit Testing and Growing Object-Oriented Software, Guided by Tests. Also, I much prefer using NUnit and NSubstitute as my unit testing and mocking frameworks. The book uses MSTest and Moq. The second part of the book discusses the SOLID principles. Each principle gets its own chapter, so it’s quite detailed. What I really like about these chapters is that the author doesn’t stop at theory or simply tell you what your code should look like. He actually goes through relevant examples and shows you how to make your code follow the SOLID principles. The decorator pattern described in the chapter on the single responsibility principle was a huge eye-opener. I’ve known about this pattern before, but the way that he uses it to make code more adaptive is something I hadn’t seen before. It elevates interfaces as major players in your code. The third and final part of the book contains chapters that go through a couple of iterations of a sample project. The characters in these chapters use Scrum to plan the project and use the adaptive patterns in the book to develop it. It felt realistic and it was entertaining, and it helped to remind me of the practices recommended in the book. There wasn’t much that I disliked about the book, but one thing stands out. A lot of the examples (and even the sample project) focused on ASP.NET MVC development. Being a desktop app developer, I’m more interested in WPF and MVVM. He mentions them a few times, but only to say that the same principles as MVC apply to them. I don’t think they do. WPF and MVVM focus on data-binding, which make view models much more dynamic than the static view models in an ASP.NET MVC application. In summary, this book will help you in becoming a better developer. Your code will go from being a big ball of mud to clean code that is adaptive to change. ## Technical Specifications | Specification | Value | |---------------|-------| | Best Sellers Rank | #1,833,676 in Books ( See Top 100 in Books ) #151 in Microsoft C & C++ Windows Programming #207 in Microsoft .NET #236 in C# Programming (Books) | | Customer Reviews | 4.4 out of 5 stars 193 Reviews | ## Images ![Adaptive Code via C#: Agile coding with design patterns and SOLID principles - Image 1](https://m.media-amazon.com/images/I/71DtELRzHyL.jpg) ## Customer Reviews ### ⭐⭐⭐⭐⭐ Required reading for all professional C# developers *by J***S on November 29, 2014* Holy cow. This is essential reading for every professional C# developer who works in Agile-Scrum teams, or who wants to. In fact I think this should be required reading for every professional C# developer. I dare say perhaps employers should filter their candidates based on whether they have already read this book. Ultimately this book boils down everything that every company that has been tinkering with Agile or formally using Agile has been most consistently using as its set of core guidelines for project management and SOLID principles as its core set of coding guidelines. It summarizes the software industry's most popular "best practices". This book will teach you at a high level how software in an Agile (Scrum/XP) environment is managed. It will teach you how the code architecture is or should be layered. It will teach you how to write testable code. Ultimately it will teach you how to write code that can adapt to changes--changes including late-discovered new features, realization of bad design, reprioritization of themes, replaced team members, and so on. Every project has changes. This book doesn't teach agile code. It teaches agile *coding*, the process of writing adaptive code, which goes beyond the code itself, and should be embraced by an entire team, otherwise only portions of the concepts are usable. This is true of any agile development book. Mind you, this book also reinforces the *basic* formulation of formal software engineering patterns and practices in the 2000s (now mid-2010s). I have seen teams exercise these "best practices" when their budget or skillset did not afford it. Agile code requires up front investment for long-term savings and sanity. For small projects, if up-front investment cannot be afforded at all but for a quick-and-dirty prototype, management may favor the easier implementation and deployment--the shameful but functional prototype working in production. Personally I think such outputs are occasionally appropriate, as long as they are formally recognized as serious technical debt. I've seen projects go both ways--formal projects abandoning all Scrum/XP (or in some cases any) project management methodologies and unit tests and ending up with a mess of hardly maintainable code, and informal projects going hardcore TDD but missing too many Scrum-XP components and ultimately they never get built--mini-projects that perhaps should never have been formalized with Agile-Scrum, because to do it successfully requires that everyone on board understands the value of every part of the process. But there are still a huge number of excellent habits the quick-and-dirty cowboy developer can still pick up by reading from this book and exercising much of what it suggests. One can still maximize code quality and adaptability following some basic conventions, and these conventions introduce a little extra cost but, exercised conservatively, the immediate tangible benefits outweigh the costs even for the quick-and-dirty prototypes. In such cases, while the entirety of this book is not useful, much of it still is. But this book runs the gamut of development in professional team environments, so it's a good read on the whole because every developer's career goes through what every project must go through: changes in his career. Be prepared. I've come across a few books produced in the previous decade that took too long to explain the principles or were otherwise so completely dry that I honestly could not read them. Gary McLean Hall writes very readable text. It is concise without being distractingly dry and doesn't litter the book with overzealous humor to keep it interesting as it doesn't need to. It is, simply, pointed yet approachable. There are plenty of examples in the book to demonstrate or illustrate his points. And he is surprisingly complete in combining SOLID principles and Agile project methodologies into one book. I'm still surprised by how thick this book *isn't*. It doesn't waste a lot of time. There's a lot to learn. And I'm still reading it; this review will be updated when I'm done, but these are my first impressions. ### ⭐⭐⭐⭐⭐ Take your code to the next level *by C***N on July 17, 2016* I highly recommend this book. It’s not for the absolute beginner, but if you’re an intermediate or even senior programmer I think you’ll find this book very helpful. The book starts with a summary of Scrum, and I think it makes a good quick reference. For a more in-depth description of Scrum, see the book Scrum: The Art of Doing Twice the Work in Half the Time, which I also recommend (I actually listened to the audiobook). The chapter on dependencies and layering was an excellent discussion on organizing projects in Visual Studio solutions. The idea is to minimize dependencies between your code and external APIs. This helps to untangle your code and keep its components isolated, which makes it easier to maintain them. I applied this concept to one of my projects and I immediately saw the benefits. The book has a chapter on unit testing, but it’s more of a refresher. If you really want to understand unit testing well, read The Art of Unit Testing and Growing Object-Oriented Software, Guided by Tests. Also, I much prefer using NUnit and NSubstitute as my unit testing and mocking frameworks. The book uses MSTest and Moq. The second part of the book discusses the SOLID principles. Each principle gets its own chapter, so it’s quite detailed. What I really like about these chapters is that the author doesn’t stop at theory or simply tell you what your code should look like. He actually goes through relevant examples and shows you how to make your code follow the SOLID principles. The decorator pattern described in the chapter on the single responsibility principle was a huge eye-opener. I’ve known about this pattern before, but the way that he uses it to make code more adaptive is something I hadn’t seen before. It elevates interfaces as major players in your code. The third and final part of the book contains chapters that go through a couple of iterations of a sample project. The characters in these chapters use Scrum to plan the project and use the adaptive patterns in the book to develop it. It felt realistic and it was entertaining, and it helped to remind me of the practices recommended in the book. There wasn’t much that I disliked about the book, but one thing stands out. A lot of the examples (and even the sample project) focused on ASP.NET MVC development. Being a desktop app developer, I’m more interested in WPF and MVVM. He mentions them a few times, but only to say that the same principles as MVC apply to them. I don’t think they do. WPF and MVVM focus on data-binding, which make view models much more dynamic than the static view models in an ASP.NET MVC application. In summary, this book will help you in becoming a better developer. Your code will go from being a big ball of mud to clean code that is adaptive to change. ### ⭐⭐⭐⭐ Four Stars *by A***N on June 2, 2016* Great book. Informative. Good for developer who are moving to a more senior role. --- ## Why Shop on Desertcart? - 🛒 **Trusted by 1.3+ Million Shoppers** — Serving international shoppers since 2016 - 🌍 **Shop Globally** — Access 737+ million products across 21 categories - 💰 **No Hidden Fees** — All customs, duties, and taxes included in the price - 🔄 **15-Day Free Returns** — Hassle-free returns (30 days for PRO members) - 🔒 **Secure Payments** — Trusted payment options with buyer protection - ⭐ **TrustPilot Rated 4.5/5** — Based on 8,000+ happy customer reviews **Shop now:** [https://www.desertcart.co.uk/products/7513025-adaptive-code-via-c-agile-coding-with-design-patterns-solid](https://www.desertcart.co.uk/products/7513025-adaptive-code-via-c-agile-coding-with-design-patterns-solid) --- *Product available on Desertcart United Kingdom* *Store origin: GB* *Last updated: 2026-06-20*