Depois de ler o livro The Pragmatic Programmer , um dos argumentos que achei mais interessantes foi "escrever código que escreve código".

Tentei pesquisar na internet mais explicações ou artigos sobre o assunto e, embora tenha encontrado bons artigos sobre o assunto, ainda não encontrei nenhuma implementação de código específica ou bons exemplos.

Eu sinto que ainda não é um argumento tão comum, algo que carece de documentação ou que não é adotado por tantas pessoas, e eu gostaria de saber mais sobre isso.

O que você acha do assunto? É algo que realmente aumentará sua produtividade? Quais são alguns bons recursos sobre o assunto, entre livros, blogs, apresentações de slides, etc?

Alguns exemplos de código seriam muito apreciados para me permitir entender melhor sua implementação.

Aqui está a página wiki sobre o assunto com várias técnicas de programação relevantes, como Meta Programação, Programação Generativa e Geração de Código.

No mundo Lisp, é bastante comum ver o código que escreve código que escreve código (e assim por diante). Portanto, qualquer projeto Lisp ou Scheme de tamanho decente servirá como um bom exemplo de código. Eu recomendo olhar para o compilador Racket e as fontes de tempo de execução, bem como o Bigloo , suas bibliotecas são simplesmente brilhantes.

Quanto à produtividade: estou usando a metaprogramação como uma técnica dominante em quase todo o meu trabalho de desenvolvimento, e isso claramente ajuda bastante, reduzindo o tamanho do código e aumentando sua legibilidade. A chave está no uso de idiomas específicos do domínio , e a metaprogramação é uma das maneiras mais eficientes de implementá-los.

Prefiro ir um pouco mais longe e, em vez de escrever código que escreve código, escreve código que gera objetos, métodos, funções. Isso pode ser conseguido com macros Lisp ou recursos de modificação de programa dinâmico Ruby, por exemplo.

A pequena diferença é que você não termina com os arquivos de origem que foram gerados automaticamente. Geralmente, esses arquivos não são legíveis por humanos e não podem ser modificados; portanto, por que se preocupar com eles? Não gosto da ideia de aumentar minha base de código com algo que não posso controlar.

Um livro que gostei de ler sobre o assunto foi Metaprogramação de Ruby (se você conhece o idioma Ruby)

Edite após a seguinte pergunta no comentário:

Por que seria útil ainda ter que codificar o código gerador? Devo escrever um código capaz de gerar coisas diferentes, dependendo da entrada do usuário, para poder reutilizá-lo repetidamente?

Primeiro, a metaprogramação não é uma meta, mas uma ferramenta. Não use metaprogramação porque "é legal" ou "o X disse que todo desenvolvedor deveria usá-lo".

Eu acho que uma boa razão para usar a metaprogramação é generalizar algum padrão comum (padrão como algo que se repete) que você encontrou em seu código e que nenhuma outra técnica de programação usual (herança, padrões de design etc.) pode alcançar.

Como dito por Jordan , um caso de uso típico é manipulação de banco de dados e ORM (Object Relation Mapping). Mais uma vez, no Ruby, você deve observar o ActiveRecord, que é um ótimo exemplo de metaprogramação aplicada ao ORM.

Como nota final:

Não pense "Quero aplicar a metaprogramação, onde posso aplicá-la no meu código?".

Pense "Eu vejo esse padrão que se repete em todo o meu código, não consigo encontrar uma maneira de refatorar o código em algo menor e mais reutilizável. Talvez a metaprogramação possa me ajudar?"

Melhor ainda, use o código que outra pessoa escreveu que escreve seu código para você.

A automação de código geralmente é boa para ORMs e outros códigos de interação com o banco de dados e, é claro, para a criação de código repetitivo, mas semelhante.

Claro, se você estiver criando muitas classes parecidas, talvez possa ter conseguido a mesma coisa em uma linguagem dinâmica muito antes, mas discordo.

Isso é adotado por muitas pessoas, embora você frequentemente encontre o software rotulado como gerador de código.

Veja empresas e produtos como CodeSmith e MyGeneration ou navegue neste artigo da Wikipedia: http://en.wikipedia.org/wiki/Comparison_of_code_generation_tools

