From: ········@bayou.uh.edu
Subject: Re: C++ briar patch (Was: Object IDs are bad)
Date:
Message-ID: <5l66uo$nqo$1@Masala.CC.UH.EDU>
Dean Roddey (·······@ng.netgate.net) wrote:
: ········@bayou.uh.edu wrote:
[Snip]
: Yes I have a lot of experience with it. I personally find it quite
: adequate, otherwise I wouldn't waste my time. I find that C++ has the
: best, at this time, compromise of performance vs. abstraction for what I
: want to do. Maybe 5 years from now I'll be willing to give up some of
: the performance for something more abstract, I'll get back to you on
: that in 5 years. But, whatever it is will, for better or worse, have to
: be something mainstream in which I can make a good living. I sincerely
: hope it is not Java.
Well as a person who has the misfortunate of maintaining code that
others have written, I've seen absolutely nothing from C++ that would
convince me that it is worthwhile. Of course you already have formed
your opinions as I have mine, so it seems that this is an unresolvable
issue.
Just out of interest, what precisely do you have against Java? I'm no
Java advocate, and I couldn't care less about the language, but I'm
interested in knowing what specific complaints you have about it. I
for one would rather code in Java than C++ any day of the week and
feel that while the language does not live up to the hype, and is
not exactly the best designed language in the world, that it is still
a relatively decent language as far as imperative languages go.
: > : 2) You can't write them in C++.
: >
: > I'd love to know where you got this from. Again read my
: > passage. If you have difficulty understanding it then I'll
: > explain it to you using simpler language. Otherwise, I'd
: > appreciate it if you would refrain from distorting my
: > statements.
: >
: That was a bit of sarcasm in reply to your obviously entrenched hatred
: of something that just is. Were you sexually abused by a C++ programmer
: as a child or something?
You are a really funny guy do you know that?
: > : Is that a statement about C++, or about you? I've heard so many people
: > : who are just anti-C++ that its become white noise to me.
: >
: > If you've heard so many anti-C++ people putting down C++ then maybe
: > _THAT_ should tell you something.
: >
: Duh! Go to any language forum and you'll hear pretty much the same
: thing. EVERY language has its ups and downs. The reason I've heard so
: many about C++ is that I spend time in those forums and deal with people
: who seem to have nothing better to do with their lives than abuse it
: (and I periodically take time out of my very productive C++ development
: efforst to argue with them.)
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.
: > : C++ is a
: > : compromise that is intended to meet in the middle of the ease of use vs.
: > : performance/power scale.
: >
: > C++ is neither easy to use, nor is it powerful. Compare C++ with a
: > real language like Common Lisp or Ada, and you will see what
: > ease of use AND power are like.
: >
: I have experience with the Modula and Ada worlds. I don't find them
: particularly any better. Somehow people have this feeling that if you
: just pretend like pointers don't exist, then everything will be happy. I
: don't see it that way. I don't have any experience with Lisp, so I can't
: argue with you one way or the other about it. However, it would say that
: it is too far outside the mainstream for me to put any serious effort
: into, even if it was the greatest thing since sliced bread.
Well Ada provides pointers, but unlike C++ has many safety mechanisms
to guard against them, and unlike C, does not force you to use them
for the most trivial of tasks. For instance, you've got pointers
that are specifically for memory allocation and that can't be used
for modifying the value of another variable (ie: aliasing), then
you've got an alias which is used as such but can't be used for
memory allocation. Not only that, but any variable which can
be aliased must be specifically marked as such. Furthermore in
Ada, pointers only allocate memory for one specific type so
so you don't have any of the nonsense of allocating multiple
blocks and treating it as an array, but you can achieve the same
effect by having a pointer capable of allocating memory of a type
of unbounded array. Add to this the fact that unlike C and C++,
dereferencing a Null pointer in Ada is guaranteed to cause an
error. These couple to eliminate the kinds of horrors that pointers
in C and C++ give you, while retaining all the power and flexibility
that one comes to expect.
Of course Common Lisp doesn't need pointers since it has an
entirely different way of doing things, but then you didn't have
any comments about it so I find no need to get into details about
that -- but if you are interested, I will be happy to enlighten you.
: > I refuse to consider a language powerful when it has such ridiculous
: > limitations as the inability to treat user defined data types as
: > full first class members (look at arrays). Hey no strings built in?
: > Gee, we can still crash our system thanks to pointers which are still
: > a way of life. Got a declaration designed to protect data? Typecast
: > your way around it! If this is your idea of power and ease, then
: > you've just lost what little credibility you had. C++ is a ridiculous
: > farce, and I have no intention of considering it as anything more
: > than a nuisance which I must deal with.
: >
: You are confusing the basic language capabilities with the libraries.
What I am discussing are language issues, not library issues.
: They are not the same. Everyone has their favorite 'its got X built in'
: language, but C++ was not designed to be that. In fact, its very lack of
: anything built it is why it dominates.
So C++'s lack of useful functionality is supposed to be a benefit?
I think not.
: It does not tell me how to
: architect me system, it lets me architect my system the way I see fit.
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.
: It does not have assumptions about the maximum size of a file or the
: security system of a host OS, etc... It lets anyone build a class
: framework on them that takes advantages of those features fully, unlike
: a system which builds things into the language. So C++ can be the force
: behind many different systems, all of which represent vastly different
: views of the world. That is its power, and that's why you will probably
: still be whining 10 years from now.
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.
: Yes C++ lets you typecast constness off, because it assumes you are an
: adult with a brain and you are getting paid to understand why you did
: it. The compiler will warn you if you do this, so its not rocket science
: to deal with it (and it provides a lot of flexibility when you need it,
: though you seldom do.)
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.
: BTW, I don't build my world around my credibility with you. Sorry about
: that.
Apology accepted.
: > Advanced with relation to what? Again I see nothing advanced with
: > C++ when compared to languages like Scheme or Common Lisp or
: > Ada. Templates you say? Scheme and Common Lisp have full dynamism
: > which trashes templates any day of the week and Ada has generics.
: >
: C++ templates provide significant optimization and compile tiem safety
: gains. This avoids the overhead involved in more indirect means of
: acheive the same thing. Here again, this probably has a lot to do with
: why C++ dominiates, because it takes a practical approach that
: appreciates the limitations of even today's CPUs to handle the load
: placed on them by significantly sized systems. If you don't like them,
: you don't have to use them. Or better, why don't you swoon us with your
: technical description of why List and Ada's mechanisms are better and
: how they compare in performance to C++ template generated code?
First and foremost, remember the 80/20 rule. 80% of the speed
of the code is due to 20% of the code, so the whole attitude of
"It's screwed up but it's fast" won't cut the mustard. Write it,
have it working, then optimize the 20% intelligently. As for
why Lisp is better, it's simple -- you need do nothing special
to take advantage of generics. That's it, no funny instantiation
syntax, no nothing. As for Ada, I don't recall claiming that
it's generics were better than C++, only that it had them for
years. It involves a similar (syntactically) mechanism, which
you should know since you claim you used it.
: > OOP you say? Common Lisp has CLOS, which is superior in every
: > respect to C++'s hack, and is easier to use to boot, not to mention
: > more transparent.
: >
: Here again I cannot argue with you because I don't know Lisp. However, I
: can only say that if it was that great why don't you write a better
: office suite than Office 97 in Lisp and put MS out of business? We'd all
: like to see that.
I'm not out to be the anti-Bill, I'm hoping the DOJ will do that for
us (yeah I know doubtful). I write code that interest me, and Office 97
doesn't exactly strike me as amusing if you catch my drift.
: > Strings? Oh wait, C++ doesn't have them, or was this one of the
: > things that the STL patch was supposed to fix? Common Lisp had
: > strings for ages.
: >
: C++ still does not HAVE strings, nor does it want them. Strings are
: things that come along with a class framework, and which are part of a
: much larger architecture than the language could ever provide. The
: problem with having such things built in is that they then become
: limitations on the developer of frameworks (because they probably don't
: have the common semantics or capabilities that the framework designer
: builds into his/her other classes.) Once again, you are arguing against
: something that a C++ person considers a PLUS! If I buy framework X, then
: I want the strings in it to be consistent in style and architecture to
: the overall scheme of framework X, not something sticking out like a
: sore thumb that the framework had to hack around.
So you are saying that the lack of a FUNDAMENTAL data type is an
advantage? You are joking aren't you?
: > Where are the advanced features? From where I'm standing I see
: > a pathetic joke of a language with layer upon layer of complexity
: > piled on it in a futile attempt to catch up to numerous other
: > languages which left it in the dust long ago.
: >
: 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?
: The reason it looks that way is because you are standing in a big pool
: of self generated hatred for a language that seems to dominate despite
: your feelings about it.
My hatred for C++ comes from my having programmed in it, and having
to maintain it, and seeing first hand the liability it is. But you
are right in that I have no intention of thinking of C++ as anything
other than a nuisance. My mind is made up.
: > And this is not considering the very laughability of adding
: > OO to what is in essence a poorly designed high-level assembler
: > wanna-be.
: >
: That is exactly why C++ runs rough shod over your beloved languages.
: That is why it covers a large range of applications under one roof. You
: are damning it for its strengths.
And according to you it's strengths were the fact that it didn't provide
you with anything. I direct you to your claim that the fact that
C++ didn't provide strings was an advantage.
: --
: Dean Roddey
: The CIDLib Class Libraries
: 'CIDCorp
: ·······@ng.netgate.net
: http://ng.netgate.net/~droddey/
--
Cya,
Ahmed
From: Dean Roddey
Subject: Re: C++ briar patch (Was: Object IDs are bad)
Date:
Message-ID: <33794402.1E28@ng.netgate.net>
········@bayou.uh.edu wrote:
> Just out of interest, what precisely do you have against Java? I'm no
> Java advocate, and I couldn't care less about the language, but I'm
> interested in knowing what specific complaints you have about it. I
> for one would rather code in Java than C++ any day of the week and
> feel that while the language does not live up to the hype, and is
> not exactly the best designed language in the world, that it is still
> a relatively decent language as far as imperative languages go.
>
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.)
1) Lack of MI of implementation
2) Lack of templates
3) Forces me to use their base object, not mine
4) Forces me to use their view of exceptions, not mine
5) Does not have stack based objects
6) Does not have the performance I require for my ray tracer and fractal
systems.
7) Forces me to use their view of run time typing, not mine
8)
> : Duh! Go to any language forum and you'll hear pretty much the same
> : thing. EVERY language has its ups and downs. The reason I've heard so
> : many about C++ is that I spend time in those forums and deal with people
> : who seem to have nothing better to do with their lives than abuse it
> : (and I periodically take time out of my very productive C++ development
> : efforst to argue with them.)
>
> 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.
> Well Ada provides pointers, but unlike C++ has many safety mechanisms
> to guard against them, and unlike C, does not force you to use them
> for the most trivial of tasks. For instance, you've got pointers
> that are specifically for memory allocation and that can't be used
> for modifying the value of another variable (ie: aliasing), then
> you've got an alias which is used as such but can't be used for
> memory allocation. Not only that, but any variable which can
> be aliased must be specifically marked as such. Furthermore in
> Ada, pointers only allocate memory for one specific type so
> so you don't have any of the nonsense of allocating multiple
> blocks and treating it as an array, but you can achieve the same
> effect by having a pointer capable of allocating memory of a type
> of unbounded array. Add to this the fact that unlike C and C++,
> dereferencing a Null pointer in Ada is guaranteed to cause an
> error. These couple to eliminate the kinds of horrors that pointers
> in C and C++ give you, while retaining all the power and flexibility
> that one comes to expect.
>
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.
>
> : They are not the same. Everyone has their favorite 'its got X built in'
> : language, but C++ was not designed to be that. In fact, its very lack of
> : anything built it is why it dominates.
>
> 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.
> 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.
> : It does not have assumptions about the maximum size of a file or the
> : security system of a host OS, etc... It lets anyone build a class
> : framework on them that takes advantages of those features fully, unlike
> : a system which builds things into the language. So C++ can be the force
> : behind many different systems, all of which represent vastly different
> : views of the world. That is its power, and that's why you will probably
> : still be whining 10 years from now.
>
> 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.
> 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.
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.
> 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.
> : 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.
-------------------------
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"
>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.)
>
>1) Lack of MI of implementation
That's a good thing, in many viewpoints.
>2) Lack of templates
Also a good thing, in many viewpoints.
>3) Forces me to use their base object, not mine
So? You can still make all your objects inherit from your own
subclass of the base. At least you have a base class, unlike C++.
>4) Forces me to use their view of exceptions, not mine
I don't understand this one. I've never seen a language, other than
assembler, where I had control over how to view exceptions. You use
the language's version or not at all.
>5) Does not have stack based objects
GOOD!!! This is a sucky point in C++, IMHO. Once you add this,
you have to worry about what happens when you go out of scope;
probably have to call a destructor; now you've got destructors
being called implicitly, which can conflict when you call them
explicitly, and the whole thing becomes a mess. You have
potential bugs if you pass pointers to these objects that may
vanish implicitly, unless you pass the entire object, which can
be SLOW (ie, copy all non-reference fields, then have special
code for each reference field).
Those issues, and other rules, vanish if you don't have stack based
objects. And your language reference books shrink. And all for a miniscule
increase in some memory allocation.
>6) Does not have the performance I require for my ray tracer and fractal
>systems.
Get a better compiler.
>7) Forces me to use their view of run time typing, not mine
They give you a consistent view of it.
--
Darin Johnson
·····@usa.net.delete_me
From: Eli Barzilay
Subject: Re: C++ briar patch (Was: Object IDs are bad)
Date:
Message-ID: <3379D62F.1438@cs.cornell.edu>
> ...
> 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.
... and instead of spending 2 hours for compilations, spend 6. (How
about some more minesweeper?)
--
Eli
Barzilay:
Maze
is Life!
In article <·············@ng.netgate.net> Dean Roddey <·······@ng.netgate.net> writes:
>Absolutely it is. People never understand this. C++ does not force any
>view on you.
ROTFL.
C++ forces and enforces a particular world view a lot more than lisp.
I mean, you can implement the CLOS object system in standard non-OO
lisp without changing the language. C++ had to change C and came up
with a particular world view of what OO should be. In Lisp, if you
don't like the way CLOS works, you can roll your own.
Now *that* is what is means to not force a view on you.
From: M. Prasad
Subject: Re: C++ briar patch (Was: Object IDs are bad)
Date:
Message-ID: <337B0364.7FC9@polaroid.com>
Chris Bitmead uid(x22068) wrote:
[snip]
> C++ forces and enforces a particular world view a lot more than lisp.
>
> I mean, you can implement the CLOS object system in standard non-OO
> lisp without changing the language. C++ had to change C and came up
> with a particular world view of what OO should be. In Lisp, if you
> don't like the way CLOS works, you can roll your own.
There were numerous programs written in C in the object
oriented style before the advent of C++. For instance,
there was the "Toy Operating System" from Berkeley (circa '82).
Designed to teach CS students, it was written with
"object handles" implemented as typedefs of "void *", and
member functions as structure members
which could be referenced after appropriate
conversion of the "void *". Much of this was
user transparent. (There is no reason why
you can't just add function pointers to
a structure -- it doesn't have to be called
a "class"!)
C++ took what was happening in the C world anyway,
and formalized it. Along with a few other changes.
I think this may be one of the reasons for
the success of C++. Instead of asking people
to covert to its own world view, it just took
what people were doing anyway, and made it easier.
The other major factor in C++'s popularity
may have been the advent of Windows. With
Windows, the complexity level was getting to
be too much for straight C programming, and
people found a tool which helped them manage
the complexity without asking them to dump
their C expertise or to accept other peoples'
notions of what a good language should be.
Of course there were other tools doing
essentially the same thing, such as Objective-C.
C++ may have had the upper hand here because
people tended to trust something from AT&T.
Not because AT&T was doing major marketing of it.
(It is not even clear they knew how, shold they
have wanted to, at the time. And strangely,
it would seem the influential C groups in AT&T saw
C++ as competition and hence did not give it their
support anyway!)
It is just that Bell Labs had done Unix and C, and
was a familiar and trusted name to most people.
So there was a little less hesitancy in trying
out something new from them.
From: Mukesh Prasad
Subject: Re: C++ briar patch (Was: Object IDs are bad)
Date:
Message-ID: <337C540C.3461@polaroid.com>
········@bayou.uh.edu wrote:
> It wouldn't be called a class because it wouldn't be a class.
> No information hiding, no inheritance, no polymorphism, it's
> nothing more than a data structure with some function pointers
> as fields.
Yes, you got the idea -- that's how object orieted programming
was initially done in languages like C. However, with liberal
pre-processor use thrown in, some decent programming methodologies
could be implemented. You could implement inheritance and
polymorphism, though for information hiding you just would
make your objects opaque e.g something like
typedef void * MyObject;
#define MyclassMethod( obj, method ) \
((Myclass *) obj)->method()
Of course, you could defeat this by typecasting the object.
(So in C++ you have official ways to get at the internals
of the object.)
> That is a point against C, not a point for C++. Furthermore,
> C++ for Windows is still a bloody mess. It takes a ridiculous
> amount of red tape to even write a "Hello World" program -- last
> I saw, it was well over 100 lines of code to write "Hello World",
> while numerous other languages were doing it in 1! The only
> thing keeping people from going berserk are the fancy IDEs which
> automate the redundancy (check out VC++), and even then it's
> still like pulling teeth.
So what language do you want to do Windows programming in?
SmallTalk? Actor?
SmallTalk has been very popular in the press, and Wall Street
banks have been impressed enough by it to bank on it.
But other than some mild successes, for more than two
decades now, it hasn't gone anywhere.
So far, Windows had not been standardized enough for serious
programming in any language at a "higher level" than C or C++.
There were too many things you could do, too many ways to
enable this button when the user moved his mouse _this_ way
or popup this tooltip when _that_ menu was active, or
automatically change the status-bar when the mouse was
over this location, or have your own home-grown list-boxes
or tree-controls or drawing-pad object...
It is easy to form opinions from a bit of theory, but if
you have actually had to implement production quality
large scale windows programs, I am sure you know what
I mean -- something which allowed the level of detailed
access like C, was necessary for Windows programming.
C++ just made it possible for MFC or OWL to simplify
things for the user, while still allowing the massive
amount of experimentation going on with Windows
programming.
(I am discounting Unix a little bit, because though
X-Windows popularized Windows in general, Windows never
did overthrow the entrenched Unix model of computer usage.
To this day, most Unix users use their desktops as a
bunch of prettified shell terminals.)
Windows are standardized enough now that Java can have
window support built in. But still, you have to buy
into a model of standardization. This would not
have been possible in the early days of Windows,
when "popup" versus "pulldown" were barely defined,
and it was not clear which one is more useful when.
> Wrong. Objective-C only added object orientation to
> C (and followed a different model at that), while C++
> added a whole slew of features, of which object orientation
> was but one.
I think the success of C++ was tied to the object-orientation.
Overloaded functions, operator overloading, etc were an extra
good/bad thing depending upon your philosophy, but were not crucial.
The new stuff, templates, exceptions and all, are useful
and already tried out in other languages. Do they make an already
large language too big? We will find out in a few years...
C++ certainly has momentum so that compiler companies that
implement C++ compilers, have enough resources to implement
all of this.
> I say it's entrenchment. You've got something that's already
> widespread, and you release something that's both better and
> compatible, and people are more apt to take it. I mean,
> C++ did not force C programmers to change their ways, it was
> like an optional expansion pack -- "Hey you can use me or
> forget it and stick with C, no hurry, no risk". That is
> something a change-phobic industry would accept with open
> arms.
Yeah. That change-phobic industry is built from you and I.
I am not going to spend five years perfecting my Esperanto
unless I know it is going to be of some use to me. Nor am I
going to throw away my Qwerty and carry Dvorak
keyboards everywhere I go. (Some people do, but
they are usually change-phobic in other ways.)
Inertia exists in physics. It also exists in societies
and cultures. Some would say it is a good thing
and protects us from spending all our time on
trying out every new thing that came along!
Only some people, "the early adopters", can be
counted on to try new things and bring back
the good or bad news.
Mukesh Prasad <·······@polaroid.com> writes:
>Windows are standardized enough now that Java can have
>window support built in. But still, you have to buy
>into a model of standardization. This would not
>have been possible in the early days of Windows,
>when "popup" versus "pulldown" were barely defined,
>and it was not clear which one is more useful when.
In the early days of GUIs, we had Smalltalk.
I've recently been playing with an oldfashioned Smalltalk system,
and the GUI interface is a binary order of magnitude easier to use
than anything I've seen under W95 (or Java).
In 1984 I was using Xerox Lisp machines, and the window system
then was a *decimal* order of magnitude easier to understand
and program than anything from Microsoft, Sun, or the X Consortium.
Except for the availability of colour, and the price of the hardware,
GUI interfaces have _not_ got more usable: they have just got a lot
bigger and hugely (by comparison with the old Xerox 1189) slower.
>Yeah. That change-phobic industry is built from you and I.
>I am not going to spend five years perfecting my Esperanto
>unless I know it is going to be of some use to me. Nor am I
>going to throw away my Qwerty and carry Dvorak
>keyboards everywhere I go.
And don't forget the FUD factor.
If somebody told you you would need to carry a Dvorak keyboard,
they were lying to you. I've been resisting the switch for
years, but I'm coming to the conclusion that maybe I ought to
give Dvorak a go.
>Only some people, "the early adopters", can be
>counted on to try new things and bring back
>the good or bad news.
And then the next wave, knowing what is good, can do something
different.
--
Will maintain COBOL for money.
Richard A. O'Keefe; http://www.cs.rmit.edu.au/%7Eok; RMIT Comp.Sci.