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

I have seen a lot of Scrum projects flop and flop hard. There are so many IT shops that look at the little iterative Scrum diagram and think, "well that looks easy enough", and they are off and running. Regretfully they don't understand that Scrum is just a process, and a development process is only as good as the team you've assembled. In real world development project's processes should be tailored for a given project. Allowing you to account for your team's skills and availability, your business's needs, the tools you have available, the environment you are working in, the difficulty of the solution, the working environment - team member locations, greenfield vs. brownfield development, and many more things that are usually not taken into consideration when a project is started. I have seen projects fail for any of the above factors not being handled correctly. I usually see projects fail for multiple reasons. Lack of architecture, managers that have no business managing, business owners who want to over step the boundary that exists between the decisions we need them to make and the technical decisions they need to leave to the technical team, and of course the one this book addresses, inexperienced developers. After a short introduction the author takes us on a tour of Scrum. I really liked that the author stayed grounded in reality during the tour and at the end of it brings us back to the topic he is covering, quality code. The book is broken down into 3 parts. I have listed each along with the chapters they contain. 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 Appendix A: Adaptive tools Appendix B: GitHub code samples online Very few developers take the time to learn the coding principles, practices, and patterns found in this book. The author has done the development community a great service by assembling all these topics and one book. Prior to this book you could still learn all these techniques, but you would have to go looking for them in different books and locations on the Internet. There were some books that covered all these topics in the past but they were much more difficult to get through. The author's writing style really helps absorb this material. This book also uses C# so .NET developers should feel right at home. The books I am referring to used Java, C, or C++. Agile coding techniques in this book are not optional. They are a key piece of the puzzle in a shop or on a project that is attempting to run with agile processes. Keep in mind that agile is a state of being, not a process, not a set of development practices, not a way of budgeting, and not an architecture. All those things must be done in a certain way in order to achieve an agile state on a project. Adaptive Code via C#: Agile coding with design patterns and SOLID principles does a great job of showing the developer how to achieve their part of the puzzle that are needed to create an agile environment. Another book that just came out, Microsoft .NET - Architecting Applications for the Enterprise (2nd Edition), does an excellent job of showing the architect how to achieve their part of the many pieces of the puzzle that are needed to create an agile environment. Absolutely buy both, but developers should start here, and architects should start with Microsoft .NET - Architecting Applications for the Enterprise (2nd Edition). There are very few books that assemble and present the amount of important material as this one. It is an absolute must read for every .NET software architect and developer.

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

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

Microsoft .NET - Architecting Applications for the Enterprise (2nd Edition) Book Review

