Les livres français

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.

Pour un panorama complet du monde de l'orienté objet, ce livre est certainement à conseiller. L'auteur, par ailleurs professeur à l'ULB (université libre de Bruxelles) démontre son talent pédagogique, dès le début. De nombreuses allusions font d'ailleurs remarquer que ce livre est principalement prévu pour un public étudiant se familiarisant avec la programmation orientée objet, sans rien en connaître, mais ayant déjà connaissance d'un langage de programmation procédural (ou au moins les principes).
Dès le premier exemple, on se plonge dans un environnement Java, sans que cela n'ait été introduit, sans donner vraiment d'explication sur la syntaxe - cela n'est pas vraiment nécessaire, le code est suffisamment documenté pour que la compréhension ne tarde pas. Ensuite sont présentés les différents langages, en s'axant sur leurs particularités syntaxiques, sur les points qui choquent en comparaison au Java. Il n'y a que le minimum qui est présenté, il ne faut pas prendre ce livre pour ce qu'il n'est pas : il introduit à la programmation orientée objet, il n'a pas pour vocation d'apprendre un langage.
C'est d'ailleurs sur ces langages que se portent mes seuls griefs à l'encontre de ce livre : les langages sont parfois fortement détournés pour suivre le discours de l'auteur. On montrera, par exemple, du code Python très peu pythonique, sans utilisation de décorateurs comme @staticmethod ou la définition d'autres constructeurs quand des arguments mots-clés peuvent être utilisés. Du côté C++, on voit, dans les premiers exemples, des directives #include pointées sur... des fichiers .cpp ! Il faut attendre le quinzième chapitre sur les interfaces pour voir l'existence de fichiers .h, ce qui permet de s'assurer de très mauvaises pratiques dans du code C++... Cela passe aussi pour une faiblesse du langage, qu'un utilisateur du C++ pourra faire passer pour une méconnaissance du langage. Passons le fait que le C++/CLI devient du Visual C++ .Net, nom qui n'est attesté sur le Web presque exclusivement comme les nouvelles versions de l'EDI de Microsoft pour le C++, partie de l'environnement plus complet Visual Studio, ainsi que le fait qu'il semble jusqu'au chapitre sur l'héritage que la seule raison de traiter le C++ est de pouvoir en dire tout le mal qu'on peut. Sans oublier que la STL est entièrement nonobstée et que l'on juge les complexités du C++ comme des écarts par rapport aux autres langages, alors qu'il en est l'aîné. On remarque aussi que le PHP est exclusivement utilisé en contexte Web, comme s'il était incapable de faire autre chose (sans oublier que le décorum HTML tout autour ne facilite pas la compréhension de l'exemple, en ajoutant un bon nombre de lignes parfaitement inutiles).
En conclusion de ce paragraphe, on dira que ce livre n'est absolument pas là pour apprendre un langage ou l'autre, ce n'est pas son but, il veut simplement apprendre les bases de la programmation orientée objet, en déclinant les concepts aux différents langages, en montrant leurs différences. Tous les concepts sont illustrés dans tous les langages, permettant ainsi de visualiser in situ les différences de pensée entre les concepteurs. Ces exemples, d'ailleurs, évoluent au fur et à mesure de la progression de la compréhension du lecteur : les premiers exemples sont fort didactiques, on finit dans les derniers chapitres à simuler les réactions chimiques ayant lieu dans un réacteur, on passe d'exemples simplistes à des exemples réalistes.
À un niveau plus général, on remarquera quelques fautes d'orthographe restées malgré les relectures, les schémas de mauvaise facture (réalisés probablement à l'aide d'un logiciel peu évolué tel que Paint), qui font vraiment tache à côté des schémas UML, ainsi que des captures d'écran sur des systèmes d'exploitation relativement préhistoriques (aux alentours de Windows Millenium).
Ce ne sont pas ces quelques défauts qui vont entacher le principal du livre. On appréciera notamment le large chapitre dédié à UML2, ainsi que les schémas UML utilisés bien avant leur formalisation pour aider à comprendre les principes. Des exercices terminent la grande majorité des chapitres, permettant au lecteur de vérifier qu'il a bien assimilé les concepts ; on regrettera de ne voir les solutions que sur le site de l'éditeur, pas dans une annexe au livre.
Il faut aussi remarquer que l'utilisation plus pratique de l'orienté objet est aussi couverte : ainsi, on parlera des méthodes pour la communication entre un client et un serveur à l'aide de RMI, de Corba et d'autres. Sera aussi discutée la sérialisation dans les divers langages, sans toutefois rentrer dans les détails, car ils deviennent plus spécifiques aux langages. On regrettera de ne pas voir ici la sérialisation selon boost pour le C++ ou la fonction serialize() de PHP : ces deux langages ne sont pas arriérés, ils permettent aussi la sérialisation, alors qu'aucune mention n'en est faite.
Des sujets plus pointus comme le multithreading sont aussi abordés : point noir de ce chapitre, C++ et PHP sont oubliés. Signaler qu'aucune méthode vraiment propre n'existe en PHP n'est pas un luxe, préciser l'existence d'une pléthore de possibilités en C++ est un minimum pour tout qui parle de multithreading et de C++ (il n'aurait pas été utile de développer le sujet, mais au moins d'indiquer dans quelle direction chercher si le besoin s'en fait sentir). Les autres langages jouissent d'une description des méthodes disponibles en standard pour obtenir une application multithreadée, en tenant compte de la problématique des accès concurrents.
En bref ? Un ouvrage plus qu'excellent, didactique, qui passe par tous les jalons, toutes les étapes, sans en oublier une, pour la programmation orientée objet. Que le lecteur soit débutant ou plus avancé, il trouvera dans ce livre de quoi apprendre ou se remettre à niveau. Par contre, prendre ce livre pour apprendre un langage n'est pas forcément la meilleure idée, ce n'est pas son objectif, les explications ne vont d'ailleurs pas en ce sens. Le style assez humoristique de l'auteur en fait un livre très facile à lire.
Vous avez lu ce livre ? Qu'en pensez-vous ?

