Agile Principles, Patterns, and Practices in C# by Robert C. Martin

Agile Principles, Patterns, and Practices in C# Reviews

• 
  Gabrielam13

  Design patterns explicate în jurul unor exemple de aplicații, principiile SOLID exhaustiv prezentate, o introducere generală, dar suficientă a UML, clean design la nivel de componente și pachete, toate legate prin lupa principiilor agile sunt părțile constituente ale cărții, pe care le-am savurat și sorbit cu mult mai mult entuziasm decât cele din ”Clean code”. Aceasta se poate datora faptului că, fiind mai amplă, Uncle Bob și-a permis să explice mai îndetaliat toate principiile, dar și faptului că am învățat lucruri noi dincolo de poezia deja repetitivă a codului curat (traducerea sună amuzant în română).
  
  Rămân negreșit fana lui Robert C. Martin, dar aștept cu nerăbdare să descopăr și alți profesioniști în ale programării. Am să mă dedic să îi urmăresc în continuare video-urile, ale căror intenții le înțeleg acum mult mai clar.
• 
  Vỹ Hồng

  This is a great book on software development process and design.
  
  The agile development definition and practices are easy to digest and are common practice nowadays. I particularly enjoy the programming episode between the author and his colleague. It illustrates how software designs are not great from the beginning, but are refined through an iterative process.
  
  Next, the author presents the agile design principles. These are great principles for software development in general, and not limited to agile software development.
  
  In the next section, a payroll case study is presented. This is the driest part of the book, but necessary to illustrate and consolidate the principles and practices outlined in the previous chapters.
  
  The author also presents quite a few OOP design pattern in details, often comparing 2 similar patterns together. They're good reminders if you've known the patterns before, or good introduction if you haven't. My only complain is that they seem scattered and unstructured. If you're like me, you'd often wonder there's a OOP design pattern chapter right in the middle of the "case study" section with no explanation.
  
  The next section about packaging the payroll system is surprisingly educative. This part makes me think about how to structure software components so that they are most maintainable. Something you do every time you add a new class or a new component.
  
  I didn't finish the whole book. I lost interest after the author throws more OOP design patterns at me without explanations the second time. Maybe I'll come back at a later day. But I'm satisfied with what I've learnt for now.
• 
  Qusai Sabri

  A great book filled with best practices, not easy to read, as a programmer when I pick a book about programming I expect more technical/coding maybe even small projects from A to Z, this book has more definitions and stories,
  
  I would definitely recommend this book to experienced programmers and specially team leaders as they have the ability to apply those design patterns and force the best practices on the whole team.
  
  This book is not for junior programmers (in my opinion), "Clean Code" by the same author might be a better book to read.
• 
  Sylvain

  Covers a (too) vast territory. Long to read. Not everything is interesting...
• 
  Marko Kunic

  Besides design pattern, here you will also learn about package designs, different types of UML diagrams, testing and much more. If you have time give it a read, it is worth it.
• 
  Andrzej

  The book is good introduction to agile approach in building software.
  First part is about agile planning, extreme programming, testing and refactoring. You can treat this part as good starter to be familiar with those issues.
  The rest of the book is focused on agile architecture - design patterns, best practices. It's based on a sample problems authors solves together with reader. There is a lot of code. I mean - really a lot. Most of these code could be replaced with much shorter pseudo-code and I think book will be easier to read.
  
  There are better books describing design patterns, extreme programming, unit testing etc., but you can treat this book as a really god starter, allowing you to understand the basics of mentioned topics.
  
• 
  Jeremy Morgan

  I think this is a pretty decent book. Had I read it 10 years ago I think I would have been really impressed with it.
  
  This book covers a lot of good patterns in it, sprinkled in amongst Agile stuff. I don't think the "fit" was quite made though.
  
  Mid to senior developers may not get as much out of this, because you're likely already familiar with the patterns that are discussed in the book. However, beginners can get a good introduction to the concepts and it's not a complete waste of time.
  
  Some parts were clumsy and the book contradicts itself in places leaving unanswered questions. But it's not a bad book and it contains good information.
• 
  Harish Babu

  A must read for programers
  
  Well structured, covers important topics with really good examples that can be followed through. Optional challenges to do through out. Don’t skip over the appendixes.
• 
  John MacIntyre

  I wish I read this sooner. This book really solidified my understanding of SOLID (pun not intended). I also wish I had this as my intro to UML as well; just enough to communicate and take notes.
  
