Aucun appareil Kindle n'est requis. Téléchargez l'une des applis Kindle gratuites et commencez à lire les livres Kindle sur votre smartphone, tablette ou ordinateur.

  • Apple
  • Android
  • Windows Phone
  • Android

Pour obtenir l'appli gratuite, saisissez votre numéro de téléphone mobile.

Prix Kindle : EUR 25,84

Économisez
EUR 31,15 (55%)

TVA incluse

Ces promotions seront appliquées à cet article :

Certaines promotions sont cumulables avec d'autres offres promotionnelles, d'autres non. Pour en savoir plus, veuillez vous référer aux conditions générales de ces promotions.

Envoyer sur votre Kindle ou un autre appareil

Envoyer sur votre Kindle ou un autre appareil

Design Patterns Explained: A New Perspective on Object-Oriented Design par [Shalloway, Alan, Trott, James R.]
Publicité sur l'appli Kindle

Design Patterns Explained: A New Perspective on Object-Oriented Design Format Kindle


Voir les formats et éditions Masquer les autres formats et éditions
Prix Amazon
Neuf à partir de Occasion à partir de
Format Kindle
"Veuillez réessayer"
EUR 25,84

Polars Polars


Descriptions du produit

Présentation de l'éditeur

"One of the great things about the book is the way the authors explain concepts very simply using analogies rather than programming examples–this has been very inspiring for a product I'm working on: an audio-only introduction to OOP and software development."

–Bruce Eckel

"...I would expect that readers with a basic understanding of object-oriented programming and design would find this book useful, before approaching design patterns completely. Design Patterns Explained complements the existing design patterns texts and may perform a very useful role, fitting between introductory texts such as UML Distilled and the more advanced patterns books."

–James Noble

Leverage the quality and productivity benefits of patterns–without the complexity! Design Patterns Explained, Second Edition is the field's simplest, clearest, most practical introduction to patterns. Using dozens of updated Java examples, it shows programmers and architects exactly how to use patterns to design, develop, and deliver software far more effectively.

You'll start with a complete overview of the fundamental principles of patterns, and the role of object-oriented analysis and design in contemporary software development. Then, using easy-to-understand sample code, Alan Shalloway and James Trott illuminate dozens of today's most useful patterns: their underlying concepts, advantages, tradeoffs, implementation techniques, and pitfalls to avoid. Many patterns are accompanied by UML diagrams.

Building on their best-selling First Edition, Shalloway and Trott have thoroughly updated this book to reflect new software design trends, patterns, and implementation techniques. Reflecting extensive reader feedback, they have deepened and clarified coverage throughout, and reorganized content for even greater ease of understanding. New and revamped coverage in this edition includes

  • Better ways to start "thinking in patterns"
  • How design patterns can facilitate agile development using eXtreme Programming and other methods
  • How to use commonality and variability analysis to design application architectures
  • The key role of testing into a patterns-driven development process
  • How to use factories to instantiate and manage objects more effectively
  • The Object-Pool Pattern–a new pattern not identified by the "Gang of Four"
  • New study/practice questions at the end of every chapter

Gentle yet thorough, this book assumes no patterns experience whatsoever. It's the ideal "first book" on patterns, and a perfect complement to Gamma's classic Design Patterns. If you're a programmer or architect who wants the clearest possible understanding of design patterns–or if you've struggled to make them work for you–read this book.

Quatrième de couverture

"One of the great things about the book is the way the authors explain concepts very simply using analogies rather than programming examples―this has been very inspiring for a product I'm working on: an audio-only introduction to OOP and software development."

―Bruce Eckel

"...I would expect that readers with a basic understanding of object-oriented programming and design would find this book useful, before approaching design patterns completely. Design Patterns Explained complements the existing design patterns texts and may perform a very useful role, fitting between introductory texts such as UML Distilled and the more advanced patterns books."

―James Noble

Leverage the quality and productivity benefits of patterns―without the complexity! Design Patterns Explained, Second Edition is the field's simplest, clearest, most practical introduction to patterns. Using dozens of updated Java examples, it shows programmers and architects exactly how to use patterns to design, develop, and deliver software far more effectively.

You'll start with a complete overview of the fundamental principles of patterns, and the role of object-oriented analysis and design in contemporary software development. Then, using easy-to-understand sample code, Alan Shalloway and James Trott illuminate dozens of today's most useful patterns: their underlying concepts, advantages, tradeoffs, implementation techniques, and pitfalls to avoid. Many patterns are accompanied by UML diagrams.