Pour un panorama complet du monde de l'orienté objet, ce livre est certainement à conseiller. L'auteur, par ailleurs professeur à l'ULB (université libre de Bruxelles) démontre son talent pédagogique, dès le début. De nombreuses allusions font d'ailleurs remarquer que ce livre est principalement prévu pour un public étudiant se familiarisant avec la programmation orientée objet, sans rien en connaître, mais ayant déjà connaissance d'un langage de programmation procédural (ou au moins les principes).
Dès le premier exemple, on se plonge dans un environnement Java, sans que cela n'ait été introduit, sans donner vraiment d'explication sur la syntaxe - cela n'est pas vraiment nécessaire, le code est suffisamment documenté pour que la compréhension ne tarde pas. Ensuite sont présentés les différents langages, en s'axant sur leurs particularités syntaxiques, sur les points qui choquent en comparaison au Java. Il n'y a que le minimum qui est présenté, il ne faut pas prendre ce livre pour ce qu'il n'est pas : il introduit à la programmation orientée objet, il n'a pas pour vocation d'apprendre un langage.
C'est d'ailleurs sur ces langages que se portent mes seuls griefs à l'encontre de ce livre : les langages sont parfois fortement détournés pour suivre le discours de l'auteur. On montrera, par exemple, du code Python très peu pythonique, sans utilisation de décorateurs comme @staticmethod ou la définition d'autres constructeurs quand des arguments mots-clés peuvent être utilisés. Du côté C++, on voit, dans les premiers exemples, des directives #include pointées sur... des fichiers .cpp ! Il faut attendre le quinzième chapitre sur les interfaces pour voir l'existence de fichiers .h, ce qui permet de s'assurer de très mauvaises pratiques dans du code C++... Cela passe aussi pour une faiblesse du langage, qu'un utilisateur du C++ pourra faire passer pour une méconnaissance du langage. Passons le fait que le C++/CLI devient du Visual C++ .Net, nom qui n'est attesté sur le Web presque exclusivement comme les nouvelles versions de l'EDI de Microsoft pour le C++, partie de l'environnement plus complet Visual Studio, ainsi que le fait qu'il semble jusqu'au chapitre sur l'héritage que la seule raison de traiter le C++ est de pouvoir en dire tout le mal qu'on peut. Sans oublier que la STL est entièrement nonobstée et que l'on juge les complexités du C++ comme des écarts par rapport aux autres langages, alors qu'il en est l'aîné. On remarque aussi que le PHP est exclusivement utilisé en contexte Web, comme s'il était incapable de faire autre chose (sans oublier que le décorum HTML tout autour ne facilite pas la compréhension de l'exemple, en ajoutant un bon nombre de lignes parfaitement inutiles).
En conclusion de ce paragraphe, on dira que ce livre n'est absolument pas là pour apprendre un langage ou l'autre, ce n'est pas son but, il veut simplement apprendre les bases de la programmation orientée objet, en déclinant les concepts aux différents langages, en montrant leurs différences. Tous les concepts sont illustrés dans tous les langages, permettant ainsi de visualiser in situ les différences de pensée entre les concepteurs. Ces exemples, d'ailleurs, évoluent au fur et à mesure de la progression de la compréhension du lecteur : les premiers exemples sont fort didactiques, on finit dans les derniers chapitres à simuler les réactions chimiques ayant lieu dans un réacteur, on passe d'exemples simplistes à des exemples réalistes.
À un niveau plus général, on remarquera quelques fautes d'orthographe restées malgré les relectures, les schémas de mauvaise facture (réalisés probablement à l'aide d'un logiciel peu évolué tel que Paint), qui font vraiment tache à côté des schémas UML, ainsi que des captures d'écran sur des systèmes d'exploitation relativement préhistoriques (aux alentours de Windows Millenium).
Ce ne sont pas ces quelques défauts qui vont entacher le principal du livre. On appréciera notamment le large chapitre dédié à UML2, ainsi que les schémas UML utilisés bien avant leur formalisation pour aider à comprendre les principes. Des exercices terminent la grande majorité des chapitres, permettant au lecteur de vérifier qu'il a bien assimilé les concepts ; on regrettera de ne voir les solutions que sur le site de l'éditeur, pas dans une annexe au livre.
Il faut aussi remarquer que l'utilisation plus pratique de l'orienté objet est aussi couverte : ainsi, on parlera des méthodes pour la communication entre un client et un serveur à l'aide de RMI, de Corba et d'autres. Sera aussi discutée la sérialisation dans les divers langages, sans toutefois rentrer dans les détails, car ils deviennent plus spécifiques aux langages. On regrettera de ne pas voir ici la sérialisation selon boost pour le C++ ou la fonction serialize() de PHP : ces deux langages ne sont pas arriérés, ils permettent aussi la sérialisation, alors qu'aucune mention n'en est faite.
Des sujets plus pointus comme le multithreading sont aussi abordés : point noir de ce chapitre, C++ et PHP sont oubliés. Signaler qu'aucune méthode vraiment propre n'existe en PHP n'est pas un luxe, préciser l'existence d'une pléthore de possibilités en C++ est un minimum pour tout qui parle de multithreading et de C++ (il n'aurait pas été utile de développer le sujet, mais au moins d'indiquer dans quelle direction chercher si le besoin s'en fait sentir). Les autres langages jouissent d'une description des méthodes disponibles en standard pour obtenir une application multithreadée, en tenant compte de la problématique des accès concurrents.
En bref ? Un ouvrage plus qu'excellent, didactique, qui passe par tous les jalons, toutes les étapes, sans en oublier une, pour la programmation orientée objet. Que le lecteur soit débutant ou plus avancé, il trouvera dans ce livre de quoi apprendre ou se remettre à niveau. Par contre, prendre ce livre pour apprendre un langage n'est pas forcément la meilleure idée, ce n'est pas son objectif, les explications ne vont d'ailleurs pas en ce sens. Le style assez humoristique de l'auteur en fait un livre très facile à lire.
Vous avez lu ce livre ? Qu'en pensez-vous ?

