Quels étaient les modèles de conception de l'ère de la programmation procédurale? [fermé]

Similaire: Comment la programmation a-t-elle été réalisée il y a 20 ans?

La POO est assez à la mode de nos jours, ayant ses racines dans Simula 67 dans les années 1960, et plus tard rendue populaire par Smalltalk et C ++ . Nous avons DRY, SOLID, de nombreux livres sur les modèles de conception dans le monde orienté objet.

Mais quels étaient les grands principes de la programmation avant l'adoption à grande échelle du paradigme OOP? Et quels étaient les principaux modèles de conception?

J'étais développeur Cobol avant d'apprendre Java. Je l'ai développé depuis plus de 35 ans.

À l'époque des langages procéduraux, la plupart du traitement se faisait en batch. Remontez assez loin dans l'histoire, et même la compilation du programme a été faite avec un jeu de cartes perforées en lot.

Contrairement à l' affirmation de Kilian Foth , nous avions des modèles de conception dans les années 1970 et 1980. Il y avait une certaine façon de coder une correspondance / fusion multi-fichiers dans Cobol. Il y avait une certaine façon de coder l'ajout de transactions au fichier maître (bande) dans Cobol. Il y avait une certaine façon de coder la génération de rapports dans Cobol. C'est pourquoi IBM Report Writer n'a jamais vraiment gagné du terrain dans de nombreux magasins Cobol.

Il y a eu une application précoce du principe DRY. Créez beaucoup de paragraphes pour ne pas vous répéter. Des techniques de codage structuré ont été développées dans les années 1970 et Cobol a ajouté des mots structurés (verbes) au langage en 1985.

Généralement, lorsque nous avons écrit un nouveau programme Cobol, nous avons copié un ancien programme Cobol et changé les noms pour protéger les innocents. Nous n'avons presque jamais codé un programme Cobol à partir d'une feuille de papier vierge ou d'un écran vierge. C'est un grand modèle de conception lorsque vous pouvez copier et coller des programmes entiers.

Il y avait tellement de modèles de conception Cobol qu'il a fallu des années pour qu'un programmeur Cobol les apprenne tous. C'est une des raisons pour lesquelles les programmeurs Cobol utilisent aujourd'hui, pour la plupart, la syntaxe de 1985.

Les «modèles de conception» dans les logiciels n'existaient pas à l'époque dont vous parlez, car le concept n'avait pas été inventé. Ce n'est pas moi d'être désinvolte - c'est en fait la raison; être appelé un nom reconnaissable est ce qui fait d'un modèle de conception un "modèle de conception" plutôt qu'un simple code que vous continuez à utiliser sous une forme ou une autre (par exemple, une "usine" plutôt que "le type de classe statique que j'aime utiliser plutôt que un assortiment de constructeurs ") et le concept lui-même ne fait pas exception.

Cela dit, bien sûr, il y avait des choses qui remplissaient exactement le même rôle dans le travail des praticiens que les modèles de conception. Mais vous serez déçus d'en entendre parler: les "tours des gourous" typiques à l'époque étaient des choses qui nous ennuient maintenant - par exemple, des listes liées individuellement, des boucles contrôlées par un index incrémenté à chaque itération, un "accesseur intelligent" "des méthodes qui semblent ne rien faire mais qui vous donnent plus de latitude pour changer d'avis sur les détails de l'implémentation ultérieurement.

C'est vrai, les choses que nous tenons maintenant pour acquises - qui font parfois même partie des langages que nous utilisons - étaient des concepts avancés (et parfois jalousement gardés) connus uniquement des codeurs plus expérimentés. Les chances sont, presque tout ce qui n'est pas tout à fait insignifiant que vous apprenez aujourd'hui dans un cours de programmation de base est passé par une phase où c'était l'équivalent moral d'un "modèle de conception" pour les praticiens de l'époque. La construction de logiciels n'est peut-être pas encore une discipline d'ingénierie rigoureuse, mais si vous étudiez l'état de l'art des années 50 et 60, vous ne pouvez pas nier qu'elle a parcouru un chemin énorme depuis ses débuts.

