Quels changements sont trop gros pour être facilités par une conception appropriée?

Question

C'est une question plutôt vague, mais c'est quelque chose que je n'ai jamais ressenti, j'ai été répondu de manière satisfaisante en lisant sur le design approprié.

Généralement, lors de l'apprentissage de la programmation, de l'abstraction, de la prise en compte, etc., le Saint Graal de la conception - et la raison pour laquelle ils prétendent toujours que vous utilisez les techniques de développement en question - est qu'il rendra votre programme "facile à changer" , "maintenable", "flexible", ou l'un des synonymes utilisés pour exprimer un concept aussi productif. En marquant Ivars Private, en divisant le code en de nombreuses petites méthodes autonomes, en gardant les interfaces générales, vous obtenez censément la possibilité de modifier votre programme avec une facilité et une grâce totale.

Pour des changements relativement petits, cela a bien fonctionné pour moi. Les modifications des structures de données internes utilisées par une classe pour augmenter les performances n'ont jamais été une difficulté majeure, et aucun des modifications à l'extrémité de l'interface utilisateur, indépendamment de l'API, tel que la refonte d'un système d'entrée de texte ou la révision des graphiques pour un élément de gameplay .

Tous ces changements semblent intrinsèquement autonomes. Aucun d'entre eux n'implique de modifications du comportement ou de la conception du composant de votre programme modifié, en ce qui concerne le code extérieur qu'elle concernait. Que vous écriviez ou non de manière procédurale ou dans un style OO, avec de grandes fonctions ou de petites, ce sont des changements faciles à apporter même si vous n'avez qu'un design modérément bon.

Cependant, chaque fois que les changements deviennent grands et velus - c'est-à-dire que les changements à l'API - aucun de mes précieux "modèles" n'est jamais venu à la rescousse. Le grand changement reste important, le code affecté reste affecté et de nombreuses heures de travail à forte affectation me attendent.

Voici donc ma question. Quelle est la taille d'un changement que la conception appropriée prétend être en mesure de faciliter? Y a-t-il une autre technique de conception, soit à l'insu de moi, soit que je n'ai pas réussi à mettre en œuvre, qui rend vraiment la modification de son collant simple, ou cette promesse (que j'ai entendue par tant de paradigmes différents) est simplement une bonne idée, complètement déconnecté des vérités immuables du développement de logiciels? Y a-t-il un "outil de changement" que je peux ajouter à ma ceinture d'outils?

Plus précisément, le problème auquel je suis confronté qui m'a conduit aux forums est le suivant: j'ai travaillé sur la mise en œuvre d'un langage de programmation interprété (implémenté en D, mais ce n'est pas pertinent), et j'ai décidé que les arguments de mes fermetures devraient être Mottes clés, plutôt que positionnels tels qu'ils sont actuellement. Cela nécessite de modifier tout le code existant qui appelle des fonctions anonymes, ce qui, heureusement, est plutôt petit parce que je suis tôt dans le développement de ma langue (<2000 lignes), mais je serais énorme si j'avais pris cette décision à un stade ultérieur. Dans une telle situation, y a-t-il un moyen que, par une bonne prévoyance dans la conception, j'aurais pu faciliter cette modification, ou certains changements (la plupart) changent-ils intrinsèquement de grande envergure? Je suis curieux de savoir si c'est en quelque sorte un échec de mes propres compétences en conception - si c'est le cas, je serais très désireux de les améliorer avec le matériel de lecture nécessaire s'il existe un moyen d'améliorer la gravité du problème.

Pour être clair, je ne suis en aucun cas sceptique à l'égard de la POO ou à l'un des autres modèles couramment utilisés. Pour moi, cependant, leurs vertus sont dans l'écriture originale, plutôt que le maintien des bases de code. L'héritage vous permet de bien abstraction des modèles répétitifs, le polymorphisme vous permet de séparer le code par une fonction comprise humaine (quelle classe) plutôt que par effet compris (quelle branche de la branche switch déclaration) et les petites fonctions autonomes vous permettent d'écrire dans un style "ascendant" très agréable. Cependant, je suis sceptique quant à leurs prétentions de flexibilité.