Building on their best-selling First Edition, Shalloway and Trott have thoroughly updated this book to reflect new software design trends, patterns, and implementation techniques. Reflecting extensive reader feedback, they have deepened and clarified coverage throughout, and reorganized content for even greater ease of understanding. New and revamped coverage in this edition includes

  • Better ways to start "thinking in patterns"
  • How design patterns can facilitate agile development using eXtreme Programming and other methods
  • How to use commonality and variability analysis to design application architectures
  • The key role of testing into a patterns-driven development process
  • How to use factories to instantiate and manage objects more effectively
  • The Object-Pool Pattern―a new pattern not identified by the "Gang of Four"
  • New study/practice questions at the end of every chapter

Gentle yet thorough, this book assumes no patterns experience whatsoever. It's the ideal "first book" on patterns, and a perfect complement to Gamma's classic Design Patterns. If you're a programmer or architect who wants the clearest possible understanding of design patterns―or if you've struggled to make them work for you―read this book.


© Copyright Pearson Education. All rights reserved.


Détails sur le produit

  • Format : Format Kindle
  • Taille du fichier : 4869 KB
  • Nombre de pages de l'édition imprimée : 480 pages
  • Utilisation simultanée de l'appareil : Jusqu'à 5 appareils simultanés, selon les limites de l'éditeur
  • Editeur : Addison-Wesley Professional; Édition : 2 (12 octobre 2004)
  • Vendu par : Amazon Media EU S.à r.l.
  • Langue : Anglais
  • ASIN: B001U5VJW2
  • Synthèse vocale : Activée
  • X-Ray :
  • Word Wise: Non activé
  • Composition améliorée: Non activé
  • Moyenne des commentaires client : Soyez la première personne à écrire un commentaire sur cet article
  • Classement des meilleures ventes d'Amazon: n°360.212 dans la Boutique Kindle (Voir le Top 100 dans la Boutique Kindle)
  •  Voulez-vous faire un commentaire sur des images ou nous signaler un prix inférieur ?

click to open popover

Commentaires en ligne

Il n'y a pas encore de commentaires clients sur Amazon.fr
5 étoiles
4 étoiles
3 étoiles
2 étoiles
1 étoile

Commentaires client les plus utiles sur Amazon.com (beta)

Amazon.com: 4.3 étoiles sur 5 128 commentaires
111 internautes sur 113 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 learn OO in 'design patter' way 7 décembre 2001
Par Yu H. Chou - Publié sur Amazon.com
Format: Broché
There are 2 ways of learning new concepts and principles:
1. learn principles first, then try to use them
2. observe good implementations first, then learn to appreciate the principles behind them
The authors successfully convince me that the 2nd way is the better way of learning a paradigm like OO. The authors first give us a little principles (Chapter 1), and then intorduce to us the good designs one by one (Part III, IV, V). While explaining these good design solutions (design patterns), authors didn't forget to stop and show us what we have been through, and the principles we can draw from our experience.
This is really a joyful and mind-shifting reading.
This book is not trying to teach you everything about design pattern and OO. But it lays a very sold foundation in your brain, and force you to think in a new perspective.
Of course, you should read GoF after or along with reading this one.
Also recommend:
Craig Larman: Applying UML and Design Pattern (this book puts the things you learned into real developement process)
107 internautes sur 109 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Explained thoroughly and concretely 2 juin 2002
Par Michael Wade - Publié sur Amazon.com
Format: Broché Achat vérifié
I have read the Gang of Four book, which I highly respect and view as a kind of Bible for Patterns. The analogy is apt in that you don't read the Bible once, expecting to "get it" the first time through. You need to read, re-read, read commentaries and explainations. And even so, I found the patterns nebulous. Don't get me wrong! The G of Four book is a must have. But this is the first book that took me from the beginning to the end, explaining in concrete examples that I could understand. One of the key points is applying Patterns to the entire software process, not just design, AND MOREOVER, using many Patterns in the solution of software problems.
I also really enjoyed the writing style. Someone else has complained that it is written in first person even though there is more than one author. Personally, I don't care how many authors are involved, I want results. And the first person choice brought me into the inner circle, where someone was explaining things directly to me. It is a great read, with an almost ideal style of writing for my personality. They break out bulleted lists (another complaint from someone) that gives me the highlights of what we are going to cover. I cannot explain what a great difference that made. One great lecturer from JPL said when giving a lexture: "Tell them what you're going to tell them. Tell them. Then tell them what you told them." A brilliant speaker, this methodology lends itself to writing I think as much as speaking. Design Patterns I have read and done my best to understand, but this book breaks them down into easy to understand, and more importantly, cases where they can apply in simple language.
Possibly most importantly, they describe how learning patterns can be used together with learning OO. I have been doing OO design for many, many years. I read the GofFour, but it was soooo dry, and although I tried hard to put them into practice in my software, I was always disappointed with the results. It felt that the Patterns were tacked on to handle some specific portion of the software. This book, OTOH, addresses the issue of teaching OOD and Patterns at the same time. Even though I considered myself a "good" OO person, I found that after reading this book the Patterns began to fit together with my designs. Wonderful!
All this may not mean much to you, but if you are interested in Patterns, the Gang of Four, then please do yourself a favor and buy this book. Not only will you not regret it, it will [pull] you in and teach you in ways you never thought possible. Go for it, you will have no regrets. I have read many, many, many, software books, and this one just shines.
53 internautes sur 55 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 THE Introduction to Design Patterns 9 août 2001
Par Christopher J. Falter - Publié sur Amazon.com
Format: Broché
This sparkling little introduction to design patterns is clear, well-organized, and supplied with sufficient sample code to help you understand and use 14 of the most important design patterns. Best of all, the authors provide insight into how using design patterns meshes with best practices in object-oriented analysis and design (OOAD).
They explain the shortcomings of traditional OOAD by supplying an example of a brittle, overly complex design that they themselves had crafted. They identify the culprit as overreliance on specialization.
The authors then discuss 14 of the most important patterns from the Gang Of Four book, and how using them made their own design more elegant. Along the way, they elucidate several themes you need to know in order to use design patterns:
* Encapsulation can hide more than data. It can hide complexity (the Facade pattern) or an ill-suited interface (the Adapter pattern), for example.
* Find what is common and make it an interface; find what varies, and encapsulate it.
* Don't get lost by plunging into the details of implementation too early; instead, use design patterns to address your problem space at a conceptual level.
As suits an introductory work, the authors do not deal with all the design patterns from the Gang Of Four, and not with the same depth. Fortunately, they supply ample footnotes to provide further reading for those of us who want more depth.
Bottom Line: You know that if you just turn nouns in your problem space into objects and verbs into methods, you won't magically get a sound design. On the other hand, it is easy to get lost in the complexity of Gamma's classic. Resolve the dilemma by reading this book first!
Footnote: as I feel that the vast majority of potential readers will not have the opportunity to attend Shalloway's 2-day course, I will not use the fact that it duplicates much of the book's content as a reason to lower my rating. It's a 5-star work all the way.
34 internautes sur 34 ont trouvé ce commentaire utile 
4.0 étoiles sur 5 Nice option for getting started correctly with patterns... 18 mai 2005
Par Thomas Duff - Publié sur Amazon.com
Format: Broché
Trying to understand design patterns based on most texts can be as painful as poking yourself in the eye. The book Design Patterns Explained - A New Perspective on Object-Oriented Design (2nd Edition) by Alan Shalloway and James R. Trott is considerably easier on your eye and your pain threshold...

