From: ········@bayou.uh.edu
Subject: Re: C++ briar patch (Was: Object IDs are bad)
Date: 
Message-ID: <5ldfik$v1h$1@Masala.CC.UH.EDU>
Dean Roddey (·······@ng.netgate.net) wrote:

[Snip -- my request for complaints about Java]

: This has been covered ad nauseum, but here is my short list, without
: justifications cause I don't have the time to do that yet again. Each of
: these represents a major rant on my part (long done, many times over in
: the Java forums.)

Ok, in that case I'll refrain from commenting since you don't wish to
go over that again.  I will say that I have different complaints about
Java, but I'll leave it at that.

[Snip -- list of grievances against Java]


: > Ahhhh but unlike other language abusers, the C++ haters I've seen have
: > provided great reasons to demonstrate why C++ stinks, reasons that
: > the advocates never manage to counter.  With non-C language haters,
: > the "arguments" are more like complaints, with little or no reason
: > provided.
: > 

: I won't even bother to answer that because its pure opinion, which I
: could only counter with opinion of my own.

Ok fair enough.


[Snip -- info on Ada's "pointers"]

: Those are relatively interesting, but not nearly useful enough to get
: off the mainstream and use Ada for any work of my own. I would not argue
: if C++ adopted some of those things, nor would I if it adopted some
: other things from the Modula/Ada family. If I could create my own
: language, it would be nice but even less people would use it than Ada
: unfortunately.

Well when I wrote that passage I never expected you to drop your C++
compiler and embrace Ada :).  Ada does have some very nice features,
and in fact many languages (not just C++) would do well to adopt
some of them.  Of course I've since moved on to the functional
world so I don't use Ada, but I still have a deep respect for it.


[Snip]

: > So C++'s lack of useful functionality is supposed to be a benefit?
: > I think not.
: > 

: Absolutely it is. People never understand this. C++ does not force any
: view on you. Therefore, people can create class libraries for you to buy
: that represent many ways of doing things. This increases the chances
: that there is one that suits your particular needs. This is the
: antithesis of the 'built in' scheme, and it is what really makes C++
: appealing to so many people.

The problem is that you continue to assume that providing functionality
means locking the user into a closed world -- that is not so.  Scheme
is also a bad example in this case, because one of the things it is
known for is its small size.  A better comparison would be C++
with Common Lisp.  Common Lisp provides you with tons of goodies,
but at the same time you are not locked into anything -- you can
alter everything from adding your own control structures to
changing the syntax of the language!  This is vastly more control
and "malleability" than what C++ provides, and Common Lisp does
this WHILE providing you with numerous _USEFUL_ features.



: > Sure, you are free to spend ages programming in preparation for your
: > real program.  I do not like re-writing things that should be
: > available.  When I program I want to concentrate as much as possible
: > on the problem domain and not spend my time trying to find ways
: > around ridiculous limitations in the implementation language.
: > 

: As I've said. You BUY THE CLASS LIBARIES YOU WANT! No one starts a major
: C++ project with just a raw compiler. They start with a class library
: that they buy (or that comes with their compiler) that provides far more
: out of the box functionality than any 'built in' language ever will, and
: allows you pick from a list that best suits your needs.

Why should I buy class libraries for basic things that should be part
of the "core" implementation?  I mean according to your argument not
only am I stuck with missing functionality, but I have to spend money
to get the functionality that I should have had?  If I'm going to
buy third party packages, they will be packages that I cannot reasonably
expect to find in an implementation.

[Snip]

: > You are making a classic mistake of thinking that security means
: > limitations.  Again I point you to Ada.  Ada is secure, Ada gives
: > you the power of C++ (if not more).  There is nothing that says
: > that a language should let you hang yourself just to buy you power,
: > this myth has been propagated by C++ advocates who are desperately
: > looking for a reason to justify the inherent flaws in the language.
: >

: There was nothing in the preceededing paragraph about that. The security
: point was talking about using the securty system of the host OS.

Then I misunderstood.  Yet even with your definition you fail to make
any point for C++.


: > That's very nice, but you forget one thing -- programmers are people
: > and people make mistakes.  Not providing safety measures is great
: > if you are dealing with a species of super-intelligent, perfect
: > programmers, but you aren't.  You are dealing with people and with
: > that in mind these lack of safety measures are nothing short of
: > stupid.
: > 

: If you compile your progam and don't read the errors and warning that
: compiler generates, then you should probably move more towards the
: basket weaving genre of employment opportunities. Any decent C++
: compiler will warn you about pretty much any questionable thing you do.

Stop right there.  Now we're getting into the gray area of "what vendors
_SHOULD_ do".  This is a Bad Place(tm).  Leaving critical details
to vendors who have their own agendas is not the wisest of moves.
Furthermore, while I do agree that good programmers should heed
warnings, the fact remains that there is no enforcement for the
not-so-good programmers in your project, or the ones who goof and
miss a warning for some reason or other.  Again too much trust
is placed in the programmer.  The whole problem with projects is
that you don't have absolute control over what others do.


: And if that's not enough you can buy something like Bounds Checker than
: will load your program and run it and check for a humongous number of
: other things at runtime. The fact that people don't use the tools
: available is not my fault, nor is it the fault of C++ or any other
: language.

The fact that people have to spend extra money to get such a thing
rather than have an intelligently defined runtime that should do
these BASIC tasks is C++'s problem.  


: > So you are saying that the lack of a FUNDAMENTAL data type is an
: > advantage?  You are joking aren't you?
: > 

: No I'm not. I explained this above a couple of times.

And you did so inadequately each time.  Your explanations are predicated
upon the faulty assumption that power and flexibility are mutually
exclusive features.  They are not. 


: > : It doesn't do much good to mention them because you already have
: > : convinced yourself that they are stupid but... multiple inheritance,
: > : templates, namespaces, inlining, mutable members, typesafe collections
: > : via templates, polymorphism, RTTI, strong const usage, and operator
: > : overloading come to mind.
: > 
: > Other languages have had these before C++.  Again your point?
: > 

: You didn't say that other languages had them before C++, you said that
: C++ didn't have them.

That is a blatant lie.  I did not even mention many of the features
you stated above, much less deny that C++ had them.  I strongly
suggest you be less creative in your interpretations of what I write.

What I did mention was a lack of safety and a lack of basic functionality
(using strings as an example).  Nowhere did I mention inlining,
mutable members, RTTI, etc...  I did mention being able to typecast
your way into hell so MAYBE you might get away with pinning a "strong
const usage" on me -- but that term is so generic and meaningless
("usage" says nothing about "enforcement") that doing so is
irrelevant.




: -------------------------
: Dean Roddey
: The CIDLib Class Libraries
: 'CIDCorp
: ·······@ng.netgate.net
: http://ng.netgate.net/~droddey/

: "Software engineers are, in many ways, similar to normal people"

--
Cya,
Ahmed

The grass is never greener,
On the other side,
I'll sit right here and frolic in the dirt and gravel
	"Let the Bad Times Roll" by the Vandals