Not nothing at /all/, but it's hard to get a grip on it -- especially
if you don't know or care about that Microsoft language which seems to
be his frame of reference (C#).
His rhethorical style is also annoying:
"Don't get me wrong -- I love C++! But it's useless crap! But don't
get me wrong -- C++11 is a great thing! But it's useless! But don't
get me wrong -- you should learn C++! Although it's completely
pointless unless you're herding goats in Somalia! But don't get me
wrong! ... etc."
Perhaps that's just part of the trolling.
Speaking of that, his main theme is that C++ is *so* huge and complex
compared to C# and Java. I don't know either of those two, but
perhaps someone who does can comment: is that really true today?
I guess Java was small in ~1997 when I looked at it, but that was when
they still had no standard containers or other things we now take for
granted.
Java, is smaller / "simpler" than C++, in the sense that it would be a
little easier to write a compiler for it (basically, they took a C++
like language, stripped it down pretty much as far as they could, and
started gradually adding things back in).
how much difference this makes to programmers is debatable (mostly I
think that many language designers assume "compiler complexity" ==
"ability of human programmers to understand it" or something).
a big drawback of the language is that it is actually fairly
awkward/cumbersome to write code in it (IOW: write code much beyond
invoking library facilities to do something).
it has a number of arbitrary restrictions which are IMO very annoying,
so I generally prefer not to use the language if it can be avoided.
similarly, for writing "actual code", I have typically had to write
considerably more code than would be needed to address the same problem
in C. (and, most of the rest, is people invoking library functionality
and then thinking that they actually wrote something...).
C# is like Java, but with a slightly more C++ like syntax, and some of
the stuff Java ripped out having been re-added (like "structs" and
operator overloading, but otherwise staying largely Java-like).
for the parts that matter, WRT the core language, there isn't really a
huge difference. C# doesn't really save effort over C++, and many tasks
actually require more typing and effort (for example, declaring a local
array). as well, there are some things in C and C++ that can't really be
done readily in C#, requiring them to be faked.
arguably GC makes a difference productivity-wise, but then again a
person can just as easily use the Boehm GC or similar with C or C++ anyways.
personally, I find C# a bit more annoying than either C or C++, in that
they put in lots of little nit-picky error conditions, which seem like
they serve little real purpose besides trying to promote a particular
development style (and/or hunt down certain types of bugs). many of them
would IMO make more sense as warnings.
things which are in C#'s favor:
IntelliSense works in Visual Studio (nevermind if IntelliSense is
sometimes very annoying, mostly because it gets in the way sometimes of
"just being able to quickly type out some code");
produced CIL code can be used by either a 32 or 64 bit process (vs C++
and C++/CLI, where the produced binaries/DLLs are limited to a single
target);
....
the IntelliSense mostly gives an advantage for "people just sort of
bumping along with little real idea what they are doing". (it sort of
serves a role as a kind of half-assed substitute for documentation or
reading header files in an auto-complete like form).
it does sort of work better when writing code against an API which
otherwise lacks any form of documentation (personally, I prefer
documentation more, or failing this, at least some header-files or
similar to look at). otherwise, a person can buffer relevant information
in memory or something. (FWIW: I don't really think it is probably
exactly like I have super-human memory skills or something...).
major annoyances (with IntelliSense):
it partly hijacks the arrow keys;
it "aggressively" expands things (TAB, ENTER, and SPACE, all serve to
auto-complete things), making it really annoying if the thing you are
trying to type is a prefix of the thing you want;
if trying to just quickly type-out some code, it will often start
expanding ones local variable-names to random unrelated stuff (granted,
debatably this would be less of an issue for a person not using
single-letter variable names, but I am lazy and don't want to have to
deal with longer variable names if I don't have to);
....
though, for what stuff I do, I generally prefer to stay in native land,
though, admittedly, I am more of a plain C developer than a C++
developer though (my main project is mixed language though, including C,
C++, and a my custom language). there is some C#, but this is generally
in the form of custom Paint.NET plugins and similar (couldn't get
C++/CLI plugins to work with PDN, so ended up writing C# ones...).
a fair chunk of the C code in the project is not exactly "idiomatic" /
"orthodox" though (much of it is somewhat tooled up, does an OO-in-C
thing, uses garbage-collection, ...). (lots of stupid arguments have
been had over all this, but yes, this stuff can be done, and yes, I
already do stuff this way...). (and, it is not my fault if things like
structs and function pointers are apparently beyond the abilities of
mere humans to understand, grr...). (I make fairly heavy use of both
structs and function pointers).
my personal opinion though is mostly that claims of significant
language-specific productivity differences are likely exaggerated though.
a lot more has to do with libraries and development style than it does
with language.
libraries aside, it isn't really too far outside the realm of
possibility to copy/paste/rewrite from one language to another
(including to/from C as well).
or such...