Chapter List:

Part 1 - An Introduction to Object-Oriented Software Development: The Object-Oriented Paradigm; The UML - The Unified Modeling Language

Part 2 - The Limitations of Traditional Object-Oriented Design: A Problem That Cries Out for Flexible Code; A Standard Object-Oriented Solution

Part 3 - Design Patterns: An Introduction to Design Patterns; The Facade Pattern; The Adapter Pattern; Expanding Our Horizons; The Strategy Pattern; The Bridge Pattern; The Abstract Factory Pattern

Part 4 - Putting It All Together - Thinking In Patterns: How Do Experts Design?; Solving the CAD/CAM Problem with Patterns

Part 5 - Toward a New Paradigm of Design: The Principles and Strategies of Design Patterns; Commonality and Variability Analysis; The Analysis Matrix; The Decorator Pattern

Part 6 - Other Values Of Patterns: The Observer Pattern; The Template Method Pattern

Part 7 - Factories: Lessons from Design Patterns - Factories; The Singleton Pattern and the Double-Checked Locking Pattern; The Object Pool Pattern; The Factory Method Pattern; Summary of Factories

Part 8 - Endings and Beginnings: Design Patterns Reviewed - A Summation and a Beginning; Bibliography; Index

The traditional definitive text for design patterns was written by the Gang of Four. It goes into great detail, but it can be very abstract and hard to put into practical terms for beginners. Design Patterns Explained departs from the largely theoretical information and tries to get as concrete and as practical as possible. The authors pick a number of useful patterns and concentrate on those few entries as opposed to trying to cover everything. They put forth a few case studies and use those to explain the pattern being discussed. This tends to make it much easier to understand why the pattern works well for the problem at hand, and how it translates into Java code. Also, it's written in first-person format with plenty of personal insights and opinions. This also helps to make the text much more readable than most.

In addition to just covering the patterns and how they are coded, the authors also talk about the mindset needed to think and design in patterns. This is an aspect of design patterns that I normally don't see covered well (if at all) in most other books. If you combine the focus on thinking in patterns along with the practical information on the most common ones, you get a book that delivers quite a bit more value than most in this niche.

