Adaptive Code via C#: Agile coding with design patterns and SOLID principles (Developer Reference) 1st Edition, Kindle Edition
Use the Amazon App to scan ISBNs and compare prices.
"Rebound" by Kwame Alexander
Don't miss best-selling author Kwame Alexander's "Rebound," a new companion novel to his Newbery Award-winner, "The Crossover,"" illustrated with striking graphic novel panels. Pre-order today
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Customers who bought this item also bought
Would you like to tell us about a lower price?
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
If you are a seasoned programmer, you might still find something new, but it's definitely not worth such a long read.
The book overs lots of other topics besides SOLID, basics of SCRUM, GoF patterns, Unit testing are also covered at a rudimentary level.
The author makes a lot of mistakes in this book, like saying that D in SOLID is Dependency Injection and not Dependency Inversion, writing faulty code samples - with cache that caches all entities into one variable regardless of key, saying that IoC container Resolve generic method returns TImplementation and not TAbstraction. Basically every 5 pages you will find a mistake, so be cautious.
In general i would not recommend this book.
For design patters a better read is GoF Design Patterns
For SOLID, Martin's Agile Principles, Patterns, and Practices in C# is much better
For Unit Testing see The Art of Unit Testing by Roy Osherove
And for comprehensive text on DI is Dependency Injection in .NET by Mark Seeman
Okay, first let me give a little bit of my background so that you will know whether or not this book is for you. First of all, I do not have a formal computer science degree. I do have a degree in electrical/computer engineering, but not computer science. I have had a few formal classes in object-oriented design, data structures and algorithms, operating systems, and an elective in web programming. As far as my experience goes, I have about 1 years of professional software development experience with .NET and C#. I knew nothing about SOLID or TDD at the time I started reading the book. I actually didn't even know what an interface was, but did know that I needed to improve my software design skills. On the back of the book it actually says "Not for beginner programmers... for experienced developers", but I would still consider myself a beginner with C#. Maybe Gary just explains things so well, and makes the concepts easy to understand.
Now, for the review. I have skipped the first chapter which is about SCRUM and some project management concepts I am not interested in right now. That being said, I am about 70 pages in and wow... I've had my eyes opened up to the way that software is supposed to be done. The second chapter of the book (where I started) talks about the basics of layering patterns and managing dependencies through simple interfaces. I immediately started finding examples that I could go and apply at work. That's the great thing about this book, Gary will explain a concept, and is right there with an example to show you how its done.
How exactly did this book help me? I was able to design some interfaces (not previously knowing what they were) using some of Gary's patterns and I have a much better way of managing my libraries/dependencies now.
Gary's formula for describing the different problems in software, and then explaining/giving examples on how to handle them makes this a great buy!
I will update this review if things change as I continue into the book.
The book has the following structure:
PART I AN AGILE FOUNDATION
CHAPTER 1 Introduction to Scrum
CHAPTER 2 Dependencies and layering
CHAPTER 3 Interfaces and design patterns
CHAPTER 4 Unit testing and refactoring
PART II WRITING SOLID CODE
CHAPTER 5 The single responsibility principle
CHAPTER 6 The open/closed principle
CHAPTER 7 The Liskov substitution principle
CHAPTER 8 Interface segregation
CHAPTER 9 Dependency injection
PART III ADAPTIVE SAMPLE
CHAPTER 10 Adaptive sample: Introduction
CHAPTER 11 Adaptive sample: Sprint 1
CHAPTER 12 Adaptive sample: Sprint 2
Part 1 defines the building blocks of professional software development. After a short introduction into scrum, the main problem of maintainable software is discussed from different viewing angles: dependencies. The ubiquitous tool to manage dependencies is the topic of the next chapter: No pattern without an interface. Unit tests and refactorings are the last chapter of this part and it emphasizes the important fact that unit tests are the prerequisite for refactoring and code that is not permanently adopted starts rotting. I like the writing style of the author, as he does not talk too much about theory. Instead he makes examples and show the consequences of the different approaches. You can easily follow his arguments and its fun reading.
Part 2 iterates through the SOLID principles using many good code examples. He starts with the typical coding style of the intermediate programmer, which unfortunately reminded me of some code I wrote myself, gradually refactoring it towards clean code. This process is accompanied by exhaustive reflection of the resulting quality and also shows the limits of perfection. I like most that he takes into account, that good code is not definable theoretically, but depends on the team, the experience, the customer and the whole situation.
Part 3 lets the reader be a fly on the wall of a scrum team. It shows how the team deals with changing requirements and how the SOLID principles helps them succeeding. This part leaves no doubt that the main target of this book is learning by reading and reviewing code. The many examples are all downloadable from GitHub.
The author Gary McLean Hall crafted a book, which is more than the sum of its parts. It's a concise and at the same time very practical summary of the main agile topics of the last decade rewritten from a C# perspective. It's full of code examples which help programmers to grasp the ideas behind the principles and patterns. The biggest difference to other development books in this area is, that it is not dogmatic. The author leaves no doubt, that the shown coding techniques are very powerful, but he also concedes that sometimes a simple class violating SRP is appropriate.
Garry McLean Hall coined the term "adaptive code" and I am sure that this was not the last thing we heard of him.
Most recent customer reviews
It is explains well known things in different angle, so this book is good for a lot of developers.
1.) Not creating too many layers