En l'espace d'une poignée d'années seulement, UML est devenu un standard incontournable. Ce tutoriel est une introduction à la méthode de modélisation UML et se propose de vous apprendre à l'intégrer dans vos projets.

UML est l'Unified Modeling Language standardisé par l'OMG (Object Management Group). Ce n'est pas une méthode, il ne donne pas de solution pour la mise en ?uvre d'un projet. C'est avant tout un formalisme graphique issu de notations employées dans différentes méthodes objets. Ce tutoriel se charge de vous apprendre à utiliser ce langage de modélisation unifié.

Ce cours a pour objectif de vous apprendre la modélisation dans le cadre de Merise, un guide que l'auteur a voulu essentiellement pratique et qu'il a résolument placé sous le signe de la pédagogie de l'exemple.

Né de la fusion des méthodes objet dominantes (OMT, Booch et OOSE), puis normalisé par l'OMG en 1997, UML est rapidement devenu un standard incontournable. UML n'est pas à l'origine des concepts objet, mais il en donne une définition plus formelle et apporte la dimension méthodologique qui faisait défaut à l'approche objet. Ce tutoriel a donc pour objectif, d'une part, de montrer en quoi l'approche objet et UML constituent un « plus » et d'autre part, de vous apprendre à utiliser UML dans la pratique, c'est-à-dire vous apprendre à intégrer UML dans un processus de développement et à modéliser avec UML.

À travers ce tutoriel, nous allons apprendre la méthodologie MVVM pour Modèle-Vue-VueModèle. La méthodologie MVVM permet de formaliser le développement avec WPF en garantissant des applications bien architecturées, testables et optimisant le flux de travail entre développeur et designer.

Ce cours est une introduction au développement en couches. Attention, tout ne sera pas couvert dans ce cours, mais cela vous donnera un bon aperçu de ce qu'il faut faire pour bien développer en couche !

Ce tutoriel va vous apprendre la démarche d'écriture des documents de spécifications en s'appuyant sur la notation UML. Il part de la réponse au cahier des charges jusqu'à la rédaction du dossier de conception. Ce cours ne prétend pas être une analyse ou un document méthodologique, simplement un exemple essayant de donner la réponse à une question que nous rencontrons souvent lors des formations « Quand dois-je utiliser tel ou tel schéma ? »

Ce cours a pour objectif de vous apprendre à utiliser la méthode Merise, méthode d'informatisation universelle. Toute méthode informatique doit répondre à quatre objectifs principaux : définir ce que l'utilisateur final veut informatiser (quitte à lui faire comprendre ce qu'il veut), et sa faisabilité ; vérifier la cohérence de sa demande ; structurer les données à informatiser. Cela est primordial en informatique de gestion ; rester simple. Ce point est largement battu en brèche quand une méthode est appliquée « pour la méthode ». Elle doit rester un outil d'aide à la conception ou à la réalisation.

Ce cours regroupe quelques notions pour vous apprendre la modélisation conceptuelle de système d'information par schéma entités-association (via l'étude des dépendances fonctionnelles), la traduction en schéma relationnel et la démarche inverse (rétroconception). Il présente également les extensions majeures du modèle conceptuel (agrégation, identifiant relatif et héritage).

L'analyse des données constitue le point de passage obligé de toute conception d'applications mettant en ?uvre un SGBDR (système de gestion de base de données relationnelle). La méthode MERISE, basée sur le modèle entité-association, est un outil simple et efficace, très répandu chez les développeurs français. Dans ce cours, nous allons apprendre les bases et principes fondamentaux de MERISE à l'aide d'exemples et de cas concrets.

Ce cours se charge de vous apprendre le langage UML qui s'impose à l'heure actuelle comme le standard de modélisation des applications informatiques. Le modèle des classes est utilisé pour la structure statique des données et les cas d'application sont utilisés pour l'expression des besoins des utilisateurs. C'est un tutoriel qui présente le modèle relationnel qui est le fondement des systèmes de gestion des bases de données.

