Developpez.com

Plus de 2 000 forums
et jusqu'à 5 000 nouveaux messages par jour

Les livres Design Patterns

8 livres et 18 critiques, dernière mise à jour le 18 octobre 2016 , note moyenne : 4.6

  1. Design Patterns - Catalogue de modèles de conception réutilisables
  2. Design Patterns - Elements of Reusable Object-Oriented Software
  3. Design Patterns - par la pratique
  4. Design Patterns Tête la première
  5. Refactoring to Patterns
  6. Refactoring - Improving the Design of Existing Code
  7. UML et les Design patterns
  8. UML 2 et les Design patterns
couverture du livre Design Patterns

Note 4.5 drapeau CD-Rom
Détails du livre
Sommaire
Critiques (3)
0 commentaire
 
 

Design Patterns

Catalogue de modèles de conception réutilisables

de
Traducteurs : Jean-Marie Lasvergères
Public visé : Expert

Résumé de l'éditeur

En concentrant dans ce livre toute leur riche expérience de construction de logiciels orientés objet, les quatre auteurs, tous concepteurs de haut niveau, offrent au lecteur un catalogue de solutions simples et efficaces aux problèmes classiques survenant pendant la conception de logiciels. Les vingt-trois modèles (patterns) présentés permettent de créer des conceptions plus flexibles, plus élégantes et effectivement réutilisables. Les auteurs commencent par décrire ce que sont les modèles et comment ils peuvent vous aider à concevoir des logiciels orientés objet.

Avec Design patterns pour guide, vous apprendrez à intégrer ces modèles importants dans le processus de développement de logiciels, et à les exploiter pour résoudre efficacement vos problèmes. Ils constitueront de véritables points de départ pour vos propres conceptions et développements.

Pour chaque modèle, les auteurs décrivent les circonstances dans lesquelles il s'applique, quand il le peut au vu d'autres contraintes de conception, et les consésquences et compromis de son utilisation dans des développements de grande envergure. Tous les modèles sont étirés de systètmes existants et basés sur des exemples réels. La description de chacun des modèles inclut aussi le code montrant son implémentation avec des langages orientés objet tels que C++ ou Smalltalk.

Édition : Vuibert - 480 pages , 1er juillet 1999

ISBN10 : 2711786447 - ISBN13 : 9782711786442

17x24cm

Commandez sur www.amazon.fr :