Um dos exemplos clássicos é lex e yacc. Seu principal objetivo é evitar a labuta de escrever qualquer tipo de analisador. Ao longo do caminho, eles tornam muito mais rápido a criação de analisadores complexos com muitas regras e estados e também evitam todos os erros de surpresa cometidos por pessoas que criam seus próprios.

Essa também é a idéia por trás de c, que é uma ferramenta para escrever assembler. O mesmo vale para qualquer idioma de alto nível que você queira nomear. Para ferramentas que escrevem código para você, existem alguns paradigmas simples.

Um IDE adequado ajuda fornecendo documentação na ponta dos dedos, preenchimento automático inteligente e trechos de código. Os IDE também incluem vários modelos, para que você não precise iniciar um programa do zero. Existem programas para fazer um diagrama de uml e classificar as aulas em um idioma de alto nível.

Por fim, você pode escrever suas próprias ferramentas para geração de código no seu conjunto de problemas. Foi assim que lex e yacc começaram. Qualquer tipo de idioma específico do domínio existe exatamente por esse motivo. Você cria alguns blocos de construção que descrevem sua solução em um código mais fácil de entender, agrupando atividades comuns ou seções complicadas com comandos simples. Você não está procurando uma solução para todos os problemas, apenas uma definição mais fácil do específico com o qual está lidando.

Em certo sentido, tudo o que você faz acima da camada binária é automação de código.

Metaprogramação

A metaprogramação é uma técnica controversa em muitas lojas. O motivo é que, como qualquer ferramenta poderosa, a magnitude da ajuda ou do dano é grande.

Prós

• Mais expressivo, menos código para escrever e manter (geralmente por uma ordem de magnitude ou mais)
• Consistência, comportamento mais consistente sobre a classe de problemas que você resolve com o código
• Produtividade, menos código para uma solução para um espaço maior de problemas

Contras

• Complexidade, pode ser muito complicado, embora exista menos código
• Segurança, algum tipo de segurança e análise estática em geral serão sacrificadas
• Os bugs afetam mais, pequenos erros terão um impacto maior

Sou um grande fã de metaprogramação, mas faço isso há muito tempo. Para mim, a troca de tamanho de código reduzido e comportamento consistente mais do que compensar os riscos. Menos código significa menos erros, menos código para manter, e geralmente posso adicionar grandes partes de funcionalidade rapidamente.

No entanto, isso não significa que eu acho que todos os programadores deveriam se envolver nele. Eu já vi e tive que corrigir grandes problemas criados pela metaprogramação. Geralmente a partir de quando pessoas que não entendem o conceito e tentam estender a funcionalidade, ou apenas consertam um bug. É preciso uma mentalidade específica que seja no mínimo orientada para os detalhes. A questão de usar técnicas de metaprogramação deve ser uma decisão da equipe . Se você tem membros da equipe que não entendem, não tem temperamento para isso ou é contra, nenhuma equipe deve usar a metaprogramação.

A maioria dos códigos escreve códigos. Por exemplo, o código php ajuda a escrever html. A biblioteca php pdo ajuda a escrever chamadas SQL. As funções de E / S do arquivo gravam código para se comunicar com o sistema operacional. Mesmo uma chamada de função regular é uma referência a outro bloco de código que é executado. Portanto, suas chamadas de funções estão escrevendo código.

Em termos gerais, podemos pensar em computação como escrever códigos que escrevem códigos de forma recursiva, formando uma pilha que termina quando se depara com a realidade física dos códigos conectados ao hardware.

Como você faz isso varia de acordo com seus requisitos. Supondo que você esteja usando a geração de código estático, você poderá escrever toda a infraestrutura ou usar um gerador existente, como CodeSmith ou MyGeneration. Usando estes, você só precisa escrever os modelos necessários.

Meu último projeto envolveu algumas telas básicas do ASP.NET CRUD (a geração de código é boa para isso). O processo foi definir entidades como metadados em arquivos xml. Escreva modelos para cobrir os vários artefatos necessários (classes de entidade, repositórios, classes de serviço, controles asp.net, páginas asp.net etc.). Execute o processo de geração e denomine a saída.