Ce cours est une introduction aux services Web de type REST. Il présente les grands concepts de l'architecture REST à savoir les ressources, les verbes et les représentations. Dans ce tutoriel, vous allez apprendre le style d'architecture REST.

Ce support de cours a pour objectif de vous apprendre à utiliser JAX-WS (JSR-224), une API pour développer des Web Services étendus (WSDL + SOAP) via la plateforme de développement Java.

L'injection de dépendances est une technique très intéressante pour augmenter le degré d'indépendance des différents éléments manipulés durant un développement. Ce cours a pour objectif de vous apprendre à faire de l'injection de dépendances et nous allons aborder quelques frameworks permettant de le faciliter.

Ce tutoriel représente une compilation du savoir-faire et de l'expertise de Valtech dans le domaine de l'urbanisation et de l'intégration de systèmes. Il s'intéresse aussi bien aux nouvelles perspectives offertes par la vision SOA qu'aux retours d'expériences de Valtech dans ce domaine et plus généralement dans l'urbanisation et l'intégration de systèmes.

Les ESB visent, d'une part à assurer l'interconnexion et d'autre part à gérer la médiation des communications et des interactions entre services et applications d'un SI. L'objectif de ce cours est de présenter les fonctionnalités que l'on peut attendre d'un ESB et comment il peut répondre aux besoins d'adaptation interapplications d'une SOA. C'est un cours qui a pour objectif de vous apprendre à utiliser un ESB dans une SOA.

Ce tutoriel se charge de vous apprendre les bases du développement d'une application modulaire. C'est un cours qui présente également un exemple complet d'implémentation en Java.

Lors de la conception d'une application, de nombreux problèmes peuvent survenir. Le système des Design Patterns, ou motifs de conception, représente un système objet destiné à la résolution de problèmes techniques. Ce tutoriel se charge de vous apprendre à utiliser le Design pattern.

Ce cours a pour objectif de vous apprendre à utiliser les Design Patterns du « Gang of Four » avec des exemples concis appliqués à Java. Chaque Design Pattern est présenté avec son diagramme de classes, ses objectifs, les motivations pour l'utiliser, les responsabilités des classes le constituant, puis une implémentation simple.

MVC est un design pattern très puissant, mais néanmoins assez complexe, qui permet de bien structurer de grosses applications graphiques. Nous allons apprendre à le maîtriser avec ce tutoriel.

Ce tutoriel a pour but de vous présenter la majorité des design patterns via un exemple de besoin qui sera complété par une mise en pratique en C++.

Le pattern Registry est un pattern méconnu, mais largement utilisé dans de nombreux cas. Il est utilisé pour gérer les paramètres d'un programme. Ce cours a pour objectif de vous apprendre à utiliser le pattern Registry.

Le pattern Object Pool est un pattern permettant de stocker une quantité finie d'instances d'une classe afin de les distribuer à qui en a besoin et qui sont rendues en fin d'utilisation. Souvent, on les utilise pour gérer des threads, des connexions distantes. Ce cours se charge de vous apprendre à utiliser le pattern Object Pool à travers une présentation de l'architecture et un exemple sommaire d'implémentation en C++.

Ce cours a pour objectif de vous apprendre à créer des programmes souples et puissants au moyen de modules (des éléments interchangeables, réutilisables et combinables entre eux). C'est un tutoriel qui présente de nombreux patterns importants ainsi que la manière de les utiliser et de les combiner entre eux.

Le Pattern Etat, lorsque bien utilisé, permet de concevoir des applications de qualité (faciles à comprendre, à déboguer, à maintenir, à faire évoluer) sans augmentation notable des charges de travail (temps de maintenance diminués, plus grande évolutivité). À travers ce tutoriel, nous allons apprendre à utiliser le Pattern Etat.

