Sure. I'm not contesting that templates try to solve problems that generics
do not. I am saying that all of the other problems solved by templates are
better solved by other techniques, most notably explicit code generation.
Moreover, in the overlap between generics and templates, generics are a
clear win because they are so much easier to use.

You have drawn that conclusion before looking at any evidence.

Let's look at some real examples. For trivial cases like the (useless)
static factorial function you can encode your metaprograms in C++
templates:

 http://aszt.inf.elte.hu/~gsd/halado_cpp/ch06s04.html

Here is their factorial implementation:

 #include <iostream>
 
 template <int N>
 struct Factorial
 {
     enum { value = N * Factorial<N-1>::value };
 };
 
 template <>
 struct Factorial<1>
 {
     enum { value = 1 };
 };
 
 int main()
 {
     const int fact5 = Factorial<15>::value;
     std::cout << fact5 << endl;
     return 0;
 }

This is useless because you can just use a lookup function.

Now let's look at something non-trivial, like a high-performance FFT
implementation. The fastest cross-platform FFT implementation is FFTW,
which is C code generated by an OCaml program.

Many C++ advocates have tried to do the same code generation using C++
templates because it would make such a compelling example of templates
actually being good for metaprogramming. However, every single person to
have ever attempted to do this has completely and utterly failed. Dr Dobb's
even published an article on exactly this:

 http://www.ddj.com/cpp/199500857

If you look at the OCaml source code of FFTW you will see many non-trivial
symbolic optimizations implemented using pattern matching over variant
types that optimize the generated code in ways that are prohibitively
difficult to implement using C++ templates.

The fact that C++ templates are theoretically capable of doing this because
they are Turing complete is useless because it is practically impossible to
do so because templates are so cumbersome to use for metaprogramming.

That is wrong. C++ templates cannot perform specialization based upon
run-time values.

JIT provides both precompilation and run-time compilation. C++ only provides
precompilation.

That is also wrong. Because C++ templates cannot handle run-time values the
only efficient solution is to precompile every conceivable permutation of
inputs. This results in combinatorial code explosion with incredibly
heavy-weight libraries and very slow loading times. C++ is famously bad for
this.

In contrast, JIT compilation can lazily compile code as and when it is
needed. This results in leaner libraries and executables that load faster
and even work cross-platform.

If your application requires submillisecond startup times, sure.

I'm just going to pull rank here. You need to learn some decent languages.
Look at modern statically-typed functional programming languages for a
start.

If the mood took me, I'm pretty sure U could take that challenge, and
the bonus points for UDT:
www.pobox.com/~skeet/csharp/genericoperators.html

(full download available in MiscUtil, and for the record, I also have
a .NET 2.0 version as well as the .NET 3.5 version cited)

Stating it (by itself) isn't exactly conclusive. Besides; C++
templates are compile time; I can make new types and use them with
generics at runtime. The JIT isn't perfect, but generally does a
pretty good job... pretty flexible.

Marc