Há alguma sobrecarga na escrita dos modelos, mas eles podem ser reutilizados para projetos semelhantes subsequentes. Da mesma forma, as alterações nos dados subjacentes são tratadas alterando os metadados e executando novamente a geração, tornando as alterações mais simples e rápidas de implementar.

Quanto ao teste. Como esse é um sistema de modelo, você precisará gastar algum tempo validando inicialmente a saída do processo, se o modelo estiver errado, toda a saída desse modelo estará igualmente errada. Quando estiver satisfeito com isso, você também poderá usar os geradores de código para criar testes básicos a partir dos metadados xml, que poderão ser estendidos para cobrir casos especiais. No entanto, lembre-se de que você ainda pode precisar entregar testes de código para atender a coisas específicas, a geração de código reduz seu trabalho e não o elimina completamente.

Em nossa empresa, usamos algumas ferramentas que realmente geram classes C ++ ou C # com dados baixados da Internet. Essas classes são contêineres de dados e contêm um grande número de objetos nas listas.

A metaprogramação faz parte da programação há muito tempo. Considere não apenas ferramentas como os designers SWIG ou WYSIWYG, que criam código, mas também ferramentas na linguagem como o pré-processador de C, ou mesmo os modelos de C ++ e os genéricos de C # / Java - para não mencionar o Reflection.

De fato, você poderia argumentar que todo compilador é apenas outro metaprograma - eles recebem o texto do programa e a máquina de saída ou o código da VM. E vida sem compiladores? Owch.

Aqui está um exemplo concreto do meu passado.

Eu estava trabalhando em um site que tinha cerca de 50 MB de código-fonte Delphi usando o BDE para acesso a dados. Eles queriam mudar para o uso do Direct Oracle Access para permitir uma atualização do Oracle além da versão mais alta suportada pelo BDE (8i, se bem me lembro).

Então, em vez de fazer com que uma equipe de codificadores trabalhe em todos os formulários e módulos de dados alterando todos os componentes manualmente, escrevi um script PERL que:

1. Analisou o DFM (arquivo de formulário) e identificou todos os objetos TQuery, TTable, TStoredProcedure & TDatabase - armazenando os itens em uma lista.

2. Analisou o PAS (código) e identificou o uso dos objetos - os TQueries estavam fazendo atualizações ou seleções? Além disso, ele identificou qualquer objeto criado no código, em vez de soltá-lo em um formulário no IDE.

3. Reescreva o DFM e o PAS alterando os tipos de objetos adequadamente (por exemplo, TTable -> TOracleDataSet com a propriedade SQL definida como "selecione * de" etc) e as chamadas de método. Além disso, chamadas de método extras foram adicionadas, se apropriado, para fechar, abrir e definir parâmetros.

Em resumo, três semanas de trabalho aprimorando o script para trabalhar em diferentes aplicativos escritos por equipes diferentes com diferentes estilos de codificação, em vez da estimativa original de mais de 5 desenvolvedores trabalhando por 6 meses.

E o motivo pelo qual pensei em usar essa abordagem foi através da leitura de O Programador Pragmático

Você pede exemplos ....

Ao trabalhar com SQL, você não deve alterar o banco de dados diretamente, mas deve executar scripts que fazem as alterações desejadas, incluindo alterações estruturais no banco de dados (adição de tabelas, colunas, chaves primárias, restrições e assim por diante) . Com bastante frequência, você precisará executar a mesma ação em várias tabelas ou colunas ao mesmo tempo, e fazê-las uma a uma seria tedioso, um script curto que gera um script maior que faz o que você quer pode ser real. economia de tempo.

Por exemplo, antes de o tipo de dados DATE ser introduzido no MS SQl Server, a única opção para uma coluna de data era DATETIME, que possui uma parte do tempo - uma parte do tempo que torna mais difícil lidar com os dados. Ao fazer upgrade para uma versão com o tipo de dados Data, convém atualizar as colunas em que a hora é sempre 00:00. Em um banco de dados com dezenas ou mesmo centenas de colunas DateTime, isso consumiria bastante tempo. Mas é fácil escrever um script que consulta todas as tabelas, verificando todas as colunas com um tipo de dados DATETIME para ver se é a hora das 00:00 e se não criar uma instrução ALTER para que a tabela / coluna seja alterada o tipo de dados para DATE. Presto, código que escreve código.

