Caractéristiques de programmation modulaires, exemples, avantages, applications

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

Le module est un bloc de phrases qui résout un problème particulier. Chaque module contient tout ce qui est nécessaire pour remplir sa propre fonctionnalité et peut être modifié ou modifié sans que le reste du projet soit affecté.

Exemple de résolution d'un problème à l'aide de modules. Source: kayau / cc by (https: // CreativeCommons.Org / licences / par / 3.0)

Cette façon de programmer est obtenue en maintenant une interface de module permanent utilisée par les autres composants logiciels afin d'accéder aux fonctions de chaque module.

Les modules imposent des limites logiques entre les composants, améliorant la capacité de maintenance. Ils sont incorporés via des interfaces, qui sont conçues de telle manière que la dépendance entre les différents modules est minimisée.

[TOC]

Module principal et auxiliaires

Un module principal et plusieurs modules secondaires sont ceux qui composent la programmation modulaire. À partir du module principal, les appels aux fonctions des modules auxiliaires sont effectués.

Ces modules auxiliaires existent en tant que fichiers exécutables séparés, qui sont chargés lorsque le module principal est exécuté. Chaque module a un nom unique attribué dans l'instruction du programme.

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

Caractéristiques de programmation modulaire

Modularité

Un ordinateur n'a pas besoin d'une version de panne du code pour pouvoir l'exécuter. Ce sont les limitations cognitives humaines qui obligent le code à écrire dans des fragments plus petits.

Un programme peut contenir d'autres fonctions et peut également se référer à des fonctions qui se trouvent dans d'autres fichiers. Ces fonctions ou modules sont des ensembles de phrases qui servent à effectuer une opération ou à calculer une valeur.

Afin de maintenir la simplicité et la lisibilité dans les programmes grands et complexes, une courte fonction principale est utilisée en conjonction avec d'autres fonctions, au lieu d'utiliser une longue fonction principale.

Lors de la séparation d'un programme dans des groupes de modules, chaque module sera plus facile à comprendre, se conformant ainsi aux modèles de programmation structurés de base.

Définition de la fonction

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

Name_function (Déclaration des paramètres)

phrases;

commandes;

return expression;

- L'énoncé des paramètres représente les informations transmises à la fonction.

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

Peut vous servir: Présentations électroniques: quelle est l'utilisation, les caractéristiques, les éléments

- Toutes les fonctions doivent inclure une phrase de retour.

Portée

Les variables déclarées dans la fonction principale ou dans les fonctions définies par l'utilisateur sont appelées variables locales. Ceux-ci ont une valeur lorsque la fonction est exécutée, mais sa valeur n'est pas conservée lorsque la fonction est terminée.

Les variables qui sont déclarées externes au programme principal ou aux fonctions définies par l'utilisateur sont appelées variables globales. Ces variables peuvent être tirées de toute fonction qui se trouve dans le programme.

C'est procédural

La programmation modulaire est assez procédurale, car elle est entièrement 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 plusieurs dispositifs électriques, par exemple, micro-ondes, machine à laver, séchoir, etc.

Ces appareils sont conçus pour effectuer leur tâche spécifique lors du branchement et éclairé, quelle que soit la maison où ils sont.

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

De plus, comme un dispositif électrique peut facilement se débrancher à partir de la prise de courant, un module doit être conçu de manière à ce qu'une application puisse être facilement éliminée d'une application.

En plus de l'élimination d'un dispositif électrique, n'a pas d'impact sur les fonctionnalités des autres appareils connectés, éliminer les modules d'une application ne devrait pas avoir d'impact.

Fonctions en Java

Dans Java, les modules sont écrits comme des fonctions indépendantes. Par exemple, vous pouvez avoir une fonction de code ou un blocage pour calculer la moyenne générale d'un étudiant en fonction de ses qualifications dans tous les cours que vous avez suivis.

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

Cette fonction est appelée calculoprome moyenne. Recevoir une liste de notes, à l'aide d'une matrice de type de données double et renvoie la moyenne calculée.

Dans la fonction, la variable locale de somme est initialisée à zéro, puis, au moyen d'un cycle pour, toutes les qualifications sont ajoutées à la somme. Enfin, la somme obtenue entre le nombre de notes est divisée, 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, la valeur de 10,5 serait ajoutée, puis elle serait divisée par 3, car il y a trois notes. La fonction renvoie la valeur 3.5.

Peut vous servir: objets technologiques

avantage

Programmation de projet indépendante

Plusieurs programmeurs peuvent travailler dans le même projet si vous êtes divisé en modules. Différents programmeurs peuvent concevoir indépendamment différents modules de programme, ce qui est requis pour un programme important et complexe.

Programmes efficaces

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

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

Utilisation multiple des modules

Le code écrit pour un programme est souvent utile dans d'autres. La programmation modulaire permet d'enregistrer ces sections pour une utilisation future. Parce que le code est relocable, 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 être utilisées par d'autres programmes.

Facilité de purification et de modification

Un module est plus petit qu'un programme complet, il est donc plus facile de l'essayer. 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 à réessayer.

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

Désavantages

Structure orientée vers l'objet excessivement

Cette programmation utilise des interfaces, ce qui est une idée assez efficace. Pour en profiter, certains cadres de travail apportent avec eux un ensemble complet de cours interchangeables. Par exemple, pour gérer la persistance, il pourrait y avoir plusieurs classes qui mettent en œuvre une interface de persistance.

Cependant, les environnements de développement intégrés (IDE) sont confondus avec cela. Par exemple, on pourrait essayer de trouver la source d'une méthode, et l'IDE ne saura pas quelle méthode vous voulez voir, affichant ainsi une longue liste de fichiers où il y a une méthode avec ce nom.

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 package.

Il peut vous servir: sixième génération d'ordinateurs: historique, caractéristiques, matériel, logiciel

Décomposer sans raison

Certains codes ne changent presque jamais. Dans ces cas, il peut ne pas être très logique d'essayer de le rendre plus propre ou avec une logique abstraite, si elle l'utilise simplement, cela fonctionne déjà bien.

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

Applications

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

Les bibliothèques de composants construites à partir de modules compilés séparés peuvent être combinés dans un ensemble par un outil de programmation appelé liaison.

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 qui admettent le concept de programmation modulaire figurent C, ADA, PL / I, ERLANG, PASCAL, ALGOL, COBOL, RPG, HASKELL, PYTHON, HYPERTALK, IBM / 360 Smalltalk, Morpho, Java (les packages sont considérés comme des modules), Perl, etc.

C

Dans le langage C, la programmation modulaire peut être appliquée car elle permet de remédier à une difficulté de grande ampleur 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 à l'échelle mondiale. Cela peut être fait en incluant un fichier d'en-tête, où l'implémentation de la fonction est définie.

Par exemple, il cherche à déclarer un type de données de pile et également que l'implémentation et la structure de données sont masquées pour les utilisateurs.

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

Empiler.H:

Stack externe_var1;

extern int stack_do_something (void);

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

Les références

1. CIO Wiki (2019). Programmation modulaire. Tiré de: Cio-Wiki.org.
2. Les définitions informatiques (2020). Programmation modulaire. Pris de: Defit.org.
3. New Mexico Tech (2020). Programmation modulaire avec des fonctions. Pris de: ee.NMT.Édu.
4. Christian Maioli (2020). 3 techniques créatives pour écrire du code modulaire. Balise technologique. Tiré de: TechBeacon.com.
5. Geeks pour geeks (2020). Approche modulaire dans la programmation. Tiré de: geeksforgeeks.org.
6. Étude (2020). Programmation modulaire: définition et application en Java. Tiré de: étudier.com.