PROGRAMMATION MODULAIRE: CARACTÉRISTIQUES, EXEMPLES, AVANTAGES, APPLICATIONS - LA TECHNOLOGIE - 2025

La programmation modulaire est une technique utilisée pour le développement de logiciels, où le programme est divisé en de nombreux petits blocs ou composants autonomes appelés modules, qui sont gérables, logiques et fonctionnels.

Le module est un bloc d'instructions qui résout un problème particulier. Chaque module contient tout le nécessaire pour remplir sa propre fonctionnalité et peut être édité ou modifié sans affecter le reste du projet.

Exemple de résolution d'un problème à l'aide de modules. Source: Kayau / CC BY (https://creativecommons.org/licenses/by/3.0)

Ce mode de programmation est réalisé en conservant une interface de module permanente qui est utilisée par les autres composants logiciels pour accéder aux fonctions de chaque module.

Les modules imposent des limites logiques entre les composants, améliorant ainsi la maintenabilité. Ils sont incorporés via des interfaces conçues de manière à minimiser la dépendance entre les différents modules.

Modules principaux et auxiliaires

Un module principal et plusieurs modules secondaires constituent la programmation modulaire. Depuis le module principal, des appels sont effectués vers les fonctions des modules auxiliaires.

Ces plug-ins existent sous forme de fichiers exécutables séparés, qui sont chargés lorsque le module principal s'exécute. Chaque module a un nom unique attribué dans l'instruction PROGRAM.

Les équipes de travail peuvent développer différents modules séparément sans avoir à connaître tous les modules du système. Chacune des applications modulaires est associée à un numéro de version pour offrir une flexibilité aux développeurs dans la maintenance du module.

Fonctions de programmation modulaires

Modularité

Un ordinateur n'a pas besoin d'une version éclatée du code pour l'exécuter. Ce sont les limitations cognitives humaines qui vous obligent à écrire du code en plus petits morceaux.

Un programme peut contenir d'autres fonctions et peut également faire référence à des fonctions qui se trouvent dans d'autres fichiers. Ces fonctions ou modules sont des ensembles d'instructions utilisées pour effectuer une opération ou calculer une valeur.

Afin de maintenir la simplicité et la lisibilité dans les programmes volumineux et complexes, une fonction principale courte est utilisée en conjonction avec d'autres fonctions, plutôt qu'une fonction principale longue.

En séparant un programme en groupes de modules, chaque module sera plus facile à comprendre, respectant ainsi les principes de base de la programmation structurée.

Définition de fonction

Une fonction consiste en une déclaration de sa définition suivie de commandes et d'instructions. La forme générale d'une fonction est:

Function_name (déclaration de paramètre) {

Phrases;

commandes;

expression de retour;

}

- La déclaration des paramètres représente les informations qui sont passées à la fonction.

- Les variables supplémentaires utilisées spécifiquement par la fonction sont définies dans les phrases.

- Toutes les fonctions doivent inclure une instruction return.

Portée des variables

Les variables déclarées dans la fonction principale ou dans les fonctions définies par l'utilisateur sont appelées variables locales. Celles-ci ont une valeur lorsque la fonction s'exécute, mais leur valeur n'est pas conservée lorsque la fonction se termine.

Les variables déclarées externes au programme principal ou aux fonctions définies par l'utilisateur sont appelées variables globales. Ces variables peuvent provenir de n'importe quelle fonction qui se trouve à l'intérieur du programme.

C'est procédural

La programmation modulaire est assez procédurale, puisqu'elle est complètement orientée vers l'écriture de code pour les fonctions, sans prendre en compte les données.

Exemples de programmation modulaire

Modularité dans la vraie vie

Supposons une maison qui a de l'électricité, avec plusieurs prises sur les murs. Ce système vous permet de brancher divers appareils électriques, par exemple, micro-ondes, lave-linge, sèche-linge, etc.

Ces appareils sont conçus pour exécuter leur tâche spécifique lorsqu'ils sont branchés et allumés, quel que soit leur emplacement.

Les modules d'une application doivent suivre cette même philosophie. Cela signifie qu'ils n'ont qu'à effectuer leur tâche spécifique, quelle que soit la partie de l'application dans laquelle ils se trouvent, ou même à quelle application ils sont connectés.

De même, tout comme un appareil électrique peut être facilement débranché de la prise, un module doit être conçu de manière à pouvoir être facilement retiré d'une application.

Tout comme la suppression d'un appareil électrique n'affecte pas la fonctionnalité des autres appareils connectés, la suppression de modules d'une application ne devrait pas avoir d'incidence sur la fonctionnalité des autres modules de cette application.

Fonctions en Java

En Java, les modules sont écrits comme des fonctions indépendantes. Par exemple, vous pouvez avoir une fonction ou un bloc de code pour calculer la GPA d'un élève en fonction de ses notes dans tous les cours qu'il a suivis.

La fonction doit obtenir la liste des notes en entrée, puis renvoyer la moyenne des notes calculée:

Cette fonction est appelée CalculateAverageNote. Il reçoit en entrée une liste de notes, à l'aide d'un tableau de type de données double, et renvoie la moyenne calculée.

Dans la fonction, la variable locale sum est initialisée à zéro puis, à l'aide d'une boucle for, toutes les qualifications sont ajoutées à la somme. Enfin, la somme obtenue est divisée par le nombre de notes, renvoyant la valeur résultante.

Si la matrice d'entrée avait les notes 3,5, 3,0 et 4,0, après les avoir ajoutées, elle aurait additionné la valeur de 10,5, puis elle serait divisée par 3, car il y a trois notes. La fonction renverrait la valeur 3,5.

avantage

Programmation de projet indépendante

Plusieurs programmeurs peuvent travailler sur le même projet s'il est divisé en modules. Différents programmeurs peuvent concevoir indépendamment différents modules de programme, ce qui est nécessaire pour un programme volumineux et complexe.

Développement de programme efficace

Les programmes peuvent être développés plus rapidement, car les petits modules autonomes sont plus faciles à comprendre, à concevoir et à tester que les grands programmes.

Le programmeur peut fournir l'entrée nécessaire et vérifier que le module est correct en examinant sa sortie.

Utilisation multiple de modules

Le code écrit pour un programme est souvent utile dans d'autres. La programmation modulaire permet de sauvegarder ces sections pour une utilisation future. Étant donné que le code est déplaçable, les modules enregistrés peuvent être liés à tout autre programme qui répond aux exigences d'entrée et de sortie.

Avec la programmation monolithique, ces sections de code sont intégrées dans le programme et ne sont pas disponibles pour une utilisation par d'autres programmes.

Facilité de débogage et de modification

Un module est plus petit qu'un programme complet, il est donc plus facile à tester. Chaque module peut être écrit et testé séparément du reste du programme. Une fois qu'un module a été testé, il peut être utilisé dans un nouveau programme sans avoir à le tester à nouveau.

Lorsqu'un programme doit être modifié, la programmation modulaire simplifie le travail. Les modules nouveaux ou débogués peuvent être liés à un programme existant sans changer le reste du programme.

Désavantages

Structure trop orientée objet

Cette programmation utilise des interfaces, ce qui est une idée assez efficace. Pour en profiter, certains frameworks sont livrés avec un ensemble complet de classes interchangeables. Par exemple, pour gérer la persistance, il peut y avoir plusieurs classes qui implémentent une interface de persistance.

Cependant, les environnements de développement intégrés (IDE) sont confus à ce sujet. Par exemple, vous pourriez essayer de trouver la source d'une méthode, et l'EDI ne saura pas quelle méthode vous voulez voir, affichant ainsi une longue liste de fichiers où une méthode avec ce nom existe.

Modules trop petits

Il existe de nombreux modules qui ne contiennent qu'une très petite fonction. Chaque module nécessite un temps d'analyse et de traitement supplémentaire, en plus de son en-tête dans le code.

Par conséquent, l'utilisation de nombreux petits modules ajoutera une surcharge au système de compilation, augmentant la taille du paquet.

Décomposer sans raison

Certains codes ne changent presque jamais. Dans ces cas, il peut ne pas avoir beaucoup de sens d'essayer de lui donner un aspect plus propre ou avec une logique abstraite, si sa simple utilisation fonctionne correctement.

Il y a des codes qui ne sont pas trop jolis, mais ils n'ont pas beaucoup changé ces dernières années. Il n'y a aucune raison de décomposer du code qui n'a jamais changé et qui fonctionne déjà bien en modules.

Applications

La programmation modulaire n'est qu'un concept. Sa pratique peut être appliquée dans n'importe quel langage de programmation, en particulier ceux de nature procédurale, qui ont un programme compilé séparément.

Les bibliothèques de composants construites à partir de modules compilés séparément peuvent être combinées en un ensemble à l'aide d'un outil de programmation appelé éditeur de liens.

Les noms des fonctions dans les différents modules doivent être uniques afin de faciliter leur accès au cas où les fonctions utilisées par le module principal doivent être exportées.

Parmi les langages de programmation prenant en charge le concept de programmation modulaire, citons C, Ada, PL / I, Erlang, Pascal, Algol, COBOL, RPG, Haskell, Python, HyperTalk, IBM / 360 Assembler, MATLAB, Ruby, IBM RPG, SmallTalk, Morpho, Java (les packages sont considérés comme des modules), Perl, etc.

Langage C

La programmation modulaire peut être appliquée en langage C car elle permet de remédier à une grande difficulté en la séparant en plusieurs modules.

Chacun de ces modules résout un problème particulier, tandis que le programme principal, qui est l'ensemble de ces procédures, résout le problème dans son ensemble.

Chaque fonction définie en C est par défaut accessible globalement. Cela peut être fait en incluant un fichier d'en-tête, où l'implémentation de la fonction est définie.

À titre d'exemple, nous voulons déclarer un type de données de pile et également que l'implémentation et la structure de données sont masquées aux utilisateurs.

Cela peut être fait en définissant d'abord un fichier public appelé stack.h, qui contiendra les données génériques avec le type de données stack et les fonctions prises en charge par le type de données stack.

stack.h:

extern stack_var1;

extern int stack_do_something (void);

Vous pouvez maintenant créer un fichier appelé stack.c qui contient l'implémentation du type de données stack:

Références

1. CIO Wiki (2019). Programmation modulaire. Tiré de: cio-wiki.org.
2. Définitions informatiques (2020). Programmation modulaire. Tiré de: defit.org.
3. Nouveau Mexique Tech (2020). Programmation modulaire avec fonctions. Tiré de: ee.nmt.edu.
4. Christian Maioli (2020). 3 techniques créatives pour écrire du code modulaire. Tech Beacon. Tiré de: techbeacon.com.
5. Geeks pour les geeks (2020). Approche modulaire en programmation. Tiré de: geeksforgeeks.org.
6. Étude (2020). Programmation modulaire: définition et application en Java. Tiré de: study.com.