Dê uma olhada nas macros CL (lábios comuns). Na minha opinião, é exatamente isso que você deseja. Lábios é perfeito na metaprogramação.

Também sugiro Nemerle se você deseja ter recursos .NET com suporte perfeito à metaprogramação (incluindo macros)

Mas se você deseja um verdadeiro mecanismo de geração de código, dê uma olhada no Apache Thrift

Estou apenas trabalhando em uma ferramenta desse tipo. Em nosso caso específico, geramos o código VB.NET com base na camada de dados nas assinaturas das funções no banco de dados.

É difícil começar a trabalhar e com a geração de código, pois você não tem idéia de como o código deve ser gerado, mas depois de ter um conjunto de regras estabelecido, o código que deve ser gerado sempre pode ser gerado com base nessas regras. , trabalhar com esse código não é tão difícil. Obviamente, dependendo da complexidade da geração de código e do número de regras, a tarefa pode se tornar mais difícil. Mas, em essência, a geração automática de código é usada para tarefas de codificação repetitivas e não para códigos avançados que variam muito.

Testar a saída é duplo. Primeiro, você precisa garantir que o código seja compilado, e isso é fácil. Então você deve se certificar de que a saída faça o que você quis fazer com base nos parâmetros em que foi gerada .. e a dificuldade disso varia na complexidade do código que você gera.

Minha recomendação sincera é que, se você sentir vontade de escrever código de maneira repetitiva e puder gastar tempo, tente pensar se o que está fazendo não pode ser feito pelo código gerado. E se sim (se for um código repetitivo do que quase sempre é o caso) pense quantas vezes você precisará estender, modifique levemente esse código e também quantas vezes você precisará escrever esse tipo exato de código. Se a resposta para qualquer uma dessas opções for "muitas", considere seriamente criar um gerador para esse código .

Espero que ajude,
IPP

Eu tenho um módulo PHP que gera uma página da web que contém código JavaScript que gera HTML. São três camadas bem ali. Rapaz foi tão difícil de ler!

Em uma aula de programação, tivemos que escrever um programa que pegasse uma string de fórmula do usuário e a analisasse e exibisse o valor. O solucionador mais impressionante simplesmente pegou a entrada do usuário, colocou-a em main () {printf ("% d", ...);} e executou um script para compilar, vincular e executá-la. Ele não escreveu um analisador! Hoje você pode fazer isso em uma instrução SQL SELECT.

É uma ferramenta com a qual você deve brincar e depois guardá-la para algum dia futuro, quando for útil.

Eu desenvolvi soluções simples de meta-programação com o Prolog . Onde o aplicativo principal (em C ++, por exemplo) converte uma definição abstrata de um problema em um aplicativo Prolog em tempo de execução, o qual é delegado. Geralmente, escrever funcionalidades equivalentes em C ++ levaria uma eternidade.

Eu acho que esse cenário é um excelente caso a favor do argumento código-escrita-código .

O que você acha do assunto?

A metaprogramação é mais comumente associada a linguagens não dinâmicas, uma vez que é mais difícil obter determinados comportamentos (como implementar um ORM) sem muitas linhas de código não produtivas e não inteligentes.

Mas mesmo em linguagens mais dinâmicas como PHP, a geração de código pode realmente salvar a vida e aumentar a produtividade em grande quantidade. Nas estruturas modernas, é muito comum ter andaimes que geram a maioria do modelo, formulário, teste e ações comuns para um determinado objeto de negócios que você declara. É uma das razões pelas quais estruturas como o symfony ou o RoR têm tanto sucesso que essas ferramentas de geração de código tornam o código consistente muito rapidamente e aumentam a produtividade dos programadores.

Nos sites, a maior parte da interação gira em torno de quatro ações principais:

• Crie um elemento
• Recuperar um conjunto de elementos (com possível filtragem)
• Atualize um elemento com novos atributos
• Excluir um conjunto de elementos

Pelo menos tudo o que gira em torno dessas quatro ações principais poderia e deveria ser alcançado usando ferramentas de geração de código para obter a máxima produtividade.