Below is my review of the first edition of this book. I have included it in its entirety because it is rather short. This book does a great job of putting architecture into a view that .NET developers and architects can relate to. The book covers design principles and patterns, and then relates them to each layer of a traditional layered system. It includes business, services, data access, and presentation layers. The authors include several different patterns for each layer and discuss the pros and cons of each. The book focuses on the technical aspects of .NET architecture. It does not cover the soft skills needed to be an architect, or cover the customer facing skills needed to communicate with the business stakeholders. You won't find much on process either, just an overview. These missing topics have not taken away from the book, they have made it a stronger book. There are plenty of resources on how to execute the soft skills and architecture process. This book concentrates on how to communicate with the development team through solid design and well known patterns and principles. This is a must read for all architects, no matter what your skill set is. A .NET developer looking to move into architecture should make this book their first stop on a long journey. This will definitely get you off to a very strong start. This book will not leave my side... until the 2nd edition… Now that the second edition is here, I'm not quite sure the last sentence of that review is true anymore. There is still some information that is in the first edition of the book, which has been replaced in this version of the book, that I would still like to have handy. That is not a bad thing, but I consider this version of the book volume two rather than an edition two. In chapter 9 Implementing Domain Model the authors say "Most .NET developers have grown up following the guidelines of the Table Module Pattern". In my experience most .NET developers do that, but they still do not know that. I have referred developers to the first version of this book repeatedly because it does a great job of describing the Table Module Pattern. The first edition also does a great job of explaining the Transaction Script, Active Record, Remote Façade, Data Transfer Object, Adapter, Service Layer, Model View Controller, Model View Presenter, and the Presentation Model Pattern. A lot of these patterns are still valid patterns to use in simple applications. The first edition of the book also covers Service Oriented Architecture and UML. The UML section isn't that great though, so it is not missed. The second edition of the book touches on many of the patterns and topics above but in a different context. The authors group the patterns above, and the relational models they work with, into the Data-centric age- late 1970's to the early 2000s. They say the task-based age, using domain-driven design, started in the early 2000s and has continued until present day. This edition of the book brings us up to speed on what the software architect is doing in the .NET world today using domain-driven design. I have pasted the table of contents from each edition to show you how different they are. The First Edition - Part I Principles -- Architects and Architecture Today -- UML Essentials -- Design Principles and Patterns Part II Design of the System -- The Business Layer -- The Service Layer -- The Data Access Layer -- The Presentation Layer -- Final Thoughts -- Appendix: The Northwind Starter Kit The Second Edition- PART I FOUNDATION -- Architects and architecture today -- Designing for success -- Principles of software design -- Writing software of quality PART II DEVISING THE ARCHITECTURE -- Discovering the domain architecture -- The presentation layer -- The mythical business layer PART III SUPPORTING ARCHITECTURES -- Introducing Domain Model -- Implementing Domain Model -- Introducing CQRS -- Implementing CQRS -- Introducing event sourcing -- Implementing event sourcing PART IV INFRASTRUCTURE -- The persistence layer Like the first edition of the book, this one also focuses on the technical aspects of .NET architecture. It does not cover the soft skills needed to be an architect, or cover the customer facing skills needed to communicate with the business stakeholders, although domain driven design (DDD)increases the quality of communication with the business. You won't find much on process either, just an overview. Like the first version, these missing topics have not taken away from the book, they have made it a stronger book. As I said above there are plenty of resources on how to execute the soft skills and architecture process. This book concentrates on how to communicate with the development team through solid design and well known patterns and principles. The bottom line is this book summarizes what software architecture evolved into after how it was presented in the first edition of this book. However that does not mean, the techniques in this book are good for every project. DDD is not easy and can add too much complexity to simple projects to make it worth the effort. I would say on more complex decent size projects the techniques are a must do to enable all those Scrum projects out there to actually be agile. Having 15 minute meetings every morning while passing around a ball, pretending to force deliverables executing two week iterations, and eliminating upfront thought does not make your project agile. Your team must have agile design and coding skills, and your architecture absolutely must be agile. There is also a lot of things that must happen at an enterprise level on the business side in order to have an agile environment, but that is beyond the scope of this book. The book comes with downloadable samples which really help when covering the patterns that are instanced throughout the book. Although this book does a great job of showing the development level details involved with putting an agile architecture in place I would also highly recommend .NET software architects and developers also read Adaptive Code via C#: Agile coding with design patterns and SOLID principles. It covers agile development practices that are an absolute must on an agile software development project. This book does a great job of explaining all the material it covers. The topics are explained in detail and in a way that makes them easy to understand. Every software architect, enterprise architect, project manager, CIO, developer, and tester should read this book. Even though most of these roles won't be doing the architecture it is still necessary for them to understand what the architect is doing that uses the patterns and practices in this book. Keep in mind that agile is a state of being, not a process, a set of development practices, a way of budgeting, or an architecture. All those things must be done in a certain way in order to achieve agility on a project. This book does an excellent job of showing the architect how to achieve their part of the many pieces of the puzzle that are needed to create an agile environment. Adaptive Code via C#: Agile coding with design patterns and SOLID principles does a great job of showing the developer how to achieve their part of the puzzle that are needed to create an agile environment. Absolutely buy both, but architects should start here, and developers should start with Adaptive Code via C#: Agile coding with design patterns and SOLID principles.

Microsoft .NET - Architecting Applications for the Enterprise (2nd Edition)

Microsoft .NET - Architecting Applications for the Enterprise (2nd Edition)