Macros: What's the benefit?

Question

Paul Graham writes:

For example, types seem to be an inexhaustible source of research papers, despite the fact that static typing seems to preclude true macros-- without which, in my opinion, no language is worth using.

What's the big deal with macros? I haven't spent a whole lot of time with them, but from the legacy C/C++ I've worked with they appear to be mostly used as a hack before templates/generics existed.

It's hard to imagine that

DECLARELIST(StrList, string);
StrList slist;

is somehow preferable to

List<String> slist;

Am I missing something?

Then there's the usage as a pseudo-function, like MAKEPOINTS:

POINTS MAKEPOINTS(
    DWORD dwValue
);

Why not define it as a function instead? Is this some optimization, where you avoid code duplication without having the added overhead of another stack frame?

Then there's also tricky control flow things involving GOTO, which seem to be of dubious value.

What's so great about macros? They're less type safe (in C and C++) (right?). Why won't Paul Graham program without them?

Answer 1

Macros are really only good for two things in C/C++, and should generally be the tool of last resort (if you can accomplish something without using macros, do so).

1. Creating new syntactic structures or abstractions that do not exist in the language.
2. Eliminating duplication, especially between things that must be in sync with each other.

It's almost never to use a macro as a function.

You also have to realize that LISP macros are not C/C++ macros.

Answer 2

LISP macros are an entirely different beast. C/C++ macros can merely replace a piece of text with abother piece of text using an extremely basic language. Whereas a LISP program is (after "reading") is a LISP data structure and can therefore be manipulated using the whole language.

With such macros, you could (given you're a really clever hacker) vastly extend the language and everybody could use it relatively easily, since you did it with macros. Take for example the the Common Lisp Object System. At its core, the language has nothing even remotely like objects. It is entirely implemented in the language itself, including a relatively simple syntax for use - using macros.

Of course macros are less necessary when the language has most things you'd every want built-in. OTOH, the LISP fans are of the opinion that a sufficiently simple language (LISP) with sufficiently powerful metaprogramming capabilities (macros) is better since new concepts can be incorporated into the language without changing the spec or working implementations. But the most compelling example for macro usage is the DSL area. Ruby on Rails and others show every day how useful DSLs can be. Yes, Ruby doesn't have macros, it just exploits how much Ruby syntax can be bent. In other languages, or when even Ruby's syntax isn't flexible enough, you need macros or a fully-blown parser/interpreter to implement a complex DSL.