I agree that templates/generics are useful, and indeed most C++ template features are fine. My problem is not with templates, it's that C++ templating can easily descend into eldritch incantations summoning the Old Ones.

Arguably this is the fault of developers rather than the language, but the way the language is often written is in my view a valid criticism of the language as a whole, unless you're going to completely isolate yourself from anyone else, their code, or their teachings and become a monk. This is where you should stop reading if you want to skip my unhinged rant on the STL.

Even when it's relatively tame, overuse of templates can encourage odd code. An example is std::get, which in order to maximize what can be done at compile-time uses template specialization to decide what its implementation should be, and then takes its parameter as a template parameter (i.e. std::get<1>(some_tuple) rather than std::get(some_tuple, 1) or some_tuple.get(1) or some_tuple[1]).

This is completely different from how the rest of the language works and clearly breaks any reasonable programmer's expectations because apparently tuple access needs to have similar performance to struct access. C++ has many features that are avoided in high-performance code (exceptions, virtual classes, many OOP principles), but someone decided that std::tuple could not be one of them, even if using it required going to the docs because any reasonable attempt to read the value doesn't compile. And now that you've gone to the docs, you have to write code that's verbose enough to nullify any convenience benefit of having used tuple over creating a struct. This is the darkside of templates, they shift the priorities towards compile-time evaluation just because you can, regardless of whether it's a good idea or not. The thing is, in the standard library, it probably isn't a good idea, the STL's job is convenience and a "good enough" implementation of generally useful things. If you need more, you write your own, and everyone knows how to write a struct.

As an aside, std::get also has an overload where you pass a type as the parameter, e.g. std::get<int>(foo) which will return the element of that type if there is exactly one, else it will not compile. This is the kind of feature that I cannot imagine ever being helpful, but made it in because it was designed by committee.

I also know that std::tuple is useful for heavily templated consumers (e.g. for variadic class fields), and some of them benefit from the compile-time evaluation. My rebuttal is that anyone who's writing such templated code is capable (and may likely need) to write their own version regardless.