Adaptive Code via C#: Agile coding with design patterns and SOLID principles

I really enjoyed reading this book. The author, Gary McLean, shares his experience and opinions and is easy to follow. Nothing is left to chance. The book is about Scrum and the SOLID principles with an emphasis on the later. While the book states that it assumes the reader to be an experienced developer it still goes into detail on what an interface is in C# (my guess is this is what happens when you have your mother review your book) -- this is the only redundant section in the book.Dependency injection (the D in SOLID) is in particular important to know when working with C#, because the Microsoft development community is particular fund of dependency injection frameworks. While the case is made for dependency injection, dependency injection frameworks are merely implied being the preferred solution (OK, dependency injection frameworks are preferable to poor mans dependency injection, defined for the occasion in the book). The Wikipedia page on the topic does list a number of disadvantages with dependency injection (see https://en.wikipedia.org/wiki/Dependency_injection#Disadvantages), so I would have liked the author to have defended is recommendations against this critique (or at least some critique).Anyway, I enjoy reading something that I can agree or disagree with. And this is what this books gives and on a high level. If you find the topics relevant, the book is really good reading.

After about 10 years of commercial programming I started to learn about SOLID design principals (and old set of principles from the eighties), it radically changed the way I code and the way I teach the programmers I manage.Therefore I was extremely eager when I saw this book available for pre-order. I purchased it on the day it was released and read it within 2 days. It is clear, concise and extremely practical. The role playing chapter at the end ties together everything you learn throughout the book - and the accompanying C# code that shows how SOLID patterns can be written into your code - along with showing you how to review C# code and spot anti-patterns is priceless.Thanks to the authors for getting this book right. I have read so many SOLID books which have failed to bridge the gap between theory and practical application, this one nails it!As an added bonus I learned a bit more about Agile development (the bits we've fallen short of in the past), for which I am very grateful.

I found the explanations to be very clear and well-written, but the book is very intense and doesn't hold you by the hand. I had to dedicate time to each chapter, read it multiple times and try and apply it practically before I could move on to the next concept. Basically it is a book for professionals.

Worth a spot on every .NET developer's bookshelf, a great book on advanced programming techniques. The book expects you to know enough C# code to come to deal with any problem and then goes through numerous patterns/principles/approach that you can use to make best use of the code you already have. The book is only 385 pages and I got it read in 10 days but I will have to re read it quite a few more times to make practical use of all the finer points. To be honest the code is a bit abstract but there was a bit more hands on in the final two chapters.If you do don't know SOLID, don't have a good mental picture of Scrum and are serious about programming then I would definitely recommend this book for you. BUT it does expect you to be at an experienced level. Its well written and interesting : )

Really liked the coverage of the principles, however I did not enjoy the scrum chapters using an imaginary team found this wasted my time. Would of like more investment into other design patterns.

Excellent book on best practices on how to develop and architect SOLID projects. Well written and easy to understand and touches pretty much every best practice you need to know. Examples are in c# but the concepts are platform agnostic

Great book, as I’m only starting out in my development career this book has been great to understand the ways of keeping code maintainable. Its written in a very understandable manner and stays interesting throughout, with plenty of code examples and scenarios further on.

Good, solid book covering C# code and highlights some of the points to consider when writing and refactoring code to SOLID principles. A worthy additional to any C# programmer's book-shelf. There is plenty of useful information contains in the chapters. The IoC and dependancies chapters are almost worth buying in their own right. Recommended reading even if you have been doing Agile design and development for a while there will be something to learn here.

J'ai trouver ce livre très agréable à lire, j'ai appris énormément de chose que l'on apprend pas sur les banc de l'école !Il m'a permis de découvrir de nouveau pattern et également de comprendre mieux l'utilité de certain déjà vu. J'ai également aimé l'approche de l'auteur de ne pas vendre les principes SOLID comme "la solution miracle", mais comme des principes à connaitre pour pouvoir les utiliser dans les situations adéquates.Ce que je pourrais peut être reprocher au bouquin et que certains exemples parfois complexifie encore plus le sujet abordé.Pour les francophones comme moi, le livre est en anglais mais est accessible ( quelques recherches google pour les certains proverbes américains on été nécessaire )Je suis curieux de savoir ce qu'apporte la deuxième édition de ce bouquin...

The future!

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.

This is a book that refreshes you of all the good concepts that you might have forgotten as you got into "Rapid Application Development" mode in .Net and into agile methodology. This books make you stop, rethink, makes you apply all the good practices to your code and still do it the agile way. SOLID concepts are explained well. No chapter is too exhaustive to be boring or too short to not to understand. It is a perfect book that can be read over in a weekend..Yeah, I said weekend. Despite its ~400 pages, it goes at such a speed that you will be able to complete it in a day or two. A must read for anyone doing agile development and C#.

The book is a warm recomendation. Author uses clear and concise way of presenting the main OOP concepts starting from the bad written code and then introducing the changes that lead to a proper OOP code. That is exactly what is missing in a number of other sources that are dealing with the same topic - lack of bad to right code transition. The only way for someone who writes bad code to start writing the proper code is to show him why his code is bad and then propose improvements. Otherwise he can not understand what problems in his old code will be solved by the new code. Chepters covering Unit testing and dependency Injection are my favourite. I also like the way how covariance and contravariance are clearified during the discussion about Liskov Substitution Principle..Although I find this book very good and helpful, I have one complaint though. I didn't like the way how author presented Composite pattern describing it as "specialized Decorator pattern". I pretty much disagree with that. Maybe opposite would be more correct since the Decorator can be seen as a special case of Composite when the number of components is 1. However, the chellenges that those two patterns are dealing with are completely different so putting them in a relation is wrong. Decorator pattern gives the solution to the problem of how to change the behavior of one component. Composite deals with the problem of how to treat the individual object and group of individual objects uniformly. Same has been described in GOF Desing Patterns book where Composite is presented first and Decorator afterwards saying that the Decorator can be seen as "degenerate composite" but with remark that Decorator adds additional responsibilities to the component which is the crucial difference between those two patterns and reason why one can not be treated as specialization of another.Looking forward to more books from the same author :)