My first email to Walter, ever

[Andrei Alexandrescu]

While doing some unrelated research I stumbled upon my very first email 
to Walter, dated April 26, 2004. I liked to see from today's perspective 
where a great collaboration and friendship have started. I thought 
others would also enjoy to see it, so I'm sharing it with Walter's 
approval and a few minor edits.

On 4/26/04 6:54 PM, Andrei Alexandrescu wrote:
> [Walter: I'm going to be ruthless. Put your bulletproof vest on.]
>
> Hi Walter, this is Andrei, we met at SD in Santa Clara.
>
> I was bitching to myself and then together with a friend (e-meet
> [...]) about how hard it is to do metaprogramming in C++. He
> mentioned D is much better at it, and we browsed the online
> documentation for D's templates
> (http://www.digitalmars.com/d/template.html), which we noticed
> (apologies if I am wrong) is not much more more than a
> cleaned-syntax version of C++'s templates, which in turn are
>  [...].
>
> That sucks.
>
> So I said I'd give you the highest order bits of what I think what a
> better language for metaprogramming ought to be like. In spite of my
> ruthlessness, please accept this as a statement of hope that you'd
> be willing to think about this and do something about it.
>
> A metalanguage should bear the same programming style as the base
> language that it serves. I think that's only fair: the programmer
> learns one syntax and set of semantics (e.g. conditionals,
> iterations, objects...), and applies it as transparently as it gets
> to both metaprogramming and regular programming. C++ has a rich
> mixed-mode language for straight programming, and a half-assed (or
> should I say quarter-assed) functional language for metaprogramming.
> You carried this schism in D, while just cleaning the corners.
>
> Terrible. If you have conditionals, iteration, functions, and objects
> in D's straight programming support, you should have conditionals,
> iteration, functions, and objects in D's metalanguage. (I'm not
> asking for things like virtuals, exceptions, contracts, and other
> higher-order stuff on grounds that metaprograms are usually smaller
> and aren't subjected to as many scale issues as regular programs
> are.) Those should be combined with introspection primitives, such
> as:
>
> * The venerable typeof
>
> * For a class, enumerate all of its members, and figure out their
> attributes (protection level, static or not, type...)
>
> * For a module/namespace, enumerate all of its symbols and figure
> out their attributes.
>
> * For a function, figure out its return type and the type of each of
> its formal arguments.
>
> * Figure out if a certain function exists (that should be easy if
> you have the tools above). That will be useful to decide, for
> example, if an iterator supports random access.
>
> * And if you really want to go meta, define metacode that can take
> an AST node as a parameter and can visit the AST and figure out what
> each node is. That would allow things such as loop fusion and other
> advanced stuff. But for now, let's leave those aside.
>
> Does anything make sense so far? :o)
>
>
>
> Andrei
>