- Tapa dura: 552 páginas
- Editor: Prentice Hall; Edición: 002 (1 de octubre de 2002)
- Colección: Alan Apt Series
- Idioma: Inglés
- ISBN-10: 0135974445
- ISBN-13: 978-0135974445
- Valoración media de los clientes: 3 opiniones de clientes
- Clasificación en los más vendidos de Amazon: nº56.974 en Libros en idiomas extranjeros (Ver el Top 100 en Libros en idiomas extranjeros)
- Ver el Índice completo
Agile Software Development, Principles, Patterns, and Practices (Alan Apt Series) (Inglés) Tapa dura – 1 oct 2002
|Nuevo desde||Usado desde|
Hay una nueva edición de este producto:
Los clientes que compraron este producto también compraron
Los clientes que vieron este producto también vieron
Descripción del producto
Reseña del editor
Written by a software developer for software developers, this book is a unique collection of the latest software development methods. The author includes OOD, UML, Design Patterns, Agile and XP methods with a detailed description of a complete software design for reusable programs in C++ and Java. Using a practical, problem-solving approach, it shows how to develop an object-oriented application-from the early stages of analysis, through the low-level design and into the implementation. Walks readers through the designer's thoughts - showing the errors, blind alleys, and creative insights that occur throughout the software design process. The book covers: Statics and Dynamics; Principles of Class Design; Complexity Management; Principles of Package Design; Analysis and Design; Patterns and Paradigm Crossings. Explains the principles of OOD, one by one, and then demonstrates them with numerous examples, completely worked-through designs, and case studies. Covers traps, pitfalls, and work arounds in the application of C++ and OOD and then shows how Agile methods can be used. Discusses the methods for designing and developing big software in detail. Features a three-chapter, in-depth, single case study of a building security system. For Software Engineers, Programmers, and Analysts who want to understand how to design object oriented software with state of the art methods.
Best selling author and world-renowned software development expert Robert C. Martin shows how to solve the most challenging problems facing software developers, project managers, and software project leaders today.
- This comprehensive, pragmatic tutorial on Agile Development and eXtreme programming, written by one of the founding father of Agile Development:
- Teaches software developers and project managers how to get projects done on time, and on budget using the power of Agile Development.
- Uses real-world case studies to show how to of plan, test, refactor, and pair program using eXtreme programming.
- Contains a wealth of reusable C++ and Java code.
- Focuses on solving customer oriented systems problems using UML and Design Patterns.
Robert C. Martin is President of Object Mentor Inc. Martin and his team of software consultants use Object-Oriented Design, Patterns, UML, Agile Methodologies, and eXtreme Programming with worldwide clients. He is the author of the best-selling book Designing Object-Oriented C++ Applications Using the Booch Method (Prentice Hall, 1995), Chief Editor of, Pattern Languages of Program Design 3 (Addison Wesley, 1997), Editor of, More C++ Gems (Cambridge, 1999), and co-author of XP in Practice, with James Newkirk (Addison-Wesley, 2001). He was Editor in Chief of the C++ Report from 1996 to 1999. He is a featured speaker at international conferences and trade shows.Ver Descripción del producto
No es necesario ningún dispositivo Kindle. Descárgate una de las apps de Kindle gratuitas para comenzar a leer libros Kindle en tu smartphone, tablet u ordenador.
Obtén la app gratuita:
Universidad, Máster, Formación Profesional, descubre nuestra tienda de libros de Estudios Superiores.
Detalles del producto
Si eres el vendedor de este producto, ¿te gustaría sugerir ciertos cambios a través del servicio de atención al vendedor?
3 opiniones de clientes
Valorar este producto
Ha surgido un problema al filtrar las opiniones justo en este momento. Vuelva a intentarlo en otro momento.
As the book's subtitle suggests, it covers practices, principles, and patterns that have been demonstrated to be useful in software development. It does so by presenting examples, with plenty of source code. This is one of the book's strongest points, since programmers can immediately learn how to apply well-known design patterns in programming languages such as C++ or Java. Moreover, code reading is a usually neglected activity in a software developer's education. Such activity, however, is a suitable tool for transferring programming expertise, as well as the proper way to illustrate the importance of the practices and principles discussed in the text.
The book starts with the manifesto of the so-called agile movement. Once the stage for agile development is set, the book presents the set of extreme programming practices, and devotes a few chapters to describing some of them in greater detail (the planning game, test-first design, and refactoring).
Apart from the aforementioned development practices, the book includes two sections devoted to design principles. The first of them addresses class design problems, while the second covers package design. Using an analogy that compares software designers to surgeons, the author makes it clear that a design must remain clean. In order to achieve that licit goal, which boils down to improving cohesion and decreasing coupling, several design principles are studied. For instance, with regard to class design, inheritance use and abuse is regulated by the Liskov Substitution Principle ("subtypes must be substitutable for their base types"). With respect to package design, in my opinion the best section of the book, Martin explains how to avoid undesirable dependencies between packages, why they are not desirable, and how they can be detected using software metrics.
The book also presents a good overview of some of the most well-known software design patterns. Martin groups them according to their applications, and discusses them in the chapters that precede each one of the three main case studies included in the book. The first case study illustrates how quick analysis and design sessions lead to unit tests, which in turn are used to implement actual applications, where interfaces are clearly separated from implementation details. The second case study shows how a system design evolves over time, and how design patterns are incorporated into it as they are needed. Finally, the last big case study describes the decisions that lead to the construction of a software framework for big applications. These case studies include literally thousands of lines of C++ and Java source code, which let the reader grasp how practices, principles, and patterns are used in the real world.
Finally, the book's appendices include clear-cut explanations of the unified modeling language (UML) notations, a satire of two antagonistic software development approaches, and a reprint of a Jack Reeves' C++ Journal paper on software design. The parody of the development companies is overstretched, but enlightening; it describes common situations that would arise in a bureaucracy-driven management environment (namely, a strict waterfall development model), and it underscores the best qualities of agile development (namely, fluid communication among project stakeholders, and value maximization through feature prioritization and incremental development).
In short, Martin has done an excellent job of writing an entertaining and instructive "bible of agile practices and design concepts." No wonder this book received the Software Development 13th Jolt Product Excellence Award. Its 30 chapters and four appendices contain a mix of textual explanations, dialogues, and code listings that make it stand out over other books in its category.
PS: A newer C# version of the same book also exists: Agile Principles, Patterns, and Practices in C#.
Opiniones de clientes más útiles en Amazon.com
How happy I am that I did. This book is an absolute trove of knowledge and experience. It has a full exposition of the SOLID principles, as well as a primer on the author's strict approach to TDD. Over half of the book is devoted to in-depth discussion of design patterns, with fully developed case studies. I've been using patterns for several years, but this is by far the most accessible work that I've found with this much breadth and detail.
What took me totally by surprise was something I'd been looking for for a while and could not find: a straight-up practical example of pair programming. Bob spends 42 pages on a transcript of a pair session he participated in to do the bowling score kata. That alone almost would have made it worth it for me, because I am curious about good implementation of pairing, and I have no ready examples.
The other point that really hit home as an eye opener was the principle "do the simplest thing that will work." Since coming to OOP and design patterns, I've been too concerned with elegantly engineering things, and sometimes lost sight of the goal and the best way to reach it. This principle, in tandem with the strict "test-first, write one failing test and code it" approach, gave me "permission" to solve problems clearly and simply, without unneeded abstractions.
If you want to expand your understanding of the aforementioned methodologies, and especially if you already appreciate the author's style and perspective, I couldn't recommend this book enough.
This is the reference in your library. If you are in Programming world and you dont have this book, you are missing something that you wouldn't know you are missing :)
Just buy it already :)
Pros: Amazing, detailed, very very powerful concepts. Especially if you nothing on Agile development.
Cons: There is no cons on this book. If you know nothing about programming still buy it, you will need it down the track.
I wish there was a PDF of this book, Or I couldn't find one. I hate reading stuff on paper. Anyway I am about to read this book for the second time ;-)
I have used the methodology in couple of my big projects on mine and it saved my a.. .
Read it once, like scanning it. Second time read it in details and slowly until your penny drops. Third time just use it as a reference. Don't forget to have your highlighter, and Sticky note with you. Do not lend this book to anyone or you will lose it trust me.
After reading only the first 4 chapters, I already start using the UML design and come up with patterns to solve my current tasks. I would highly recommend this book to my peers.