Pour un panorama complet du monde de l'orienté objet, ce livre est certainement à conseiller. L'auteur, par ailleurs professeur à l'ULB (université libre de Bruxelles) démontre son talent pédagogique, dès le début. De nombreuses allusions font d'ailleurs remarquer que ce livre est principalement prévu pour un public étudiant se familiarisant avec la programmation orientée objet, sans rien en connaître, mais ayant déjà connaissance d'un langage de programmation procédural (ou au moins les principes).
Dès le premier exemple, on se plonge dans un environnement Java, sans que cela n'ait été introduit, sans donner vraiment d'explication sur la syntaxe - cela n'est pas vraiment nécessaire, le code est suffisamment documenté pour que la compréhension ne tarde pas. Ensuite sont présentés les différents langages, en s'axant sur leurs particularités syntaxiques, sur les points qui choquent en comparaison au Java. Il n'y a que le minimum qui est présenté, il ne faut pas prendre ce livre pour ce qu'il n'est pas : il introduit à la programmation orientée objet, il n'a pas pour vocation d'apprendre un langage.
C'est d'ailleurs sur ces langages que se portent mes seuls griefs à l'encontre de ce livre : les langages sont parfois fortement détournés pour suivre le discours de l'auteur. On montrera, par exemple, du code Python très peu pythonique, sans utilisation de décorateurs comme @staticmethod ou la définition d'autres constructeurs quand des arguments mots-clés peuvent être utilisés. Du côté C++, on voit, dans les premiers exemples, des directives #include pointées sur... des fichiers .cpp ! Il faut attendre le quinzième chapitre sur les interfaces pour voir l'existence de fichiers .h, ce qui permet de s'assurer de très mauvaises pratiques dans du code C++... Cela passe aussi pour une faiblesse du langage, qu'un utilisateur du C++ pourra faire passer pour une méconnaissance du langage. Passons le fait que le C++/CLI devient du Visual C++ .Net, nom qui n'est attesté sur le Web presque exclusivement comme les nouvelles versions de l'EDI de Microsoft pour le C++, partie de l'environnement plus complet Visual Studio, ainsi que le fait qu'il semble jusqu'au chapitre sur l'héritage que la seule raison de traiter le C++ est de pouvoir en dire tout le mal qu'on peut. Sans oublier que la STL est entièrement nonobstée et que l'on juge les complexités du C++ comme des écarts par rapport aux autres langages, alors qu'il en est l'aîné. On remarque aussi que le PHP est exclusivement utilisé en contexte Web, comme s'il était incapable de faire autre chose (sans oublier que le décorum HTML tout autour ne facilite pas la compréhension de l'exemple, en ajoutant un bon nombre de lignes parfaitement inutiles).
En conclusion de ce paragraphe, on dira que ce livre n'est absolument pas là pour apprendre un langage ou l'autre, ce n'est pas son but, il veut simplement apprendre les bases de la programmation orientée objet, en déclinant les concepts aux différents langages, en montrant leurs différences. Tous les concepts sont illustrés dans tous les langages, permettant ainsi de visualiser in situ les différences de pensée entre les concepteurs. Ces exemples, d'ailleurs, évoluent au fur et à mesure de la progression de la compréhension du lecteur : les premiers exemples sont fort didactiques, on finit dans les derniers chapitres à simuler les réactions chimiques ayant lieu dans un réacteur, on passe d'exemples simplistes à des exemples réalistes.
À un niveau plus général, on remarquera quelques fautes d'orthographe restées malgré les relectures, les schémas de mauvaise facture (réalisés probablement à l'aide d'un logiciel peu évolué tel que Paint), qui font vraiment tache à côté des schémas UML, ainsi que des captures d'écran sur des systèmes d'exploitation relativement préhistoriques (aux alentours de Windows Millenium).
Ce ne sont pas ces quelques défauts qui vont entacher le principal du livre. On appréciera notamment le large chapitre dédié à UML2, ainsi que les schémas UML utilisés bien avant leur formalisation pour aider à comprendre les principes. Des exercices terminent la grande majorité des chapitres, permettant au lecteur de vérifier qu'il a bien assimilé les concepts ; on regrettera de ne voir les solutions que sur le site de l'éditeur, pas dans une annexe au livre.
Il faut aussi remarquer que l'utilisation plus pratique de l'orienté objet est aussi couverte : ainsi, on parlera des méthodes pour la communication entre un client et un serveur à l'aide de RMI, de Corba et d'autres. Sera aussi discutée la sérialisation dans les divers langages, sans toutefois rentrer dans les détails, car ils deviennent plus spécifiques aux langages. On regrettera de ne pas voir ici la sérialisation selon boost pour le C++ ou la fonction serialize() de PHP : ces deux langages ne sont pas arriérés, ils permettent aussi la sérialisation, alors qu'aucune mention n'en est faite.
Des sujets plus pointus comme le multithreading sont aussi abordés : point noir de ce chapitre, C++ et PHP sont oubliés. Signaler qu'aucune méthode vraiment propre n'existe en PHP n'est pas un luxe, préciser l'existence d'une pléthore de possibilités en C++ est un minimum pour tout qui parle de multithreading et de C++ (il n'aurait pas été utile de développer le sujet, mais au moins d'indiquer dans quelle direction chercher si le besoin s'en fait sentir). Les autres langages jouissent d'une description des méthodes disponibles en standard pour obtenir une application multithreadée, en tenant compte de la problématique des accès concurrents.
En bref ? Un ouvrage plus qu'excellent, didactique, qui passe par tous les jalons, toutes les étapes, sans en oublier une, pour la programmation orientée objet. Que le lecteur soit débutant ou plus avancé, il trouvera dans ce livre de quoi apprendre ou se remettre à niveau. Par contre, prendre ce livre pour apprendre un langage n'est pas forcément la meilleure idée, ce n'est pas son objectif, les explications ne vont d'ailleurs pas en ce sens. Le style assez humoristique de l'auteur en fait un livre très facile à lire.
Vous avez lu ce livre ? Qu'en pensez-vous ?

Pour un panorama complet du monde de l'orienté objet, ce livre est certainement à conseiller. L'auteur, par ailleurs professeur à l'ULB (université libre de Bruxelles) démontre son talent pédagogique, dès le début. De nombreuses allusions font d'ailleurs remarquer que ce livre est principalement prévu pour un public étudiant se familiarisant avec la programmation orientée objet, sans rien en connaître, mais ayant déjà connaissance d'un langage de programmation procédural (ou au moins les principes).
Dès le premier exemple, on se plonge dans un environnement Java, sans que cela n'ait été introduit, sans donner vraiment d'explication sur la syntaxe - cela n'est pas vraiment nécessaire, le code est suffisamment documenté pour que la compréhension ne tarde pas. Ensuite sont présentés les différents langages, en s'axant sur leurs particularités syntaxiques, sur les points qui choquent en comparaison au Java. Il n'y a que le minimum qui est présenté, il ne faut pas prendre ce livre pour ce qu'il n'est pas : il introduit à la programmation orientée objet, il n'a pas pour vocation d'apprendre un langage.
C'est d'ailleurs sur ces langages que se portent mes seuls griefs à l'encontre de ce livre : les langages sont parfois fortement détournés pour suivre le discours de l'auteur. On montrera, par exemple, du code Python très peu pythonique, sans utilisation de décorateurs comme @staticmethod ou la définition d'autres constructeurs quand des arguments mots-clés peuvent être utilisés. Du côté C++, on voit, dans les premiers exemples, des directives #include pointées sur... des fichiers .cpp ! Il faut attendre le quinzième chapitre sur les interfaces pour voir l'existence de fichiers .h, ce qui permet de s'assurer de très mauvaises pratiques dans du code C++... Cela passe aussi pour une faiblesse du langage, qu'un utilisateur du C++ pourra faire passer pour une méconnaissance du langage. Passons le fait que le C++/CLI devient du Visual C++ .Net, nom qui n'est attesté sur le Web presque exclusivement comme les nouvelles versions de l'EDI de Microsoft pour le C++, partie de l'environnement plus complet Visual Studio, ainsi que le fait qu'il semble jusqu'au chapitre sur l'héritage que la seule raison de traiter le C++ est de pouvoir en dire tout le mal qu'on peut. Sans oublier que la STL est entièrement nonobstée et que l'on juge les complexités du C++ comme des écarts par rapport aux autres langages, alors qu'il en est l'aîné. On remarque aussi que le PHP est exclusivement utilisé en contexte Web, comme s'il était incapable de faire autre chose (sans oublier que le décorum HTML tout autour ne facilite pas la compréhension de l'exemple, en ajoutant un bon nombre de lignes parfaitement inutiles).
En conclusion de ce paragraphe, on dira que ce livre n'est absolument pas là pour apprendre un langage ou l'autre, ce n'est pas son but, il veut simplement apprendre les bases de la programmation orientée objet, en déclinant les concepts aux différents langages, en montrant leurs différences. Tous les concepts sont illustrés dans tous les langages, permettant ainsi de visualiser in situ les différences de pensée entre les concepteurs. Ces exemples, d'ailleurs, évoluent au fur et à mesure de la progression de la compréhension du lecteur : les premiers exemples sont fort didactiques, on finit dans les derniers chapitres à simuler les réactions chimiques ayant lieu dans un réacteur, on passe d'exemples simplistes à des exemples réalistes.
À un niveau plus général, on remarquera quelques fautes d'orthographe restées malgré les relectures, les schémas de mauvaise facture (réalisés probablement à l'aide d'un logiciel peu évolué tel que Paint), qui font vraiment tache à côté des schémas UML, ainsi que des captures d'écran sur des systèmes d'exploitation relativement préhistoriques (aux alentours de Windows Millenium).
Ce ne sont pas ces quelques défauts qui vont entacher le principal du livre. On appréciera notamment le large chapitre dédié à UML2, ainsi que les schémas UML utilisés bien avant leur formalisation pour aider à comprendre les principes. Des exercices terminent la grande majorité des chapitres, permettant au lecteur de vérifier qu'il a bien assimilé les concepts ; on regrettera de ne voir les solutions que sur le site de l'éditeur, pas dans une annexe au livre.
Il faut aussi remarquer que l'utilisation plus pratique de l'orienté objet est aussi couverte : ainsi, on parlera des méthodes pour la communication entre un client et un serveur à l'aide de RMI, de Corba et d'autres. Sera aussi discutée la sérialisation dans les divers langages, sans toutefois rentrer dans les détails, car ils deviennent plus spécifiques aux langages. On regrettera de ne pas voir ici la sérialisation selon boost pour le C++ ou la fonction serialize() de PHP : ces deux langages ne sont pas arriérés, ils permettent aussi la sérialisation, alors qu'aucune mention n'en est faite.
Des sujets plus pointus comme le multithreading sont aussi abordés : point noir de ce chapitre, C++ et PHP sont oubliés. Signaler qu'aucune méthode vraiment propre n'existe en PHP n'est pas un luxe, préciser l'existence d'une pléthore de possibilités en C++ est un minimum pour tout qui parle de multithreading et de C++ (il n'aurait pas été utile de développer le sujet, mais au moins d'indiquer dans quelle direction chercher si le besoin s'en fait sentir). Les autres langages jouissent d'une description des méthodes disponibles en standard pour obtenir une application multithreadée, en tenant compte de la problématique des accès concurrents.
En bref ? Un ouvrage plus qu'excellent, didactique, qui passe par tous les jalons, toutes les étapes, sans en oublier une, pour la programmation orientée objet. Que le lecteur soit débutant ou plus avancé, il trouvera dans ce livre de quoi apprendre ou se remettre à niveau. Par contre, prendre ce livre pour apprendre un langage n'est pas forcément la meilleure idée, ce n'est pas son objectif, les explications ne vont d'ailleurs pas en ce sens. Le style assez humoristique de l'auteur en fait un livre très facile à lire.
Vous avez lu ce livre ? Qu'en pensez-vous ?