• 
  Jonn Louie Lim

  This was my gateway book to Agile software development as a developer. It's a reference I still regularly revisit from time to time.
• 
  Andrew Slater

  Still relevant. A classic.
• 
  Scott

  Thicc book, teaches SOLID principles with code examples and case studies.
• 
  Kevin Garner

  After finishing this book and thinking about how useful its contents would be for me in the workplace right now in the (almost) final quarter of 2014, I have concluded that this book is a valuable addition to my programmer bookshelf, albeit a mixed bag of good and stale bits. The good aspects of this book will remain useful. However, the stale parts are... well... a little too stale and beg for a new edition, which it seems Uncle Bob doesn't plan to undertake.
  
  The good points:
  The book has aspects that will keep this book on the shelf, ready to crack open at a moment's notice: justification for denouncement of excessive documentation and diagramming, encouragement of realistic / sustainable work hours, explanations of design patterns in a (loosely) C# context, explanations of agile PPPs from an angle I had not previously considered, demonstrations on how to produce reliable software development estimates, emphasis on test-first design / development as the foundation on which this book is written, the list could go on (but not much further).
  
  The stale points:
  To be fair, any language specific examples will become stale pretty quickly, as technology is always advancing at breakneck speeds. The Author(s) do state early on that they're not telling you "how to do C#!"; rather, they're extending a lofty olive branch to the .NET developer community (thanks....?) and wanting to discuss more language agnostic topics (refer to the good points listed above). A lot of reviewers point out that C# is really just a namesake in this book. Therefore, let's just go ahead and say it: the C# is really stale; there are such amazing things C# can do now that have made the language much more expressive, maintainable, dynamic, and capable. Funnily enough, some of these advancements were called for in Jack Reeves' article included in Appendix B of this book when he was referring to C++'s success at its onset.
  
  In a nutshell:
  This book is worth having around. I will refer back to this book often for inspiration on various design patterns. However, I would like a more modern C# publication on implementing these patterns in a way that actually leverages the language and avoids (now) known anti-patterns. It would be grand if someone took the content of this book to the next level with more modern insight.
  
  After having finished Agile C#, I experienced enlightenment in some ways, but at the same time, I need a C# palate cleanser.
• 
  Vinicius Saueia

  Excelent book, the exercices/examples are nicely contextualized and the reading flows naturally. The concepts that uncle Bob shows are universal and are not questions of C# only.
• 
  Tom

  Great, great book. The first section describing agile development is useful for anyone in the software industry, while the remainder of the book is a must-read for all software developers. The descriptions of patterns and principles are thorough yet clearly explained, supplemented by plenty of code and diagrams. Definitely a book that I'll keep nearby when writing code.
  
  Note: Martin's Agile Software Development: Principles, Patterns, and Practices is very similar to this book. I think Agile Principles, Patterns, and Practices in C# is an updated version of the other book, with more chapters on UML diagrams and all of the example code in C#.
• 
  Emil Petersen

  I hate to say it, but this book was almost too practical. I don't know how he did it. It starts out really well with great and sensible ways to work together to make software. Then a flood of C# code enters. Every design principle and pattern is nuked with examples, which should be great but somehow is not. I did not need the specifics in code when I read and so it was a bit of a nuisance after the first 5 principles. It's a bit harsh, but the lay of the land is I ended up liking the book, but not more. Would probably still recommend it - depending on how
  Code Complete turns out.
• 
  Ueliton Freitas

  This book is simply spectacular. In my opinion, with its simple and didactic dialogue focused on OO programming, provides the necessary security to develop any software project. Including project management, requisites analysis, architecture, code representation (UML), testing and TDD. All concepts with examples and source code, and even if the reader does not know C#, learning a new language.
• 
  Joe

  If you can buy only one book on agile development in C#, this is the book you should buy. It is well written and a pleasuer to read. It has many examples in C# illlustrating agile development with patterns.
• 
  Jakub Zalas

  This is THE book that should be read by any developer who claims to be Agile to confront this view with reality. Amazing overview of test driven development, solid principles of object oriented design, rules of package design and practical design patterns.
• 
  Waylon Martinez

  GREAT BOOK!!!! I don't think that I have had more fun reading a programming book.
• 
  Minh Ha

  Fascinating book. Useful for OO programmers who want to improve their code quality.
• 
  Kevin

  This book had moments of greatness (some of the design pattern explanations and the bowling game TDD session), but was ultimately dragged down by pages of legacy code and mindless numbers of tests.