Dans le monde de la conception et du développement d'applications, il est crucial de structurer de manière efficace le processus de création pour assurer un développement fluide et une maintenance simplifiée.
Parmi les différentes approches disponibles, la méthode des briques se distingue par sa facilité d'application et sa capacité à rendre les interactions entre les différentes fonctionnalités plus compréhensibles.
Comprendre la méthode des briques
L'importance de la méthode des briques
Application concrète de la méthode des briques
Décomposition de l'API en briques principales
La visualisation de l'API AG-1
Démonstration : Création d'un réseau social avec la méthode à Brique
Brique "Publication de messages"
Gérer le flux de données pour un contrôle total de l'application
La méthode des briques repose sur une approche modulaire de la conception d'applications.
Elle consiste à décomposer l'application en différentes fonctionnalités ou "briques", chaque brique représentant un élément distinct de l'application.
Ces briques peuvent ensuite être connectées entre elles pour visualiser le flux de données et d'informations au sein de l'application, ce qui facilite la conception et la communication au sein de l'équipe de développement.
Le schéma de template est une représentation générale d'une structure modulaire de traitement des données.
Dans ce schéma, chaque brique est une unité fonctionnelle qui reçoit une entrée, effectue une action et produit une sortie.
Dans chaque brique, on peut distinguer les sections suivantes :
Entrée : C'est la donnée qui est introduite dans la brique pour être traitée. L'entrée peut provenir de sources externes ou d'une autre brique précédente dans le flux de traitement des données.
Nom : Le nom de la brique décrit généralement la fonction principale ou l'objectif de cette brique. Il sert à identifier la brique et à comprendre rapidement son rôle dans le flux global de traitement des données.
Action : Il s'agit de la tâche ou des opérations effectuées par la brique sur l'entrée qu'elle a reçue. Cette action peut être une transformation, une validation, un calcul ou toute autre opération pertinente.
Sortie : C'est le résultat ou le produit de l'action effectuée par la brique. La sortie peut être utilisée comme entrée pour la brique suivante, être stockée pour une utilisation ultérieure ou être présentée à l'utilisateur final.
Les flèches dans le schéma indiquent le flux de données d'une brique à l'autre.
Les sorties d'une brique deviennent les entrées de la brique suivante, ce qui permet de créer un flux de données fluide et continu.
Ce modèle permet une modularité et une flexibilité accrues dans la conception des systèmes. Il facilite également la compréhension et la maintenance du système, car chaque brique peut être étudiée et modifiée indépendamment des autres.
Comment appliquer la méthode des briques
Il n'y a pas de règle stricte pour utiliser un système de briques, mais voici une méthode qui peut être utilisée :
L'approche par briques offre plusieurs avantages clés :
Illustration de la méthode des briques
Pour mieux comprendre comment la méthode des briques peut être appliquée, prenons l'exemple de la conception de l'API AG-1.
La méthode des briques a été utilisée pour décomposer l'API en plusieurs briques principales, chacune représentant une fonctionnalité majeure de l'application.
Par exemple, des briques ont été créées pour la gestion des mouvements, l'exploration et la capture de ressources, et l'attaque et la défense.
Ces briques ont ensuite été décomposées en sous-briques pour représenter des fonctionnalités spécifiques.
Pour mieux illustrer l'application de la méthode des briques, examinons plus en détail la conception de l'API AG-1.
La première étape de la conception a consisté à décomposer l'API en plusieurs briques principales, chacune représentant une fonctionnalité majeure du jeu.
Par exemple :
Détail des briques et sous-briques
Chaque brique a ensuite été décomposée en sous-briques représentant des fonctionnalités spécifiques.
Par exemple, la brique "Programme" a été décomposée en sous-briques "Création de Programme", "Chargement de Programme", "Mise à jour de Programme" et "Suppression de Programme".
Chaque sous-brique a été connectée aux autres briques et sous-briques avec lesquelles elle interagit, permettant de visualiser clairement le flux de données et d'informations au sein de l'API.
Mise à jour et évolution des briques
Au fur et à mesure du développement de l'API, certaines briques et sous-briques ont dû être modifiées, ajoutées ou supprimées pour répondre à l'évolution des besoins du jeu.
La méthode des briques a facilité ces évolutions en rendant visible l'impact potentiel de chaque changement sur le reste de l'API.
Cette approche a permis de développer une API robuste et flexible, capable de gérer une variété de scénarios de jeu tout en restant facile à comprendre et à maintenir pour l'équipe de développement.
C'est un exemple concret de la valeur de la méthode des briques pour la conception et le développement d'applications.
Grâce à cette visualisation, j'ai pu facilement identifier où des améliorations pourraient être apportées.
Par exemple, je pouvais rapidement voir si une brique était trop complexe et devait être divisée en briques plus petites, ou si deux briques pouvaient être fusionnées pour simplifier le flux de données.
Les avantages pratiques de la méthode des briques
En utilisant la méthode des briques pour développer l'API AG-1, j'ai pu maintenir une vue d'ensemble claire du projet tout au long de son développement.
Non seulement cela a rendu le processus de développement plus efficace, mais cela a également facilité ma compréhension de l'ensemble de la structure de l'API.
De plus, il a été beaucoup plus facile d'expliquer la structure de l'API à d'autres parties prenantes, comme les utilisateurs finaux et d'autres développeurs intéressés.
La Brique Data : Un élément central de la conception
Au cœur de la méthode à Brique se trouve la Brique Data.
Conçue pour être l'équivalent d'une table de base de données ou de la structure de plusieurs tables, la Brique Data représente les données manipulées, traitées et échangées entre les différentes Briques du système.
De plus, la Brique Data sert aussi de représentation des entrées et des sorties de chaque Brique.
Chaque Brique reçoit des données en entrée, effectue un certain traitement sur ces données, et produit des données en sortie. Ces entrées et sorties sont toutes représentées sous forme de Brique Data.
Dans cette perspective, la Brique Data sert également d'interface d'échange entre les Briques, permettant le passage de données d'une Brique à l'autre, tout comme les arguments sont passés entre les fonctions dans un programme.
C'est un élément essentiel qui favorise la modularité et l'interchangeabilité des composants du système.
Dans le cas de la G1, par exemple, la Brique Data est matérialisée sous forme de JSON, qui est stocké côté utilisateur.
C'est une approche différente, qui montre la flexibilité de la méthode à Brique et sa capacité à s'adapter à différentes architectures de données.
Github du client-ag3
Prenons l'exemple de la création d'un réseau social simple.
Cette application offrirait les fonctionnalités suivantes : création de compte utilisateur, gestion de profil, publication de messages sur son profil, système d'amis avec possibilité d'envoyer, recevoir, accepter ou refuser des demandes d'amis, et enfin, visibilité du profil limitée aux utilisateurs qui sont amis.
Pour ce faire, nous allons utiliser la méthode à Brique pour décomposer le système en composants modulaires et interchangeables.
Cette brique est responsable de la création d'un nouveau compte utilisateur.
Elle prend en entrée une Brique Data contenant les informations fournies par l'utilisateur (nom, email, mot de passe, etc.) et renvoie une Brique Data contenant les informations du compte nouvellement créé.
Cette Brique Data peut correspondre à une entrée dans une table de base de données "Utilisateurs".
Cette brique permet à un utilisateur de gérer son profil.
Elle prend en entrée une Brique Data contenant les informations de l'utilisateur et les modifications souhaitées, et renvoie une Brique Data mise à jour.
Cette Brique Data correspond à une entrée dans la table "Utilisateurs".
La brique "Publication de messages" permet à un utilisateur de publier des messages sur son profil.
Elle prend en entrée une Brique Data contenant le message à publier et l'identifiant de l'utilisateur, et renvoie une Brique Data indiquant le résultat de l'action.
Cette Brique Data correspond à une entrée dans une table "Messages".
Cette brique gère l'ensemble des fonctionnalités relatives aux amis : envoi, réception, acceptation et refus de demandes d'amis.
Elle prend en entrée une Brique Data contenant l'identifiant de l'utilisateur et l'action à effectuer (envoyer une demande, accepter une demande, etc.), et renvoie une Brique Data indiquant le résultat de l'action.
Cette Brique Data correspond à une entrée dans une table "Amis".
Cette brique contrôle qui peut voir le profil d'un utilisateur.
Elle prend en entrée une Brique Data contenant l'identifiant de l'utilisateur et l'identifiant de l'utilisateur qui tente de voir le profil, et renvoie une Brique Data indiquant si l'accès est autorisé ou non.
Cette Brique Data pourrait correspondre à une entrée dans une table "Permissions".
En utilisant la méthode à Brique, nous pouvons décomposer notre application en briques gérables, chacune avec ses propres entrées (Brique Data) et sorties (Brique Data).
Cela rend le système plus facile à comprendre, à développer et à maintenir, tout en favorisant la modularité et l'interchangeabilité des composants.
Le flux de données est un aspect crucial de la méthodologie à brique, car il permet de gérer et de contrôler toutes les données qui circulent au sein de l'application.
En effet, en découpant l'application en différentes briques, il est possible de mieux appréhender la manière dont les données sont échangées entre ces dernières.
Cela permet notamment de mieux gérer les erreurs et les exceptions, et de faciliter le débogage et la maintenance de l'application.
En effet, en connaissant précisément le flux de données, il est plus facile de localiser et de résoudre les problèmes.
Un exemple pratique de gestion du flux de données dans la méthodologie à brique est l'échange de données avec une API.
En utilisant une API, il est possible d'échanger des données avec une autre application, ce qui nécessite une bonne gestion du flux de données pour assurer un échange efficace et sécurisé.
De plus, en mettant en place un système de logs pour chaque brique, il est possible d'analyser et de contrôler précisément le flux de données et d'identifier les éventuels problèmes.
Cela permet également de mieux comprendre le fonctionnement de l'application dans son ensemble et de faciliter les évolutions futures.
En somme, la gestion du flux de données est un aspect crucial de la méthodologie à brique, qui permet d'avoir un contrôle total sur l'application et de faciliter sa maintenance et son évolution.
En connaissant précisément le flux de données, il est possible d'anticiper les problèmes et de mieux gérer les échanges de données avec les différentes briques de l'application.
La méthodologie à brique est une approche de développement de logiciels qui consiste à découper une application en plusieurs briques, chacune représentant une fonctionnalité spécifique.
Chaque brique peut être pensée comme un bloc de construction, qui peut être connecté à d'autres briques pour former une application complète.
Cette approche permet de structurer l'application de manière modulaire, ce qui facilite la maintenance et l'ajout de nouvelles fonctionnalités.
Le schéma ci-dessous illustre comment cette méthodologie peut être appliquée à la création d'un compte utilisateur.
Dans la première brique, les données d'entrée nécessaires à la création d'un compte utilisateur sont collectées, telles que l'adresse e-mail et le mot de passe.
Ces données sont ensuite validées dans la même brique pour s'assurer qu'elles sont correctes et conformes aux exigences.
Cette validation constitue l'action principale de la première brique.
Ensuite, sans nécessiter de nouvelles entrées, les données validées sont transmises directement à la deuxième brique.
Cette deuxième brique est responsable de l'enregistrement du compte utilisateur dans le système avec les informations fournies.
Le résultat de cette action est l'identifiant de l'utilisateur.
Le passage des données d'une brique à une autre sans nécessiter de nouvelles entrées ni de copier-coller inutile des entrées et des sorties facilite grandement la compréhension du flux de données et le maintien du processus.
De plus, si une modification doit être apportée à une étape spécifique, il suffit de modifier la brique correspondante, sans affecter le reste de l'application.
Cela facilite également le travail en équipe, chaque développeur pouvant se concentrer sur sa propre brique sans affecter les autres.
En utilisant cette méthodologie à brique, le processus de création de compte utilisateur peut être facilement compris et maintenu.
Si une modification doit être apportée à une étape spécifique, il suffit de modifier la brique correspondante, sans affecter le reste de l'application.
Cela permet également de faciliter le travail en équipe, car chaque développeur peut se concentrer sur sa propre brique, sans affecter les autres.
Nous allons maintenant passer à la partie suivante et discuter de la façon dont cette méthodologie peut être utilisée pour la gestion des logs.
Par la suite, une fois que la brique de création de compte utilisateur est mise en place, il est important de gérer les logs pour assurer la fiabilité et la sécurité de l'application.
Pour cela, une brique de surveillance des logs peut être mise en place.
Cette brique aura pour but de surveiller et d'enregistrer les différentes actions effectuées par l'utilisateur au sein de l'application.
Voici un exemple de schéma représentant la brique de surveillance des logs :
Dans ce schéma, nous avons une brique unique :
"Enregistrement des logs".
Les données d'entrée pour cette brique sont l'identification de l'utilisateur, l'action effectuée et la date et l'heure.
La sortie de cette brique est "Aucune", indiquant qu'il n'y a pas de données supplémentaires produites par cette brique.
L'action effectuée par cette brique est l'enregistrement des informations dans une base de données.
Cette brique permet ainsi de garder une trace de toutes les actions effectuées par les utilisateurs au sein de l'application.
En cas de problème ou de besoin de retracer les actions d'un utilisateur, les logs permettent de remonter l'historique des actions effectuées.
Ces deux briques, la brique de création de compte utilisateur et la brique de surveillance des logs, sont des exemples de briques pouvant être mises en place dans le cadre de la méthodologie à brique.
Il est possible d'en créer de nombreuses autres, en fonction des besoins spécifiques de chaque application.
La méthode des briques offre une approche efficace et simplifiée pour la conception et le développement d'applications.
Elle permet de décomposer une application complexe en briques gérables, de visualiser les interactions entre les différentes fonctionnalités et de faciliter les évolutions et les mises à jour.
La méthodologie "à brique", mise en avant dans cet article, trouve des parallèles notables avec des concepts bien établis dans le domaine du développement de logiciels.
Notamment, elle rappelle les principes de la programmation modulaire et de l'architecture microservices, où l'application est divisée en composants indépendants et interopérables, chacun remplissant une fonction spécifique.
Toutefois, la méthodologie "à brique" se distingue par ses particularités.
Tout en conservant l'essence de la modularité et de l'indépendance des composants, elle accentue l'importance de la réutilisabilité et de l'interopérabilité des briques.
De plus, chaque brique dispose d'entrées et sorties clairement définies, facilitant ainsi leur intégration au sein d'un système plus vaste.
Alors que des approches comme la programmation modulaire et l'architecture microservices sont certainement utiles et pertinentes, la méthodologie "à brique" apporte une perspective rafraîchissante et complémentaire à la conception et au développement de logiciels.
Abonnez-vous
Abonner vous, pour recevoir les nouvelles publications et obtenir ma formation programmation pour débutant 100% gratuite.
À PROPOS
Je m'appelle Gregory Lafitte, ancien étudiant de l'école 42, et aujourd’hui ingénieur informatique.
Je partage mes connaissances et mon expérience dans les métiers du numérique.
Créé avec © systeme.io • Politique de confidentialité • Mentions légales