Are there real world applications that use metaprogramming?

We all know that MetaProgramming is a Concept of Code == Data (or programs that write programs).

Bu开发者_运维百科t are there any applications that use it & what are the advantages of using it?

This Question can be closed but i didnt see any related questions.

IDEs are full with metaprogramming:

• code completion
• code generation
• automated refactoring

Metaprogramming is often used to work around the limitations of Java:

• code generation to work around the verbosity (e.g. getter/setter)
• code generation to work around the complexity (e.g. generating Swing code from a WYSIWIG editor)
• compile time/load time/runtime bytecode rewriting to work around missing features (AOP, Kilim)
• generating code based on annotations (Hibernate)

Frameworks are another example:

• generating Models, Views, Controllers, Helpers, Testsuites in Ruby on Rails
• generating Generators in Ruby on Rails (metacircular metaprogramming FTW!)

In Ruby, you pretty much cannot do anything without metaprogramming. Even simply defining a method is actually running code that generates code.

Even if you just have a simple shell script that sets up your basic project structure, that is metaprogramming.

Since code as data is one of key concepts of Lisp, the best thing would be to see the real applications of projects written in these.

On this link you can see an article about a real world application written partly in Clojure, a dialect of Lisp.

The thing is not to write programs that write programs, just because you can, but to add new functionality to your language when you really need it. Just think if you could simply add new keyword to Java or C#...

If you implement metaprogramming in a language-independent way, you get a program analysis and transformation system. This is precisely a tool that treats (arbitrary) programs as data. These can be used to carry out arbitrary transformations on arbitrary programs.

It also means you aren't limited by the specific metaprogramming features that the compiler guys happened to put into your language. For instance, while C++ has templates, it has no "reflection". But a program transformation system can provide reflection even if the base langauge doesn't have it. In particular, having a program transformation engine means never having to say "I'm sorry, your language doesn't support metaprogramming (well enough) so I can't do much except write code manually".

See our DMS Software Reengineering Toolkit for such a program transformation system. It has been used to build test coverage and profiling tools, code generation tools, tools to reshape the architecture of large scale C++ applications, tools to migrate applications from one langauge to another, ... This is all extremely practical. Most of the tasks done with DMS would completely impractical to do by hand.

Not a real world application, but a talk about metaprogramming in ruby:

• http://video.google.com/videoplay?docid=1541014406319673545

Google TechTalks August 3, 2006 Jack Herrington, the author of Code Generation in Action (Manning, July 2003) , will talk about code generation techniques using Ruby. He will cover both do-it-yourself and off-the-shelf solutions in a conversation about where Ruby is as a tool, and where it's going.

A real world example would be Django's model metaclass. It is the class of the class, from which models inherit from and responsible for the outfit of the model instances with all their attributes and methods.

Any ORM in a dynamic language is an instant example of practical metaprogramming. E.g. see how SQLAlchemy or Django's ORM creates classes for tables it discovers in the database, dynamically, in runtime.

ORMs and other tools in Java world that use @annotations to modify class behavior do a bit of metaprogramming, too.

Metaprogramming in C++ allows you to write code that will get transformed at compilation.

There are a few great examples I know about (google for them):

• Blitz++, a library to write efficient code for manipulating arrays
• Intel Array Building Blocks
• CGAL
• Boost::spirit, Boost::graph

Many compilers and interpreters are implemented with metaprogramming techniques internally - as a chain of code rewriting passes.

ORMs, project templates, GUI code generation in IDEs had been mentioned already.

Domain Specific Languages are widely used, and the best way to implement them is to use metaprogramming.

Things like Autoconf are obviously cases of metaprogramming.

Actually, it's unlikely one can find an area of software development which won't benefit from one or another form of metaprogramming.