

C/C++/Java have dominated programming for 30 yrs & are at a turning point [2000] - damian2000
http://www.gotw.ca/publications/c_family_interview.htm?m=0

======
norswap
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.

~~~
bunderbunder
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.

~~~
shrughes
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.)

------
buster
Aaaand obviously not.

And incoming Clojure/Scala/Ruby comments in 3...2....1... go! :)

~~~
ArbitraryLimits
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."

~~~
thebluesky
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.

<http://en.wikipedia.org/wiki/Java_version_history>

language changes in java since 2000:

JDK 1.3 synthetic proxy classes (seldom used)

JDK 1.4 assert keyword (seldom used)

JDK 5 generics, enums, autoboxing, varargs, annotations

JDK 6 nothing

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.

~~~
ArbitraryLimits
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.

~~~
thebluesky
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.

<http://en.wikipedia.org/wiki/Java_annotation>

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.

