It has been quite clear to me. Java Standard API is huge but it does notJorgen said:On 09/18/10 03:49 PM, Daniel wrote:
Don't forget the biggest convenience of all: programmer availability!When one of my favourite tool sets degraded to Java (and I do mean
degraded, it's memory footprint grew from about 50 to over 700MB!) I
asked the developers why and they told me they simply couldn't get
enough skilled C++/Motif programmers where Java programmers where two a
That's an interesting point, to which I'm not sure I agree,
although I can see where a manager might think so. C++ is
clearly a more complicated language than Java.
Is that so clear in practice? I don't use Java myself, but I'm on the
company Java mailing list. There seems to be a huge set of APIs,
frameworks and abbreviations you have to know, and there seems to be
plenty of fashions you have to follow (e.g. FOO-driven development,
where FOO changes quarterly).
add to the complexity for a programmer.
Java syntax is simple (or so it was before an idiotic addition of
worse-than-useless Java generics).
Java API you do not care to use directly does not add to the complexity
even if you use it indirectly (via API you do care do use). You do not
make a mistake in interpreting Java code your are looking at if you are
not aware of the contents of non-directly-imported classes. If you see
an unfamiliar name you know that you don't know what it is and have an
idea on where to look for what it is (in classes/packages directly
imported into your source file or in your source file's package).
In C++, a convoluted syntax (e.g. visually indistinguishable
passing-by-value vs passing-by-reference) and semantics that you do not
care to use but the headers you include use (operator overloading,
user-defined conversions, macros etc) hit you hard. If you see
something like << in the code it often may or may not be one of the
functions you are familiar with and you won't have a clue until you look
up for operator<< declarations in all headers included directly *or
indirectly* (compare to Java) to your source file (that is, to stay on
the safe side, you will have to search through the headers often (or, if
you are lucky to have a very good C++ code browser, to hop through 1000
definitions of operator<< trying to understand which one, if any, will
be resolved for that particular right-side argument and ooh left-side
argument was also not what you thought it was..)).