Pour un panorama complet du monde de l'orienté objet, ce livre est certainement à conseiller. L'auteur, par ailleurs professeur à l'ULB (université libre de Bruxelles) démontre son talent pédagogique, dès le début. De nombreuses allusions font d'ailleurs remarquer que ce livre est principalement prévu pour un public étudiant se familiarisant avec la programmation orientée objet, sans rien en connaître, mais ayant déjà connaissance d'un langage de programmation procédural (ou au moins les principes).
Dès le premier exemple, on se plonge dans un environnement Java, sans que cela n'ait été introduit, sans donner vraiment d'explication sur la syntaxe - cela n'est pas vraiment nécessaire, le code est suffisamment documenté pour que la compréhension ne tarde pas. Ensuite sont présentés les différents langages, en s'axant sur leurs particularités syntaxiques, sur les points qui choquent en comparaison au Java. Il n'y a que le minimum qui est présenté, il ne faut pas prendre ce livre pour ce qu'il n'est pas : il introduit à la programmation orientée objet, il n'a pas pour vocation d'apprendre un langage.
C'est d'ailleurs sur ces langages que se portent mes seuls griefs à l'encontre de ce livre : les langages sont parfois fortement détournés pour suivre le discours de l'auteur. On montrera, par exemple, du code Python très peu pythonique, sans utilisation de décorateurs comme @staticmethod ou la définition d'autres constructeurs quand des arguments mots-clés peuvent être utilisés. Du côté C++, on voit, dans les premiers exemples, des directives #include pointées sur... des fichiers .cpp ! Il faut attendre le quinzième chapitre sur les interfaces pour voir l'existence de fichiers .h, ce qui permet de s'assurer de très mauvaises pratiques dans du code C++... Cela passe aussi pour une faiblesse du langage, qu'un utilisateur du C++ pourra faire passer pour une méconnaissance du langage. Passons le fait que le C++/CLI devient du Visual C++ .Net, nom qui n'est attesté sur le Web presque exclusivement comme les nouvelles versions de l'EDI de Microsoft pour le C++, partie de l'environnement plus complet Visual Studio, ainsi que le fait qu'il semble jusqu'au chapitre sur l'héritage que la seule raison de traiter le C++ est de pouvoir en dire tout le mal qu'on peut. Sans oublier que la STL est entièrement nonobstée et que l'on juge les complexités du C++ comme des écarts par rapport aux autres langages, alors qu'il en est l'aîné. On remarque aussi que le PHP est exclusivement utilisé en contexte Web, comme s'il était incapable de faire autre chose (sans oublier que le décorum HTML tout autour ne facilite pas la compréhension de l'exemple, en ajoutant un bon nombre de lignes parfaitement inutiles).
En conclusion de ce paragraphe, on dira que ce livre n'est absolument pas là pour apprendre un langage ou l'autre, ce n'est pas son but, il veut simplement apprendre les bases de la programmation orientée objet, en déclinant les concepts aux différents langages, en montrant leurs différences. Tous les concepts sont illustrés dans tous les langages, permettant ainsi de visualiser in situ les différences de pensée entre les concepteurs. Ces exemples, d'ailleurs, évoluent au fur et à mesure de la progression de la compréhension du lecteur : les premiers exemples sont fort didactiques, on finit dans les derniers chapitres à simuler les réactions chimiques ayant lieu dans un réacteur, on passe d'exemples simplistes à des exemples réalistes.
À un niveau plus général, on remarquera quelques fautes d'orthographe restées malgré les relectures, les schémas de mauvaise facture (réalisés probablement à l'aide d'un logiciel peu évolué tel que Paint), qui font vraiment tache à côté des schémas UML, ainsi que des captures d'écran sur des systèmes d'exploitation relativement préhistoriques (aux alentours de Windows Millenium).
Ce ne sont pas ces quelques défauts qui vont entacher le principal du livre. On appréciera notamment le large chapitre dédié à UML2, ainsi que les schémas UML utilisés bien avant leur formalisation pour aider à comprendre les principes. Des exercices terminent la grande majorité des chapitres, permettant au lecteur de vérifier qu'il a bien assimilé les concepts ; on regrettera de ne voir les solutions que sur le site de l'éditeur, pas dans une annexe au livre.
Il faut aussi remarquer que l'utilisation plus pratique de l'orienté objet est aussi couverte : ainsi, on parlera des méthodes pour la communication entre un client et un serveur à l'aide de RMI, de Corba et d'autres. Sera aussi discutée la sérialisation dans les divers langages, sans toutefois rentrer dans les détails, car ils deviennent plus spécifiques aux langages. On regrettera de ne pas voir ici la sérialisation selon boost pour le C++ ou la fonction serialize() de PHP : ces deux langages ne sont pas arriérés, ils permettent aussi la sérialisation, alors qu'aucune mention n'en est faite.
Des sujets plus pointus comme le multithreading sont aussi abordés : point noir de ce chapitre, C++ et PHP sont oubliés. Signaler qu'aucune méthode vraiment propre n'existe en PHP n'est pas un luxe, préciser l'existence d'une pléthore de possibilités en C++ est un minimum pour tout qui parle de multithreading et de C++ (il n'aurait pas été utile de développer le sujet, mais au moins d'indiquer dans quelle direction chercher si le besoin s'en fait sentir). Les autres langages jouissent d'une description des méthodes disponibles en standard pour obtenir une application multithreadée, en tenant compte de la problématique des accès concurrents.
En bref ? Un ouvrage plus qu'excellent, didactique, qui passe par tous les jalons, toutes les étapes, sans en oublier une, pour la programmation orientée objet. Que le lecteur soit débutant ou plus avancé, il trouvera dans ce livre de quoi apprendre ou se remettre à niveau. Par contre, prendre ce livre pour apprendre un langage n'est pas forcément la meilleure idée, ce n'est pas son objectif, les explications ne vont d'ailleurs pas en ce sens. Le style assez humoristique de l'auteur en fait un livre très facile à lire.
Vous avez lu ce livre ? Qu'en pensez-vous ?