Le grand paradigme précédent était la programmation structurée . Au lieu d'UML, il y avait une variété de diagrammes différents (organigrammes, diagrammes de flux de données, organigrammes, etc.). Le développement s'est déroulé principalement de haut en bas et a suivi un processus de décomposition fonctionnelle. L'une des idées de base était que la structure de votre programme devrait ressembler à un losange: le module principal en haut, se déployant en modules de contrôle de haut niveau, qui invoquaient des routines dans les modules de niveau inférieur. Ces modules de niveau inférieur reposent sur des modules de niveau encore inférieur, qui ont tous (théoriquement) finalement convergé vers une poignée de routines d'E / S de base. Les modules de haut niveau étaient censés contenir la logique du programme, ceux de niveau inférieur étaient plus concernés par l'intégrité des données et la gestion des erreurs.

Les concepts importants introduits pendant cette période étaient la dissimulation d'informations, la modularité et la forte cohésion / faible couplage. Voir les travaux de Dave Parnas pour quelques articles fondateurs sur ces sujets. Consultez également le travail de Larry Constantine, Tom DeMarco et Ed Yourdon.

Je suppose qu'un grand (en plus de la programmation structurée elle-même) était le concept de passer une poignée - dans OO, vous avez un objet et il contient l'état et la fonctionnalité. De retour avant OO, vous auriez une charge de fonctions indépendantes, et vous passeriez une poignée à un certain état entre elles - un cookie si vous voulez. Cela vous a donné des principes OO sans avoir réellement OO.

Vous pouvez le voir beaucoup dans l'ancien code Win32, vous passeriez un HANDLE qui serait un type opaque représentant un état alloué dans le noyau Windows. Vous pouvez le faire vous-même en passant un pointeur sur une structure que vous avez précédemment allouée comme premier paramètre aux fonctions qui opéraient sur ces données.

Puisque personne n'a encore mentionné l'évidence: un grand modèle de conception à l'ère procédurale était Object. Comme de nombreux modèles de conception populaires avant (par exemple, sous-routine) et après (par exemple, Iterator), il est devenu si populaire qu'il a même obtenu un support linguistique.

Une "machine à états finis" peut compter comme un modèle et les FSM ont été écrits (par exemple pour les protocoles de communication) en utilisant des langages pré-OO.

Les «gestionnaires d'interruption» et les TSR étaient également très populaires, par exemple sous DOS.

Des termes comme «Code Spaghetti» et «Point de sortie unique» sont en fait des remises en question de cette époque. De nos jours, nous appelons le code que nous n'aimons pas le "code spaghetti", mais c'est vraiment une référence au code lié (mal) avec les GOTO et les JMP.

(Aujourd'hui, nous souffrons de "code ravioli", dans lequel le code est comme un tas de classes indépendantes, étroitement emballées, un peu comme une assiette de raviolis. Cependant, certains experts OO demandent à juste titre, "Mais n'est-ce pas ce que OO est censé ressembler?")

"Single Point of Exit" aujourd'hui n'est qu'un coup de frein de refactorisation frustrant. Beaucoup de développeurs à qui j'ai parlé n'en ont même pas entendu parler et sont consternés quand je l'explique. Mais dans le passé, cela signifiait de ne pas sauter soudainement d'un bloc de code et dans le code de spaghetti. Sautez à la fin de la logique, puis quittez gracieusement.

En étirant ma mémoire, en arrière, je semble me souvenir que l'idée de regrouper le code dans des procédures était un grand pas en avant. L'idée que vous puissiez regrouper des procédures en modules interopérables et réutilisables était en quelque sorte le Saint Graal de la programmation.

EDIT: "Code auto-modifiable" était également un modèle utilisé notamment sur le Doom original. C'est là que le programme écraserait réellement ses instructions avec des instructions plus rapides en fonction de son état. Quand j'étais un tyke qui suivait un cours de programmation au Musée des sciences, mon instructeur nous a sévèrement averti: "N'écrivez pas de code auto-modifiant!"

EDIT EDIT: Cependant, avant Internet, le mot voyageait beaucoup plus lentement. L'idée de mettre en œuvre des algorithmes et des structures de données était autrefois beaucoup plus importante. Aujourd'hui, je trie tout le temps sans même savoir quel type j'utilise. Mais à l'époque, vous deviez le coder vous-même. Je me souviens d'un article qui parlait des défis de programmation qui prenaient des jours que nous éliminons aujourd'hui en une demi-heure, ou moins. Une programmation "algorithmique" et "structure de données" vraiment concise serait probablement sur la liste, beaucoup plus qu'aujourd'hui.