- Programmation procédurale
-
La programmation procédurale est un paradigme de programmation basé sur le concept d'appel procédural. Une procédure, aussi appelée routine, sous-routine ou fonction (à ne pas confondre avec les fonctions de la programmation fonctionnelle reposant sur des fonctions mathématiques) contient simplement une série d'étapes à réaliser. N'importe quelle procédure peut être appelée à n'importe quelle étape de l'exécution du programme, y compris à l'intérieur d'autres procédures, voire dans la procédure elle-même (récursivité).
La programmation procédurale est souvent un meilleur choix qu'une simple programmation séquentielle ou programmation non-structurée. Avantages possibles :
- La possibilité de réutiliser le même code à différents emplacements dans le programme sans avoir à le retaper ;
- Une façon plus simple de suivre l'évolution du programme. La programmation procédurale permet de se passer d'instructions telles que "GOTO" et "JUMP" évitant ainsi bien souvent de se retrouver avec un programme compliqué qui part dans toutes les directions (appelé souvent « programmation spaghetti ») ;
- La création d'un code plus modulaire et structuré.
Procédures et modularité
La modularité est généralement une caractéristique souhaitable pour un programme informatique. C'est particulièrement le cas pour les programmes complexes et/ou importants en taille, que l'on peut ainsi découper en modules indépendants les uns des autres. Dans ce cadre, on parle d'« arguments » pour les entrées et de « valeurs de retour » pour les sorties.
La portée des variables est l'un des mécanismes qui permet la modularité des procédures. Elle empêche une procédure d'accéder aux variables locales d'une autre procédure, évitant ainsi les collisions de noms.
Il est possible, pour une procédure donnée, de définir une interface simple (et idéalement permanente). Les procédures constituent donc un moyen efficace de développement de code par plusieurs personnes, ou plusieurs groupes de personnes, notamment via des bibliothèques.
Comparaison avec une programmation orientée objet
La programmation orientée objet permet une mutualisation et une unicité de l'information et des traitements/procédures/méthodes (en théorie). En effet les traitements et valeurs sont conservées en mémoire dans des unités logiques, les objets. La création/maintenance en mémoire/suppression de ces objets (dépositaires d'informations et de traitements) a lieu de manière déterministe. C'est-à-dire par la volonté du programmeur, par les instructions codées.
Dans le modèle de programmation procédurale, lorsqu'une procédure principale se termine, elle est déchargée de la mémoire par le système, avec ses variables et ses traitements. Une procédure principale en exécution ne peut pas accéder à des traitements ou informations d'une autre procédure principale. Des réplications de code sont donc fortement susceptibles de survenir. Par exemple, une procédure principale appelant une sous procédure de tri ne pourra pas exposer ladite sous procédure à une autre procédure principale.
Le paradigme objet permet de répondre plus facilement à des besoins où des traitements similaires sont attendus dans des endroits différents d'une solution. Un monde de bulles s'appelant les unes les autres est une analogie assez parlante de ce type de programmation. Le modèle procédurale peut se voir comme pyramidal, hiérarchisé. Il fonctionne bien pour des besoins où les traitements attendus sont peu ou pas répétitifs/similaires.
Langages procéduraux
Les langages de programmation procédurale facilitent la tâche du programmeur en permettant de privilégier une approche procédurale. Le plus vieil exemple de ce type de langage est l'ALGOL. D'autres exemples sont Fortran, PL/I, Modula-2 et Ada (dans sa première version).
Wikimedia Foundation. 2010.