51.30 € TTC (prix éditeur 53.00 € TTC) livraison gratuite !
Préface
Avant-propos
Guide pour les lecteurs
Introduction
Etude de cas : conception d'un éditeur de documents
Modèles créateurs
Fabrique abstraite, monteur, fabrication, prototype, singleton
Modèles structuraux
Adaptateur, pont, composite, décorateur, façade, poids mouche, procuration
Modèles de comportement
Chaine de responsabilités, commande, interpréteur, itérateur, médiateur, memento, observateur, état, startégie, patron de méthode, visiteur
Conclusion
Glossaire
Guide de notation
Classes Fondations
Critique du livre par la rédaction bigboomshakala le 13 mars 2003
Un excellent ouvrage qui présente 23 modèles de conception courants. Pour en apprécier pleinement le contenu il est nécessaire que le lecteur/développeur maîtrise au moins un langage OO et est une réelle maturité dans la pratique de la POO.
Chaque modèle de conception est présenté de la façon suivante :
  • Nom de modèle et classification
  • Intention
  • Alias
  • Motivation
  • indications d'utilisation
  • Structure (représentation graphique : notation OMT, diagramme
  • d'interaction)
  • Constituants
  • Collaborations (comment les constituants collaborent-ils pour assumer
  • leurs responsabilités?)
  • Conséquences
  • Implémentation
  • Exemples de code (C++ et/ou Smalltalk)
  • Utilisations remarquables (présentation d'au moins deux exemples
  • appartenant à des systèmes existants)
  • Modèles apparentés

Le point de ce livre est de ne pas se contenter de présenter les modèles et leur structure, mais également de les situer dans un contexte concret pour en apprécier les effets, d'en détailler les avantages et inconvénients, et de montrer de quelle façon plusieurs modèles peuvent travailler ensemble.
Le CD-ROM accompagnant ce livre contient le texte électronique de l'édition originale (Addison Wesley), ainsi que le code de tous les exemples décrits.
Critique du livre par la rédaction khayyam90 le 14 avril 2004
Agréable à lire, ce catalogue de design patterns se veut très complet et surtout très orienté sur les aspects pratiques de l'utilisation des modèles de conception. Chaque modèle est étudié sur le plan théorique et sur le plan pratique, en présentant des exemples d'implémentations, la plupart du temps en C++. De nombreuses variantes de ces modèles sont également présentées, permettant ainsi de mieux comprendre leurs problématiques et les solutions qu'ils y apportent.
La première partie du livre fournit un résumé efficace de la POO et des problèmes qu'on y rencontre. Puis il traite d'un exemple concret pour mettre en avant les problématiques liées à la conception objet et pour finir il présente le catalogue des modèles de conception proprement dit. Ainsi, ce livre n'est pas exclusivement réservé aux concepteurs chevronnés. Tous les concepts abordés, y compris les concepts de base de la POO, sont d'abord expliqués et présentés de manière simple. Par contre les apprentis concepteurs risquent de pas avoir le recul nécessaire pour profiter pleinement de tous les concepts et de toutes les solutions présentées.
Cet ouvrage n'est pas fait pour être lu d'une traite du début à la fin, c'est un ouvrage prévu pour qu'on s'y réfère en cas de doute, pour résoudre un problème de conception ou pour vérifier l'implémentation d'un modèle particulier. Bref, il fait partie des livres à posséder dans sa bibliothèque.
Critique du livre par la rédaction nico-pyright(c) le 19 juin 2004
Voilà un livre de haut niveau.
Dès le début, malgré un rappel théorique sur des notions de programmation orientée objet qui se révèle très intéressant, on se rend compte qu'il est nécessaire d'avoir déjà une forte connaissance de la programmation OO et pas mal d'expérience dans la conception informatique.
Ce livre est une référence dans la mesure où sont décrit 23 patterns connus. C'est un livre à usage sporadique dont il faut se servir comme d'un catalogue.
A ne pas lire d'une traite, on peut commencer par lire les descriptions et les motivations des patterns. Une fois l'aperçu global des patterns assimilé, on pourra revenir de nombreuses fois approfondir le sujet lorsque le besoin de tel pattern se faire sentir dans notre conception.
Point fort : on appréciera la description de chaque pattern en termes de motivations et d'implications, les cas concret où ils peuvent être rencontré et leur classification sémantique en 3 groupes qui permet de mieux les appréhender et de les retrouver.
Point faible : on regrettera la complexité de lecture, les tournures techniques et abstraites. Le livre manque également d'exemple concret, pour se faire une première idée proche de choses familières du quotidien.
Ce livre est destiné à un public confirmé et est à mon avis à déconseiller aux débutants qui auront tout intérêt à se familiariser avec certains patterns autrement, pour commencer. Par contre, il se révèle indispensable pour les concepteurs avertis qui veulent tirer le maximum de la puissance de ces patterns et des années d'expériences et de maturité.




 Poster une réponse

Avatar de forum forum - Robot Forum https://www.developpez.com
le 15/07/2014 à 21:32
Design Patterns
Catalogue de modèles de conception réutilisables
En concentrant dans ce livre toute leur riche expérience de construction de logiciels orientés objet, les quatre auteurs, tous concepteurs de haut niveau, offrent au lecteur un catalogue de solutions simples et efficaces aux problèmes classiques survenant pendant la conception de logiciels. Les vingt-trois modèles (patterns) présentés permettent de créer des conceptions plus flexibles, plus élégantes et effectivement réutilisables. Les auteurs commencent par décrire ce que sont les modèles et comment ils peuvent vous aider à concevoir des logiciels orientés objet.

Avec Design patterns pour guide, vous apprendrez à intégrer ces modèles importants dans le processus de développement de logiciels, et à les exploiter pour résoudre efficacement vos problèmes. Ils constitueront de véritables points de départ pour vos propres conceptions et développements.

Pour chaque modèle, les auteurs décrivent les circonstances dans lesquelles il s'applique, quand il le peut au vu d'autres contraintes de conception, et les consésquences et compromis de son utilisation dans des développements de grande envergure. Tous les modèles sont étirés de systètmes existants et basés sur des exemples réels. La description de chacun des modèles inclut aussi le code montrant son implémentation avec des langages orientés objet tels que C++ ou Smalltalk.

[Lire la suite]




couverture du livre Design Patterns

Note 3 drapeau CD-Rom
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

Design Patterns

Elements of Reusable Object-Oriented Software

de
Public visé : Expert

Résumé de l'éditeur

Maintenant sur CD, the bestseller renommé internationallement a plus de valeur que jamais!

Utilisez le contenu de ce CD pour créer vos propres documents de design et vos composants réutilisables. Le CD contient 23 patterns que vous pouvez copier et coller dans vos propres documents de design, du code d'exemple démontrant l'implémentation du pattern, le contenu complet de Design Pattern au format HTML avec de nombreux liens hyper-textes croisés, accès grâce à un navigateur standard, mécanisme de recherche dynamique en Java, , environnement utilisateur graphique facilitant la navigation.

Publié en 1995, ce travail de fond sur le design de logiciel orienté objet présente un catalogue de solutions simples et succintes aux problèmes de design communs. Créés par 4 designers expérimentés, ces 23 patterns contenus dans ce livre sont devenus une ressource essentielle pour quiconque développe du logiel orienté objet réutilisable. En réponse à la demande des lecteurs, le texte complexe et le catalogue de pattern est maintenant disponible sur CD-ROM. Cette version électronique de Design Patterns permet aux programmeurs d'installer le livre sur un ordinateur ou un réseau pour une utilisation comme référence en ligne pour créer une logiciel orienté objet réutilisable.

Les auteurs décrivent dans un premier temps ce que sont les patterns et comment ils peuvent vous aider dans le processus de design. Par la suite, ils nomment, expliquent, évaluent et cataloguent systématiquement les designs récurrents dans les systèmes orientés objet. Chaque pattern est extrait d'exemple du monde réel et incluent du code qui montrent comment ils peuvent être implémentés dans des langages orientés objet tels C++ ou Smalltalk. Les lecteurs qui ont le livres choisiront le CD pour tirer parti de son mécanisme de recherche dynamique et des patterns prêt à l'installation.

Édition : Addison-Wesley Professional - 0 pages , 1re édition, 1er juin 1997

ISBN10 : 0201634988 - ISBN13 : 9780201634983

Commandez sur www.amazon.fr :

39.93 € TTC (prix éditeur 39.93 € TTC) livraison gratuite !
[list][*]1. Introduction.
  • What Is a Design Pattern?
  • Design Patterns in Smalltalk MVC.
  • Describing Design Patterns.
  • The Catalog of Design Patterns.
  • Organizing the Catalog.
  • How Design Patterns Solve Design Problems.
  • How to Select a Design Pattern.
  • How to Use a Design Pattern.
[*]2. A Case Study: Designing a Document Editor.
  • Design Problems.
  • Document Structure.
  • Formatting.
  • Embellishing the User Interface.
  • Supporting Multiple Look-and-Feel Standards.
  • Supporting Multiple Window Systems.
  • User Operations.
  • Spelling Checking and Hyphenation.
  • Summary.
[*]3. Creational Patterns.
  • Abstract Factory.
  • Builder.
  • Factory Method.
  • Prototype.
  • Singleton.
  • Discussion of Creational Patterns.
[*]4. Structural Pattern.
  • Adapter.
  • Bridge.
  • Composite.
  • Decorator.
  • Facade.
  • Flyweight.
  • Proxy.
  • Discussion of Structural Patterns.
[*]5. Behavioral Patterns.
  • Chain of Responsibility.
  • Command.
  • Interpreter.
  • Iterator.
  • Mediator.
  • Memento.
  • Observer.
  • State.
  • Strategy.
  • Template Method.
  • Visitor.
  • Discussion of Behavioral Patterns.
[*]6. Conclusion.
  • What to Expect from Design Patterns.
  • A Brief History.
  • The Pattern Community.
  • An Invitation.
  • A Parting Thought.
[*]Appendix A: Glossary.[*]Appendix B: Guide to Notation.
  • Class Diagram.
  • Object Diagram.
  • Interaction Diagram.
[*]Appendix C: Foundation Classes.
  • List.
  • Iterator.
  • ListIterator.
  • Point.
  • Rect.
Critique du livre par la rédaction Matthieu Brucher le 27 juillet 2004
Tout d'abord, je préfère les livres aux versions électroniques, c'est comme ça, c'est personnel, mais ça enlève beaucoup du charme - la version papier est plus difficle à trouver, pas dispo sur Amazon, par ex -. On est obligé d'être scotché à son ordinateur au lieu de pouvoir en profiter dans le train, ... Ensuite, c'est un catalogue de patterns, comme indiqué dans la description, donc on a le droit 23 fois à la même chose, dans le même ordre, juste le contenu qui change, c'est parfois un peu difficile à lire d'une traite, d'où le concept de catalogue !
Passé la première impression un peu limite, on se dit que c'est bien fait. 3 grandes parties pour classer les patterns les plus utilisés. En plus, on commence par un exemple concret où on utilise plusieurs de ces patterns. Enfin, on dit plutôt qu'on peut utiliser tel pattern pour faire ceci ou cela, c'est vrai que c'est pas la même chose. Mais pour celui qui n'a jamais entendu parler de pattern, c'est important de voir comment on peut les utiliser.
Chaque pattern est agrémenté d'un diagramme UML pour savoir comment ça se passe. Mais on est pas obligé de connaître l'UML, un rapide récapitulatif est aussi disponible sur cxe qui sera utilisé dans les diagrammes, ce qui fait que j'ai même compris ce qui se passait Un exemple d'implémentation est à chaque fois donné, en C++ et en SmallTalk, ça change du sempiternel Java. Y'a pas que ses programmeurs qui peuvent bénéficier des patterns... Et aussi une petite explication sur ce qu'on fait et comment, c'est bien aussi.
Avec un peu de recul, ce catalogue est bien. Il n'a pas vieilli, la preuve d'une qualité de son contenu, ces patterns sont toujours encore utilisables et à utiliser. D'autres existent aussi, les auteurs en sont bien concients, et c'est bien, ils ne considèrent pas avoir la science infuse. Donc pour conclure, c'est sans doute LA référence en terme de pattern, même si on aurait préféré une version papier.




 Poster une réponse

Avatar de forum forum - Robot Forum https://www.developpez.com
le 15/07/2014 à 21:32
Design Patterns
Elements of Reusable Object-Oriented Software
Maintenant sur CD, the bestseller renommé internationallement a plus de valeur que jamais!

Utilisez le contenu de ce CD pour créer vos propres documents de design et vos composants réutilisables. Le CD contient 23 patterns que vous pouvez copier et coller dans vos propres documents de design, du code d'exemple démontrant l'implémentation du pattern, le contenu complet de Design Pattern au format HTML avec de nombreux liens hyper-textes croisés, accès grâce à un navigateur standard, mécanisme de recherche dynamique en Java, , environnement utilisateur graphique facilitant la navigation.

Publié en 1995, ce travail de fond sur le design de logiciel orienté objet présente un catalogue de solutions simples et succintes aux problèmes de design communs. Créés par 4 designers expérimentés, ces 23 patterns contenus dans ce livre sont devenus une ressource essentielle pour quiconque développe du logiel orienté objet réutilisable. En réponse à la demande des lecteurs, le texte complexe et le catalogue de pattern est maintenant disponible sur CD-ROM. Cette version électronique de Design Patterns permet aux programmeurs d'installer le livre sur un ordinateur ou un réseau pour une utilisation comme référence en ligne pour créer une logiciel orienté objet réutilisable.

Les auteurs décrivent dans un premier temps ce que sont les patterns et comment ils peuvent vous aider dans le processus de design. Par la suite, ils nomment, expliquent, évaluent et cataloguent systématiquement les designs récurrents dans les systèmes orientés objet. Chaque pattern est extrait d'exemple du monde réel et incluent du code qui montrent comment ils peuvent être implémentés dans des langages orientés objet tels C++ ou Smalltalk. Les lecteurs qui ont le livres choisiront le CD pour tirer parti de son mécanisme de recherche dynamique et des patterns prêt à l'installation.

[Lire la suite]




couverture du livre Design Patterns

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (3)
0 commentaire
 
 

Design Patterns

par la pratique

de
Public visé : Débutant

Résumé de l'éditeur

Que vous soyez développeur confirmé ou débutant, ce livre vous apportera un nouvel éclairage sur les Design patterns. Vous y trouverez une dizaine de patterns fondamentaux montrés de manière simple et compréhensible. Vous assimilerez facilement la logique de ces patterns et vous posséderez alors toutes les clés pour en aborder de nouveaux en toute confiance.

Chaque pattern est expliqué en détail, à partir d'un exemple concret qui permet de mieux comprendre son rôle. Grâce aux exemples de code qui vous plongeront directement dans la pratique, vous aborderez les Design patterns de manière pragmatique. En outre, chaque pattern fait l'objet d'un tableau récapitulatif qui synthétise son rôle et sa mise en oeuvre.

Édition : Eyrolles - 278 pages , 1re édition, 1er septembre 2002

ISBN10 : 2212111398 - ISBN13 : 9782212111392

Commandez sur www.amazon.fr :

36.10 € TTC (prix éditeur 38.00 € TTC) livraison gratuite !
Le modèle orienté objet
UML, le langage de modélisation unifié
Limites de la conception orientée objet traditionnelle
Solution orientée objet standard
Introduction aux design patterns
Origine des design patterns
Le pattern Façade
Le pattern Adaptateur
Au-delà de l'approche traditionnelle
Le pattern Pont
Le pattern Fabrique abstraite
Principes et stratégies des design patterns
Le pattern Stratégie
Le pattern Décorateur
Les patterns Singleton et Verrouillage
Le pattern Observateur
Le pattern Méthode de modèle
Le pattern Méthode d'usine
La matrice d'analyse
Conclusion et nouvelles perspectives
Critique du livre par la rédaction Louis-Guillaume MORAND le 13 mai 2004
J'aurais donc du mal à commenter la qualité de la description et/ou la présentation des différents patterns rencontrés dans ce livre mais je peux néanmoins juger de la qualité de l'approche des auteurs de ce livre. Ils ont réussi à me faire voir la programmation objet d'une toute autre manière ainsi que l'idée que j'avais de l'utilisation des design patterns.
Ce livre n'est sûrement pas la référence comme le serait le livre du "Gang des quatres" (Erich GAMMA, Richard HELM, Ralph JOHNSON, John VLISSIDES), mais reste pour moi un des meilleurs livres pour commencer l'approche des design patterns. En effet, chaque pattern est présenté dans des cas d'utilisations simples et clairs, mais surtout, l'auteur cherche à montrer comment utiliser conjointement différents patterns afin de rendre vos applications plus stables et évolutives.
Il risque de fort de rester mon livre de chevet pour les mois à venir.
Critique du livre par la rédaction Matthieu Brucher le 31 mai 2004
La majorité des ouvrages sur les patterns, ou modèles de conception, sont des catalogues. Des catalogues plus ou moins intéressants, expliquant le fonctionnement de ces patterns, mais c'est tout. Ici, on n'expose que quelques patterns, mais les modèles de conception ne sont pas seuls. On expose aussi en détail le pourquoi de l'orienté objet et de ses liens avec les patterns et comment ils peuvent s'imbriquer.
Outre cet aspect que je n'ai trouvé dans aucun autre livre sur les patterns, il y a aussi l'intérêt du lecteur dans l'ouvrage qui est entretenu par l'entrelacement d'explications et de présentation des patterns. Ces changements sont très utiles pour aérer un livre et peu d'auteurs en profitent, à tort.
Enfin, c'est tout de même un livre sur les patterns, et on en expose ici que 10, ce qui est peu. On pourra dire que ce sont les modèkes de conception les plus courants, mais les autres patterns du Gang of Four sont aussi intéressants. Il aurait été intéressant d'en ajouter.
Pour conclure, ce livre est à mettre entre toutes les mains qui ne connaissent pas les patterns ET leur utilité dans le concept orienté objet.
Critique du livre par la rédaction Baptiste Wicht le 29 juin 2005
Ce livre de par son approche très pratique permet à tout le monde de découvrir les designs patterns, concepts ô combien nécessaire à tout programmeur qui se respecte.
Ce livre ne va seulement nous faire découvrir différents patterns, mais va aussi nous expliquer le pourquoi de la nécessité de ceux-ci et donc la limite de la programmation orienté objet traditionnelle. Il va aussi nous montrer la manière de penser en termes de pattern et la méthodologie à adapter. Tout cela illustré par de bons exemples qui nous permettent de comprendre directement le comment et de ne pas nous perdre dans de trop grosses théories.
Son seul défaut est peut-être le nombre restreint de patterns qu'il expose (10). Les plus importants ont certes été cités, mais d'autres patterns auraient eu leur place dans ce livre.
En conclusion, je dirais que ce livre offre à tout un chacun la possibilité de comprendre les designs patterns, par des exemples simples et précis. Ce livre n'est pas un catalogue de patterns qui se contente d'expliquer à quoi sert tel ou tel pattern et la manière dont il fonctionne, ce livre est construit de manière plus pédagogique pour nous permettre de comprendre l'utilité réelle des designs patterns.




 Poster une réponse

Avatar de forum forum - Robot Forum https://www.developpez.com
le 15/07/2014 à 21:32
Design Patterns
par la pratique
Que vous soyez développeur confirmé ou débutant, ce livre vous apportera un nouvel éclairage sur les Design patterns. Vous y trouverez une dizaine de patterns fondamentaux montrés de manière simple et compréhensible. Vous assimilerez facilement la logique de ces patterns et vous posséderez alors toutes les clés pour en aborder de nouveaux en toute confiance.

Chaque pattern est expliqué en détail, à partir d'un exemple concret qui permet de mieux comprendre son rôle. Grâce aux exemples de code qui vous plongeront directement dans la pratique, vous aborderez les Design patterns de manière pragmatique. En outre, chaque pattern fait l'objet d'un tableau récapitulatif qui synthétise son rôle et sa mise en oeuvre.

[Lire la suite]




couverture du livre Design Patterns Tête la première

Note 4.92857142857 drapeau
Détails du livre
Sommaire
Critiques (7)
0 commentaire
 
 

Design Patterns Tête la première

de
Public visé : Débutant

Résumé de l'éditeur

Si vous souhaitez vous distinguer des développeurs ordinaires et devenir une force de proposition pour les architectures d'applications, vous vous devez de maîtriser les design patterns. Pour cela, rien ne vaut l'expérience de ceux qui ont déjà été confrontés aux mêmes problèmes. Vous profiterez à la fois de leur savoir-faire et de ce qui se fait de mieux en matière de conception. Qui plus est, vous gagnerez un temps précieux que vous occuperez bien mieux à autre chose de plus complexe et de plus amusant, ce qui fera le bonheur de vos chefs. Le plus important demeure que vous ne voulez pas vous endormir en apprenant les design patterns.

Si vous connaissez déjà la collection Tête la première, vous savez déjà à quoi vous en tenir. Voici les principaux bénéfices que vous tirerez de cet ouvrage :
  • Distinguer les principaux patterns (Fabrique, Singleton, Adaptateur, Itérateur, Composite, etc.);
  • Apprendre à les utiliser : quand et comment les appliquer dans vos conceptions, sans pour autant vous laisser gagner par la patternite
  • Contrôler l'accès aux objets avec des proxies
  • Maîtriser les mécanismes MVC et de son acolyte Web : MVC 2
  • Ne plus se sentir désoeuvré face à des problèmes de conception en apprenant à réaliser des conceptions souples qui s'adaptent à vos besoins
  • Arriver à reconnaître les design patterns qui vous entourent au quotidien dans les API Java, les frameworks ou autres applications, et comprendre enfin comment ils fonctionnent
  • Réaliser des conceptions bien pensées et faciles à maintenir.

Sous des dehors amusants et ludiques, cet ouvrage n'en demeure pas moins un guide d'apprentissage pas à pas. L'approche des auteurs est axée sur la pédagogie. Les concepts s'appuient sur des images et des exercices qui stimulent le cerveau. Jeux, images, interviews, mots-croisés, sont autant de moyens de vous amener à exploiter intelligemment les design patterns et de vous transmettre une vision claire et pragmatique des problèmes de conception. L'heure est venue de vous plonger dans les design patterns, tête la première !

Édition : O'Reilly - 639 pages , 1re édition, 1er septembre 2005

ISBN10 : 2841773507 - ISBN13 : 9782841773503

Commandez sur www.amazon.fr :

51.30 € TTC (prix éditeur 54.00 € TTC) livraison gratuite !
Bienvenue aux Design Patterns
Tenez vos objets au courant : le pattern Observateur
Décorez les objets : le pattern Décorateur
Un peu de cuisine orientée objet : les pattern fabriques
Des objets uniques en leur genre : le pattern Singleton
Encapsuler l'invocation : le pattern Commande
Savoir s'adapter : les patterns Adaptateurs et Façade
Encapsuler les algorythmes : le pattern Patron de méthode
Des collections bien gérées : les patterns Itérateurs et Composite
L'état des choses : le pattern Etat
Contrôler l'accès aux objets : le pattern Proxy
Patterns de Patterns : patterns composés
Les patterns dans le monde réel : Mieux vivre avec les patterns
Critique du livre par la rédaction nico-pyright(c) le 21 avril 2006
Ce livre constitue une introduction aux design patterns.
C'est dans un style très original et très didactique que les auteurs ont l'ambition de nous plonger dans le monde des design patterns.
Leur but : nous apprendre les designs patterns les plus courants et nous donner le gout d'aller plus loin, d'en découvrir d'autres.
La méthode : des exemples originaux, proche du quotidien et de l'humour pour expliquer des concepts malgré tout très abstraits, qui peuvent vite devenir rébarbatif. Ainsi, ce livre se lit très facilement, à l'image d'un roman où au fil des pages, on est curieux de découvrir la suite des aventures de nos héros, les design patterns.
Cependant, il est à noter que ce livre ne constitue pas un catalogue de référence, il n'est pas non plus exhaustif. Ce qu'on va y trouver c'est vraiment l'apprentissage associé à la détente.
Ainsi, à la fin de la lecture, on ressort sans peine avec des concepts en tête et une boite à outils facilement disponible pour des conceptions élégantes.
Il est à noter que des notions en conception orientée objet sont un plus pour suivre ce livre.
Je recommande ce livre à toute personne qui souhaite débuter dans la connaissance des designs patterns et qui souhaite tirer parti des expériences éprouvées en termes de conception.
Vraiment un très bon livre !
Critique du livre par la rédaction Matthieu DELOISON le 1er février 2008
Comment enseigner les Design Patterns sans être fastidieux ni ennuyeux à mourrir ?
C'est la solution utilisée par le livre Design Patterns Tête la Première, les explications de ce livre sont très pédagogiques, il y a une réelle réflexion qui permet au lecture d'être dans de très bonnes conditions pour assimiler tous ces concepts le plus simplement possible. La lecture de ce livre est un plaisir, cela devient un jeu d'apprendre et de comprendre les Design Patterns.
Pour appréhender correctement ce livre, il faut néanmoins des bonnes bases en langage objet (quelque soit le langage : java, actionscript...). Je conseille ce livre à tous ceux qui souhaite approfondir leurs connaissances dans les différents concepts de programmation, ces connaissances vont seront très utiles (voir indispensable) lors de vos projets informatiques
une fois que l'on connaît les Design Patterns et que l'on a appris à les utiliser à bon escient, il n'est plus possible de s'en passer!
Bienvenue à toi futur lecteur dans le monde des Design Patterns.
Critique du livre par la rédaction Benjamin Roux le 25 octobre 2008
Voici un livre qui sort de l'ordinaire, comme le montre la couverture "Apprenez comment la vie amoureuse de Jim s'est améliorée depuis qu'il préfère la composition à l'héritage". Comment faire de l'humour avec un sujet aussi sérieux que les design patterns ?
La réponse n'étant pas évidente les auteurs ont décidé de consacrer une dizaine de pages au début du livre pour se justifier selon eux l'Homme retient mieux ce qui le surprend, pourquoi pas ? Mais c'est surtout lorsque l'on entame le sujet proprement dit que l'on comprend l'intérêt de leur méthode, en effet les exemples pleuvent, les ré-explications aussi : tout est fait pour que le lecteur comprenne et retienne : des exemples sous formes de dialogues, d'images et de schémas. Personnellement c'est en connaisseur que j'ai abordé ce livre, je pouvais donc cerner le problème dès le premier exemple. J'ai donc demandé à d'autres personnes et c'est un fait : tout le monde arrive à identifier le problème et comprendre l'intérêt de la solution proposée, pas forcément au premier exemple d'où l'intérêt des nombreuses ré-explications. Les patterns proposés sont nombreux et variés et l'on peut en dénombrer une bonne quinzaine. Les auteurs prennent bien le soin d'expliquer que les patterns sont des pratiques éprouvées que l'on ne doit surtout pas utiliser partout mais après avoir lu ce livre vous serez atteints de patternite aigüe et essaierez d'en placer le plus possible ! Attention ce livre cible avant tout les amateurs en pattern : si vous souhaitez un ouvrage faisant office de référence passez votre chemin !
Critique du livre par la rédaction Eric REBOISSON le 27 février 2009
Une fois de plus, un opus très réussi dans la collection Tête la première. Tout simplement titré "Design patterns", ce livre aurait pu s'appeler "Comment faire passer la pilule design patterns en douceur et efficacement". En effet le sujet de la conception par patron n'est pas toujours évident à traiter et ce livre le fait très bien dans un style propre à la collection Tête la première.
Pour ceux qui ne connaissent pas cette collection, la mise en page est déroutante et amusante (on apprend mieux comme ça!), on se croirait sur un bout de feuille dans un bureau avec un collègue nous expliquant le pourquoi du comment des patrons de conception. Cependant les explications sont claires et toujours agrémentées de schémas qui dans leur simplicité attirent naturellement l'intérêt du lecteur, on trouvera également en fin de chapitre un petit contrôle de connaissance, une bonne jauge pour contrôler ses acquis. Au final, des informations pertinentes sur les design patterns, une pédagogie qui a déjà fait ses preuves, aucune place à l'ennui et je suis sûr pour ceux qui liront ce livre une très bonne maîtrise des principaux design patterns.
Une grande réussite pour ce guide d'apprentissage auquel je ne mettrai pas la note maximale (rien n'est parfait, et ce n'est pas LE guide de référence), mais qui est un incontournable dans le domaine de la conception, vous pouvez donc l'acheter les yeux fermés.
Critique du livre par la rédaction Thomas Lebrun le 9 mai 2009
Ce livre est un plaisir à lire !
Si vous ne connaissiez rien aux design patterns, alors ce livre est celui qu'il vous faut.
Clair, simple à lire et à comprendre, ce livre (et ses exemples) sont réellement pédagogiques et fournissent une parfaite connaissance du sujet.
Il y a longtemps que je n'avais pas pris un tel plaisir à lire un livre comme celui-là: ce fut un réel bonheur et je le recommande vivement !
Critique du livre par la rédaction farscape le 30 juillet 2009
Ce livre n'est pas un livre comme les autres !
Les auteurs appliquent des méthodes d'apprentissage résultants des dernières recherches en sciences cognitives afin de faciliter la lecture et la mémorisation ; c'est le crédo de la collection "tête la première". De ce point de vue je trouve le résultat plutôt réussi, le livre se lit comme un roman !
Les auteurs utilisent pour cela beaucoup d'images, d'exercices, des jeux sous forme de mots croisés, des interviews imaginaires avec les différents patterns, discussions et point de vue entre programmeurs imaginaires. Sous ses dehors ludiques et pas mal d'humour, « Tête la première design patterns » n'est donc pas un livre de référence (souvent ennuyeux) ou un catalogue de solutions sur les patterns mais un vrai livre d'apprentissage. Il aborde progressivement les différents patterns en imaginant à chaque fois un problème fictif à résoudre.
Fidèles à leur engagement pédagogique exposé en début de livre, les auteurs ont favorisé la mise en application et l'étude pratique du pattern plutôt qu'une approche théorique classique, les exemples étudiés sont simples et s'appuient sur le langage JAVA, mais pas de panique, le code mis en ouvre dans ce livre est très simple et ne causera aucun problème à un programmeur utilisant le C# ou le C++. Seule exception : le pattern proxy s'appuie sur des fonctionnalités propres à JAVA avec l'utilisation du système RMI, il ne pourra donc pas être transposé directement en C++ pour l'exemple donné.
Pour les programmeurs C++, les exemples de ce livre ont été transposés et sont disponibles à l'emplacement : Head First Design Patterns in C++ : http://sourceforge.net/projects/hfdp-cpp
Les chapitres du livre correspondent aux principaux patterns étudiés (excepté les trois derniers chapitres) soit au total 14 chapitres pour 630 pages. Le chapitre premier, sur l'introduction aux design patterns, est un modèle du genre en termes d'apprentissage pédagogique et donne le ton pour le reste du livre. Le lecteur se sent vraiment intégré à la discussion sur le sujet traité, les principes de conceptions sont abordés progressivement jusqu'à la solution finale utilisant le pattern. Il en sera de même tout au long des autres chapitres : à chaque fois les nouveaux principes de conceptions sont cités. Exemples : « identifiez les aspects de votre application qui varient et séparez-les de ceux qui demeurent constants » ou encore « préférez la composition à l'héritage »
En conclusion : Vous vous intéressez aux patterns ? Vous voulez progresser dans la conception de vos systèmes logiciels et concevoir des solutions souples évolutives et maintenables ? Vous n'avez pas envie d'un livre aride et prise de tête ? Alors assurément avec « Design patterns - Tête la première » vous ne serez pas déçus. Il deviendra vite votre livre de référence vous permettant par la suite d'aborder sereinement d'autres livres traitant de catalogue de patterns.
Critique du livre par la rédaction nicolas581 le 11 septembre 2016
Le livre a été publié en 2005 soit une dizaine d'années maintenant. Même si les principes et les notions sont toujours d'actualités, on ne peut que regretter que les implémentations écrites en Java aient un peu vieillies (Java 1.4).

La démarche adoptée pour la présentation de beaucoup de design patterns est la suivante : énoncé d'un problème ouvert sur lequel vous devez réfléchir, indication d'une première solution triviale qui montre des limites en terme d'évolutivité et de maintenabilité puis exploration d'autres solutions plus adaptées qui mettent en œuvre le pattern du chapitre. Je vous conseille donc de lire avec une feuille à côté pour griffonner des solutions.

Je ne conseillerai pas ce livre à une personne qui découvre la programmation, il faut déjà avoir écrit quelques programmes de plusieurs classes avec la mise en place de composition et d'héritage. Il peut être lu par un étudiant qui a déjà suivi quelques cours d'informatique ou un développeur qui ne vient pas du monde objet. Si vous êtes plus expérimenté, cela peut vous servir de base de discussion avec des juniors pour expliquer les design patterns.




 Poster une réponse

Avatar de forum forum - Robot Forum https://www.developpez.com
le 15/07/2014 à 21:32
Design Patterns Tête la première
Si vous souhaitez vous distinguer des développeurs ordinaires et devenir une force de proposition pour les architectures d'applications, vous vous devez de maîtriser les design patterns. Pour cela, rien ne vaut l'expérience de ceux qui ont déjà été confrontés aux mêmes problèmes. Vous profiterez à la fois de leur savoir-faire et de ce qui se fait de mieux en matière de conception. Qui plus est, vous gagnerez un temps précieux que vous occuperez bien mieux à autre chose de plus complexe et de plus amusant, ce qui fera le bonheur de vos chefs. Le plus important demeure que vous ne voulez pas vous endormir en apprenant les design patterns.

Si vous connaissez déjà la collection Tête la première, vous savez déjà à quoi vous en tenir. Voici les principaux bénéfices que vous tirerez de cet ouvrage :
  • Distinguer les principaux patterns (Fabrique, Singleton, Adaptateur, Itérateur, Composite, etc.);
  • Apprendre à les utiliser : quand et comment les appliquer dans vos conceptions, sans pour autant vous laisser gagner par la patternite
  • Contrôler l'accès aux objets avec des proxies
  • Maîtriser les mécanismes MVC et de son acolyte Web : MVC 2
  • Ne plus se sentir désoeuvré face à des problèmes de conception en apprenant à réaliser des conceptions souples qui s'adaptent à vos besoins
  • Arriver à reconnaître les design patterns qui vous entourent au quotidien dans les API Java, les frameworks ou autres applications, et comprendre enfin comment ils fonctionnent
  • Réaliser des conceptions bien pensées et faciles à maintenir.

Sous des dehors amusants et ludiques, cet ouvrage n'en demeure pas moins un guide d'apprentissage pas à pas. L'approche des auteurs est axée sur la pédagogie. Les concepts s'appuient sur des images et des exercices qui stimulent le cerveau. Jeux, images, interviews, mots-croisés, sont autant de moyens de vous amener à exploiter intelligemment les design patterns et de vous transmettre une vision claire et pragmatique des problèmes de conception. L'heure est venue de vous plonger dans les design patterns, tête la première !

[Lire la suite]




couverture du livre Refactoring to Patterns

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

Refactoring to Patterns

de
Public visé : Débutant

Résumé de l'éditeur

Ce livre traite du mariage du refactoring - le processus d'amélioration du design du code existant - avec des patterns, les solutions classiques aux problèmes récurrents de design. Refactoring to Patterns suggère que l'utilisation des patterns pour améliorer un design existant est meilleur que l'utilisation des patterns tôt dans un nouveau design. Ceci est vrai, que le code soit jeune ou vieux. Nous améliorons les designs avec des patterns en appliquant des séquences de transformations de design de bas niveau, aussi connu sous le nom de refactorings.

Édition : Addison-Wesley Professional - 400 pages , 1re édition, 1er août 2004

ISBN10 : 0321213351 - ISBN13 : 9780321213358

Commandez sur www.amazon.fr :

42.72 € TTC (prix éditeur 42.72 € TTC) livraison gratuite !
[list][*]1. Why I Wrote This Book.
  • Over-Engineering.
  • The Patterns Panacea.
  • Under-Engineering.
  • Test-Driven Development and Continuous Refactoring.
  • Refactoring and Patterns.
  • Evolutionary Design.
[*]2. Refactoring.
  • What Is Refactoring?
  • What Motivates Us to Refactor?
  • Many Eyes.
  • Human-Readable Code.
  • Keeping It Clean.
  • Small Steps.
  • Design Debt.
  • Evolving a New Architecture.
  • Composite and Test-Driven Refactorings.
  • The Benefits of Composite Refactorings.
  • Refactoring Tools.
[*]3. Patterns.
  • What Is a Pattern?
  • Patterns Happy.
  • There Are Many Ways to Implement a Pattern.
  • Refactoring to, towards, and away from Patterns.
  • Do Patterns Make Code More Complex?
  • Pattern Knowledge.
  • Up-Front Design with Patterns.
[*]4. Code Smells.
  • Duplicated Code.
  • Long Method.
  • Conditional Complexity.
  • Primitive Obsession.
  • Indecent Exposure.
  • Solution Sprawl.
  • Alternative Classes with Different Interfaces.
  • Lazy Class.
  • Large Class.
  • Switch Statements.
  • Combinatorial Explosion.
  • Oddball Solution.
[*]5. A Catalog of Refactorings to Patterns.
  • Format of the Refactorings.
  • Projects Referenced in This Catalog.
  • A Starting Point.
  • A Study Sequence.
[*]6. Creation.
  • Replace Constructors with Creation Methods.
  • Move Creation Knowledge to Factory.
  • Encapsulate Classes with Factory.
  • Introduce Polymorphic Creation with Factory Method.
  • Encapsulate Composite with Builder.
  • Inline Singleton.
[*]7. Simplification.
  • Compose Method.
  • Replace Conditional Logic with Strategy.
  • Move Embellishment to Decorator.
  • Replace State-Altering Conditionals with State 166
  • Replace Implicit Tree with Composite.
  • Replace Conditional Dispatcher with Command.
[*]8. Generalization.
  • Form Template Method.
  • Extract Composite.
  • Replace One/Many Distinctions with Composite.
  • Replace Hard-Coded Notifications with Observer.
  • Unify Interfaces with Adapter.
  • Extract Adapter.
  • Replace Implicit Language with Interpreter.
[*]9. Protection.
  • Replace Type Code with Class.
  • Limit Instantiation with Singleton.
[*]10. Accumulation.
  • Move Accumulation to Collecting Parameter.
  • Move Accumulation to Visitor.
[*]11. Utilities.
  • Chain Constructors.
  • Unify Interfaces.
  • Extract Parameter.
[list]
Critique du livre par la rédaction Matthieu Brucher le 8 août 2007
Une sorte de suite à Refactoring de Martin Fowler, puisque tous les processus décrits ou presque utilisent des patterns décrits dans ce livre. Les différentes catégories sont aussi bien séparées l'auteur n'oblige pas à aller jusqu'aux patterns décrits dans Design Patterns, on n'en a pas toujours besoin - vive les surpopulations de singletons par exemple -. Selon ce qu'on a à faire, plusieurs solutions sont utilisables, plus ou moins loin de ces patterns.
Le code proposé est du Java, il est parfois un peu difficile de faire le lien avec d'autres langages orientés objet offrant des outils différents. En revanche, pour chaque refactoring to pattern, un petit topo sur pourquoi et comment faire est proposé. Ces petites étapes permettent de s'en sortir. L'introduction du livre est très importante, par exemple, un accent y est mis sur l'élémentarité des étapes, simples de préférence.
Comme précisé ci-dessus, ce livre fait la part belle à Fowler, le livre fait aussi partie de la collection Fowler. Ensuite est-ce que c'est pour la signature Fowler qu'il y a autant de référence au livre Refactoring ? Non, ce dernier est une base, un fondement que Refactoring to Patterns utilise pour aller plus loin, plus vite. Ce que Refactoring ne pouvait aborder par manque de place, Refactoring to Patterns l'aborde et va au bout. Sans imposer, juste en proposant.




 Poster une réponse

Avatar de forum forum - Robot Forum https://www.developpez.com
le 15/07/2014 à 21:32
Refactoring to Patterns
Ce livre traite du mariage du refactoring - le processus d'amélioration du design du code existant - avec des patterns, les solutions classiques aux problèmes récurrents de design. Refactoring to Patterns suggère que l'utilisation des patterns pour améliorer un design existant est meilleur que l'utilisation des patterns tôt dans un nouveau design. Ceci est vrai, que le code soit jeune ou vieux. Nous améliorons les designs avec des patterns en appliquant des séquences de transformations de design de bas niveau, aussi connu sous le nom de refactorings.

[Lire la suite]




couverture du livre Refactoring

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

Refactoring

Improving the Design of Existing Code

de
Public visé : Débutant

Résumé de l'éditeur

Pendant que l'application de technologies objet - particulièrement dans le langage de programmation Java - devient courant, un nouveau problème est apparu dans la communauté du développement logiciel. Un nombre significatif de programmes mal designés ont été créés par des développeurs moins expérimentés, se traduisant par des applications qui sont inefficaces et difficiles à maintenir et à étendre. Les professionnels des systèmes logiciels découvrent de plus en plus la difficulté de travailler avec ces applications héritées, "non optimales". Pendant plusieurs années, les programmeurs objets d'un niveau d'expert ont employés une collection grandissante de techniques pour améliorer l'intégrité et la performance de ce genre de programmes existants. Connus sous le nom de "refactoring", ces pratiques sont restées dans le domaine des experts car aucune tentative avait été menée pour les transcrire dans une forme que tous les développeurs pouvaient utiliser... jusqu'à aujourd'hui. Dans Refactoring: Improving the Design of Existing Code, Martin Fowler, mentor renommé de la technologie objet ouvre une nouvelle voie, démystifiant ces pratiques avancées et démontrant comment les développeurs peuvent se rendre compte des bénéfices de ce nouveau processus.

Avec un entraînement adéquat, un designer aguerri de système peut prendre un mauvais design et le transformer en code robuste, bien designé. Dans ce livre, Martin Fowler nous montre où sont traditionnellement les opportunités pour le refactoring et comment passer d'un mauvais design à un bon. Chaque étape de refactoring est simple - apparemment trop simple pour mériter d'être effectuée. Refactorer peut impliquer déplacer un champ d'une classe à une autre, extraire du code d'une méthode pour en faire une nouvelle ou même modifier une hierarchie. Si ces étapes individuelles peuvent sembler élémentaires, l'effet cumulatif de ces petits changements peut améliorer grandement un design. Refactorer est un moyen efficace pour empêcher un logiciel de pérécliter.

Outre les discussions sur les différentes techniques de refactoring, l'auteur donne un catalogue détaillé de plus de 70 étapes avec des références judicieuses pour nous apprendre quand les appliquer, des instructions pas à pas pour chaque application d'un tel pattern et un exemple illustrant comment fonctionne le refactoring. Les exemples illustratifs sont écrits en Java, mais les idées sont applicables à tout langage orienté objet.

Édition : Pearson Education - 464 pages , 1re édition, 1er juin 1999

ISBN10 : 0201485672 - ISBN13 : 9780201485677

Commandez sur www.amazon.fr :

42.17 € TTC (prix éditeur 42.17 € TTC) livraison gratuite !
  1. Refactoring, a First Example.
    • The Starting Point.
    • The First Step in Refactoring.
    • Decomposing and Redistributing the Statement Method.
    • Replacing the Conditional Logic on Price Code with Polymorphism.
    • Final Thoughts.
  2. Principles in Refactoring.
    • Defining Refactoring.
    • Why Should You Refactor?
    • When Should You Refactor?
    • What Do I Tell My Manager?
    • Problems with Refactoring.
    • Refactoring and Design.
    • Refactoring and Performance.
    • Where Did Refactoring Come From?
  3. Bad Smells in Code.
    • Duplicated Code.
    • Long Method.
    • Large Class.
    • Long Parameter List.
    • Divergent Change.
    • Shotgun Surgery.
    • Feature Envy.
    • Data Clumps.
    • Primitive Obsession.
    • Switch Statements.
    • Parallel Inheritance Hierarchies.
    • Lazy Class.
    • Speculative Generality.
    • Temporary Field.
    • Message Chains.
    • Middle Man.
    • Inappropriate Intimacy.
    • Alternative Classes with Different Interfaces.
    • Incomplete Library Class.
    • Data Class.
    • Refused Bequest.
    • Comments.
  4. Building Tests.
    • The Value of Self-testing Code.
    • The JUnit Testing Framework.
    • Adding More Tests.
  5. Toward a Catalog of Refactorings.
    • Format of the Refactorings.
    • Finding References.
    • How Mature Are These Refactorings?
  6. Composing Methods.
    • Extract Method.
    • Inline Method.
    • Inline Temp.
    • Replace Temp with Query.
    • Introduce Explaining Variable.
    • Split Temporary Variable.
    • Remove Assignments to Parameters.
    • Replace Method with Method Object.
    • Substitute Algorithm.
  7. Moving Features Between Objects.
    • Move Method.
    • Move Field.
    • Extract Class.
    • Inline Class.
    • Hide Delegate.
    • Remove Middle Man.
    • Introduce Foreign Method.
    • Introduce Local Extension.
  8. Organizing Data.
    • Self Encapsulate Field.
    • Replace Data Value with Object.
    • Change Value to Reference.
    • Change Reference to Value.
    • Replace Array with Object.
    • Duplicate Observed Data.
    • Change Unidirectional Association to Bidirectional.
    • Change Bidirectional Association to Unidirectional.
    • Replace Magic Number with Symbolic Constant.
    • Encapsulate Field.
    • Encapsulate Collection.
    • Replace Record with Data Class.
    • Replace Type Code with Class.
    • Replace Type Code with Subclasses.
    • Replace Type Code with State/Strategy.
    • Replace Subclass with Fields.
  9. Simplifying Conditional Expressions.
    • Decompose Conditional.
    • Consolidate Conditional Expression.
    • Consolidate Duplicate Conditional Fragments.
    • Remove Control Flag.
    • Replace Nested Conditional with Guard Clauses.
    • Replace Conditional with Polymorphism.
    • Introduce Null Object.
    • Introduce Assertion.
  10. Making Method Calls Simpler.
    • Rename Method.
    • Add Parameter.
    • Remove Parameter.
    • Separate Query from Modifier.
    • Parameterize Method.
    • Replace Parameter with Explicit Methods.
    • Preserve Whole Object.
    • Replace Parameter with Method.
    • Introduce Parameter Object.
    • Remove Setting Method.
    • Hide Method.
    • Replace Constructor with Factory Method.
    • Encapsulate Downcast.
    • Replace Error Code with Exception.
    • Replace Exception with Test.
  11. Dealing with Generalization.
    • Pull Up Field.
    • Pull Up Method.
    • Pull Up Constructor Body.
    • Push Down Method.
    • Push Down Field.
    • Extract Subclass.
    • Extract Superclass.
    • Extract Interface.
    • Collapse Hierarchy.
    • Form Template Method.
    • Replace Inheritance with Delegation.
    • Replace Delegation with Inheritance.
  12. Big Refactorings.
    • Tease Apart Inheritance.
    • Convert Procedural Design to Objects.
    • Separate Domain from Presentation.
    • Extract Hierarchy.
  13. Refactoring, Reuse, and Reality.
    • A Reality Check.
    • Why Are Developers Reluctant to Refactor Their Programs?
    • A Reality Check (Revisited).
    • Resources and References for Refactoring.
    • Implications Regarding Software Reuse and Technology Transfer.
    • A Final Note.
    • References.
  14. Refactoring Tools.
    • Refactoring with a Tool.
    • Technical Criteria for a Refactoring Tool.
    • Practical Criteria for a Refactoring Tool.
    • Wrap Up.
  15. Putting It All Together.
[/list]
Critique du livre par la rédaction Matthieu Brucher le 22 novembre 2006
Une référence, voilà ce qu'est devenu ce livre pour moi. Le catalogue de patterns - parce que je considère ces petites étapes comme des patterns - est dense, presque exhaustif - je suis sûr qu'on pourrait en trouver d'autres -, mais il y a les patterns les plus simples et les plus utiles. Comme le texte au dos du livre le dit, certaines étapes semblent vraiment trop simples, et c'est le cas. Tout le monde sait inliner une fonction. On a un peu plus de mal en extrayant une méthode d'une autre méthode, mais de manière générale, on serait tomber tôt ou tard sur ces patterns.
L'avantage du livre, ce n'est pas de nous redire ce qu'on sait, c'est de nous montrer une étape à laquelle on n'a pas pensé et qui résoud le problème qu'on a. Enfin, c'est pas un problème, c'est juste que le code commence à sentir mauvais. D'ailleurs, l'odeur du code, c'est une des caractéristiques de ce livre, Martin Fowler nous donne des pistes pour apprendre à reconnaître l'odeur d'un code. Ca m'a fait sourire de se dire que le code avait une odeur. Et c'est vrai que lorsqu'on regarde le code qu'on faisait quand on était plus jeune, on se rend compte qu'il pue.
Un autre point de ce livre, c'est qu'il met l'accent sur les tests, principalement unitaires. Et effectivement, pour un livre qui parle de refactoring, c'est important. Il faut bien que le code après modification ait le même effet que sans modification ! L'exemple qui est donné est aussi explicite, on utilise plusieurs méthodes au fur et à mesure de l'avancement de la procédure, c'est très intéressant de voir comment ça marche.
Enfin, le code est du Java, mais pour quelqu'un qui connait le C++, ça passe sans problème. Chaque opération est suffisemment simple pour être presque identique à son équivalent en C++. Enfin, un petit topo sur ce qui existait à l'époque sur le refactoring est donné, et même s'il est un peu dépassé, ce topo est très instructif.




 Poster une réponse

Avatar de forum forum - Robot Forum https://www.developpez.com
le 15/07/2014 à 21:32
Refactoring
Improving the Design of Existing Code
Pendant que l'application de technologies objet - particulièrement dans le langage de programmation Java - devient courant, un nouveau problème est apparu dans la communauté du développement logiciel. Un nombre significatif de programmes mal designés ont été créés par des développeurs moins expérimentés, se traduisant par des applications qui sont inefficaces et difficiles à maintenir et à étendre. Les professionnels des systèmes logiciels découvrent de plus en plus la difficulté de travailler avec ces applications héritées, "non optimales". Pendant plusieurs années, les programmeurs objets d'un niveau d'expert ont employés une collection grandissante de techniques pour améliorer l'intégrité et la performance de ce genre de programmes existants. Connus sous le nom de "refactoring", ces pratiques sont restées dans le domaine des experts car aucune tentative avait été menée pour les transcrire dans une forme que tous les développeurs pouvaient utiliser... jusqu'à aujourd'hui. Dans Refactoring: Improving the Design of Existing Code, Martin Fowler, mentor renommé de la technologie objet ouvre une nouvelle voie, démystifiant ces pratiques avancées et démontrant comment les développeurs peuvent se rendre compte des bénéfices de ce nouveau processus.

Avec un entraînement adéquat, un designer aguerri de système peut prendre un mauvais design et le transformer en code robuste, bien designé. Dans ce livre, Martin Fowler nous montre où sont traditionnellement les opportunités pour le refactoring et comment passer d'un mauvais design à un bon. Chaque étape de refactoring est simple - apparemment trop simple pour mériter d'être effectuée. Refactorer peut impliquer déplacer un champ d'une classe à une autre, extraire du code d'une méthode pour en faire une nouvelle ou même modifier une hierarchie. Si ces étapes individuelles peuvent sembler élémentaires, l'effet cumulatif de ces petits changements peut améliorer grandement un design. Refactorer est un moyen efficace pour empêcher un logiciel de pérécliter.

Outre les discussions sur les différentes techniques de refactoring, l'auteur donne un catalogue détaillé de plus de 70 étapes avec des références judicieuses pour nous apprendre quand les appliquer, des instructions pas à pas pour chaque application d'un tel pattern et un exemple illustrant comment fonctionne le refactoring. Les exemples illustratifs sont écrits en Java, mais les idées sont applicables à tout langage orienté objet.

[Lire la suite]




couverture du livre UML et les Design patterns

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

UML et les Design patterns

de
Public visé : Débutant

Résumé de l'éditeur

UML et les Design Patterns fournit aux développeurs et aux étudiants les connaissances indispensables pour comprendre et maîtriser l'analyse et la conception orientées objet (A/COO). Son objectif ne se limite pas à la création de diagrammes et à la notation UML ; il vise à leur application réelle dans le contexte de la conception de systèmes logiciels. Craig Larman, expert de renom en technologie objet et en méthodes itératives, présente ici une unique étude de cas homogène, exposant progressivement les techniques capitales de l'analyse et de la conception orientées objet, tout en mettant l'accent sur les activités, les principes et les patterns les plus essentiels.

Édition : Campus Press - 660 pages , 1re édition, 20 juillet 2003

ISBN10 : 2744016233 - ISBN13 : 9782744016233

Commandez sur www.amazon.fr :

40.85 € TTC (prix éditeur 40.85 € TTC) livraison gratuite !
Chap. I Analyse et Conception Orientée Object (A/COO)
Chap. II. Développement Itératif et Processus Unifié
Chap. III.Etude de Cas : Système NextGen
Chap. IV. Initialisation
Chap. V. Comprendre les besoins
Chap. VI. Modèle de Cas d'Utilisation : rédaction des spécifications dans un contexte
Chap. VII. Identification des autres besoins
Chap. VIII. De l'initialisation à l'élaboration
Chap. IX. Modèle de cas d'utilisation : création de DSS
Chap. X. Modèle du domaine : les concepts
Chap. XI. Modèle du domaine : les associations
Chap. XII. Modèle du domaine : les attributs
Chap. XIII. Les Contrats d'opération
Chap. XIV. Des besoins à la conception dans l'itération en cours
Chap. XV. Notation des diagrammes d'interaction
Chap. XVI. GRASP : conception objet et reponsabilités
Chap. XVII. Modèle de conception : réalisation des cas d'utilisation avec les patterns GRASP
Chap. XVIII. Déterminer la visibilité
Chap. XIX. Diagrammes de classes de conception
Chap. XX. Modèle d'implémentation
Chap. XXI. Itération 2 et ses exigences
Chap. XXII. GRASP : autres patterns
Chap. XXIII. Conception et patterns GoF
Chap. XXIV. Itération 3 et ses exigences
Chap. XXV. Mise en relation des cas d'utilisation
Chap. XXVI. Modélisation de la généralisation
Chap. XXVII. Affinement du Modèle du domaine
Chap. XXVIII. Nouveaux DSS et contrats
Chap. XXIX. Modélisation du comportement et diagrammes d'états-transitions
Chap. XXX. Conception de l'architecture logique avec des patterns
Chap. XXXI. Organisation des packages
Chap. XXXII. Introduction à l'analyse architecturale
Chap. XXXIII. Autes réalisations de cas d'utilisation avec des objets et des patterns
Chap. XXXIV. Conception d'un framework de persistance
Chap. XXXV. Dessin et outils
Chap. XXXVI. Introduction à la planification itérative et à la conduite de projets
Chap. XXXVII. Commentaires sur le développement itératif et UP
Chap. XXXVIII. Compléments sur la notation UML
Critique du livre par la rédaction Petrus le 18 août 2003
Incontournable ! Un ouvrage à la hauteur de l'experience de Craig Larman, l'un des plus grands spécialistes de génie logiciel et d'Unified Modeling Language nous gratifie d'un excellent livre, pour chefs de projets ou développeurs concernés et/ou confirmés. Une profonde analyse du développement itératif à l'aide de la notation UML et des Design Patterns nous est ainsi livrée sous une forme trés pédagogique.
Une étude de cas unique est suivie tout au long des chapitres et sert de référence pour chaque exemple. Néanmoins, il ne faut pas que le développeur s'attende à trouver une étude exhaustive de la notation UML ou des diagrammes ultra-complets, en effet, l'ouvrage s'attache essentiellement a présenter l'intérêt du recours à UML dans un cycle de développement itératif comme Unified Process. des analogies au RUP de Philipe kruchten ou XP sont également introduites. Côté Patterns, nous retrouvons les modèles de responsabilités (Pattern GRASP) et GoF (Gang Of Four).
On regrette cependant l'absence d'un CD avec des documentations ou des logiciels de modélisation UML en version d'évaluation (Together ou Rational), mais aussi que le titre ne reflète pas de façon adaptée le réel contenu de l'ouvrage.




 Poster une réponse

Avatar de forum forum - Robot Forum https://www.developpez.com
le 15/07/2014 à 21:32
UML et les Design patterns
UML et les Design Patterns fournit aux développeurs et aux étudiants les connaissances indispensables pour comprendre et maîtriser l'analyse et la conception orientées objet (A/COO). Son objectif ne se limite pas à la création de diagrammes et à la notation UML ; il vise à leur application réelle dans le contexte de la conception de systèmes logiciels. Craig Larman, expert de renom en technologie objet et en méthodes itératives, présente ici une unique étude de cas homogène, exposant progressivement les techniques capitales de l'analyse et de la conception orientées objet, tout en mettant l'accent sur les activités, les principes et les patterns les plus essentiels.

[Lire la suite]




couverture du livre UML 2 et les Design patterns

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

UML 2 et les Design patterns

de

Résumé de l'éditeur

UML et les Design Patterns fournit aux développeurs et aux étudiants les connaissances indispensables pour comprendre et maîtriser l'analyse et la conception orientées objet (A/COO). Son objectif ne se limite pas à la création de diagrammes et à la notation UML ; il vise à leur application réelle dans le contexte de la conception de systèmes logiciels. Craig Larman, expert de renom en technologie objet et en méthodes itératives, présente ici une unique étude de cas homogène, exposant progressivement les techniques capitales de l'analyse et de la conception orientées objet, tout en mettant l'accent sur les activités, les principes et les patterns les plus essentiels.

Édition : Pearson Education - 850 pages , 3eédition, 20 mars 2005

ISBN10 : 2744070904 - ISBN13 : 9782744070907

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € TTC) livraison gratuite !
  • Chap. I Analyse et Conception Orientée Object (A/COO)
  • Chap. II. Développement Itératif et Processus Unifié
  • Chap. III.Etude de Cas : Système NextGen
  • Chap. IV. Initialisation
  • Chap. V. Comprendre les besoins
  • Chap. VI. Modèle de Cas d'Utilisation : rédaction des spécifications dans un contexte
  • Chap. VII. Identification des autres besoins
  • Chap. VIII. De l'initialisation à l'élaboration
  • Chap. IX. Modèle de cas d'utilisation : création de DSS
  • Chap. X. Modèle du domaine : les concepts
  • Chap. XI. Modèle du domaine : les associations
  • Chap. XII. Modèle du domaine : les attributs
  • Chap. XIII. Les Contrats d'opération
  • Chap. XIV. Des besoins à la conception dans l'itération en cours
  • Chap. XV. Notation des diagrammes d'interaction
  • Chap. XVI. GRASP : conception objet et reponsabilités
  • Chap. XVII. Modèle de conception : réalisation des cas d'utilisation avec les patterns GRASP
  • Chap. XVIII. Déterminer la visibilité
  • Chap. XIX. Diagrammes de classes de conception
  • Chap. XX. Modèle d'implémentation
  • Chap. XXI. Itération 2 et ses exigences
  • Chap. XXII. GRASP : autres patterns
  • Chap. XXIII. Conception et patterns GoF
  • Chap. XXIV. Itération 3 et ses exigences
  • Chap. XXV. Mise en relation des cas d'utilisation
  • Chap. XXVI. Modélisation de la généralisation
  • Chap. XXVII. Affinement du Modèle du domaine
  • Chap. XXVIII. Nouveaux DSS et contrats
  • Chap. XXIX. Modélisation du comportement et diagrammes d'états-transitions
  • Chap. XXX. Conception de l'architecture logique avec des patterns
  • Chap. XXXI. Organisation des packages
  • Chap. XXXII. Introduction à l'analyse architecturale
  • Chap. XXXIII. Autes réalisations de cas d'utilisation avec des objets et des patterns
  • Chap. XXXIV. Conception d'un framework de persistance
  • Chap. XXXV. Dessin et outils
  • Chap. XXXVI. Introduction à la planification itérative et à la conduite de projets
  • Chap. XXXVII. Commentaires sur le développement itératif et UP
  • Chap. XXXVIII. Compléments sur la notation UML
