struct Sync {
    void Lock();
    void Release();
};

struct Locker {
    Locker(Sync& obj_) : obj(obj_) { obj.Lock(); }
    ~Locker() { obj.Release(); }
    Sync& obj;
};

#define LOCK(x)\
Locker locker_##__FILE__##__LINE__(x);

{
    LOCK(s);
    std::out << s.SayHelloWorld();
}

Lisp
• Metaprogramming seems to have originated in Lisp.
Lisp is a programmable programming language.
—John Foderaro
In Lisp, you don’t just write your program down toward the language, you also build the language up toward your program.
—Paul Graham
• Lisp isn’t the only programmable language.

Ruby
• Rubyists have been rediscovering metaprogramming.
• Ruby style and idioms are still changing and adapting.
• Rails leverages metaprogramming heavily.
• To great effect!
• Ruby is a natural for metaprogramming.

How To Think About Metaprogramming
• Defining new constructs for your programming language.
• OK, but … constructs to do what?
• Whatever your domain-specific language (DSL) needs to do.

Another Way To Think About Metaprogramming
• A new set of conceptual tools for eliminating duplication (and other smells) from your code.

Domain Specific Language for Builds

All my three build languages share another characteristic — they are all examples of a Domain Specific Language (DSL). However they are different kinds of DSL. In the terminology I've used before:
* make is an external DSL using a custom syntax
* ant (and nant) is an external DSL using an XML based syntax
* rake is an internal DSL using Ruby.

The fact that rake is an internal DSL for a general purpose language is a very important difference between it and the other two. It essentially allows me to use the full power of ruby any time I need it, at the cost of having to do a few odd looking things to ensure the rake scripts are valid ruby. Since ruby is a unobtrusive language, there's not much in the way of syntactic oddities. Furthermore since ruby is a full blown language, I don't need to drop out of the DSL to do interesting things — which has been a regular frustration using make and ant. Indeed I've come to view that a build language is really ideally suited to an internal DSL because you do need that full language power just often enough to make it worthwhile — and you don't get many non-programmers writing build scripts.

event_queue "airspace" do
  generate_event_every 5.minutes + 26.seconds
  collision_radius 197.feet + 6.inches
end

builder = SimpleBuilder.new
builder.entry { |x|
  x.name me.name
  x.email me.email
}

<entry><name>Jim</name><email>jim@fakemail.com</email></entry>

route "Problems" do
  step "Problem Resolution"
end

route "EMail Order" do
  step "Validate Customer"
  step "Assemble Order"
  step "Charge Credit Card" do
    on "invalid", :route => "Problems", :step => "Problem Resolution"
  end
  step "Ship"
end
  
generate_sql

INSERT INTO queues(id, name) VALUES (1, 'Validate Customer');
INSERT INTO queues(id, name) VALUES (2, 'Validate Books');
INSERT INTO queues(id, name) VALUES (3, 'Charge Credit Card');
INSERT INTO queues(id, name) VALUES (4, 'Ship Order');
INSERT INTO queues(id, name) VALUES (5, 'Problem Resolution');

INSERT INTO routes(id, name) VALUES (1, 'EMail Book Orders');
INSERT INTO routes(id, name) VALUES (2, 'Problems');

INSERT INTO steps(id, route_id, queue_id) VALUES(1, 1, 1);
INSERT INTO steps(id, route_id, queue_id) VALUES(2, 1, 2);
INSERT INTO steps(id, route_id, queue_id) VALUES(3, 1, 3);
INSERT INTO steps(id, route_id, queue_id) VALUES(4, 1, 4);
INSERT INTO steps(id, route_id, queue_id) VALUES(5, 2, 5);

INSERT INTO alternatives(id, step_id, code, next_step_id)
  VALUES (1, 3, 'invalid', 5);

E>event_queue "airspace" do
E>  generate_event_every 5.minutes + 26.seconds
E>  collision_radius 197.feet + 6.inches
E>end
E>

(2 * #orange) + (3 * #apple) "= 2orange+3apple"
0.65s * #US * 100 "= 65.00US"

4 ~> 'kg'    "makes 4 kilograms"
5 as: 'cd.m/hr2'    "makes 5 meter-candelas per hour squared"
1 ~> 'm' ~> 'cm'    "makes 1 meter, and converts it into 100 centimeters"
4 mL "makes 4 milliliters"

E>builder = SimpleBuilder.new
E>builder.entry { |x|
E>  x.name me.name
E>  x.email me.email
E>}
E>

E><entry><name>Jim</name><email>jim@fakemail.com</email></entry>
E>

aBuilder entry: [:entry |
    entry name: self name.
    entry email: [:email |
        item title: 'This is my email'.
        item description: 'This is the description of the e-mail']].

E>route "Problems" do
E>  step "Problem Resolution"
E>end

E>route "EMail Order" do
E>  step "Validate Customer"
E>  step "Assemble Order"
E>  step "Charge Credit Card" do
E>    on "invalid", :route => "Problems", :step => "Problem Resolution"
E>  end
E>  step "Ship"
E>end
  
E>generate_sql
E>

E>INSERT INTO queues(id, name) VALUES (1, 'Validate Customer');
E>INSERT INTO queues(id, name) VALUES (2, 'Validate Books');
E>INSERT INTO queues(id, name) VALUES (3, 'Charge Credit Card');
E>INSERT INTO queues(id, name) VALUES (4, 'Ship Order');
E>INSERT INTO queues(id, name) VALUES (5, 'Problem Resolution');

E>INSERT INTO routes(id, name) VALUES (1, 'EMail Book Orders');
E>INSERT INTO routes(id, name) VALUES (2, 'Problems');

E>INSERT INTO steps(id, route_id, queue_id) VALUES(1, 1, 1);
E>INSERT INTO steps(id, route_id, queue_id) VALUES(2, 1, 2);
E>INSERT INTO steps(id, route_id, queue_id) VALUES(3, 1, 3);
E>INSERT INTO steps(id, route_id, queue_id) VALUES(4, 1, 4);
E>INSERT INTO steps(id, route_id, queue_id) VALUES(5, 2, 5);

E>INSERT INTO alternatives(id, step_id, code, next_step_id)
E>  VALUES (1, 3, 'invalid', 5);
E>

courseTitlesForProfessorNamed: aString
  |courses|
  courses := (professors * courses
       select: [[:ea | (ea lastName = aString) & (ea id = ea professorID)].
  ^ (courses project: #title) copyFrom: 1 to: 10.

SELECT title 
    FROM Professor, Course 
    WHERE Professor.lastName = 'Foo' AND Professor.id = Course.professorID LIMIT 10