Moins de 200 pages, mais pas le plus facile à lire ;-).
Le francophone Richard Basque s'attaque à un exercice peu évident: démystifier CMMI (Capability Maturity Model Integration) et CMM en général. Ses explications, ses retours d'expérience emprunts de modestie sont très enrichissants. On comprend mieux les enjeux de ce que l'auteur présente comme un "compendium de bonnes pratiques" pour le développement de systèmes basés sur le logiciel.

Un chapitre complet détaille la terminologie utilisée dans les spécifications des "normes" CMM (CMMI, SW-CMM) du SEI (Software Engineering Institute) et permet de mieux assimiler les chapitres suivants. CMM se basant en partie sur la représentation "étagée" d'une organisation en matière de développement logiciel et de maîtrise des processus, chaque "étage" ou "niveau" est défini et détaillé dans un chapitre (domaines de processus, objectifs, pratiques, produits de sortie typiques, sous-pratiques...).

Si votre organisation souhaite développer une approche orientée CMM, le chapitre 10 "Un cas concret" est fait pour vous, et pourrait pratiquement être lu en introduction (évaluation SCAMPI...).

Un ouvrage dans l'ensemble trés théorique et destiné aux décideurs, ingénieurs en qualité logicielle, et curieux des pratiques, méthodes et approches en matière de développement et d'intégration logicielle.

Les sites pour mieux comprendre CMMI :

• le site du SEI (Software Engineering Institute) ;
• CMMI et SW-CMM ;
• Alcyonix.
  

UML est un langage de modélisation décrit par une norme qui propose différents diagrammes. Le développeur qui souhaite utiliser UML doit connaître ces diagrammes pour les comprendre d'une part et les construire d'autre part. La première partie de ce livre (chapitres 1, 2 et 3) est une présentation théorique qui va à l'essentiel. De plus, bien conscients de l'importance de la pratique, les auteurs ont eût la bonne idée d'inclure des exercices corrigés.

UML n'étant pas une méthode, il n'y a pas de guide à suivre. La deuxième partie de ce livre (chapitres 4, 5 et 6) vise à combler cette lacune. Les auteurs décrivent leur démarche (UP7) basée sur UP (Unified Process) et tirée de leurs expériences. Cette partie est la plus intéressante car ils partagent 18 fiches guides qu'ils mettent en œuvre dans deux études de cas.

En conclusion, j'ai particulièrement aimé dans ce livre son côté pragmatique et son apport d'une démarche d'élaboration des diagrammes UML qui le distingue des autres ouvrages sur le sujet.

Après un enseignement du même type, j'ai souhaité lire cet ouvrage afin de pérenniser mes connaissances et de découvrir les nouveautés UML proposées. Comme le précise la 4ème de couverture, ce livre est destiné à un public large : du débutant aux professionnels qui souhaitent rester à la page.

L'auteur met à notre disposition 10 chapitres d'une introduction à UML en passant par les différents diagrammes à leurs mise en œuvre. Chaque chapitre est introduit très clairement à travers son sommaire détaillé et surtout des objectifs clairs. Des travaux dirigés complets (où vous pouvez même apprendre à faire une mousse au chocolat), avec corrections en fin d'ouvrage, permettent d'appliquer les connaissances acquises par chapitre. Nous pouvons y apprendre comment modéliser une même chose de manière différente via des significations implicites ou explicites d'UML. L'auteur nous démontre tout ce qu'il est possible de faire mais aussi ce qu'il ne faut pas faire. Nous apprenons à "lire et écrire l'UML".

Une plus value de cet ouvrage est la référence à la modélisation de bases de données relationelles via UML. Enfin nous avons l'explication afin de quitter MERISE et de tenter une approche via UML où nous est présenté une implémentation claire en SQL. Il en fait de même via une implémentation JAVA ou C++ ce qui peut être une barrière pour certains.

L'auteur ne cache pas les zones de flou de la norme UML, précise clairement les nouveautés d'UML2.2 ce qui est très pratique lorsque l'on a déjà pratiqué. Un vocabulaire précis et consciencieux est acquis au fil des chapitres.

Pour conclure, ce livre permet d'apprendre ou revoir pas à pas l'UML2 au travers d'une introduction orientée objet, tous les diagrammes y compris les nouveautés, le langage précis et beaucoup d'illustrations. Les références aux normes UML ainsi qu'à d'autres ouvrages permettent aux curieux d'aller plus loin.
Enfin, le chapitre intitulé mise en œuvre d'UML permet une vision plus large de l'application d'UML avec une ouverture élargie via des méthodes actuelles telles que SCRUM, XP, ...

D'entrée de jeu, les auteurs précisent ce qu'est UML (Un support de modélisation par objets de systèmes et de processus) et ce qu'il n'est pas. Si vous cherchez un guide de modélisation, cet ouvrage ne vous conviendra donc pas, pas plus d'ailleurs que d'autres livres sur UML. Cependant, celui-ci a l'avantage de présenter les liens qu'UML entretient avec RUP et MDA.

Dans ce livre, l'idée de présenter UML en utilisant des exemples du même domaine (le monde équin en l'occurrence) est une bonne idée. Il est donc dommage qu'au chapitre 6, un exemple avec des voitures arrive de manière impromptue. Le graphisme de ces exemples étant par ailleurs différent, on peut se demander si ce n'est pas un ajout de dernière minute ?

Si vous cherchez des exemples de code, vous ferez l'impasse sur celui-ci qui en est dépourvu. D'autant que si les exemples proposés modélisent de vrais systèmes (au sens large du terme), on a parfois du mal à voir l'application informatique sous-jacente !

Si, en revanche, UML vous intéresse en tant que langage graphique de modélisation, indépendant de l'implémentation (PIM de MDA), cet ouvrage atteint son objectif. Et chose appréciable, il fournit des exercices avec corrigés, un glossaire des termes et même un lexique français/anglais.