Na minha empresa, usamos o symfony, e seu administrador-gerador é uma ferramenta excepcional, que até gera código em tempo de execução (e o armazena em cache), o que significa que nem precisamos usar nenhum tipo de tarefa ou ferramenta externa para Para gerar um novo código, precisamos apenas limpar nosso cache. Eu aconselho fortemente o uso desse tipo de ferramenta para operações CRUD.

Mas, fazer o que os colaboradores incríveis do symfony fizeram, não é uma tarefa fácil. Eu mesmo implementei algumas tarefas de geração de código e fazer algo verdadeiramente consistente e com uma ampla implementação para cobrir a maioria dos casos extremos não é fácil.

É algo que realmente aumentará sua produtividade?

Acredito que a metaprogramação é muito muito importante em níveis mais baixos de trabalho (estruturas, cache, compiladores etc.), mas algo que devemos abordar com extrema cautela se estivermos fazendo coisas na camada de negócios.

Usar a geração de código é, sem dúvida, um grande impulsionador da produtividade. Implementando suas próprias ferramentas de geração de código, não muito, a menos que você mesmo esteja criando uma estrutura.

Quais são alguns bons recursos sobre o assunto, entre livros, blogs, apresentações de slides, etc?

O melhor recurso para entender a programação é sempre um código fonte bom e bem comentado. Eu diria que analisar os geradores de administração RubyOnRails e Symfony é uma boa idéia.

Embora muitas respostas aqui se refiram ao que é comumente conhecido como metaprogramação, havia de fato um campo associado à IA conhecido como programação automática que tratava de programas que compreendiam ou sintetizavam programas [1].

Qualquer compilador (ou metaprograma, gerador de código, tradutor, sistema macro, ...) trabalha com transformações, gerando uma saída de uma entrada executando seu algoritmo fixo de transformação. Mas um compilador ou metaprograma tradicional não, dada uma definição, descrição ou exemplo do que é uma classificação (por exemplo, [5, 3, 9] => [3,5,9]), cria um algoritmo de classificação. Tais problemas são do interesse deste campo "programação automática".

[1] - Relatório de andamento dos sistemas de compreensão de programas ftp://db.stanford.edu/pub/cstr/reports/cs/.../CS-TR-74-444.pdf

Meta programação pode ser muito difícil de manter. A princípio, parece elegante, mas quando você começa a encontrar casos extremos, os erros são detectados tardiamente (no código que foi gerado) e tudo se torna um pesadelo para usar / depurar.

Eu escrevi principalmente código python e, na minha experiência, a meta programação é sempre uma má escolha com essa linguagem. Você sempre pode refatorar coisas para fazer isso com recursos de idioma normal chatos. O resultado é menos desagradável, mas mais fácil de conviver.

O OP pede recursos.

Você pode achar interessante o nosso DMS Software Reengineering Toolkit . É uma ferramenta de metaprogramação pura, destinada a permitir a criação de ferramentas personalizadas de análise e transformação de programas.

[Para seguir um comentário à pergunta do OP, quando usado para criar uma ferramenta de transformação específica, o DMS é uma linha de produtos que escreve código, que escreve código:]

O DMS consegue isso por ser independente (mas não independente) das linguagens de programação de destino. O DMS fornece os serviços padrão necessários para uma ampla variedade de tarefas de metaprogramação, assim como um sistema operacional fornece uma ampla variedade de serviços para tarefas de programação padrão. Esses serviços incluem análise forte, construção automática de árvores de sintaxe abstact, correspondência de padrões e reescrita em árvores, bibliotecas de tabelas de símbolos que gerenciam facilmente idiomas com regras de escopo desagradáveis, como herança múltipla, fluxo de controle, fluxo de dados, fluxo de dados, apontar e chamar análise de grafos. Nada disso é significativo na ausência de linguagens específicas para processar; portanto, o DMS aceita definições de linguagem que estão vinculadas a essas peças gerais de máquinas, gerando análise específica de idioma, construção AST, correspondência / reescrita de padrão específico de idioma de destino usando o target- sintaxe de idioma,

