Programmation automatique: écrire du code qui écrit du code
Après avoir lu le livre The Pragmatic Programmer , l'un des arguments que j'ai trouvé le plus intéressant était "écrire du code qui écrit du code".
J'ai essayé de chercher sur le net pour plus d'explications ou d'articles à ce sujet, et même si j'ai trouvé de bons articles sur le sujet, je n'ai toujours pas trouvé d'implémentation de code spécifique ou de bons exemples.
Je pense que ce n'est toujours pas un argument si courant, quelque chose qui manque de documentation ou qui n'est pas adopté par tant de gens, et j'aimerais en savoir plus.
Que pensez-vous du sujet? Est-ce quelque chose qui augmentera vraiment votre productivité? Quelles sont les bonnes ressources sur le sujet, parmi les livres, les blogs, les diaporamas, etc.?
Quelques exemples de code seraient grandement appréciés pour me permettre de mieux comprendre son implémentation.
Voici la page wiki sur le sujet avec diverses techniques de programmation pertinentes, comme la méta-programmation, la programmation générative et la génération de code.
Dans le monde LISP, il est assez courant de voir le code qui écrit le code qui écrit le code (et ainsi de suite). Ainsi, tout projet LISP ou Scheme de taille décente servira de bon exemple de code. Je recommanderais de regarder le compilateur Racket et les sources d'exécution, ainsi que Bigloo , leurs bibliothèques sont tout simplement géniales.
Quant à la productivité: j'utilise la métaprogrammation comme technique dominante dans presque tous mes travaux de développement, et cela aide clairement beaucoup, à la fois en réduisant la taille du code et en augmentant sa lisibilité. La clé réside dans l'utilisation de Domain Specific Languages , et la métaprogrammation est l'un des moyens les plus efficaces de les implémenter.
Je préfère aller un peu plus loin, et, au lieu d'écrire du code qui écrit du code, écrire du code qui génère des objets, des méthodes, des fonctions. Cela peut être réalisé avec des macros LISP ou Ruby capacités de modification de programme dynamique par exemple.
La petite différence est que vous ne vous retrouvez pas avec des fichiers sources générés automatiquement. Habituellement, ces fichiers ne sont pas lisibles par l'homme et ne peuvent pas être modifiés, alors pourquoi s'en soucier. Je n'aime pas l'idée d'augmenter ma base de code avec quelque chose que je ne peux pas contrôler.
Un livre que j'ai aimé lire sur le sujet était Metaprogramming Ruby (si vous connaissez Ruby language)
Modifier après la question suivante en commentaire:
Pourquoi devrait-il être utile s'il me reste à coder le code générateur? Dois-je écrire un code capable de générer différentes choses en fonction de l'entrée de l'utilisateur, afin de pouvoir le réutiliser encore et encore?
Premièrement, la métaprogrammation n'est pas un objectif, mais un outil. N'utilisez pas de métaprogrammation car "c'est cool" ou "X a dit que chaque développeur devrait l'utiliser".
Je pense qu'une bonne raison d'utiliser la métaprogrammation est de généraliser un modèle commun (modèle comme quelque chose qui se répète) que vous avez trouvé dans votre code et qu'aucune autre technique de programmation habituelle (héritage, modèles de conception, etc.) ne peut atteindre.
Comme dit par Jordan , un cas d'utilisation typique est la gestion de base de données et ORM (Object Relation Mapping). Encore une fois, dans Ruby, vous devriez regarder ActiveRecord qui est un excellent exemple de métaprogrammation appliquée à ORM.
Comme note finale:
Ne pensez pas "Je veux appliquer la métaprogrammation, où pourrais-je l'appliquer dans mon code?".
Pensez "Je vois ce modèle qui se répète partout dans mon code, je ne peux pas trouver un moyen de refactoriser le code en quelque chose de plus petit et plus réutilisable. Peut-être que la métaprogrammation peut m'aider? "
Encore mieux, utilisez du code écrit par quelqu'un d'autre qui écrit votre code pour vous.
L'automatisation du code est généralement bonne pour les ORM et autres codes d'interaction de base de données, et bien sûr pour la construction de code répétitive mais similaire.
Bien sûr, si vous construisez de nombreuses classes similaires, vous auriez peut-être pu accomplir la même chose dans un langage dynamique beaucoup plus tôt, mais je m'égare.
Ceci est adopté par de nombreuses personnes, bien que vous trouverez souvent le logiciel étiqueté comme générateur de code.
Voir des entreprises et des produits comme CodeSmith et MyGeneration, ou jetez un œil à cet article Wikipedia: http://en.wikipedia.org/wiki/Comparison_of_code_generation_tools
Un des exemples classiques est Lex et yacc. Leur objectif principal est d'éviter la corvée d'écrire tout type d'analyseur. En cours de route, ils accélèrent considérablement la construction d'analyseurs complexes avec de nombreuses règles et états, et ils évitent également toutes les erreurs surprenantes commises par les utilisateurs.
C'est aussi l'idée derrière c, qui est un outil pour écrire l'assembleur. La même chose vaut pour toute langue de haut niveau que vous souhaitez nommer. Pour les outils qui écrivent du code pour vous, il existe quelques paradigmes simples.
Un bon IDE aide en fournissant de la documentation à portée de main, une saisie automatique intelligente et des extraits de code. Les IDE incluent également divers modèles, vous n'avez donc pas à démarrer un programme à partir de zéro. Il existe des programmes pour prendre un diagramme uml et des classes approximatives dans un langage de haut niveau.
Enfin, vous pouvez écrire vos propres outils de génération de code dans votre ensemble de problèmes. C'est ainsi que Lex et yacc ont commencé. Tout type de langage spécifique à un domaine existe précisément pour cette raison. Vous créez des blocs de construction qui décrivent votre solution dans un code plus facile à comprendre, en regroupant des activités courantes ou des sections compliquées avec des commandes simples. Vous ne cherchez pas une solution à chaque problème, juste une définition plus simple de celui que vous traitez.
Dans un sens, tout ce que vous faites au-dessus de la couche binaire est l'automatisation du code.
métaprogrammation
La métaprogrammation est une technique controversée dans de nombreux magasins. La raison en est, comme tout outil puissant, l'ampleur de l'aide ou de la douleur est grande.
Avantages
- Plus expressif, moins de code à écrire et à maintenir (souvent d'un ordre de grandeur ou plus)
- Cohérence, comportement plus cohérent sur la classe de problèmes que vous résolvez avec le code
- Productivité, moins de code pour une solution à un espace problème plus grand
Contre
- Complexité, cela peut être très compliqué même s'il y a moins de code
- La sécurité, parfois la sécurité de type et l'analyse statique en général seront sacrifiées
- Les bogues affectent davantage, les petites erreurs auront un impact plus important
Je suis un grand fan de la métaprogrammation, mais je le fais depuis longtemps. Pour moi, le compromis entre une taille de code réduite et un comportement cohérent fait plus que compenser les risques. Moins de code signifie moins de bugs, moins de code à maintenir, et je peux généralement ajouter de grandes fonctionnalités très rapidement.
Cependant, cela ne signifie pas que je pense que tous les programmeurs devraient s'y engager. J'ai vu et j'ai dû résoudre de gros problèmes créés par la métaprogrammation. Habituellement à partir du moment où des personnes qui ne comprennent pas le concept et ont tenté d'étendre les fonctionnalités, ou tout simplement de corriger un bug. Il faut un état d'esprit particulier qui soit à tout le moins axé sur les détails. La question d'utiliser des techniques de métaprogrammation devrait être une décision d'équipe. Si vous avez des membres de l'équipe qui ne comprennent pas, n'ont pas le tempérament pour cela, ou sont tout simplement contre, aucune équipe ne devrait utiliser la métaprogrammation.
La plupart du code écrit du code. Par exemple, le code php aide à écrire du HTML. La bibliothèque php pdo permet d'écrire des appels SQL. Les fonctions d'E/S de fichiers écrivent du code pour communiquer avec le système d'exploitation. Même un appel de fonction régulier est une référence à un autre bloc de code qui est exécuté. Vos appels de fonctions écrivent donc du code.
En termes généraux, nous pouvons penser à l'informatique comme des codes d'écriture qui écrivent des codes de manière récursive formant une pile qui se termine lorsqu'elle se heurte à la réalité physique des codes câblés dans le matériel.
Dans notre entreprise, nous utilisons certains outils qui génèrent réellement des classes C++ ou C # avec des données téléchargées depuis Internet. Ces classes sont des conteneurs de données et contiennent un grand nombre d'objets dans des listes.
La métaprogrammation fait partie de la programmation depuis longtemps. Considérez non seulement des outils comme SWIG ou les concepteurs WYSIWYG, qui créent du code, mais aussi des outils en langage comme le préprocesseur C, ou même les modèles C++ et les génériques C #/Java, sans parler de la réflexion.
En fait, vous pourriez faire valoir que chaque compilateur n'est qu'un autre méta-programme - ils prennent le texte du programme et la machine de sortie ou VM code. Et, la vie sans compilateurs? Owch.
Voici un exemple concret de mon passé.
Je travaillais sur un site qui avait environ 50 Mo de code source Delphi utilisant le BDE pour l'accès aux données. Ils voulaient passer à l'utilisation de Direct Oracle Access pour permettre une mise à niveau Oracle au-delà de la version la plus élevée prise en charge par le BDE (8i si je me souviens bien).
Donc, au lieu de faire travailler une équipe de codeurs à travers chaque formulaire et module de données en changeant chaque composant manuellement, j'ai écrit un script Perl qui: -
Analyse le DFM (fichier de formulaire) et identifie tous les objets TQuery, TTable, TStoredProcedure et TDatabase - stockant les éléments dans une liste.
Analysé le PAS (code) et identifié l'utilisation des objets - les TQueries faisaient-elles des mises à jour ou des sélections? En outre, il a identifié tous les objets créés dans le code plutôt que déposés sur un formulaire dans l'EDI.
Réécriture du DFM & PAS en changeant les types d'objet de manière appropriée (par exemple TTable -> TOracleDataSet avec la propriété SQL définie sur "select * from", etc.) et les appels de méthode. En outre, des appels de méthode supplémentaires ont été ajoutés le cas échéant pour fermer, ouvrir et définir des paramètres.
En bref, 3 semaines de travail pour peaufiner le script pour travailler sur différentes applications écrites par différentes équipes avec différents styles de codage au lieu de l'estimation originale de 5+ développeurs travaillant pendant 6 mois.
Et la raison pour laquelle j'ai même pensé utiliser cette approche était en lisant The Pragmatic Programmer
La façon dont vous procédez varie en fonction de vos besoins. En supposant que vous utilisez la génération de code statique, vous pouvez écrire vous-même toute l'infrastructure ou utiliser un générateur existant tel que CodeSmith ou MyGeneration. En les utilisant, il vous suffit d'écrire les modèles requis.
Mon dernier projet impliquant cela était quelques écrans de base ASP.NET CRUD (la génération de code est bonne pour cela). Le processus est allé définir des entités comme des métadonnées dans des fichiers xml. Écrivez des modèles pour couvrir les divers artefacts requis (classes d'entités, référentiels, classes de service, contrôles asp.net, pages asp.net, etc.). Exécutez le processus de génération et stylisez la sortie.
Il y a des frais généraux dans l'écriture des modèles mais ils peuvent être réutilisés pour des projets similaires ultérieurs. De même, les modifications apportées aux données sous-jacentes sont gérées en modifiant les métadonnées et en réexécutant la génération, ce qui simplifie et accélère la mise en œuvre des modifications.
Quant aux tests. Comme il s'agit d'un système basé sur des modèles, vous devrez passer un certain temps à valider initialement la sortie du processus, si votre modèle est incorrect, toutes les sorties de ce modèle seront également erronées. Une fois que cela vous convient, vous pouvez également utiliser les générateurs de code pour créer des tests de base à partir des métadonnées xml que vous pouvez ensuite étendre pour couvrir des cas spéciaux. Cependant, n'oubliez pas que vous devrez peut-être encore effectuer des tests de code pour répondre à des choses spécifiques, la génération de code réduit votre travail, elle ne l'élimine pas complètement.
Vous demandez des exemples ....
Lorsque vous travaillez avec SQL, vous ne devez pas modifier la base de données directement, mais êtes plutôt censé exécuter des scripts qui apportent les modifications que vous souhaitez, y compris les modifications structurelles de la base de données (ajout de tables, de colonnes, de clés primaires, de contraintes, etc.) . Très souvent, vous devrez prendre la même action contre un grand nombre de tables ou de colonnes en même temps, et les faire un par un serait fastidieux, un court script qui génère un script plus grand qui fait ce que vous voulez peut être un vrai gagne-temps.
Par exemple, avant l'introduction du type de données DATE sur MS SQL Server, le seul choix pour une colonne de date était DATETIME qui a une partie temps - une partie temps qui rend le traitement des données un peu plus difficile. Lors de la mise à niveau vers une version avec le type de données Date, vous souhaiterez peut-être mettre à jour les colonnes où l'heure est toujours 00:00. Dans une base de données avec des dizaines voire des centaines de colonnes DateTime, cela prendrait beaucoup de temps. Mais il est facile d'écrire un script qui interroge toutes les tables, vérifiant chaque colonne avec un type de données DATETIME pour voir si l'heure est autre que 00:00 et sinon créer une instruction ALTER pour la table/colonne à modifier le type de données à DATE. Presto, code qui écrit du code.
Alors que de nombreuses réponses se réfèrent ici à ce qui est communément appelé méta-programmation, il y avait en fait un champ associé à l'IA connu sous le nom de programmation automatique qui concernait les programmes = comprendre ou synthétiser programmes [1].
Tout compilateur (ou méta-programme, générateur de code, traducteur, macro système, ...) travaille avec des transformations, générant une sortie à partir d'une entrée en réalisant son algorithme fixe de transformation. Mais un compilateur ou un méta-programme traditionnel ne crée pas d'algorithme de tri, étant donné une définition, une description ou un exemple de ce qu'est le tri d'une liste (par exemple [5, 3, 9] => [3,5,9]). De tels problèmes d'où l'intérêt de ce domaine de "programmation automatique".
[1] - Rapport d'avancement sur les systèmes de compréhension des programmes ftp://db.stanford.edu/pub/cstr/reports/cs/.../CS-TR-74-444.pdfShare
J'ai un module PHP qui génère une page Web contenant du code JavaScript qui génère du HTML. C'est trois couches juste là. Boy était si difficile à lire!
Dans une classe de programmation, nous devions écrire un programme qui prendrait une chaîne de formule de l'utilisateur et l'analyserait et afficherait la valeur. Le solveur le plus impressionnant a simplement pris l'entrée utilisateur, l'a enveloppée dans main () {printf ("% d", ...);} et a exécuté un script pour le compiler, le lier et l'exécuter. Il n'a pas écrit un analyseur! Aujourd'hui, vous pouvez le faire dans une instruction SQL SELECT.
C'est un outil avec lequel vous devriez jouer, puis le ranger pour un jour futur où il sera pratique.
J'ai développé des solutions méta-programmation soignées avec Prolog. Où l'application principale (en C++, par exemple) traduit une définition abstraite d'un problème en une application Prolog au moment de l'exécution, qui est ensuite déléguée à. Souvent, l'écriture de fonctionnalités équivalentes en C++ prenait une éternité.
Je pense que ce scénario est un excellent cas en faveur de l'argument code-writing-code.
Que pensez-vous du sujet?
La métaprogrammation est le plus souvent associée aux langages non dynamiques, car il est plus difficile de réaliser certains comportements (tels que la mise en œuvre d'un ORM) sans beaucoup de lignes de code non productives et non intelligentes.
Mais même dans des langages plus dynamiques tels que PHP, la génération de code peut vraiment nous sauver la vie et augmenter considérablement la productivité. Dans les cadres modernes, il est très courant d'avoir des échafaudages qui génèrent la plupart des modèles, formulaires, tests et actions courants pour un certain objet métier que vous déclarez. C'est l'une des raisons pour lesquelles les frameworks tels que symfony ou RoR ont autant de succès, ces outils de génération de code rendent le code cohérent très rapidement et augmentent la productivité des programmeurs.
Dans les sites Web, la plupart des interactions s'articulent autour de quatre actions principales:
- Créer un élément
- Récupérer un ensemble d'éléments (avec filtrage possible)
- Mettre à jour un élément avec de nouveaux attributs
- Supprimer un ensemble d'éléments
Au moins tout ce qui tourne autour de ces 4 actions principales pourrait et IMHO DEVRAIT être réalisé en utilisant des outils de génération de code pour atteindre une productivité maximale.
Dans mon entreprise, nous utilisons symfony, et son générateur d'administration est un outil exceptionnel, qui génère même du code au moment de l'exécution (et le met en cache), ce qui signifie que nous n'avons même pas besoin d'utiliser n'importe quel type de tâche ou d'outil externe pour générer du nouveau code, nous avons juste besoin de nettoyer notre cache. Je conseille vivement d'utiliser ce type d'outil pour les opérations CRUD.
Mais faire ce que les formidables contributeurs de symfony ont fait n'est pas une tâche facile. J'ai moi-même implémenté des tâches de génération de code et faire quelque chose de vraiment cohérent et avec une implémentation large pour couvrir la plupart des cas d'angle n'est pas facile.
Est-ce quelque chose qui augmentera vraiment votre productivité?
Je crois que la métaprogrammation est très très importante dans les niveaux inférieurs de travail (frameworks, cache, compilateurs, etc.) mais quelque chose que nous devons aborder avec une extrême prudence si nous faisons des choses sur la couche métier.
L'utilisation de la génération de code est sans aucun doute un important booster de productivité. Implémenter vos propres outils de génération de code, pas tant que vous ne construisez pas vous-même un framework.
Quelles sont les bonnes ressources sur le sujet, parmi les livres, les blogs, les diaporamas, etc.?
La meilleure ressource pour comprendre la programmation est toujours un code source bon et bien commenté. Je dirais que regarder dans les générateurs d'administrateur RubyOnRails et Symfony est une bonne idée.
Jetez un œil aux macros CL (Common Lips). À mon avis, c'est exactement ce que vous voulez. Les lèvres sont parfaites en métaprogrammation.
Je suggère également Nemerle si vous voulez avoir des pouvoirs .NET avec un support parfait de métaprogrammation (y compris les macros)
Mais si vous voulez un vrai moteur de génération de code jetez un oeil sur Apache thrift
Je travaille juste sur un tel outil. Dans notre cas particulier, nous générons le code VB.NET basé sur la couche de données sur les signatures des fonctions de la base de données.
Commencer à travailler sur et avec la génération de code est difficile au début car vous ne savez pas comment le code doit être généré, mais une fois que vous avez un ensemble de règles établi, et le code qui doit être généré peut toujours être généré sur la base de ces règles, travailler avec ce code n'est pas si difficile. Bien sûr, selon la complexité de la génération de code et le nombre de règles, la tâche peut devenir plus difficile. Mais en substance, la génération de code automatique est utilisée pour les tâches de codage répétitives et non pour le code avancé qui varie beaucoup.
Test la sortie est double. Vous devez d'abord vous assurer que le code compile, et c'est facile. Ensuite, vous devez vous assurer que la sortie fait ce que vous vouliez faire en fonction des paramètres sur lesquels elle a été générée .. et la difficulté de cela dépend de la complexité du code que vous générez.
Ma recommandation sincère est que si vous avez envie d'écrire du code de manière répétitive, et vous pouvez vous en donner le temps .. Essayez de penser si ce que vous faites ne peut pas être fait par du code généré. Et si c'est le cas (si c'est du code répétitif que c'est presque toujours le cas), pensez combien de fois devrez-vous étendre, modifiez légèrement ce code et aussi combien de fois devez-vous écrire ce type de code exact. Si la réponse à l'un d'entre eux est "plusieurs", alors vous devriez sérieusement envisager de créer un générateur pour ce code.
J'espère que cela pourra aider,
IPP
La méta-programmation peut être très difficile à maintenir. Au début, il a l'air élégant, mais lorsque vous commencez à courir dans des cas d'angle, les erreurs sont détectées tardivement (sur le code qui a été généré), et le tout devient un cauchemar à utiliser/déboguer.
J'ai principalement écrit python code, et selon mon expérience, la méta-programmation est toujours un mauvais choix avec ce langage. Vous pouvez toujours refactoriser les choses pour le faire avec des fonctionnalités de langage normal ennuyeuses. Le résultat est moins funky , mais plus facile à vivre.
Voir le jeu de problèmes 4 de Philip Greenspun à partir de MIT cours 6.916: Génie logiciel de services Web innovants ( http://philip.greenspun.com/teaching/psets/ps4/ps4.adp ).
Son objectif dit: "Enseigner aux élèves les vertus des métadonnées. Plus précisément, ils apprennent à représenter formellement les exigences d'un service Web, puis à créer un programme informatique pour générer les programmes informatiques qui implémentent ce service.
C'est l'un des problèmes posés par les recrues potentielles d'ArsDigita ( http://en.wikipedia.org/wiki/ArsDigita ) à résoudre lors de la première bulle.
Le livre "SQL for Web Nerds" dans le pset a été déplacé dans ( http://philip.greenspun.com/sql/ ).
OP demande des ressources.
Vous pourriez trouver notre DMS Software Reengineering Toolkit intéressant. Il s'agit d'un pur outil de métaprogrammation, destiné à permettre la création d'outils d'analyse et de transformation de programme personnalisés.
[Pour suivre un commentaire à la question d'OP, lorsqu'il est utilisé pour créer un outil de transformation spécifique, DMS est une ligne de produits qui écrit du code, qui écrit du code:]
DMS y parvient en étant agnostique (mais pas indépendant) des langues de programmation cible. DMS fournit les services standard requis par une grande variété de tâches de métaprogrammation, tout comme un système d'exploitation fournit une grande variété de services pour les tâches de programmation standard. Ces services incluent une analyse syntaxique forte, la construction automatique d'arbres syntaxiques abstact, la correspondance de modèles et la réécriture sur les arbres, des bibliothèques de tables de symboles qui gèrent facilement les langages avec des règles de cadrage désagréables telles que l'héritage multiple, le flux de contrôle, le flux de données, les points vers et l'appel. analyse graphique. Rien de tout cela n'est significatif en l'absence de langages spécifiques à traiter, donc DMS accepte les définitions de langage qui sont liées à ces machines générales, produisant une analyse spécifique au langage, AST construction, langue cible- correspondance/réécriture de modèles spécifiques à l'aide de la syntaxe du langage cible, d'analyseurs spécifiques à la langue cible, etc.
Et comme un système d'exploitation, DMS est conçu pour avoir très peu d'opinions ou de contraintes sur les (méta) programmes que vous souhaitez écrire, ce qui signifie qu'il peut être utilisé à des fins diverses: extraire des métriques, trouver du code mort, implémenter des tisserands d'aspect, traduire langauges, génération de codes à partir de DSL, réarchitecture de grandes applications. (DMS a déjà été utilisé pour toutes ces tâches).
Il faut des définitions de langage robustes si vous ne voulez pas passer votre temps à tout coder dans le manuel de référence de langauge (pensez à ce que cela signifie pour Java et C++). DMS résout ce problème en ayant un bibliothèque de définitions de langauge complètes disponibles. L'analogue ici est un peu comme avoir une base de données disponible pour votre système d'exploitation; vous n'avez pas à en implémenter une pour commencer à écrire votre application centrée sur la base de données.
Vers 2001, j'ai commencé à travailler sur un projet qui faisait un usage intensif des objets métier et des objets de données. Je devais construire le site Web frontal, mais j'ai raccroché en me tordant les pouces car la couche métier et la couche d'accès aux données n'étaient pas complètement développées. Après quelques semaines, j'ai commencé à regarder attentivement ce que faisaient ces couches. Fondamentalement, ils exposaient les données renvoyées par les procédures stockées en tant que collections d'objets avec des propriétés correspondant aux champs des données, ou prenaient des paramètres d'entrée et les envoyaient à des procédures stockées pour être enregistrées dans des tables de base de données. Il y avait beaucoup de sérialisation/désérialisation en cours entre les deux couches, il y avait Microsoft Transaction Server impliqué, une bibliothèque de types IDL/ODL ... mais tout correspondait à un modèle.
2 semaines plus tard, j'ai eu un générateur de code élaboré qui déchargerait IDL/ODL, et déchargerait également les objets métier et de données. Il avait fallu au gars qui construisait les objets métier et de couche de données 2 ans pour arriver à déboguer et tester ces objets. En 2 semaines, avec la génération de code, nous avons eu la même sortie, mais comme tout était généré, il était quasiment sans bug.
Ce générateur de code (outil CASE de niveau inférieur) m'a suivi à travers de nombreuses itérations différentes, pendant environ 8 à 10 ans, car le principe était tellement simple: vous faites quelque chose qui doit être fait lorsque vous parlez à des bases de données, c'est assez beaucoup de codage répétitif, et une fois que vous avez bien compris, vous n'avez plus à vous en préoccuper.
Donc, oui: utilisez un générateur de code, en particulier lorsque le codage est répétitif et correspond à un modèle bien défini.
J'ai connu des gens pour utiliser des macros RegX pour faire des choses similaires, ou pour utiliser des formules Excel pour faire des choses similaires (je fais ça aussi).
Un exemple de métaprogrammation
J'ai une bibliothèque d'autorisation Ruby appelée Authority . Elle permet aux développeurs de poser des questions dans leur application avec des méthodes comme current_user.can_read?(@post) et @post.readable_by?(current_user). Ces questions sont traitées par des classes d'autorisation centralisées.
C'est la partie cruciale: L'autorité ne sait pas quelles méthodes définir avant de voir la configuration de l'utilisateur . La configuration utilisateur peut contenir:
config.abilities = {
...
:read => 'readable',
:microwave => 'microwavable', # user-defined
...
}
Dans ce cas, il doit y avoir une méthode comme current_user.can_microwave?(@post).
La métaprogrammation rend cela possible: après avoir lu la configuration, je sais quelles méthodes définir :
Authority.verbs.each do |verb|
class_eval <<-Ruby, __FILE__, __LINE__ + 1 # allows for a Nice bracktrace
def can_#{verb}?(resource)
resource.#{Authority.abilities[verb]}_by?(self)
end
Ruby
end