On 19/10/2010 10:29 PM, bearophile wrote:
Justin Johansson
There is also a big problem with reconciling templated types with OO typed
hierarchies. Often a dichotomy appears when templates and classes seem to fight
one another when you try to marriage the two idioms together (for better or for
worse but generally worse). :-(<
Right.
-------------
Peter Alexander:
I think it has very little to do with the syntax (although it certainly plays a
part).
The real problem with templates (in my opinion) is that they require a higher
level abstract view of programs that most programmers simply lack. I think this is
the same reason why functional programming escapes the masses, and why C is still
so popular.<
Some of the problems of C++ templates:
- The syntax is a big problem; if you want to use them to do complex things you
need to write lot of ugly code. The lack of basic constructs like static if
doesn't help at all.
- The semantics is not clean, there are several corner cases, that turn
template programming into a puzzle solving activity.
- C++ templates are a functional language, but the C++ compilers usually lacks
the normal tools a functional language needs, like a garbage collector and an
optimizer both designed for a functional language, and error messages good for
a functional language. This makes then slow for the compiler, and at
compile-time the compiler burns lot of RAM (they have improved a bit G++ 4.5,
as template instantiations are now looked up using hash tables:
http://cpptruths.blogspot.com/2010/03/faster-meta-programs-using-gcc-45-and.html
but it's a long way to go).
- C++ templates are powerful, because templates templates are a peek into the
realm of higher order types (kinds), but there is not much typing on the types,
so bugs are common. The Concepts were a way to add a type system to template
arguments, but it has failed.
- C++ programmers sometimes don't know much about functional programming. But
in the end the complexity of functional programs written with C++ templates is
very limited, they are often almost trivial. What makes them hard to write is
not that, it's the way you have to write such little functional programs.
D2 improves the situation a bit (with constraints, a more consistant semantics, a bit
better syntax, static ifs, more template argument types, and some shortcuts), but there's
a long way to go still. Despite the constraints D templates are still "dynamically
kinded" (the enforcement is one way only, not two way as in the Concepts, you may
solve the problem a bit manually, as Andrei has shown me), the compile-time GC is not
good enough yet, lot of useless stuff is left in the final binaries, etc.
D2 templates too may cause bloat, because there is no way to choose where you
want Java or C# style generics with auto-boxing and where you want C++-style
templates (this may be good anyway, to keep both language and compiler simpler).
Bye,
bearophile
You are a smart person bearophile, much smarter than me.
Cheers, Justin