Critique du livre par la rédaction Petrus le 14 août 2005
Incontournable ! Un ouvrage à la hauteur de l’expérience de Craig Larman, l'un des plus grands spécialistes de génie logiciel et d'Unified Modeling Language nous gratifie d'un excellent livre, pour chefs de projets ou développeurs concernés et/ou confirmés. Une profonde analyse du développement itératif à l'aide de la notation UML et des Design Patterns nous est ainsi livrée sous une forme trés pédagogique.

Une étude de cas unique est suivie tout au long des chapitres et sert de référence pour chaque exemple. Néanmoins, il ne faut pas que le développeur s'attende à trouver une étude exhaustive de la notation UML ou des diagrammes ultra-complets, en effet, l'ouvrage s'attache essentiellement à présenter l'intérêt du recours à UML dans un cycle de développement itératif comme Unified Process. des analogies au RUP de Philipe kruchten ou XP sont également introduites. Côté Patterns, nous retrouvons les modèles de responsabilités (Pattern GRASP) et GoF (Gang Of Four).

On regrette cependant l'absence d'un CD avec des documentations ou des logiciels de modélisation UML en version d'évaluation (Together ou Rational), mais aussi que le titre ne reflète pas de façon adaptée le réel contenu de l'ouvrage.




 Poster une réponse

Avatar de Winjerome Winjerome - Expert éminent sénior https://www.developpez.com
le 11/06/2014 à 19:25
UML 2 et les Design patterns


UML et les Design Patterns fournit aux développeurs et aux étudiants les connaissances indispensables pour comprendre et maîtriser l'analyse et la conception orientées objet (A/COO). Son objectif ne se limite pas à la création de diagrammes et à la notation UML ; il vise à leur application réelle dans le contexte de la conception de systèmes logiciels. Craig Larman, expert de renom en technologie objet et en méthodes itératives, présente ici une unique étude de cas homogène, exposant progressivement les techniques capitales de l'analyse et de la conception orientées objet, tout en mettant l'accent sur les activités, les principes et les patterns les plus essentiels.

[Lire la suite]



Contacter le responsable de la rubrique ALM