E, como um sistema operacional, o DMS foi projetado para ter muito poucas opiniões ou restrições sobre quais (meta) programas você deseja escrever, o que significa que pode ser usado para uma ampla variedade de finalidades: extração de métricas, localização de código morto, implementação de tecelões de aspecto, tradução linguagens, gerando códigos a partir de DSLs, pesquisando novamente grandes aplicativos. (O DMS já foi usado para todas essas tarefas).

É necessário ter definições de linguagem robustas, se você não quiser gastar seu tempo codificando tudo no manual de referência do idioma (pense no que isso significa para Java e C ++). O DMS resolve esse problema, disponibilizando uma biblioteca de definições completas de idioma. O analógico aqui é como ter um banco de dados disponível para o seu sistema operacional; você não precisa implementar um deles para continuar escrevendo seu aplicativo centrado no banco de dados.

Consulte o conjunto de problemas 4 de Philip Greenspun, no curso 6.916 do MIT: Engenharia de Software de Serviços Web Inovadores ( http://philip.greenspun.com/teaching/psets/ps4/ps4.adp ).

Seu objetivo diz: "Ensine aos alunos as virtudes dos metadados. Mais especificamente, eles aprendem a representar formalmente os requisitos de um serviço da Web e, em seguida, criam um programa de computador para gerar os programas que implementam esse serviço".

Esse é um dos conjuntos de problemas que os potenciais recrutas da ArsDigita ( http://en.wikipedia.org/wiki/ArsDigita ) foram solicitados a resolver durante a primeira bolha.

O livro "SQL for Web Nerds", referências de Philip no pset, foi movido para ( http://philip.greenspun.com/sql/ ).

Por volta de 2001, comecei a trabalhar em um projeto que fazia uso extensivo de objetos de negócios e objetos de dados. Eu estava construindo o site front-end, mas fiquei desconectado, porque a camada de negócios e a camada de acesso a dados não estavam totalmente desenvolvidas. Depois de algumas semanas disso, comecei a dar uma olhada no que essas camadas estavam fazendo. Basicamente, eles estavam expondo dados retornados de procedimentos armazenados como coleções de objetos com propriedades correspondentes aos campos nos dados ou estavam pegando parâmetros de entrada e enviando-os para procedimentos armazenados para serem salvos nas tabelas do banco de dados. Havia muita serialização / desserialização ocorrendo entre as duas camadas, havia o Microsoft Transaction Server envolvido, uma biblioteca de tipos IDL / ODL ... mas tudo se encaixava em um padrão.

Duas semanas depois, tive um gerador de código elaborado que despejaria o IDL / ODL e também despejaria os objetos de negócios e dados. O cara que construiu os objetos de negócios e da camada de dados foi 2 anos para chegar ao ponto de depurar e testar esses objetos. Em duas semanas, com a geração de código, tivemos a mesma saída, mas, como tudo foi gerado, estava praticamente livre de erros.

Esse gerador de código (ferramenta CASE de nível inferior) me acompanhou por muitas iterações diferentes, por cerca de 8 a 10 anos, porque o princípio era simples: você está fazendo algo que precisa ser feito ao conversar com bancos de dados, é bastante codificação repetitiva e, assim que você acertar, não precisa mais se preocupar com isso.

Então, sim: use um gerador de código, principalmente quando a codificação for repetitiva e se encaixar em um padrão bem definido.

Conheço pessoas que usam macros RegX para fazer coisas semelhantes ou usam fórmulas do Excel para fazer coisas semelhantes (eu também faço isso).

Um exemplo de metaprogramação

Eu tenho uma biblioteca de autorização Ruby chamada Authority . Ele permite que os desenvolvedores façam perguntas em seus aplicativos com métodos como current_user.can_read?(@post)e @post.readable_by?(current_user). Essas perguntas são respondidas por classes autorizadas centralizadas.

Esta é a parte crucial: a autoridade não sabe quais métodos definir até ver a configuração do usuário . A configuração do usuário pode conter:

config.abilities =  {
  ...
  :read      => 'readable',
  :microwave => 'microwavable',  # user-defined
  ...
}

Nesse caso, é preciso haver um método parecido current_user.can_microwave?(@post).

A metaprogramação torna isso possível: depois de ler a configuração, eu sei quais métodos definir :

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