I'd argue that Java is quite dissimilar from C/C++. Of course, the paradigms are close, but then you'd have to include Basic, Pascal and a whole score of other languages.
What makes C different is low-levelness and Java has none of that.
So it's true that Java is managed and C/C++ aren't.
But Java is still very much a descendant of C++, semantically as well as syntactically. You don't have to look any further than the type system (primitives are not objects) to see that.
C++ primitives are the practically the same as C++ objects. Just look at C++, there are a million design decisions to make things that way. You can feel the sense of apology in C++ for every place where they're distinguishable. (The only places I can think of right now are the initialization of constants in header files and usability as template parameters.)
How "obviously not?" All three languages have changed significantly since 2000. I took a good look at C++'s TR11 just last week and was amazed at how much stuff is in it. Java's gotten generics, real inner classes, all the good stuff they've ripped off from C#...It seems to me like the article is spot on, unless you interpreted "at a turning point" to mean "about to go away."
Java inner classes haven't changed since the late 90's. There have been new features added to java over the last 12 years, but it still feels like the language I've used since the late 90's.
JDK 7 project coin (collection of minor language tweaks)
As for the stuff they "ripped off from C#" I'd like to see you name some examples that weren't already present in other languages. If anything it could be argued that some of the newer C# bits are just ripping off Scala features.
My impression of Java, as someone who ends up having to use it every few years when I can't get out of it, is that the cumulative effect of generics and autoboxing can really change the feel of the language, but only if you use them, of course.
Also, I thought real closures were introduced in 1.7? That seems like a big change to me.
Re: C# I was mostly referring to annotations for reflection. If they ever wanted to add first class getter/setter methods that would be cool, too.
Closures were not added to JDK 7, they will be added to JDK8 next year.
Generics are definitely the biggest change, but not so much autoboxing (something that makes little difference to 99.9% of code).
The annotations Java devs use the most are usually @Override and @Test, unless you're using bloatware like Spring/Hibernate/J(2)EE which belongs in 2004. Annotations are useful, but not really groundbreaking for most code.
In terms of first class getter and setter, I'd say take a look at Scala (or Groovy). Lots of Java devs are looking beyond Java the language, mostly because it has been incredibly slow to evolve.
I was refering to "dominating" + "turning point".
C/C++/Java is still dominating the programming world. By far.
It may be that i don't program C and only occasionaly Java, but that's only me.
What makes C different is low-levelness and Java has none of that.