Newsgroups: comp.lang.java.advocacy,comp.lang.c++,comp.lang.smalltalk
Path: cantaloupe.srv.cs.cmu.edu!rochester!cornellcs!newsstand.cit.cornell.edu!intac!uunet!in2.uu.net!144.212.100.12!news.mathworks.com!news-xfer.netaxs.com!wdcpop.dra.net!news.dra.com!news.starnet.net!news.starnet.net!news.utdallas.edu!nrchh45.rich.nt.com!bcarh189.bnr.ca!nott!kwon!watserv3.uwaterloo.ca!undergrad.math.uwaterloo.ca!j2lynn
From: j2lynn@undergrad.math.uwaterloo.ca (James F'jord Lynn)
Subject: Re: most popular language?
Sender: news@undergrad.math.uwaterloo.ca (news spool owner)
Message-ID: <E4IwpD.K8I@undergrad.math.uwaterloo.ca>
Date: Fri, 24 Jan 1997 17:32:00 GMT
References: <1997Jan9.160751@eng.cabot.nf.ca> <32DF05B4.4B23@concentric.net> <32df779c.2627518@news.wr.com.au> <32E03FB0.2AA2@jmpstart.com>
Nntp-Posting-Host: noether.math.uwaterloo.ca
Organization: University of Waterloo
Lines: 68
Xref: glinda.oz.cs.cmu.edu comp.lang.java.advocacy:5004 comp.lang.c++:242725 comp.lang.smalltalk:49881

[clj.programmer removed from newsgroup list]
James O'Connor  <joconnor@jmpstart.com> wrote:
>Ah...but your original question was what *can't* be done, not what
>*shouldn't* be done.

    The answer to this is that nothing can't be done. Both smalltalk and C++
 are Turing complete, and so using one of the other does not change your
 computing  power. It is very possible to do the dynamic changing of a 
 "parent class" in C++, it just happened to be that it isn't supported by the
 language, and so you have to do the work yourself.
    However, you could come up with a million and one different things that you
 want done in language A and language B, and as long as they are Turing
 complete then you can do it in both.
    Go and read http://www.cs.unm.edu/~saia/computability.html, not because
 it will shed more light on this, but as punishment :).


>Which brings up something I do a lot.  Rewriting the callbacks for
>controls on a window while the window is running.  Fire up the window,
>hit the button.  Something doesn't work, rewrite the button code.  Hit
>the button code again, opps, debugger  came up,  rewrite the button code
>*in* the debugger (add variables, methods, new classes, whatever), tell
>the debugger to resume from where it stopped (or wherever I want...). 
>Now it works.  All while the window is still running.  Opps, I forgot a
>widget.  Change the widget creation code and tell the window to redraw
>itself, taking into account the new code.

    This also is not language specific, it's debugger specific. Assymetrix
 SuperCede and SuperCede for Java allow you do to this (although I've only
 tried it out in the Java version). Usually widget creation code is in the
 constructor of the widow, but if you put it in paint(Graphics) then you
 can do all of this.

>> >Any Turing-complete langauge can do whatever any other Turing-complete
>> >language can do.  I prefer Smalltalk to C++/Java for the same reasons
>> >you prefer C++ to assembly language. "It's development speed, stupid!"

    This is why I prefer Java to C++, development speed. However, I prefer
 Java to Smalltalk because the support for Java in the industry, the
 syntax (I really dislike Smalltalk syntax), but the number one reason I
 perfer Java to Smalltalk is the fact that it is strongly typed. If I want
 to hack together something quickly in a loosely typed language, then I'll
 use perl. Otherwise, if I want to have reasonable assurence that my program
 is robust, then I'll take the hrorrendously strongly typed Java any day.

    And now that JDK 1.1 has the equivelant of dynamic message dispatching 
 (in a way that is even more dynamic than in Smalltalk: the message dispatch
 [Method invoke] is based on the String name of the message [method]).
    So, if I ever need that kind of functionality, (and I still haven't in
 my real apps), then I can use it.
    However, this is all just preaching because it is obvious to me that you
 find development time in a loosley typed language to be greater than in a
 strongly typed one, whereas I find it greater in a strongly typed one. You
 feel the time you gain from the actual development of code is greater than
 the time you loose ensuring your code is robust, while I find the time I
 lose in the making of the code is less than the time I loose in ensuring the
 robustness. Whether this comes from style of programming, I'm not sure
 (although I greatly suspect it is). It may also come from differing goals
 (maybe you don't care about proven robustness). Or it may just be that you're
 used to loose typing and I'm used to strong typing, and so we work well
 in our environments and in the other we are the proverbial fishes out of
 water.
   (Incidentally, I don't think the person I'm responding to is the same as
 the person in the quote above, but I think the above still applies to the
 person I am responding to).

-- 
Royalty free widgets - http://www.undergrad.math.uwaterloo.ca/~j2lynn/java.html