Le seconde livre propose quant à lui de nous entrainer à la modélisation. Cette fois ci, les exemples sont de tous domaines et plus proche des systèmes informatiques, ce qui en fait un bon complément. Et comme tous les ouvrages de la collection TP informatiques, il est également un bon support de cours (test des prérequis et estimation de durée).

En conclusion, si c'est juste pour une vue générale d'UML, le premier livre peut vous suffire mais ci c'est pour apprendre à modéliser, l'offre groupée est intéressante.

Ce livre n'a pas pour objectif de vous apprendre à faire un diagramme UML, de nombreux livres et sites Internet le font déjà et certains le font très bien. Ce livre va plutôt tenter de vous apprendre à faire un bon diagramme UML, exercice bien plus délicat et subtil, et que peu de ressources décrivent. Ne vous attendez donc pas à y trouver des explications détaillées sur toutes les subtilités de chaque diagramme, mais il vous aidera à trancher entre plusieurs solutions de représentation en vous décrivant les avantages et les inconvénients de chaque technique.

A l'inverse d'une démarche théorique, ce livre se veut très concret et se base sur de nombreux exercices corrigés. La correction ne consistant pas à vous fournir directement une réponse, mais à argumenter les choix faits tout en proposant un processus de réflexion.

La « carte de référence UML2 » en couverture est un petit plus intéressant qui permettra de se remémorer en un seul coup d’œil les principes de base des principaux diagrammes d'UML2.

À noter pour ceux possédant ou ayant lu la 5ème édition que les évolutions sont plutôt mineures pour cette dernière édition.

Ce livre est assez incroyable par la manière dont il aborde un sujet aussi délicat que la programmation orienté objet ! Le lecteur est plongé dans une histoire fascinante ou chaque début de chapitre commence par un petit dialogue mettant un avant le problème à résoudre par la suite ! Chaque sujet est aborde dans divers langages (dont chaque subtilités sont mises en avant) et on ne manquera pas de remarquer la précision de chaque exemples. Puis pour clôturer un chapitre le lecteur est amené à exécuter divers exercices pour assimiler le tout. Chaque lecteur y trouvera son bonheur puisqu'il s'adresse a tout ceux qui désirent découvrir ou approfondir la POO tant pour ceux qui connaissent un langage en particulier que ceux qui n'en connaissent aucun. On ne se lasse pas de parcourir les pages et malgré le volume de papier on sera très vite a la fin du livre qui mêle programmation mais aussi petits rappels culturels (lies à l'informatique évidement) qui ne manqueront pas de surprendre ceux qui n'ont pas connu les débuts de l'informatique. En conclusion un excellent livre, très complet pour aborder le sujet délicat de la POO.

Se rapporte à une édition précédente.

Ce livre est une étude complète du développement orienté objet, abordé de la manière la plus pratique possible. L'auteur prend littéralement le lecteur par la main à la manière d'un professeur particulier, pour nous expliquer de manière simple et progressive le monde orienté objet, en illustrant par des cas didactiques concrets.

Les premiers chapitres peuvent paraître simplistes, surtout si le lecteur a déjà une expérience en programmation orienté objet, mais ils insistent beaucoup sur les bases essentielles de l'OO (nom intime pour "orienté objet"). Un des aspects les plus pédagogiques du livre est la présence abondante de code source qui illustre parfaitement la matière, et ce à chaque fois dans 3 langages : Java, C# et C++. Ainsi, contrairement à trop d'ouvrages théoriques sur le sujet, celui-ci reste agréable à lire, instructif et surtout pratique grâce aux exemples de programmation. Ces exemples restent souvent fort "didactiques" au début, mais une fois que la matière se complexifie, les bouts de programme présentés deviennent plus "réels" en simulant des jeux ou des applications informatiques classiques. L'aspect analyse n'est pas oublié non plus avec un chapitre entier consacré à UML et la traduction concrète de ses diagrammes principaux en code Java, C# et C++. Une série d'exercices à la fin de chaque chapitre permet au lecteur de s'auto-évaluer; ce livre est donc parfait comme support de cours.

A la fin de l'ouvrage on aura passé en revue tous les aspects de la programmation orientée objet, des plus simples au plus complexes, en terminant par les graphes. Plusieurs chapitres traitent de sujets modernes et intéressants pour le développeur tels que la sauvegarde de données (le passage d'une classe à un fichier, ou une base de données), la réalisation d'applications distribuées via RMI, Corba, webservices... Sont aussi traités d'autres sujets d'actualité comme la programmation événementielle caractéristique des interfaces utilisateur modernes, et le multithreading.

Bref un excellent ouvrage qui satisfera aussi bien le débutant complet que le programmeur ayant déjà des notions objet et souhaitant les approfondir et voir leur mise en œuvre dans des applications concrètes. Un must pour tout développeur OO.

Lorsque que MDA (Model Driven Architecture) est apparu il y a quelques années, bon nombre de développeurs l'a considéré comme un acronyme dissimulant un niveau d'abstraction supplémentaire à la modélisation UML et apportant une complexité peu implémentable dans l'industrie logicielle. Mais voila, UML a évolué, les enjeux de la modélisation, les outils de conception en entreprise ont changé et l'approche MDA peut-être exploitée, même si la spécification reste floue sur une méthode claire et formelle d'utilisation.

Après la lecture du livre MDA en action, on comprend bien que, sans appliquer tous les concepts avec exactitude, on peut mettre en place une approche de pilotage des applications basée sur les modèles. Il en résulte une définition plus formelle de l'application, un processus de conception maitrisé et (c'est ce qui intéresse les décideurs), davantage de productivité.

Xavier Blanc est Maître de conférence à l'Université Pierre et Marie Curie. Il enseigne les techniques de modélisation, et représente également le LIP6 à l'OMG. Sa contribution est notamment mesurable au sein du projet "IST ModelWare", destiné à améliorer l'interopérabilité des outils de modélisation.

L'auteur présente tout d'abord l'architecture MDA et les concepts qui y sont inhérents (modèles CIM, PIM, PSM, MOF, UML, XML). Ce premier chapitre est essentiel à la compréhension des autres chapitres qui amènent plus de profondeur au sujet. Le chapitre 2 "Modèles et niveaux méta" aborde les points les plus abstraits et les fondements de MDA. On apprécie d'ailleurs, bien que l'effort de lecture soit important, une certaine concision et recherche de la justesse des définitions, illustrés par des exemples. Ce chapitre étudiera donc les notions de modèle, méta-modèle, métaméta-modèle. Cette représentation des modèles est ensuite enrichie au chapitre 3 avec l'étude des méta-modèles d'UML2.0 (UML2.0 Superstructure et UML2.0 Infrastructure, profils UML), qui conjuguent la modélisation de la notation UML et de MOF. OCL et AS sont ensuite présentés succinctement. J'aurais aimé un dossier plus complet sur le sujet, peut-être dans une version future du livre.

L'interopérabilité et la manipulation des modèles sont abordés aux chapitres 5 et 6, ou l'on étudiera le standard XMI et les frameworks JMI et EMF. Un exemple de transformation des modèles est donné à titre d'exemple ; même remarque, c'est concrètement l'un des éléments qui amène davantage de productivité à MDA en entreprise , et j'aurai apprécié une étude de cas professionnelle.

