Speaking of strings... - Page 15


DevX Home    Today's Headlines   Articles Archive   Tip Bank   Forums   

Page 15 of 17 FirstFirst ... 51314151617 LastLast
Results 211 to 225 of 247

Thread: Speaking of strings...

  1. #211
    W.E. (Bill) Goodrich, PhD Guest

    Re: Speaking of strings...

    In article <3db05aaf$1@tnews.web.devx.com>,
    "Jason" <jason@hotmail.com> writes:

    > I am also "tactically illiterate," whatever that means.


    : And don't just post some obscure academic articles that don't tell
    : anyone anything - actually explain what you are talking about.

    : Did I use the word obscure? I don't know that for a fact.

    : I have no idea why you are right, or even what you are talking
    : about, really.

    : But the article - if I remember correctly - was not written in a
    : way that made it all that useful to me. Sounded more like a
    : thesis paper.

    : Lots of big words to describe a medium-sized idea. I'll wait for
    : the movie, thanks.

    : Please explain it in such a way that even someone of my limited
    : intellect can understand.

    : Again, please make it simple so I can understand it.

    : This is too vague and argument for me to rebut or accept.

    : Bill, you know, you could try to say this in fewer words.

    : And put down the **** thesaurus and speak common English so I don't
    : have to pull out the dictionary every time I read one of your posts.

    You pretend to have reading comprehension problems when faced with
    clear evidence "inconvenient" to your religious cant. "Boo hoo hoo,
    the words are too hard!" And yet when you have some reference or
    claim that would seem to support your cherished beliefs, you have
    shown yourself quite capable of using the same "big words" you were
    whining about. And capable of accurately summarizing complex writings.
    So it is clear that your claimed problems with reading comprehension
    are nothing less than deliberate (therefore "tactical") dissembling.
    In fact, they fit in with your other uses of the same debate tactic,
    formally known as the "appeal to ignorance".

    By using such cheap tactics, you degrade your argument. Readers
    realize that they can no longer trust anything you say. Many of
    them will also see such Appeal to Ignorance arguments as evidence
    of true ignorance on your part. Of course, your excessive use of
    personal attacks, inapropriate language, etc. have much the same
    effect. You come across as a foul mouthed clown, who is arguing for
    the sake of arguing rather than from any conviction regarding the
    subject matter.

    And they are apparently right.

    --

    W.E. (Bill) Goodrich, PhD

    *-----------------------*--------------------------------------------*
    * CHANGE YOUR SEXUALITY * http://www.nyx.net/~bgoodric/ctg.html *
    * * *
    * Without Aversive * ctgcentral@earthlink.net *
    * Behavior Modification * Creative Technology Group *
    * or Drugs * PO Box 286 *
    * * Englewood, CO 80151-0286 *
    *-----------------------*--------------------------------------------*

  2. #212
    W.E. (Bill) Goodrich, PhD Guest

    Re: Speaking of strings...

    In article <Xns92ABE0965929runebivrincom@209.1.14.29>,
    Rune Bivrin <rune@bivrin.com> writes:

    > "Jason" <jason@hotmail.com> wrote in
    > news:3db05aaf$1@tnews.web.devx.com:


    [...]

    > I went into polymorphic land, but he wouldn't follow.


    I have discussed "polymorphism" - and the fact that that the
    people who keep trying to use it as an argument are not even able
    to define it effectively - at great length here. Your lame attempts
    to raise it again are pointless. Unless, of course, YOU can define
    "polymorphism" in a concrete way without the circular tactic of using
    OO specific terms and/or constructs.

    > He didn't even mark that section as "snipped",


    What do you hope to accomplish with that blatant lie? Or are you
    hoping that some reader somewhere will somehow have failed to learn
    the meaning of the "[...]" indicator?

    > which in his own terms would constitute an overt example of tactical
    > illiteracy,


    No, but the above does serve as an example of YOUR use of that tactic.
    In this case, your unbelievable claim of ignorance of the usenet
    convention. Of course, that would be more a use of "tactical ignorance"
    than tactical illiteracy, but it is close enough to the same thing.

    > and thus proves the fallacy of his expressed ethics of discussion.


    As elsewhere, you use logical fallacies to move from a false premise
    to a groundless conclusion.

    > Do unto others what you would have them do unto you?


    So you would prefer that I lie about YOUR posts, and pretend to
    misunderstand your words? How quaint.

    > How convenient!


    > One wonders who guides the good doctor in his crusade against object
    > oriented approaches. Could it be - SATAN!?


    Interesting approach. Especially given the clearly religious parallel
    of Jason's "any means all" arguments. So you would cast me as "the
    tester" relative to Jason's Evangelism? Interesting. For someone
    whose .sig declares "- Agnostic since 1964" you seem very focussed
    on religion.

    --

    W.E. (Bill) Goodrich, PhD

    *-----------------------*--------------------------------------------*
    * CHANGE YOUR SEXUALITY * http://www.nyx.net/~bgoodric/ctg.html *
    * * *
    * Without Aversive * ctgcentral@earthlink.net *
    * Behavior Modification * Creative Technology Group *
    * or Drugs * PO Box 286 *
    * * Englewood, CO 80151-0286 *
    *-----------------------*--------------------------------------------*

  3. #213
    Mike Mitchell Guest

    Re: Speaking of strings...

    On 21 Oct 2002 01:53:01 -0700, Rune Bivrin <rune@bivrin.com> wrote:

    >Which, by the way, is the key difference between him and MM. Somehow I
    >don't get the feeling MM takes himself all too seriously.


    Confound it, sir! You have uttered a challenge that can only be
    satisfied by pistols at dawn! I take myself very seriously, you know.
    But, yes, a little levity goes a long way toward ameliorating a
    standoff between the two camps. So, put away that pistol and send the
    seconds home again. If we can't laugh a little, what's the point of
    getting up in the morning?

    > Also, his writing is higly readable, albeit grossly ignorant on OO issues. Bills is
    >just pompous and full of intellectual put-downs. Reminds me of some of
    >Saul Bellows more annoying characters.


    If I'm grossly ignorant of OOP despite having been confronted with it
    on and off for at least five years, it doesn't say much for OOP's
    ability to win friends and influence people, does it? I mean, why
    should I bust a gut on procedural programming, achieving all the
    wunnerful things I have already, when I could use OOP and bust TWO
    guts? Maybe I am just not masochistic enough to want to "do" OOP -
    including actually implementing it.

    But I'm not alone, as you well know! Seventy percent...seventy
    percent! It's like a mantra. Say it with me!

    MM

  4. #214
    Mike Mitchell Guest

    Re: Speaking of strings...

    On 20 Oct 2002 20:14:20 -0700, "Jason" <jason@hotmail.com> wrote:

    >Similar nonsense. Mike, if you are going to get so "passionate" about something,
    >you might want to try to understand a little bit about it first.


    Then do you not believe that 64-bit will be thrust at us as soon as
    Microsoft can cobble together an OS that works? Man, they need the
    revenue! Yes, we don't *need* it; that's my line. But they will insist
    we *do* need it, and there are very many CEOs who don't know enough to
    be able to make a reasonable decision given the amount of confusion
    marketing that goes on. Ergo, best upgrade, they say. Then we know
    we're running "the latest". Yeah, for that year, maybe!

    Games aficionados will buy games machines. People on the move will buy
    PDAs or use internet cafes and laptops. At home and in the office,
    word processing and spreadsheeting still need to be done and the
    machines we had *two* years ago were already powerful enough for most
    corporations. Only a few key machines need to be high-end machines
    nowadays. We will pay yet again for something we just don't need.

    MM

  5. #215
    Mike Mitchell Guest

    Re: Speaking of strings...

    On 20 Oct 2002 20:04:27 -0700, "Jason" <jason@hotmail.com> wrote:

    >>It is not just a perception; it is fact. .Net *is* harder. There is a
    >>lot more to it for a start and it totally mandates an OOP approach,
    >>which is harder per se. (See that interview with Alan Cooper.)

    >
    >So what you are saying is that you don't really understand .NET, and it must
    >be more complex because Alan Cooper says so, in an article where he also
    >says that .NET is one of the "simplifying" technologies.


    Alan Cooper said: "I just think OOP is hard. A language like C# is
    hard because OOP is harder because itís designed to solve bigger
    problems."

    I agree with him. Do you?

    MM

  6. #216
    Mike Mitchell Guest

    Re: Speaking of strings...

    On 20 Oct 2002 20:32:17 -0700, "Jason" <jason@hotmail.com> wrote:

    >So you are saying that, based on your non-experience with .NET, you went
    >out and found an anti-Microsoft article and posted it here.


    I didn't go anywhere, out, in, up, or down. The article in question
    was one of the dozens that get published on ZDNet daily, and since I
    visit that site, along with The Register, the BBC, Reuters and a few
    others, I came upon it as a matter of course. Whether it is pro- or
    anti-Microsoft I'll leave it up to you to qualify, since that
    particular condition doesn't interest me. Suffice to say, the
    marketing of web services and the ".Netization" of many (most?)
    Microsoft products were thought now, even by Microsoft, to have been
    mishandled. Should this mean that Steve "I dance for peanuts" Ballmer
    himself is being somewhat anti-Microsoft by offering just a small
    little teensy-weensy morsel of criticism?

    I'd be pro-Microsoft more often, but, well, ya know - it's just too
    darn difficult to go out and find enough suitable articles that
    support that position!

    >Let's get something straight here. You have not tried .NET.


    Neither have most people. Most people don't buy something to try it
    out. They read up on it first, they ask questions of others, they
    check out the market position and so on. It is highly unusual that one
    should be expected to acquire a good just in order to find out whether
    one likes it or not. Think how many TVs, music centres, or mountain
    bikes you bought, then sent 'em back because they weren't any good!
    Oh? None, you say? At least vendors are usually willing to take back
    an item like a TV or a bike if it was bought by mistake. Try doing
    that with software after you've removed the cellophane! Anyway, I can
    always argue that I'm waiting for version 2.0.

    > You have not
    >developed with .NET.


    True. That's because of... [see above].

    > You don't understand it, don't know what its strengths
    >and weaknesses are, don't know what problems it seeks to address, and don't
    >know what problems it does not address. In other words, you don't know diddly.
    > Yet you still insist on ramming your foot into your mouth up to the knee
    >over and over and over.


    Its strengths: XCOPY installation (perhaps, though with Everett and
    Longhorn, who knows how many side-by-side versions will have to
    co-exist?).

    Its weaknesses: Bloatware. Reinventing the wheel. XML. Java wannabe.
    20 MB runtime. Killed off classic VB. Proprietary. Yet another layer
    on top of Windows - how many more do you want?

    >If you want any credibility at all, either use .NET long enough to understand
    >it so you can insult it, or simply move on to one of the topics you actually
    >understand (see previous post).


    Well, I'll keep my options open for now, thanks all the same! But I'll
    keep reading up on those articles the guys over at ZDNet and elsewhere
    are publishing. Nothing like a bit of balance in reporting the facts,
    I say, and you must admit that the level of enthusiasm here sometimes
    amounts to little short of zealotry.

    MM

  7. #217
    Phil Weber Guest

    Re: Speaking of strings...

    > > You have not tried .NET.
    >
    > Neither have most people. Most people don't buy something to
    > try it out...Think how many TVs, music centres, or mountain
    > bikes you bought, then sent 'em back because they weren't any
    > good! Oh? None, you say? At least vendors are usually willing to
    > take back an item like a TV or a bike if it was bought by mistake.
    > Try doing that with software after you've removed the cellophane!


    Mike: Your arguments are becoming progressively weaker. Are you aware that free
    trial versions of VS.NET are readily available? You don't have to "buy" anything
    in order to try it out. You don't even have to install anything, if you'd prefer
    not to: Microsoft allows you to try a copy that's running on its servers. Try
    that with a TV or a bike!
    --
    Phil Weber



  8. #218
    Patrick Steele [MVP] Guest

    Re: Speaking of strings...

    In article <50b8rug4tsv5pl6ha7t37bq36opd57gne7@4ax.com> (from Mike
    Mitchell <kylix_is@yahoo.co.uk>),
    > Its weaknesses: Bloatware.


    False. Disk is cheap. People said that 5 years ago and it's even more
    true today.

    > Reinventing the wheel.


    Are there really any new wheels to be invented?

    > XML.


    That's your personal bias. Given the current market demands, excluding
    XML wouldn't be a very good idea.

    > Java wannabe.


    Java is very popular and successful. Why not imitate it (and improve
    upon it in the process)?

    > 20 MB runtime.


    Non-issue.

    > Killed off classic VB.


    False.

    > Proprietary.


    Mono? Rotor?

    > Yet another layer on top of Windows - how many more do you want?


    A barely valid point. Given the extra power you now have with .NET, the
    new layer is welcomed.

    --
    Patrick Steele
    Microsoft .NET MVP
    http://radio.weblogs.com/0110109

  9. #219
    W.E. (Bill) Goodrich, PhD Guest

    Re: Speaking of strings...

    In article <Xns92ABEAC04D9A5runebivrincom@209.1.14.29>,
    Rune Bivrin <rune@bivrin.com> writes:

    > "W.E. (Bill) Goodrich, PhD" <bgoodric@netzero.net> wrote in
    > news:3DB05CB4.4E9A9597@netzero.net:


    > I noticed you wouldn't discuss the polymorphic attributes of
    > Windows controls, with or without OO wrappers. What's the matter?
    > Did your feet get wet?


    I notice that, like the others, you have proven unwilling (apparently
    unable) to define your terms as requested. What's the matter? Don't
    you even know what you are talking about?

    > > There are three possible classifications: OO specific, OO neutral,
    > > or OO antagonistic. The IF statement was in common use long
    > > before Dahl and Nygaard first proposed the OO concept, so it
    > > clearly is not OO specific. Nothing about it mitigates against OO,
    > > so it clearly is not OO antagonistic. So it must be OO neutral.
    > > The fallacy of your question lies in the attempt to cast it as an
    > > either/or.


    > Once again this insidious "fallacy".


    Yes, such fallacies DO seem to be rather pervasive in your arguments.
    And Jason's.

    > I specifically pointed out - and which point you conveniently moved
    > out of context to three paragraphs later - that I didn't care.


    An entirely irrelevant - and apparently untrue - claim. You obviously
    DO care, since you raised the point and have now reacted to my
    response.

    Your fallacy I mentioned is a common trick of the desperate: the
    false dichotomy. You falsely cast an issue in terms of ONLY two
    choices, when those two answers do not reflect the nature of the
    issue.

    > Thus I have not expressed a position on the issue,


    Again, a false leap. Expressing an emotional disinterest (even if you
    were honestly doing so) is not the same thing as not expressing a
    position on the issue.

    > but you choose to wear your thorn-tinted glasses and read
    > something into this which I didn't intend.


    You made a statement. I answered it. You CLAIMED indifference to the
    statement you made (yet responded with apparent emotion to my reply).
    Exactly WHAT are you claiming that I "read into" your "But then we're
    facing the issue of the Popes beard: Is an IF statement OO or
    procedural?" (another example of the religious orientation you have
    shown elsewhere).

    > Bear in mind that OO may well have existed as a pattern in the
    > world of programming before the Norwegian duo formalized it.


    Irrelevant. OO, as discussed here, IS a formalized set of principles
    and constructs for the design and implementation of software. Trying
    to "see" it in code which predates the beginning of that
    formalization merely reinforces the religious nature of your argument.
    And goes a long way toward rendering your claims (and Jason's)
    meaningless.

    > Whether it existed before the IF statement I don't know. You are not
    > suggesting Newton invented gravity, are you?


    And again, the attempt to draw a parallel between a modality and
    theories of physics. Gravity operates completely independent of human
    intervention. OO does not. Your analogy is completely pointless and
    invalid.

    > Following your argument, if an IF statment is OO neutral, it
    > implies that the constituent parts of a component/module/object has
    > no bearing on how to view the item as a whole.


    Given the importance of formal logic to software design and
    implementation, your apparent inability to handle even the most basic
    elements says something quite sad.

    No, the former does NOT imply the latter. By your leap of illogic,
    the statement that "water is Ph neutral" would imply that "the
    constituent parts of a solution have no bearing on the acidity of the
    solution as a whole". Clearly an absurd leap of illogic on your part.

    > Accordingly, it is the exposed interface of a unit that we will have
    > to use to classify it.


    And since your premise was false, that "conclusion" is groundless. In
    terms of a formal approach to both design and implementation (such as
    OO), it is more relevant to classify a particular "unit" in terms of
    compliance (or not) with the formalities of the approach and use (or
    not) of those elements which specifically differentiate the approach
    from other approaches. Accordingly, a subprogram which was not
    designed with OOD, was not deliberately and specifically implemented
    using OOP, and does not use OO specific constructs (as opposed to OO
    neutral constructs) is clearly NOT OO in any meaningful way. If
    someone adds your superficial varnish, that does not change that
    fact, any more than adding a non-OO wrapper to an OOD designed, OOP
    implemented, class focused subprogram would render it "not OO".

    You can choose to argue that the varnish itself is OO, as in some of
    Jason's misguided attempts to argue that "any OO means ALL is OO",
    but the argument is effectively meaningless. Especially when used in
    an attempt to claim that any program which makes ANY use whatsoever
    of ANY OO varnished code is thereby object ORIENTED.

    Your claim is like declaring that we should classify the Ph of a
    solution based on the color of the solution.

    > Ergo! an ActiveX control is an object!


    Again, you started with an invalid premise, went through an
    unsupported leap of illogic to an intermediate unsupported (and false)
    claim, and from there to yet another unsupported claim. Your attempt
    to claim QED is completely worthless.

    It is like declaring that Nitric Acid is actually Ph neutral because
    it looks like water.

    > Moreover, I could make the point - but will refrain from doing so


    Yet again you play the game of trying to avoid a response. A good
    indication that you know your argument is invalid.

    > - that an if statment could really be seen as a method call on a
    > boolean expression, taking one or two code blocks as parameters,
    > albeit with a somewhat kludgy syntax.


    And if you DID try to "make that point", you would reduce "OO" to
    complete meaninglessness. You would be saying that EVERYTHING is OO,
    which would mean that NOTHING is OO (because there would no longer
    be anything that distinguishes OO from not OO). And all of the
    claimed "benefits" of OO would be completely invalid, since the worst
    "any way" undocumented spaghetti code would be OO. If you are going
    to argue that OO is anything but a meaningless and worthless fiction,
    you will need to be very clear about what differentiates OO from "not
    OO".

    > Looking at most assembler code that I know bears this out. First the
    > outcome of the condition is established, and then the code branches
    > accordingly. Hey, it's almost like a bit-sized vtable!


    For someone who was going to "refrain from doing so" you are certainly
    going on at length. Once again, once you destroy the distinction
    between OO and "not OO" you effectively render OO a pointless fiction.
    Any claim you make about about OO becomes equally true about "non OO".

    > I have used languages which implemented loops with code blocks, where
    > these were objects in themselves.


    In your rather religious view.

    > So either you take things for being what they appear to be, in
    > which case an IF statement is OO antagonistic (no inheritance, no
    > polymorphism and no encapsulation), or you take them for being what
    > they might be, given your particular preferred world view, in
    > which case the answer will vary.


    Again with the false dichotomy. The first "alternative" is illogical,
    incorrect (your "antagonistic" claim does not follow), and largely
    irrelevant. The second is so vague as to be meaningless.

    > Nothing in this world is ever truly neutral.


    Absolute nonsense. You are back to religious argument. "Neutral" is
    not an absolute term in the first place. It is a construct which in
    turn is defined relative to another construct (usually in the form of
    a "scale") or constructs. And by most such definitions, there are
    indeed things which are "truly neutral". While something may be
    unquestionably neutral on one scale and "not neutral" on another, the
    latter fact has absolutely no bearing on the truth of the former.

    > Even absolutely pure water contains both acid and its counterpart
    > (whatever that is termed in english),


    "Alkaline" or "Base" - both are acceptable. And no, absolutely pure
    water contains neither acid not alkali. Neither Oxygen nor Hydrogen
    is inherently acidic or alkaline, and absolutely pure water contains
    nothing but molecules consisting of two atoms of Hydrogen and one
    atom of Oxygen (a molecule which is neither acidic nor alkaline).
    And the DEFINITION of neutrality on that scale (Ph) is at the macro
    level rather than at the component level.

    > although they will cancel each other out on a large scale.


    Thereby rendering "pure water" neutral (even if it were not already
    true).

    > > The issue of a "superficial OO varnish on procedural code" becomes
    > > relevant when someone (like Jason) tries to argue that the code is
    > > "OO based" and therefore users of that code are "using and
    > > benefiting from OOP libraries and methodologies." When the
    > > elements in those libraries are older "procedural" (to use your
    > > classification) code with a superficial OO varnish, then the
    > > argument is invalid. The code is neither "OO based" nor a result
    > > of OOP methodologies, and the primary benefit comes from the older,
    > > underlying code.


    > > Say I write an FFT function, without using any classes or other
    > > OO specific constructs or methodologies (which I have). If
    > > someone comes along and slaps that "superficial OO varnish" (in
    > > the form of a wrapper) on it, Jason would be completely wrong to
    > > point to the varnished version as support for his claim. The
    > > primary benefit - especially to someone who is not trying to do
    > > OOP - comes from my non OO code rather than the varnish.


    > Of course.


    So you agree that Jason's claim is invalid. Thank you.

    > The cost/benefit aspect of this was never in question.


    Irrelevant. The issue was the SOURCE of the benefit and, as you just
    acknowledged, Jason was completely wrong in his position on that
    issue.

    > To someone who doesn't like quacking ducks, earplugs will be a good
    > investment.


    Again, irrelevant.

    > But I contend, your honor, that if an FFT function is carefully
    > wrapped in a warming blanket of object oriented concepts, I will
    > be using object oriented mechanisms whilst invoking said
    > functionality.


    Intentionally, or incidentally? That is the core of that part of the
    issue. If you are using that incidentally, because it is the only way
    you have of getting to the real functionality, then you are not
    "benefiting" from that varnish at all while you ARE benefiting from
    the core non OO code. OTOH, if you are deliberately using those
    mechanisms as part of an intentionally OO body of code, that use is
    irrelevant to the already established OO nature of your code.

    > The fallacy of your argument lies in the strategical inability to
    > recognize that OO might have other aspects to it than what the
    > ulterior design motives bring to the table.


    Freudian slip? Just what ARE your ulterior motives?

    You have not identified any fallacy in my stated argument. Indeed,
    you seem intent on misusing words in an attempt at obfuscation.

    > Hence the established distinction between Object Oriented Design
    > and Object Oriented Programming.


    Again, you are claiming a relationship that does not exist. Even if
    the word salad in your previous sentence had some meaning, the one
    above would not logically follow. To date, all you and Jason have
    done is weaken the definitions of OOD and OOP to the brink of
    nonexistence.

    > I like (*not*) the way you use the word "slaps" to create an
    > illusion that all wrappers are hastily and sloppily concocted by
    > an army of chimps, whereas your FFT function dwells on the pinnacles
    > of engineering.


    Interesting interpretation. But irrelevant to the point. The primary
    value of the call to the FFT function lies in the original code, not
    in the OO varnish. The argument that Jason and you have tried to
    support would claim otherwise, irrespective of HOW sloppily the OO
    varnish was slapped on.

    > >> I don't know - and frankly, my dear, I don't give a ****!


    > > Which is fine, as long as you don't try to advance Jason's
    > > misguided argument.


    > Misguided.


    Yes, misguided. By reducing the definition of OOP to "programming
    which includes or uses anything which can be described - no matter
    how tenuously - as an OO related construct or concept" he comes very
    close to defining it out of existence (as demonstrated above). He
    certainly renders all his claims about "benefits" of OOD/OOP void,
    since they are conspicuously absent from a lot of what he has expanded
    the definition to call OOP.

    > Hmmm, ain't that special! Bill, this is not a court of law, and
    > there is no jury of your peers present.


    No, this is a public forum, and there is an audience which includes
    innocent bystanders who may be misled by Jason's nonsense. Injecting
    a bit of rigor into the discussion improves the chance that they will
    examine the claims rather than swallow them uncritically.

    > Just because you're right


    Thank you for acknowledging that.

    > doesn't mean everybody who disagrees with you is wrong.


    I don't claim that every such person is. However, I most certainly do
    contend that I have shown that Jason's misguided claims are wrong.
    Just because YOU agree - in a general sort of way - with the broad
    outlines of his position doesn't make any part of his specific
    arguments right.

    > You should consult a specialist about that condition.


    About being right? About rigorous debate in a public forum?

    > >> The good doctor has painted himself into a corner where every
    > >> sign of functional OO has to be written off as "non-OO code in
    > >> an OO wrapper".


    > > Not at all. Jason is the one in the corner, having built his
    > > argument on the claim that the elements in question are "OO based"
    > > (rather than varnished) and that their use constitutes "using and
    > > benefiting from OOP libraries and methodologies." When it is well
    > > known that the libraries are in fact old code with your superficial
    > > OO varnish, his argument falls apart. To support his claim, he
    > > would have to demonstrate that (1) the components he cites were in
    > > fact created with OOD/OOP rather than "varnished", and (2) that
    > > the OO nature of the components is responsible for a significant
    > > part of the value of each individual component, especially to non
    > > OO programmers who simply use the component. He has done neither.


    > I see this as a impromptu boxing ring, and we're all in some corner
    > right now.


    That certainly helps explain your personal attacks and meaningless
    feints. But that metaphor does not map itself at all to your earlier
    "painted" metaphor.

    I see this more as a scale, weighing the relative merits of the
    evidence and argument for claim and counterclaim, and thereby helping
    readers and participants understand the issues involved. Jason's
    juvenile games clearly tip the scales in favor of my position, as do
    your (somewhat less pervasive) games.

    > However, I pointed out the fallacy of your statement that windows
    > controls are not implemented using OO techniques.


    The underlying code was. Long ago. Your claim has no merit.

    > Something which you conveniently chose to snip, thus getting egg
    > on your high browed self.


    No, something I have already answered repeatedly, and declined to
    repeat.

    > >> If possible, any evidence to the contrary should be attributed
    > >> to "fallacies".


    > > Not at all. But I will not hesitate to point out such fallacies
    > > when they are advanced as arguments. Such as the false dichotomy
    > > I addressed above. Unfortunately, certain of the posters here
    > > seem to use such fallacies as their primary mode of argument.


    > Arguments of what, Bill? Could you please state your view of the
    > relation between modular programming and object orientation?


    I already have, a number of times. OO, while based in large part on
    the earlier and more pervasive MP, puts a heavy emphasis on constructs
    and approaches which weaken modularity and thereby reduce the benefits
    of the coopted elements. OO exists in its current form largely due to
    Academic politics and the failure of its Academic predecessor (SSP)
    to effectively address issues of realtime and interactive software.
    While MP was never a movement in Academic politics, its pervasive
    popularity among effective designers and programmers has significantly
    contributed to the decades long useful lives of much of the mission
    critical software in use throughout the world.

    When the programmers are kept on a tight leash, OOD/OOP can be useful
    in certain narrow problem domains. In more general use by less
    disciplined developers, the OO specific constructs can - and often
    do - render large bodies of code virtually impossible to upgrade or
    maintain.

    While both modalities share many of the precepts of MP - and call for
    certain formal practices - there are specific differences in design
    and implementation. Such as the relationships between data structures
    and bodies of code. MP, with its conceptual and practical separation
    of data and code, is closer to the way people think (and the way
    computers operate) than the merging of code and data inherent in OO.

    > Without using the words "fallacy", "dichotomy", "fad" or other
    > derogatory samples of your vast vocabulary. Remember, he is not
    > always right who cries the loudest or longest.


    However, he who most often substitutes personal insults and cynical
    games for substance rarely - if ever - has the more valid position.

    --

    W.E. (Bill) Goodrich, PhD

    *-----------------------*--------------------------------------------*
    * CHANGE YOUR SEXUALITY * http://www.nyx.net/~bgoodric/ctg.html *
    * * *
    * Without Aversive * ctgcentral@earthlink.net *
    * Behavior Modification * Creative Technology Group *
    * or Drugs * PO Box 286 *
    * * Englewood, CO220 47246 <bnk8rucpu8iqn2j6bfms9dss8uno46nojo@4ax.com> article retrieved - head and body follows
    From: Mike Mitchell <kylix_is@yahoo.co.uk>
    Newsgroups: vb.dotnet.discussion
    Subject: Re: It's a jungle out there...
    Date: Mon, 21 Oct 2002 20:23:23 +0100
    Message-ID: <bnk8rucpu8iqn2j6bfms9dss8uno46nojo@4ax.com>
    References: <3da969dc$1@10.1.10.29> <3db2eaf1@tnews.web.devx.com> <3db377c9$1@tnews.web.devx.com>
    X-Newsreader: Forte Free Agent 1.92/32.572
    MIME-Version: 1.0
    Content-Type: text/plain; charset=us-ascii
    Content-Transfer-Encoding: 7bit
    NNTP-Posting-Host: modem-1390.aardvark.dialup.pol.co.uk
    X-Trace: 21 Oct 2002 12:14:24 -0700, modem-1390.aardvark.dialup.pol.co.uk
    Lines: 19
    Path: tnews.web.devx.com
    Xref: dnews vb.dotnet.discussion:47246

    On 20 Oct 2002 20:43:05 -0700, "Jason" <jason@hotmail.com> wrote:

    >In other words, avoid inheritance whenever you can. When you really need
    >it, it will be obvious. If it isn't obvious, pick another solution.


    But one of the biggest features VB programmers supposedly were crying
    out for was inheritance! Of course, *I* don't believe that more than a
    handful were clamouring for it anyway, since so many users produced
    many fine applications without ever writing a class. But now you've
    *got* inheritance, you're saying, steer well clear except in a few
    specific cases? I thought the whole story of OOP was to design a few
    base classes, then inherit like f**k and thereby get your software
    reuse? Yes, I agree it's mostly bollocks, but then I'm not a fan of
    OOP in the first place, so I'm allowed to make comments like that! But
    you, Jason, I thought you of all people were fully committed to OOP
    and all its foibles. (Foibles? OOP? Shurely shome mishtake, Miss
    Moneypenny!)

    MM

  10. #220
    Kunle Odutola Guest

    Re: Speaking of strings...

    Bob Butler wrote:
    > "Kunle Odutola" <kunle.odutola@REMOVETHISokocha.freeserve.co.uk> wrote
    > in message news:3db2eaf4@tnews.web.devx.com
    > <cut>
    >> The approach you condemn has the benefit that new code requires
    >> additions and not changes to exisiting, tested code.

    >
    > Too bad that concept can't be applied to the millions of lines of
    > existing VB6 code when attempting to go to VB.Net


    It can. VB6 still works and, if you need inter/intra-app integration, COM
    Interop is your friend.

    Kunle


  11. #221
    PWilmarth Guest

    Re: Speaking of strings...


    >You come across as a foul mouthed clown, who is arguing for
    >the sake of arguing rather than from any conviction regarding the
    >subject matter.
    >
    >And they are apparently right.
    >
    >--
    >
    >W.E. (Bill) Goodrich, PhD
    >

    I'm sorry, but you are just as guilty of degrading the debate with personal
    attacks. Checked out your website . . . Your Phd is in which discipline?
    Sounds like you are hanging around with the mental health folks too much.


  12. #222
    Rune Bivrin Guest

    Re: Speaking of strings...

    "W.E. (Bill) Goodrich, PhD" <bgoodric@netzero.net> wrote in
    news:3DB417CF.38DD4FE2@netzero.net:

    > I have discussed "polymorphism" - and the fact that that the
    > people who keep trying to use it as an argument are not even able
    > to define it effectively - at great length here. Your lame attempts
    > to raise it again are pointless. Unless, of course, YOU can define
    > "polymorphism" in a concrete way without the circular tactic of using
    > OO specific terms and/or constructs.

    All I have ever read from you on the topic of polymorphism is the request
    for definition. As for "at great length", alas, that is correct.

    >
    >> He didn't even mark that section as "snipped",

    >
    > What do you hope to accomplish with that blatant lie? Or are you
    > hoping that some reader somewhere will somehow have failed to learn
    > the meaning of the "[...]" indicator?

    Mea culpa. Mea maxima culpa. All I can say is I read too quickly. A must,
    given the circumstances...

    >
    >> which in his own terms would constitute an overt example of tactical
    >> illiteracy,

    >
    > No, but the above does serve as an example of YOUR use of that tactic.
    > In this case, your unbelievable claim of ignorance of the usenet
    > convention.

    What grounds do you have for stating that I claim "ignorance of the usenet
    convention"? Of several possible reasons, you elect the most damning.
    Interesting!
    As far as I know, but I may be wrong, the use of [...] is not a "usenet
    convention". It's a well established convention in the entire academic
    world, and one which has spilled over into the usenet. Maybe it's just an
    academic fad?

    > Of course, that would be more a use of "tactical ignorance"
    > than tactical illiteracy, but it is close enough to the same thing.

    So ignorance and illiteracy are close enough to be interchangeable?
    Intriguing...


    >> and thus proves the fallacy of his expressed ethics of discussion.

    >
    > As elsewhere, you use logical fallacies to move from a false premise
    > to a groundless conclusion.
    >
    >> Do unto others what you would have them do unto you?

    >
    > So you would prefer that I lie about YOUR posts, and pretend to
    > misunderstand your words? How quaint.

    No. Don't pretend to be more stupid than me. That's plain impossible,
    anyway!

    >> How convenient!

    >
    >> One wonders who guides the good doctor in his crusade against object
    >> oriented approaches. Could it be - SATAN!?

    >
    > Interesting approach. Especially given the clearly religious parallel
    > of Jason's "any means all" arguments. So you would cast me as "the
    > tester" relative to Jason's Evangelism? Interesting. For someone
    > whose .sig declares "- Agnostic since 1964" you seem very focussed
    > on religion.
    >

    Is this another example of tactical ignorance? Failure to recognize
    travesty of major cultural manifestation point to holes in the set of
    references which form your persona. Or just a lack of a sense of humor.


    --
    Rune Bivrin
    - OOP since 1989
    - SQL Server since 1990
    - VB since 1991


  13. #223
    Mike Mitchell Guest

    Re: Speaking of strings...

    On Mon, 21 Oct 2002 21:00:04 +0100, "Kunle Odutola"
    <kunle.odutola@REMOVETHISokocha.freeserve.co.uk> wrote:

    >It can. VB6 still works and, if you need inter/intra-app integration, COM
    >Interop is your friend.


    Friend or emergency rescue service?

    MM

  14. #224
    Rune Bivrin Guest

    Re: Speaking of strings...

    "W.E. (Bill) Goodrich, PhD" <bgoodric@netzero.net> wrote in
    news:3DB453AF.DF3FB592@netzero.net:

    [...]

    >> I noticed you wouldn't discuss the polymorphic attributes of
    >> Windows controls, with or without OO wrappers. What's the matter?
    >> Did your feet get wet?

    >
    > I notice that, like the others, you have proven unwilling (apparently
    > unable) to define your terms as requested. What's the matter? Don't
    > you even know what you are talking about?
    >

    I will, of course request that you define "definition", without using
    definition-specific constructs.

    However:
    Object Orientation: An approach to developing computer
    systems/applications/programs/software in which the data structures used
    are considered the most significant structural elements of the
    applications.

    Polymorphism: The ability to have the actions carried out by an equally
    defined operation be different, depending on the type of the data on which
    it operates.

    Inheritance: An implementation technique, which enables a datatype to
    extend and specialize the definition of another type without repeating it.
    Thus achieving a form of polymorphism.

    Encapsulation: Minimizing inconsistent coupling between different parts of
    a system by disallowing direct external access to internal data items.
    This ensures that implementation and interdependencies of data items are
    localized to the smallest possible unit where these are fully understood
    and defined.

    Interface: The externally accessible data items and functions available
    that appliy to a data structure.

    Still, you seem unwilling to actually discuss the polymorphic attributes
    of Windows controls...

    [...]
    >
    >> I specifically pointed out - and which point you conveniently moved
    >> out of context to three paragraphs later - that I didn't care.

    >
    > An entirely irrelevant - and apparently untrue - claim. You obviously
    > DO care, since you raised the point and have now reacted to my
    > response.

    Aha, so you judge me by my interface, and not my internal implementation?
    Be aware then, that I am polymorphic. You can not know what actions may be
    executed on your operations.

    > Your fallacy I mentioned is a common trick of the desperate: the
    > false dichotomy. You falsely cast an issue in terms of ONLY two
    > choices, when those two answers do not reflect the nature of the
    > issue.
    >

    So, in terms you can understand: There is a false dichotomy in your claim.
    You imply that there are only two positions in a discussion: being Bill or
    being desperate. In the real world, this is a sliding scale, and most
    people tend to dwell on the middle ground.
    Thus, you exploit a common trick of the desperate.

    >> Thus I have not expressed a position on the issue,

    >
    > Again, a false leap. Expressing an emotional disinterest (even if you
    > were honestly doing so) is not the same thing as not expressing a
    > position on the issue.

    The reader reading a position into a statement is not the same thing as
    the writer expressing that position. But, since the beauty is in the eye
    of the beholder, I will grant you your view.

    [...]
    > Exactly WHAT are you claiming that I "read into" your "But then we're
    > facing the issue of the Popes beard: Is an IF statement OO or
    > procedural?" (another example of the religious orientation you have
    > shown elsewhere).

    A large portion of our cultural baggage emanate from the domains of our
    religious history. The Popes beard is one of these gems. Look into it. You
    may be surprised at how many proverbs and sayings come from the bible and
    other religious texts. Or Shakespeare, of course.
    Me, I just use it to show off.

    >> Bear in mind that OO may well have existed as a pattern in the
    >> world of programming before the Norwegian duo formalized it.

    >
    > Irrelevant. OO, as discussed here, IS a formalized set of principles
    > and constructs for the design and implementation of software. Trying
    > to "see" it in code which predates the beginning of that
    > formalization merely reinforces the religious nature of your argument.
    > And goes a long way toward rendering your claims (and Jason's)
    > meaningless.

    So loops didn't exist before the formalization of the while construct,
    then? How you discuss OO, and how I discuss it are not the same thing.


    >> Whether it existed before the IF statement I don't know. You are not
    >> suggesting Newton invented gravity, are you?

    >
    > And again, the attempt to draw a parallel between a modality and
    > theories of physics. Gravity operates completely independent of human
    > intervention. OO does not. Your analogy is completely pointless and
    > invalid.

    In your opinion. Which you are entitled to.

    >
    >> Following your argument, if an IF statment is OO neutral, it
    >> implies that the constituent parts of a component/module/object has
    >> no bearing on how to view the item as a whole.

    >
    > Given the importance of formal logic to software design and
    > implementation, your apparent inability to handle even the most basic
    > elements says something quite sad.
    >
    > No, the former does NOT imply the latter. By your leap of illogic,
    > the statement that "water is Ph neutral" would imply that "the
    > constituent parts of a solution have no bearing on the acidity of the
    > solution as a whole". Clearly an absurd leap of illogic on your part.

    Bill, the acidity of a soloution depends on other substances, and these
    have distinct acidic properties.
    Which programming language contructs are the ones that turn a piece of
    software into OO, then?

    [...]
    >
    > Your claim is like declaring that we should classify the Ph of a
    > solution based on the color of the solution.

    I would like to think that the Ph of a solution forms part of the external
    interface of that solution, so this is a preposterous idea. Certainly one
    that I have never expressed.

    >
    >> Ergo! an ActiveX control is an object!

    >
    > Again, you started with an invalid premise, went through an
    > unsupported leap of illogic to an intermediate unsupported (and false)
    > claim, and from there to yet another unsupported claim. Your attempt
    > to claim QED is completely worthless.
    >
    > It is like declaring that Nitric Acid is actually Ph neutral because
    > it looks like water.

    I would like to think that the Ph of a solution forms part of the external
    interface of that solution, so this is a preposterous idea. Certainly one
    that I have never expressed.

    [...]
    >
    > And if you DID try to "make that point", you would reduce "OO" to
    > complete meaninglessness. You would be saying that EVERYTHING is OO,
    > which would mean that NOTHING is OO (because there would no longer
    > be anything that distinguishes OO from not OO). And all of the
    > claimed "benefits" of OO would be completely invalid, since the worst
    > "any way" undocumented spaghetti code would be OO. If you are going
    > to argue that OO is anything but a meaningless and worthless fiction,
    > you will need to be very clear about what differentiates OO from "not
    > OO".

    On the scale of singular statements, OO is indeed meaningless, as is MP,
    or any other popular abbreviation. The question is where on on that scale
    OO traits become visible. I don't think such a discreete point exists.

    [...]
    > In your rather religious view.

    And look who is preoccupied with religion now?

    [..]
    >
    >> Even absolutely pure water contains both acid and its counterpart
    >> (whatever that is termed in english),

    >
    > "Alkaline" or "Base" - both are acceptable.

    Thanks.

    And no, absolutely pure
    > water contains neither acid not alkali. Neither Oxygen nor Hydrogen
    > is inherently acidic or alkaline, and absolutely pure water contains
    > nothing but molecules consisting of two atoms of Hydrogen and one
    > atom of Oxygen (a molecule which is neither acidic nor alkaline).
    > And the DEFINITION of neutrality on that scale (Ph) is at the macro
    > level rather than at the component level.

    Consult, if you will, your chemistry books. Pure water will contain
    positive Hydrogen (H+) ions and negative hydroxy (OH-) ions.

    [...]
    >> Of course.


    >So you agree that Jason's claim is invalid. Thank you.

    No.

    [...]
    > Irrelevant. The issue was the SOURCE of the benefit and, as you just
    > acknowledged, Jason was completely wrong in his position on that
    > issue.
    >
    >> To someone who doesn't like quacking ducks, earplugs will be a good
    >> investment.

    >
    > Again, irrelevant.

    If all of this is irrelevant, why to you burden yourself with it? That is
    surely the sign of fervour without conviction!

    >
    >> But I contend, your honor, that if an FFT function is carefully
    >> wrapped in a warming blanket of object oriented concepts, I will
    >> be using object oriented mechanisms whilst invoking said
    >> functionality.

    >
    > Intentionally, or incidentally?

    Intentionally, of course. How else would I invoke that functionality when
    it's wrapped in OO constructs?

    > That is the core of that part of the
    > issue.

    That is what you wish to make the core of that part of the issue. That's
    not to say it IS the core part.

    > If you are using that incidentally, because it is the only way
    > you have of getting to the real functionality, then you are not
    > "benefiting" from that varnish at all while you ARE benefiting from
    > the core non OO code. OTOH, if you are deliberately using those
    > mechanisms as part of an intentionally OO body of code, that use is
    > irrelevant to the already established OO nature of your code.

    If the "varnish" is what's required for me to reach the core because of
    how my tool operates, I will benefit from it. Otherwise I wouldn't be able
    to use it at all, right?

    >
    >> The fallacy of your argument lies in the strategical inability to
    >> recognize that OO might have other aspects to it than what the
    >> ulterior design motives bring to the table.

    >
    > Freudian slip? Just what ARE your ulterior motives?

    Thanks, I'll put on my Freudian slippers now. They're oh, so cosy! My
    ulterior motives are so ulterior not even I can tell what they are.

    [...]
    >> Hence the established distinction between Object Oriented Design
    >> and Object Oriented Programming.

    >
    > Again, you are claiming a relationship
    > that does not exist.

    What relationship are you referring to? Is there no relationship between
    OOD and OOP?
    Your honor, I rest my case!

    > Even if the word salad

    Is this tendency of yours to use insults in every phrase a sign of lack of
    sleep or a medical condition?
    Either way, if you would like a rational discussion, write rationally, not
    emotionally.

    > in your previous sentence had some meaning, the one
    > above would not logically follow. To date, all you and Jason have
    > done is weaken the definitions of OOD and OOP to the brink of
    > nonexistence.

    No cat has two tails. One cat has one more tail than no cat. Hence, one
    cat has three tails!
    If Jason and I have obfuscated the definition of OO concepts, it's then
    something you should thank us for, given your apparent dislike for all
    things OO.

    [...]
    > Interesting interpretation. But irrelevant to the point. The primary
    > value of the call to the FFT function lies in the original code, not
    > in the OO varnish. The argument that Jason and you have tried to
    > support would claim otherwise, irrespective of HOW sloppily the OO
    > varnish was slapped on.

    Me thinks we've read this before. I want a new drug! (Huey Lewis & the
    News - Sports).
    Let me rephrase myself: The value of the call is not something which I
    wish to get into. I don't know enough about FFT to have a meaningful
    discussion about that. But OO constructs don't go away because they're
    insignificant.

    [...]
    > Yes, misguided. By reducing the definition of OOP to "programming
    > which includes or uses anything which can be described - no matter
    > how tenuously - as an OO related construct or concept" he comes very
    > close to defining it out of existence (as demonstrated above). He
    > certainly renders all his claims about "benefits" of OOD/OOP void,
    > since they are conspicuously absent from a lot of what he has expanded
    > the definition to call OOP.

    In your opinion.

    >
    >> Hmmm, ain't that special! Bill, this is not a court of law, and
    >> there is no jury of your peers present.

    >
    > No, this is a public forum, and there is an audience which includes
    > innocent bystanders who may be misled by Jason's nonsense. Injecting
    > a bit of rigor into the discussion improves the chance that they will
    > examine the claims rather than swallow them uncritically.
    >
    >> Just because you're right

    >
    > Thank you for acknowledging that.

    In your opinion.

    >
    >> doesn't mean everybody who disagrees with you is wrong.


    > I don't claim that every such person is.

    But everyone who agues with you is?

    > However, I most certainly do
    > contend that I have shown that Jason's misguided claims are wrong.
    > Just because YOU agree - in a general sort of way - with the broad
    > outlines of his position doesn't make any part of his specific
    > arguments right.

    You're saying he is all wrong in every detail, and if I agree with him I'm
    all wrong too?
    I'd say Jasons claims are every bit as valid as yours. You just choose to
    emphasize different aspects.

    [...]

    >> However, I pointed out the fallacy of your statement that windows
    >> controls are not implemented using OO techniques.

    >
    > The underlying code was. Long ago. Your claim has no merit.

    The underlying code was WHAT? Brevity isn't always beneficial. Was the
    underlying code implemented using OO techniques long ago, or was the
    underlying code not implemented using OO techniques long ago?

    If the first is true, then why are you arguing?

    If the second is true, long ago is not now, and even so, we benefit from
    the OO traits of the exposed interfaces. So why are you arguing?


    >> Something which you conveniently chose to snip, thus getting egg
    >> on your high browed self.

    >
    > No, something I have already answered repeatedly, and declined to
    > repeat.

    Something which you have requested definitions of repeatedly, but never
    really answered. According to my defintion of anwser.

    [...]
    > While both modalities share many of the precepts of MP - and call for
    > certain formal practices - there are specific differences in design
    > and implementation. Such as the relationships between data structures
    > and bodies of code. MP, with its conceptual and practical separation
    > of data and code, is closer to the way people think (and the way
    > computers operate) than the merging of code and data inherent in OO.
    >

    Claiming that OO merges code and data is completely false, but something
    which is unfortunately often stated, and often attempted, with disastrous
    effects.

    OO brings data definitions, and the code that manipulates and uses
    instances of that data definition close together.

    I maintain it's fair to say that OOP can be an effective tool for
    implementing MP, and that MP is a useful mindset when designing OO
    systems. They have very few - if any - conflicting goals.

    >> Without using the words "fallacy", "dichotomy", "fad" or other
    >> derogatory samples of your vast vocabulary. Remember, he is not
    >> always right who cries the loudest or longest.

    >
    > However, he who most often substitutes personal insults and cynical
    > games for substance rarely - if ever - has the more valid position.

    And we all know you don't substitute them. You let them complement each
    other, to the effect of silencing opposition out of sheer fatigue and
    repulse.


    --
    Rune Bivrin
    - OOP since 1989
    - SQL Server since 1990
    - VB since 1991


  15. #225
    Rune Bivrin Guest

    Re: Speaking of strings...

    "W.E. (Bill) Goodrich, PhD" <bgoodric@netzero.net> wrote in
    news:3DB453AF.DF3FB592@netzero.net:

    >> I have used languages which implemented loops with code blocks, where
    >> these were objects in themselves.

    >
    > In your rather religious view.

    Bill, I have done this. It's how I learnt OOP in the first place.
    The language in question was Object/1, from a company named MDBS. I used
    this extensively for about a year in 1990-1991. It was a merger of C
    (++) syntax with a Smalltalk class library.
    The definition of the loop construct was this (subject to memory
    failure):

    condition.Do(codeBlock)

    The condition could be any code that would evaluate to true/false.

    The code block could be regular code within curly braces, or a variable
    containg a code block object.

    Object/1 was a typeless language, where every method was overridable,
    and every method call was resolved by name at run time.
    Thus, you could get fascinating error messages like "nil does not
    understand SaveCustomer(self, 17, 'Frank')". This either meant you
    misspelled the method name in either the definition or the call, or that
    the number of parameters was incorrect.

    The product included source code for forms designers and other tools,
    and these were available for modification or inheritance as much as you
    liked. Interestingly, when you saved your code, you saved an image of
    both the application and the designers.

    It was a perfect environment for learning the pros and cons of
    inheritance. There was no end to the amount of foot-shooting I suffered
    initially.

    It has also taught me to be careful with virtual methods and non-private
    members of a class.

    --
    Rune Bivrin
    - OOP since 1989
    - SQL Server since 1990
    - VB since 1991


Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  
HTML5 Development Center
 
 
FAQ
Latest Articles
Java
.NET
XML
Database
Enterprise
Questions? Contact us.
C++
Web Development
Wireless
Latest Tips
Open Source


   Development Centers

   -- Android Development Center
   -- Cloud Development Project Center
   -- HTML5 Development Center
   -- Windows Mobile Development Center