Kill them, kill them all.

For a comment like that it strikes me that you surely ought to be using an icon looking more like this:

I don't see why we have to get all grumpy about killing them all, now do we?

Oh dear. Distinct signs of Java Kool-Aid there.

Well, not really. Let's take it one thing at a time:

This means that the program is divided rigidly into classes, even the parts that are entirely procedural in function;

If all the methods are static, the class is essentially just a namespace.

that there is a strict convention of one class to a source file

Java only enforces the limit of one class or interface that is both public and outer per source file. However, one outer class per file does make things easier.

even when this means separating fragments of code which are doing a semantically related job and would benefit from being near each other;

One would hope that in Java classes would be coherent. I found finding code in C++ a real pain. I switched to one class per source file pair/tripple before I touched Java.

in general, that classes and templates and namespaces and long multi-word names are used in a manner that suggests the author specifically wanted to avoid writing

do_foo(arg1, arg2);

if he could possibly instead write

FooDoingClass<inexplicableTemplateParameter>::getInstance()->
doFoo(RandomNamespace::arg, RandomOtherNamespace::arg2);

The Java coding convention says to only use a single word in package names. The template parameterisation there wouldn't make any sense in Java. "getInstance()" is a clear indication of non-OO code. Nothing to stop importing from a namespace in Java, although of course it can make it clearer to qualify.

only, for added annoyance, without the line break in the middle.

If only compilers rejected (hand written) source code with more than 80 characters in a line (or tabs).

Kill them all. Preferably by inducing them to use an outhouse which has been fitted with Grimtooth's Cranequin Goose.

blech.

On the plus side, no more of it will be created...

How pleased I am never having to touch C++ any more! The template system was just as good at making things unreadable as the preprocessor, but had almost no useful expressive power.

By bete noir these days is trying to write code in XSLT (sometimes it's all you've got!). It's a perfactly fine toy functional language, but it is /so/ verbose, and full of syntactic bitters.

I don't think there's any excuse for the kind of opacity shown above. using namespace RandomNameSpace; would solve one half and a typedef abbreviating the template instance class the other.

As for templates vs cpp, I'd much rather use the STL than a cpp equivalent (though sometimes the latter would be much better than neither). They're definitely something that need to be used with care and taste, but that's at least as true of all but the most trivial uses of cpp too.

syntactic bitters

I love that coinage :)
(Good luck for the weekend!)