Agile Principles, Patterns, and Practices in C# (Robert C. Martin Series) | 
 enlarge | Authors: Robert C. Martin, Micah Martin
Publisher: Prentice Hall PTR
Category: Book
List Price: $64.99
Buy New: $46.34
You Save: $18.65 (29%)
New (41) Used (10) from $43.00
Avg. Customer Rating:  19 reviews
Sales Rank: 86076
Media: Hardcover
Edition: 1
Number Of Items: 1
Pages: 768
Shipping Weight (lbs): 2.8
Dimensions (in): 9.4 x 7.1 x 1.6
ISBN: 0131857258
Dewey Decimal Number: 005.117
EAN: 9780131857254
ASIN: 0131857258
Publication Date: July 30, 2006
Availability: Usually ships in 1-2 business days
|
| Similar Items:
|
| Editorial Reviews:
Product Description
With the award-winning book Agile Software Development: Principles, Patterns, and Practices, Robert C. Martin helped bring Agile principles to tens of thousands of Java and C++ programmers. Now .NET programmers have a definitive guide to agile methods with this completely updated volume from Robert C. Martin and Micah Martin, Agile Principles, Patterns, and Practices in C#. This book presents a series of case studies illustrating the fundamentals of Agile development and Agile design, and moves quickly from UML models to real C# code. The introductory chapters lay out the basics of the agile movement, while the later chapters show proven techniques in action. The book includes many source code examples that are also available for download from the authors' Web site. Readers will come away from this book understanding *Agile principles, and the fourteen practices of Extreme Programming *Spiking, splitting, velocity, and planning iterations and releases *Test-driven development, test-first design, and acceptance testing *Refactoring with unit testing *Pair programming *Agile design and design smells *The five types of UML diagrams and how to use them effectively *Object-oriented package design and design patterns *How to put all of it together for a real-world project Whether you are a C# programmer or a Visual Basic or Java programmer learning C#, a software development manager, or a business analyst, Agile Principles, Patterns, and Practices in C# is the first book you should read to understand agile software and how it applies to programming in the .NET Framework.
|
| Customer Reviews: Read 14 more reviews...
 Agile Principles, Patterns, and Practices in C# (Robert C. Martin Series) October 30, 2008
Very good. I am uncertain of the author's example of design by coffee maker (it seemed a bit obtuse at times) but aside from that many portions of the book will be required for many of our developers. Concise, well written, easy to translate in action items ...
Well worth the money - I recommend it without hesitation.
 title is a little confusing October 26, 2008
Words like Agile and scrum applied more to project management, right?
Is Agile a OOD methodology? Is Agile a design pattern?
Agile Principles, Patterns, and Practices to be able applied any project.
It doesn't have to be restricted a software project - right?
If you are interested Object Oriented Design and Analysis, this isn't it.
Most C# developers fail on OO Design/patterns - fix it with this book September 5, 2008
Other reviewers are predictable in when they say 'this is not C# or agile' what they are really saying is 'I do not want to learn OO design'.
Agile teams must have OO design mastery or they tend to iterate to release 1 with legacy code. After that it is a disaster to change or make long-lived.
If you actually believe that agile lets you neglect OO design expertise that myth is put to bed here.
Are you a .NET C# developer who (forget agile) doesn'r really understand 'favor composition over specialization/inheritance'? Then read this.
You can work in software with a lot of gaps, but the content here defines what is mandatory for even moderate levels of team based success, and this is not my opinion this is proven fact over 10 years of our industry evolving.
Do you agree in the following as a common value of `good' for software?
FROM: http://articles.techrepublic.com.com/5100-10878_11-1050347.html
Good design
Well-designed applications offer software components that are more robust, more maintainable, and more reusable. Such applications should be able to adapt changing business needs without affecting design. For example, a banking application should be able to support new types of accounts without a change in the existing design.
Three key points of good design are:
Maintainability, which is the ease with which a software system or component can be modified to adapt to changing environments, improve performance, correct faults, or other attributes. Well-designed applications require fewer resources for maintenance and changes.
Reusability, which is the degree to which a software module or components can be used in more than one computing program or software system. Reusability of software components helps ensure faster development of software applications.
Robustness, which is the stability of software applications in extreme situations (e.g., maximum load conditions, erroneous user inputs). Robust applications have less downtime and can reduce maintenance costs.
Bad design
Nobody plans to create ill-designed applications. It often happens because of a lack of experience or because the app was designed quickly to meet an extremely tight deadline. Poorly designed applications usually have these problems in common:
They're rigid. A design is rigid if it cannot be easily changed. For example, a single change to heavily interdependent, rigid software could begin a cascade of changes in dependent packages. When such a program grows in size, the designers or maintainers cannot predict the extent of that cascade of change, and the impact of the change cannot be estimated. This makes the cost of the change impossible to estimate.
They're fragile. Poorly created programs have a tendency to break in many places when a single change is made. Simple changes to one part of the application can lead to failures in other parts that appear to be completely unrelated. Fixing those problems leads to even more issues, and the maintenance process begins to resemble a dog chasing its tail. Such fragility greatly decreases the credibility of the design and maintenance organization, which leaves users and managers unable to predict the future quality of the product.
They're not reusable. A design is difficult to reuse when its desirable parts are highly dependent upon other details, which aren't desired. If the design is highly interdependent, other designers will also be daunted by the amount of work necessary to separate the desirable portion of the design from the parts that aren't reusable. In most such cases, the cost of the separation is deemed to be higher than the cost of redevelopment of the design.
Still with me? Ok..
.NET developers historically have lacked (as compared to other OFA (one framework only) developers) at the very, very least) acceptable OO Design skills. I mean even remotely `predictably' acceptable. Sure I worked with many teams who were exceptions but they were all from other (Java/Smalltalk) environments. Even C++ developers can slant to a master of C, deep internals, and Fragile Base Class disaster (grin). So Microsoft would have been nuts as they have always know this to put multiple-inheritance into C#. I digress... This is relevant to the book I swear....
Uncle Bob Martin created a masterpiece here that is still just as (more?) relevant. It is utterly transformative for anyone who wants to be even remotely productive on a team of best-practice types.
FYI this is the book used when I teach 'Core Object Oriented Design for the C# Developer' around the country.
NOTE: Do not let the word 'Agile' fool you. This is a book about best practices in software design and development. Agile just assumes you already know this material, yet most I work with do not.
He provides definitive coverage of the most critical reasons for failure if you skip then. For example, inheritance in OO is wrong for most cases used today in .NET.
Liskov substitution principle
Read this (covered in detail in this book):
Kind Regards,
Damon Wilder Carr
http://blog.domaindotnet.com
Bob has given another excellent book July 29, 2008
I have read Bob's books/articles over the last few years. He has a way of explaining a solution that I have never experienced in any other books. This book is not an exception to that. I enjoyed reading everypart of this book. Must read for a C# developers.
Practical agile principles for developers June 17, 2008
1 out of 1 found this review helpful
Agile practices and design patterns written in a clear, concise way. Granted there are a handful of mistakes throughout the book, and the occasional awkward reference to a pattern that won't be covered for another 5 chapters, but they're easy to spot.
The information is presented just right - a little background info, succinct descriptions, and simplified code examples. Outstanding.
|
|
|
