JasonB (no@spam.com) on 8/26/09 wrote:
---------------------------
>with a small syntactic burden relative to C++.

Ok, I will give you are somewhat rigth here because there is such syntatic burden wich some may forgot, and I saw this happening, I will talk more about such details latter.

Also I had a tought now... It's easy to find at JIT compiling time that a resource acquired will be orfaned at the end of the call, I blame those VM programmers for not allocating simple cases on the stack reducing GC pressure and destroying objects at routine's end (Henrik, it's all your fault ;))

>Anything "could" be done in C++. C++ is a toolbox full of tools intended
>for a craftsman, not an apprentice. It contains tools that allow you to write
>safer code with less effort than could ever be accomplished with Java, for example

Here I can't agree with you, not all resources are allocated at the begining of a call to be released on the end of it, some objects have a longer lifespan and, if they leak, the resources only will be released on an app restart.

Finding the source of a leak may be complex, very complex, finding routines without a finally may be boring, but much simpler, you can ask to a trainee.

>So writing safer code is a matter of discipline and coding style rather than a
>straightjacket imposed on you by the language (which, in Java's case at least, actually
>makes writing really robust code nearly impossible); the difference with
>using something like C and relying on discipline and coding style is that C++ actually
>supplies you the tools to enforce that discipline if you choose to use them.
>If you want range-checked arrays, you can have them; if you want to eliminate dangerous
>pointer casts, only use the safe ones (if you need to use any at all, which is rare);
>if you want to ensure exception safety, use RAII everywhere, and so on.

C++ doesn't really enforce it, it provide tools but you may not use them and write crap, if there isn't an warning "some idiot didn't followed the guidlines" it becames hard to keep it safe.

Often when talking to old C++ programmers about how unsafe such a program may be for 24/7 operation I heard a lot of "It don't happen to me", "All guys that work with me are very experienced and don't do those stupid things" and so but still, the C++ apps leak and crash, reading Richard's previous post I found he lives in the same wrold as me where enforcing rules is more difficult than it looks like, congrats to you and your team for apparently doing a better job, but admit, you got one or other #GPF from time to time ;)

>VC++ already includes lots of warnings about potential buffer overflows
>and underflows when you don't use range-checked C functions, and can check at runtime
>for buffer overflows and return value corruption (and stack corruption in general, loss of data from assigning
>values from a larger type to a smaller one, use of an unitialised variable, etc.).

That evil company...

>And of course C++ can be a GC language as well (and in VC++ you can mix-and-match
>native code and CLR assemblies on an object file by object file basis).

I have seem a lot of people talking on how good C++/CLI should be with all those features, but see few people other than me using it, it's painful, having so many features doesn't help the day to day at all, MS recommends not mixing native and CLR code for performance reasons, I can say not mixing them is a good idea from a maintability point of view too and, if you are going to use only CLR you are better with C# wich have a simple and shorter syntax, oh, why it exists and why I use it, and don't know how many reasons MS had, the only reason to use it for me is when I need to integrate existing code, ironically the cases where I have to mix native and CLR...

Yet about the subset choosen, the "standard" way of doing thinks like polymorphism is the unsafe way while the safe way requires templates and a not so small syntatic burden, that's a invite to do things wrong, it's the oposite of C# in wich generally it's easy and obvious to the the safe thing while the unsafe have a lot of syntatic salt.