Agile Software Development, Principles, Patterns, and Practices |  | Author: Robert C. Martin
Publisher: Prentice Hall
List Price: $80.00
Buy New: $47.60
as of 11/24/2009 04:50 CST details
You Save: $32.40 (40%)
New (33) Used (18) from $35.90
Seller: new_books_today
Rating:  33 reviews
Sales Rank: 45610
Media: Hardcover
Edition: 1st
Pages: 529
Number Of Items: 1
Shipping Weight (lbs): 2.6
Dimensions (in): 10.1 x 7.8 x 1
ISBN: 0135974445
Dewey Decimal Number: 005.1
EAN: 9780135974445
ASIN: 0135974445
Publication Date: October 25, 2002
Availability: Usually ships in 1-2 business days
| |
| Also Available In:
|
| Similar Items:
| |
| Editorial Reviews:
Product Description
The known agile book. I bought it during my undergrad and never used it. Its in perfect condition
|
| Customer Reviews:
Showing reviews 1-5 of 33
An excellent introduction by examples September 12, 2008
Stratiotes Doxha Theon (Richmond, Missouri)
This is an excellent introduction to the Agile Software Development concept for anyone who learns best from examples. Mr. Martin's book is essentially a collection of introductory concepts and principles he has spoken or written about elsewhere. Much of it may be available on the web with some searching but here it is organized logically into 3 major approaches to learning: concepts, principles, and case studies. In the first chapters Mr. Martin takes us on a high flyover of Agile Software concepts such as extreme programming and test-driven development practices. Next he takes us through Java and C++ examples to demonstrate programming with key principles in mind such as "The Single-Responsibility Principle" and "The Interface-Segregation Principle." Finally he sums up the concepts and principles by examples using several real world case studies.
Mr. Martin is a master at this sort of approach to teaching software design. Those familiar with his work will immediately recognize his hand. Some (perhaps most) learn well from this approach and the organization of the book lends itself well to a classroom study or self-directed learning. This is an excellent introduction to an important and timely topic.
Are you part of the problem or are you part of the solution in the disaster that is software development? August 13, 2008
Damon Carr (Silicon Valley and New York)
Reader,
This book addresses some of the key reasons software continues to fail. It firmly ends the discussion that was never relevant of 'Agile means you do not have to REALLY known OO design'.
Indeed to be 'Agile' and not create iteratively 'crap', the only real way is via your mastery of OO Design. Long term systems that withstand change do not happen via accidential discovery with a lack of vision and core design at the core.
You can work in software with a lot of gaps, but the content here defines what is mandatory for even moderate levels of interesting work.
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
It's a great book April 17, 2008
Bing
It's a great book. As a senior developer with more than 5 year's experieces of Object-Oriented Design, I think this is a valuable pragmatic book about how to do in a practical project.
Good book February 13, 2008
Gopala Krishna Vemu
0 out of 2 found this review helpful
I bought this for my brother. Got for a good deal on Amazon. Very happy with the fast delivery by Amazon.
Very deserving in it's own right. October 12, 2007
Mitchel J. Haas (Midwest USA)
1 out of 1 found this review helpful
After reading this text, I feel it deserves the attention of other great texts such as Design patterns and Refactoring, even though much of it's content expounds upon the ideas of these two classics. It's my opinion that this text has two strong points: it explains the ideas and details of agile development very clearly, and it does an excellent job of explaining the most popular patterns originated by GOF, plus a few more. The authors style was very good, with most of the examples in Java. Being a C++ programmer, I would have liked to see more examples in that language, but this is not any fault of the author.
Showing reviews 1-5 of 33
|
|
|
|