Ce cours a pour objectif de vous apprendre à utiliser l'inversion du contrôle, un pattern essentiel pour développer une application robuste, durable et maintenable.

Le design pattern Etat permet de modifier le comportement d'un objet lorsque son état est modifié. Tout est mis en place pour donner l'impression que l'objet lui-même a été modifié. Dans ce tutoriel, nous allons apprendre à l'utiliser avec des exemples en Java.

Que sont les GRASP (General Responsability Assignement Software Patterns), ou patterns généraux d'affectation des responsabilités ? Il s'agit de patterns fondamentaux qu'il est nécessaire d'appliquer pour une bonne conception. À travers ce cours, nous allons apprendre à utiliser les GRASP.

Le composite est un modèle de structure arborescente d'un ensemble de composants cohérents. Il permet à la classe cliente de composer, et utiliser d'une manière cohérente (unique) une hiérarchie complexe d'objets. À travers ce cours, nous allons apprendre à utiliser le composite avec des exemples en Java.

La façade permet en effet de limiter les points d'entrée d'une API, ce qui a comme effet bénéfique pour votre ensemble de classes, s'il est complexe, d'avoir une chance d'être utilisé. Ce tutoriel a pour objectif de vous apprendre à utiliser la façade.

Ajout dynamique de responsabilités à un objet. L'ajout de responsabilités à un objet sonne évidemment comme un héritage. C'est en effet, le moyen le plus évident de lui fournir des responsabilités supplémentaires. Le manque de souplesse de cette méthode (l'héritage) est bien entendu, son inconvénient majeur. Ce tutoriel a pour objectif de vous apprendre à utiliser le design pattern décorateur.

Construire son application, construire l'architecture de base applicative est l'un des premiers rôles de votre programme : un point d'entrée (fonction mail en C, méthode static main en C++ et en java, etc.) qui va construire l'application, pourtant l'architecture peut être différente d'un appel à l'autre. À travers ce cours, nous allons apprendre à construire la quasi même arborescence, mais avec des implémentations différentes avec le kit.

Ce tutoriel a pour objectif de vous apprendre à utiliser le design pattern « adaptateur ». Pour des raisons de conformité à une norme, pour ne pas dépendre d'une implémentation, pour permettre l'évolutivité de votre projet, il arrive que vous ayez besoin de vous reposer sur une interface ou une API qui n'est pas précisément celle qui vous est fournie. Ce design pattern vous propose de pallier cette problématique.

Ce tutoriel a pour objectif de vous apprendre à utiliser le design pattern Singleton pour créer une classe dont on veut s'assurer qu'il n'existera qu'une et une seule instance dans l'espace et dans le temps d'un bout à l'autre du cycle de vie de l'application.

Le design pattern monteur dissocie le processus de construction d'un objet complexe de la structure de représentation de cet objet. Ce tutoriel a pour but de vous apprendre à utiliser le monteur.

Utiliser un système de stockage de données, tel qu'une base de données, avec Java (ou tout autre langage orienté objet) peut s'avérer plus compliqué qu'il n'y parait. Ceci parce qu'on se retrouve vite avec des objets encombrés de requêtes SQL (ou autres instructions) qui rendent leur utilisation assez lourde, leur modification problématique et leur maintenabilité dans le temps quasiment impossibles ! Ce tutoriel va vous apprendre un modèle de conception (design pattern) permettant d'éviter ou d'atténuer ce genre de contraintes afin de rendre votre programme plus souple.

Ce cours fait partie d'une suite de tutoriels pour vous apprendre à implémenter les 23 modèles de conception les plus connus. Dans ce cours, nous allons apprendre le fonctionnement des design patterns liés à la construction d'objets, les deux autres familles feront le sujet d'un autre tutoriel.

Dans le cadre du développement d'interfaces graphiques, le terme MVC est sans doute le plus couramment employé quand il s'agit de définir l'architecture utilisée. Pourtant, peu d'architectures utilisent encore aujourd'hui le design pattern MVC tel qu'il a été originellement décrit. Dans ce tutoriel, nous allons apprendre à utiliser les différents modèles qu'on appelle communément MVC, et voir en quoi l'utilisation du terme contrôleur est incorrecte et apporte une confusion dans la compréhension de ces modèles.

Un design pattern décrit une solution standard, utilisable dans la conception de logiciels, à des questions classiques et récurrentes. Ce tutoriel va vous apprendre les points clés pour utiliser les patterns les plus utiles.

Ce tutoriel se charge de vous apprendre à utiliser le Circuit breaker, qui est un patron de conception (design pattern) pour fiabiliser vos systèmes distribués (ou microservices).

Ce tutoriel a pour objectif de vous apprendre à utiliser les itérateurs apparus avec C# 2.0, ainsi que l'utilisation du mot clé yield.

À travers ce tutoriel, nous allons apprendre à suivre nos objets. Le modèle KVO forme avec KVC l'un des principaux socles de l'environnement de développement Cocoa. Si KVC se rapproche très largement des règles de codage définies en Java pour les Java Beans, on peut considérer que le modèle KVO est le pendant du modèle d'événements en Java. La similitude s'arrête là, car le modèle KVO est bien plus simple.

L'aspect fortement dynamique des types dans Cocoa est enrichi par un modèle de conception très simple pour permettre un accès générique aux propriétés des objets que l'on manipule. Ce modèle définit une propriété comme un couple formé d'une clef, le nom de la propriété, et de sa valeur. Ce cours a pour objectif de vous apprendre à utiliser ce modèle.

Cocoa s'appuie sur le langage Objective-C qui, contrairement au C++, ne propose pas un modèle de classe avec héritage multiple. L'héritage simple est la règle, comme dans le monde Java. Si le langage propose des solutions techniques pour contourner les limites de l'héritage en introduisant l'idée de protocoles (interfaces en Java), le socle Cocoa s'appuie sur une solution conceptuelle : la délégation. Ce cours se charge de vous apprendre le principe de la délégation dans Cocoa et sa mise en pratique.

Le modèle orienté objet de PHP 5 vous donne la capacité d'implémenter des motifs de conception pour améliorer la conception de votre code. Lorsque vous améliorez la conception de votre code de cette manière, il devient plus lisible, plus aisément maintenable et plus robuste au moment d'absorber les modifications. Ce cours se charge de vous apprendre à implémenter cinq motifs supplémentaires de conception pour PHP.

Ce tutoriel propose cinq motifs de conception (Design Pattern) implémentés en PHP : Fabrique, Singleton, Observer, Chain-of-command, Stratégie, Strategie. C'est un cours qui se charge de vous apprendre à utiliser ces motifs dans des applications PHP.

Par l'utilisation du pattern MVP vous allez apprendre à créer une application pouvant utiliser différentes interfaces graphiques (Windows, Console, Web…) en minimisant au maximum la redondance de code.

Au travers de ce cours nous allons apprendre à utiliser le design pattern Adaptateur. Nous verrons la problématique qu'il permet de résoudre ainsi que son implémentation en C#.

Parmi les design patterns que l'on trouve en programmation, il en est un que l'on oublie un peu trop à mon avis : c'est la notion de façade. Ce tutoriel a pour objectif de vous apprendre à utiliser une façade pour accéder au modèle.

Le front contrôleur est un élément central dans le modèle MVC. C'est lui le grand chef d'orchestre. Son rôle est de distribuer le travail. Ce tutoriel a pour objectif de vous présenter le front contrôleur (modèle MVC) du Zend Framework et de vous apprendre à l'utiliser.

Les design patterns sont nombreux et plus ou moins connus, au cours de ce tutoriel je vais vous présenter le plus connu et populaire, il s'agît du Singleton. Ce pattern a pour but de contrôler et de limiter à une ou quelques-unes le nombre d'instances existantes pour une classe donnée. Ce cours se charge de vous apprendre une manière d'implémenter simplement le design pattern Singleton avec VB.Net et en C#.

Le Design Pattern Observer est un simple modèle qui permet à un objet d'envoyer des événements et des informations vers d'autres objets. Les objets Observer vont donc exécuter certaines actions en fonction des indications envoyées par l'objet Observable. Ce cours a pour objectif de vous apprendre à utiliser les motifs de conception MVC et Observer avec le framework VEGAS.

Ce tutoriel se charge de vous apprendre à utiliser le Design Pattern Visitor avec le framework VEGAS. Le Design Pattern Visitor permet simplement d'ajouter sur une classe ou instance des fonctionnalités non prévues au départ sans surcharger la structure de base de l'objet et en gardant si possible une certaine flexibilité et souplesse pour ajouter ou enlever rapidement d'autres fonctionnalités sans alourdir à nouveau l'implémentation définie au départ.

MVC est un design pattern très puissant, mais néanmoins assez complexe, qui permet de bien structurer de grosses applications graphiques. Nous allons apprendre à le maîtriser avec ce tutoriel.

Ce tutoriel a pour but de vous présenter la majorité des design patterns via un exemple de besoin qui sera complété par une mise en pratique en C++.

Le pattern Registry est un pattern méconnu, mais largement utilisé dans de nombreux cas. Il est utilisé pour gérer les paramètres d'un programme. Ce cours a pour objectif de vous apprendre à utiliser le pattern Registry.

Le pattern Object Pool est un pattern permettant de stocker une quantité finie d'instances d'une classe afin de les distribuer à qui en a besoin et qui sont rendues en fin d'utilisation. Souvent, on les utilise pour gérer des threads, des connexions distantes. Ce cours se charge de vous apprendre à utiliser le pattern Object Pool à travers une présentation de l'architecture et un exemple sommaire d'implémentation en C++.

Ce cours a pour objectif de vous apprendre les avantages de la composition par rapport à un usage souvent trop systématique de l'héritage dans la conception d'API.

Ce tutoriel a pour objectif de vous apprendre la mise en ?uvre de Design Patterns avec Delphi et C#. C'est un cours pour vous apprendre en quoi les design patterns représentent un outil extraordinaire et comment les appliquer au développement avec Delphi ou C#.

Ce cours va vous apprendre les possibilités de configuration des architectures web à trois couches, apportées par le framework Spring (Java) et sa notion d'IoC (Inversion of Control), également appelée injection de dépendance (Dependency Injection).

Dans ce cours, nous allons apprendre à utiliser certains patterns, indispensables au développeur J2EE. Pour nous aider dans cette tâche, supposons que nous essayions de construire un forum, comme celui de www.developpez.com. Ce tutoriel repose sur les concepts relatifs à la norme J2EE 1.4 et aux EJB 2.1.

Dans ce tutoriel, nous allons apprendre à utiliser le pattern Singleton en environnement multithread. Le design pattern singleton fait partie des plus utilisés en programmation. Il permet de s'assurer qu'il n'y a qu'une seule instance d'une classe dans un environnement d'exécution et pour une durée d'exécution.

Ce cours va vous présenter les principaux Design Patterns appliqués à Java. Les Design Patterns représentent un espace très riche de composition ou de simplification de votre développement objet.

Le design pattern Etat permet de modifier le comportement d'un objet lorsque son état est modifié. Tout est mis en place pour donner l'impression que l'objet lui-même a été modifié. Dans ce tutoriel, nous allons apprendre à l'utiliser avec des exemples en Java.

Le composite est un modèle de structure arborescente d'un ensemble de composants cohérents. Il permet à la classe cliente de composer, et utiliser d'une manière cohérente (unique) une hiérarchie complexe d'objets. À travers ce cours, nous allons apprendre à utiliser le composite avec des exemples en Java.

Construire son application, construire l'architecture de base applicative est l'un des premiers rôles de votre programme : un point d'entrée (fonction mail en C, méthode static main en C++ et en java, etc.) qui va construire l'application, pourtant l'architecture peut être différente d'un appel à l'autre. À travers ce cours, nous allons apprendre à construire la quasi même arborescence, mais avec des implémentations différentes avec le kit.

Ce tutoriel a pour objectif de vous apprendre à utiliser le design pattern Singleton pour créer une classe dont on veut s'assurer qu'il n'existera qu'une et une seule instance dans l'espace et dans le temps d'un bout à l'autre du cycle de vie de l'application.

Ce tutoriel a pour objectif de vous apprendre à utiliser le design pattern « adaptateur ». Pour des raisons de conformité à une norme, pour ne pas dépendre d'une implémentation, pour permettre l'évolutivité de votre projet, il arrive que vous ayez besoin de vous reposer sur une interface ou une API qui n'est pas précisément celle qui vous est fournie. Ce design pattern vous propose de pallier cette problématique.

Dans ce tutoriel, nous allons apprendre les principaux patterns livrés avec ModelMaker de Delphi 7 : Mediator, Wrapper, Visitor, Decorator, Observer, Autres patterns.

Ce tutoriel a pour but de vous apprendre une adaptation possible du design pattern MVC pour une application développée en JAVA Micro Edition.

Ce tutoriel traite du développement de winforms .NET en mode MVC. À travers ce cours, vous allez apprendre à construire des applications .NET Winform avec l'architecture MVC.

Dans l'API Java, on trouve une classe au comportement tout à fait particulier, ThreadLocal. Son principe : stocker des données dans le thread courant afin de les récupérer plus tard, dans une autre méthode par exemple, sans avoir à les passer en argument à toute la chaine d'appel. Ce cours se charge de vous apprendre à utiliser cette classe.

Ce cours a pour objectif de vous apprendre les différents types d'héritage multiple que l'on trouve généralement dans les langages de programmation orientés objet à base de classes. Plus précisément, ce cours va comparer l'héritage multiple à une version bridée, nommée héritage multiple d'interfaces, que l'on trouve dans certains langages ; ceci afin de montrer en quoi les limitations introduites par cette dernière me semblent problématiques pour mettre en place une bonne architecture de code. Ce tutoriel n'est pas une introduction à l'héritage (qu'il soit simple ou multiple). Il n'entrera pas non plus dans les détails et les difficultés d'implémentation de l'héritage multiple, mais se concentrera sur le point de vue de l'utilisateur du langage.

Le pattern state, ou patron état, est l'un des patterns les plus utilisés. Dans sa définition initiale, il est très simple, mais comme beaucoup de design pattern, son implémentation concrète peut varier beaucoup selon le contexte. Ce tutoriel a pour objectif de vous apprendre plusieurs implémentations possibles de ce pattern.

Le design pattern strategy définit un objet représentant un algorithme dédié à une tâche spécifique. À travers ce cours, nous allons apprendre à utiliser le design pattern strategy.

Ce cours a pour objectif de vous apprendre à utiliser les Design Patterns du « Gang of Four » avec des exemples concis appliqués à Java. Chaque Design Pattern est présenté avec son diagramme de classes, ses objectifs, les motivations pour l'utiliser, les responsabilités des classes le constituant, puis une implémentation simple.

Ajout dynamique de responsabilités à un objet. L'ajout de responsabilités à un objet sonne évidemment comme un héritage. C'est en effet, le moyen le plus évident de lui fournir des responsabilités supplémentaires. Le manque de souplesse de cette méthode (l'héritage) est bien entendu, son inconvénient majeur. Ce tutoriel a pour objectif de vous apprendre à utiliser le design pattern décorateur.