Bien entendu, l'un des grands intérêts de l'ouvrage est de consacrer 2 chapitres à MDA avec la plateforme J2EE et MDA avec la plate-forme PHP, illustrés d'exemples de mise en œuvre, d'utilisation des Profils UML pour EJB et des transformations de PIM en PSM. Une étude de cas, certes légère puisque il s'agit du célèbre "PetStore" clos l'ouvrage. Il s'agit donc d'un bon livre, relativement théorique, qui pourra interesser les architectes et concepteurs d'applications, les chefs de projets et décideurs en quête d'informations sur l'élaboration de processus de développements.

L'ouvrage est packagé avec un CD-ROM contenant les outils pour MDA IBM Rational Software Modeler et Softeam MDA Modeler.

Ayant quelques bases en programmation orientée objet et voulant me lancer dans un projet d'envergure moyenne, je me suis intéressé au langage UML.

N'ayant jamais été déçu par des livres O'Reilly, j'ai décidé de me procurer "Introduction à UML".

Et là le choc. Le livre n'est pas du tout comme je l'attendais. L'exemple mis en place au long des chapitres n'est pas vraiment ce que l'on peut qualifier de passionnant mais a le mérite de couvrir toutes les facettes d'UML. Le style d'écriture utilisé est très précis, très clair et formel mais donne au lecteur une envie de s'assoupir.

Néanmoins, le livre couvre tout ce qu'une introduction doit couvrir et va même un peu plus loin. Très dense et complet, il est à recommander à tout ceux qui accrocheront. Une impression mitigée donc, tant le ton est sérieux et austère.

UML est un langage devenu tellement important dans le monde informatique, qu'aucun professionnel impliqué dans des projets de développement ne puisse l'ignorer.

Malheureusement la plupart des ouvrages dédiés à ce langage ne répondaient pas à mes attentes.
Je cherchais un ouvrage simple expliquant les fondements du langage, donc un livre adressé aux néophytes tels que moi.

Grâce à "Introduction à UML", toute personne souhaitant appréhender les concepts de bases de ce langage trouvera enfin chaussure à son pied. L'auteur de cet ouvrage passe en revue les 9 principaux diagrammes en expliquant comment les utiliser. Il explique également la syntaxe générale utilisée à l'intérieur même de chaque diagramme.
Après la lecture de chaque chapitre, une partie sera réservée à la résolution d'exercices en rapport aux diagrammes précédemment étudiés, pour vous permettre de vous entraîner et d'améliorer vos connaissances.

Le seul regret que j'ai à avoir est l'absence d'un glossaire reprenant les différents termes abordés dans chaque chapitre pour permettre au personnes, n'ayant pas encore ces termes techniques bien ancrés dans la tête, de s'y retrouver plus facilement.

En conclusion, je recommande cet ouvrage qui est à mes yeux l'ouvrage de référence pour toute personne souhaitant se former à UML

À l'heure où l'univers des applications web est en plein essor, il est de plus en plus évident que le développement d'applications web robustes et pérennes passe par une phase de modélisation s'appuyant sur une méthodologie correcte. L'auteur nous guide, de chapitre en chapitre dans le processus de modélisation d'une application web en utilisant 6 des 13 diagrammes proposés par UML 2.0 qui sont utiles pour la modélisation d'une application web.

Ce livre est la réédition de l'ouvrage « UML, Modéliser un site e-commerce » (dont des critiques sont disponibles) dans lequel l'auteur à remis tout ces diagrammes à jour suivant les nouveautés d'UML 2.0.

A noter la présence d'une annexe reprenant les diagrammes UML 1.4 de la précédente édition (utile pour les lecteurs de la précédente édition qui désireraient comparer les 2 types de diagrammes).

Je conseille ce livre à tout développeur web, c'est très bien écrit, très pédagogique, et l'exemple pratique à été particulièrement bien choisi.

Quel que soit le niveau d'un développeur, il sera un jour ou l'autre amené à lire et peut-être réaliser une conception décrite en UML.

Une bonne compréhension et une bonne utilisation d'UML passent avant tout par une compréhension de l'esprit et la maitrise des finesses de cet outil.

Dan son ouvrage "UML 2 en concentré", Dan Pilone, un spécialiste reconnu dans le domaine, à l'origine de multiples livres sur le sujet, s'attache à détailler tout ce qu'il faut savoir d'UML, et en particulier les nouveautés introduites par la révision 2.0 d'UML.

Après avoir fait un bref rappel des notions fondamentales, il passe ne revue chacun des diagrammes de la norme en détaillant chacune des spécificités. Il s'attache particulièrement à donner des exemples concrets pour chaque nouveau trait (attribut par exemple). Ceci rend la compréhension incrémentale voire presque intuitive.

En fin d'ouvrage, Dan Pilone introduit un chapitre visant à prôner la bonne utilisation des diagrammes UML et notamment les "anti-utilisations". Enfin, il tente une ouverture rapide vers MDA, une méthodologie permettant de générer du code à partir de modèles. Toutefois celle-ci mérite à elle seule un livre entier.

Cet ouvrage est à recommander à tous les informaticiens ou chefs de projets voulant améliorer leur compréhension d'UML ou voulant se mettre à jour vers la révision 2.0. Il se veut être un modèle didactique et pédagogique en la matière.

Un très bon livre, qui explique clairement et simplement les principes de bases d'UML 2.0 Si vous ne connaissez pas UML, alors je vous le recommande afin d'acquérir de bonnes bases.

Bien sur, c'est une version "concentrée" donc tous les sujets ne sont pas forcément abordés dans les moindres détails. Cependant, ce livre est vraiment parfait pour débuter !

De plus, il permettra aux développeurs ayant déjà des connaissances en UML 2.0, de se rafraichir la mémoire et constitue donc un excellent mémento en la matière.

UML 2 en action est un très bon ouvrage sur l'utilisation "en vrai" d'UML. Comme son nom l'indique, il vous propose de découvrir, pas à pas, au travers d'une étude de cas, ce que UML peut apporter à vos développements.

Mais avant de se ruer sur l'achat de ce livre, il faut faire attention à deux choses. D'abord, contrairement à ce que l'on peut lire dans le résumé de l'éditeur, cet ouvrage n'est pas à destination des débutants. Un pré-requis inévitable est de connaître UML et sa notation avant de se lancer dans la lecture de ce livre. En effet, celui-ci ne donne aucune indication quant à cette notation.

Ensuite, il faut être conscient que vous ne serez probablement pas intéressé par l'entièreté de l'ouvrage. Tous les chapitres ne sont pas pour tout le monde, et chacun est à destination de deux ou trois catégories de lecteurs : analystes, architectes, concepteurs, etc.
Cependant, vous pourrez toujours avoir envie de tout lire, pour vous familiariser avec d'autres branches du métier de l'informatique, ou simplement parce que vous touchez déjà à tout :-)

