Lisp Scheme Macros – How Useful Are Lisp Macros

Lisp macros combine a few distinct properties:

1. Macros define new syntax ↔ they use source-code as input
2. Macros usually are run at compile-time
3. Macros generate source-code

The best applications make use of all of those aspects. Probably the most-well known example is the (loop …) in Common Lisp, it wouldn't be anywhere close to its usefulness without one of those features. Without the source as input it would be awkward to define the actions inside the loop; without compile-time expansion it would be way too slow; and without code-generation it wouldn't be executable.

Another fine example is the binary serialization chapter in Practical Common Lisp, Practical: Parsing Binary Files.

A query macro that implements something similar to LINQ might be another good application. But it would be missing the auto-completion that makes LINQ as nice as it is. Almost anything that today is solved by special purpose code-generators with XML inputs (e.g. XAML) could also be implemented using Lisp macros.

Byte code weaving and macros are two different things.

Byte code weaving is a way to intercept function calls, so that you can inject some sort of functionality (generally a cross-cutting concern such as logging) into a function call, either before or after the function is executed. Byte code weaving is done at the byte code level, which means that it occurs after compilation. The function itself is not affected. This is one of the techniques that Aspect Oriented Programming uses.

Macros are a way to extend the syntax of a language. In its simplest form, a macro is simply a way to record keystrokes, and then play them back using a hot key. Language macros work in a similar fashion; a keyword or other syntax construct substitutes for some sort of macro expansion. This is oversimplified, of course; a better example of a macro specific to Lisp can be found here.