While any serious design pattern student will want to get the Gang of Four book, this volume would be a much better way to get started...
81 internautes sur 90 ont trouvé ce commentaire utile 
2.0 étoiles sur 5 too verbose and unfocused; not worth the price 15 mai 2002
Par WT - Publié sur Amazon.com
Format: Broché
I found "Design Patterns Explained" disappointing, and not worth its price, for many reasons. It has, nonetheless, some very good qualities. In the following, I'll write a detailed review starting with the disappointing features and finishing with the good qualities. I apologize if you consider this review too long for this forum.
First, "Design Patterns Explained" is very verbose without being particularly clear. The authors spend about 25% of the length of the book (the first 80 pages or so) going on and on about an alleged new perspective on object-oriented software design which is, in the end, not particularly new nor sufficiently concrete to be useful. In addition, I found the discussion of the architectural origins of design patterns to be too general and confusing for the beginner software designer.
Second, it constantly refers to the Gang of Four (GoF) book as if the authors of "Design Patterns Explained" needed confirmation of their ideas. Frankly, it tired me to the point of thinking that one might as well just read the GoF book instead. That wouldn't be a bad idea, in fact, since the GoF book is arguably the best book written so far on the subject of design patterns; its second chapter alone is worth more than "Design Patterns Explained" and is the best written, clearest, most concise (yet concrete) introduction to design patterns I have seen to this date.
Third, this book's Overview section at the beginning of each chapter is unnecessary, wasteful of paper and ink, repetitive, and downright annoying because it confuses what should be a useful summary with the listing of obvious facts about the chapter in question. For a typical example, consider the overview section of Chapter 16, "The Singleton Pattern and the Double-Checked Locking Pattern:"
"In this chapter,
* I introduce the Singleton pattern.
* I describe the key features of the Singleton pattern.
* I introduce a variant to the Singleton called the Double-Checked Locking pattern.
* I describe some of my experiences using the Singleton pattern in practice."
None of these four bulleted items says anything that the reader would not already infer from the chapter title or expect from a well written book.
And speaking of annoying features, the entire text is written in the first person, even though the book has two authors. There's nothing intrinsically wrong about that practice. It is extremely disconcerting, however, to read someone's "experiences using the Singleton pattern in practice" while not being able to determine whose experiences those are.
Next, the authors make Java their choice of language for the examples in the main body of each chapter, with C++ code at the end of each chapter. I applaud that choice, but the Java code often cannot be compiled. True, the authors admit right off the start that the code is fragmentary. But, if you're going to write a loop that uses an Enumeration, with the degree of detail that is found on page 270 (Example 17-1 on the implementation of the Observer pattern), then make sure it is complete and correct. The example just mentioned is missing the critical nextElement() call:
public void notifyObs() {
for (Enumeration e =
myObs.elements();
e.hasMoreElements() ;) {
((Observer) e).update(this);
}
}
This is not an isolated case. In addition, whenever a UML diagram contains code in a comment box, that code is written in C++, not in Java. For a typical example, refer to the bottom of p. 251, Figure 15-7, where we find statements such as component->Operation and Decorator::Operation().
For a book intended for beginners, and of this size (less than 350 pages) and cost [price], the faults I mentioned are just too many and too serious. A seasoned software designer may be able to recover quickly and painlessly from them, but a beginner trying to understand why the code cannot be compiled would surely feel frustrated.
Yet, the book is not completely devoid of qualities. Here are several:
The authors constantly emphasize the fact that requirements do change, often unexpectedly, and that a good design always anticipates those changes. Likewise, the authors advocate that designers should be proactive in their dealings with clients.
I also liked the fact that the authors always present first the obvious, often inflexible, approaches to a problem before presenting the design-pattern solution.
Another good point about this book is how the authors offer a cooperative look at the patterns discussed, often explaining how certain patterns can be used together.
Their notion of seniormost patterns constraining other patterns is also very useful and one that I had not seen in any other book. Kudos to the authors for presenting that concept.
Chapter 9 is a very clear presentation of the Bridge pattern and chapter 12, a detailed walkthrough of a case study, is likely to be very useful to the beginner software designer.
Chapter 20, "The Analysis Matrix," is probably the best contribution of this book to the toolbag of software designers, beginner and seasoned alike.
The book's website looks quite good. I've explored it briefly and have a sense that the authors tried hard to create a useful site.
In conclusion, although this book has several very good qualities, it is too unfocused and verbose, and has several serious defects, to be really useful to a beginner software designer and to justify its price. If you can get your company or someone else to pay for it, it will be a good deal. Otherwise, don't bother getting it. Instead, put the same amount of effort into reading the GoF book and you should come out a good designer.
Ces commentaires ont-ils été utiles ? Dites-le-nous