En dehors de cela, cependant, on ne peut rien trouver à redire à ce livre. Il explique en détails et avec une simplicité déconcertante comment vous pouvez vraiment utiliser UML. Ressorti de ce livre, vous comprendrez les réels intérêts d'UML pour toute la première partie du cycle de développement : de l'analyse des besoins à la conception détaillée, comme le signale si bien le sous-titre de l'ouvrage.

C'est pourquoi je recommande fortement ce livre comme deuxième ouvrage sur UML ; après (ou avec) un premier qui vous apprendra la notation de ce langage.

Sébastien Doeraene

La différence avec les autres livres traitant d'UML ? Ici rien à voir avec un petit guide utilisateur en 13 leçons pour tout connaitre d'UML : les auteurs présentent une étude de cas grandeur nature, UML est intégré à une démarche globale, un processus itératif, 2TUP en l'occurrence, et voila toute la différence. Fini les concepts abstraits, vous avez la réflexion et la démarche, la modélisation et la conception, à chaque étape ses diagrammes, avec de multiples études de cas accompagnées de définitions, conseils et de « choses à ne pas faire ». Tout est détaillé pour vous permettre de mettre en œuvre ce langage dans vos propres projets, et est suffisamment clair pour ne pas vous perdre et vous éviter d'abandonner après le premier chapitre.

Quelque soit votre langage de prédilection, ne vous laissez pas arrêter par l'intitulé en J2EE: dans le cas qui nous intéresse, seuls les 2 derniers chapitres traitant de la conception sont avec les exemples écrits en Java. Avec UML2 en action, Vous avez en main le livre nécessaire pour appréhender UML dans un contexte pratique et professionnel et par chance il est en français. Tout étudiant, professionnel ou universitaire se doit de connaitre ce langage et pour ça le livre de Pascal Roques et Franck Vallée est le compagnon idéal.

À lire et a posséder absolument.

Ce livre va vous montrer comment utiliser UML 2 pour modéliser des objets. Vous allez apprendre comment décrire dans le langage UML la statique des objets, mais aussi leur dynamique, ainsi que la définition de fonction d'un programme Pour faire cela, le livre va vous faire découvrir les diagrammes de cas d'utilisation, de classes, de communication et de séquence.

Ce livre ne se veut pas exhaustif, c'est une introduction qui vous permettra de débuter avec UML. Et de ce coté-là, il remplit tout à fait son but. En plus, il vous proposera même des exercices pour mettre en application ce que vous avez appris à chaque chapitre. On peut tout de même lui reprocher le fait d'avoir voulu mettre trop de choses dans peu de pages, ce qui se traduit parfois par des informations trop résumées et donc compliquées à comprendre. Mais en général, le style est plutôt agréable et les informations intéressantes. De plus, chaque nouvelle connaissance qui est abordée est expliquée à l'aide d'exemples concrets.

En conclusion, ce livre vous permettra de découvrir UML et de le mettre en application pour vos projets. Il ne vous permettra pas par contre de connaître l'entier du langage UML. Pour cela, dirigez-vous vers un ouvrage plus conséquent.

Généralement, les livres sur la modélisation traite des modèles, et juste des modèles. Ou alors, dans le cas des patterns, on a une liste de recettes à appliquer pour des morceaux de son modèle. C'est là qu'intervient ce livre. La modélisation des applications orienté développeur n'était pas un sujet convert dans les ouvrages traditionnels, c'est fait maintenant.

L'approche proposée dans ce livre est de commencer par le code et de remonter l'arbre de la conception jusqu'à l'analyse des besoins, donc vraiment du point de vue d'un développeur. En fait, UML 2 pour les développeurs est une méthode de travail complète, exposée dans le dernier chapitre, pour qu'un développeur sache comment développer son application avec méthode.

Les diagrammes de classes, de séquence et de cas d'utilisation sont exposés, ce n'est donc pas tout UML 2, mais que la partie utile à un développeur. Ensuite, le code est orienté Java, mais en fait il suffit de connaître les limitations de son langage (ce qui est le cas d'un développeur normalement), et donc appliquer les lignes directrices à un autre langage est facile.

Les exercices de ce livre occupent une grande partie de l'ouvrage, ils font partie intégrante de la réflexion. Ils sont simples mais pertinents, et surtout indispensables.

Un livre très complet qui entraine ses lecteurs dans l'évolution de la conception des bases de données d'une manière progressive et intéressante car basée sur des exemples clairs, précis et adaptés au sujet en question. Après un historique toujours intéressant, l'auteur nous plonge directement dans le vif du sujet en comparant les diagrammes mis à disposition par UML et Merise. D'ailleurs, un chapitre entier, à la fin du livre, est consacré à un comparatif des meilleurs outils UML pouvant générer du code SQL.
L'approche des divers concepts (associations binaires, contraintes, agrégations, ...), d'abord théorique devient vite pratique. Cette manière de présenter la modélisation permet aux développeurs/concepteurs de bien cerner les différents problèmes rencontrés à tous les niveaux de la conception de leurs bases de données.
Chaque chapitre se termine par des exercices dont les corrigés sont disponibles via le site de l'éditeur.

Conclusion : Un livre qui touche un très grand public : développeurs, enseignants, concepteurs, ... et qui ne se limite pas à décrire UML 2 puisqu'il place le langage de conception UML face aux autres méthodes existant déjà. Les programmeurs habitués à utiliser Merise peuvent s'y référer s'ils désirent migrer vers UML.
Comme d'habitude, l'auteur nous livre un ouvrage très bien construit qui englobe beaucoup de références au niveau de la conception/modélisation mais aussi au niveau SQL.

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.

Ce livre nous explique tout ce qu'il faut savoir sur les cas d'utilisation. Il s'avère extrêmement simple à comprendre pour un débutant et nous fait passer par toutes les étapes de la créations des cas d'utilisation. L'auteur nous propose aussi quelques exercices dans le livre pour tester si les connaissances ont bien été acquises.

L'auteur commence par nous donner une vision globale de ce qu'est un cas d'utilisation et à quoi ils servent. Il continue ensuite en nous détaillant chaque partie d'un cas d'utilisation (portée, intervenants, niveaux...). Tout cela, toujours de manière très organisé et facile à suivre. On ajoute à chaque fois une couche de connaissance à nos propres cas d'utilisation. Il parcourt ainsi toutes les parties des cas d'utilisation. Pour en arriver ensuite aux différents formats des cas d'utilisation.

Ensuite dans las partie 2 du livre, on va parler de comment intégrer ces cas d'utilisation dans le processus global, de la gestion de nombreux cas d'utilisation en même temps. Et enfin, une liste très utile de choses à ne pas faire.

La partie 3 est consacrée à toute une série d'aide-mémoire qui reprennent les points importes de chaque chose inhérente aux cas d'utilisation.

La dernière partie nous montrer comment sont faits les cas d'utilisation en UML et nous donne les corrections de certains exercices et aussi à un glossaire très utile.

Tout au long du livre, nous avons droit à des exemples réels, à des histoires vraies et à des citations de personnes très impliquées dans les cas d'utilisation. Tout cela concrétise encore nos idées sur les cas d'utilisation. je conclurai en disant que ce livre est très bien pour toutes personnes ne sachant pas ce qu'est un cas d'utilisation ou croyant que c'est juste deux petits bonhommes et des flèches