Re: Writer's Uninformed Statements

[Ralph D. Cole]

Please take a look at Elden Nelson's "Reality Check" column in VBPJ's August
issue.

"Are You a Techno-Retro-Grouch?":
<http://dweb6.devx.com/premier/mgznar...108/rc0108.asp>

<g>
-ralph

[Ralph]

"Ralph D. Cole" <nt_consulting32@SPAMhotmail.com> wrote:
>
> ...
>"Are You a Techno-Retro-Grouch?":
><http://dweb6.devx.com/premier/mgznar...108/rc0108.asp>
>
><g>
>-ralph

Oops! That URL will not work. Duh!
So much for my "attention to detail" skills.
Oh well I tried.

[Joe \Nuke Me Xemu\ Foster]

"Ian R" <ianr@na.net> wrote in message <news:3b94ea59@news.devx.com>...

> The framework exposes a lot of things for those that need it.

Things like deterministic object finalization, right?

> > you become more productive? And yet, as we all know, despite the hype
> > of the last five years since OOP was rediscovered, reuse is an elusive
> > goal most people have yet to attain. I would argue that a
>
> That has nothing to do with OOP. It like anything, including procedural
> code, can be abused. For those who do understand it, it can make development
> easier, faster and more scaleable.

Yup, you can leak resources much more quickly in VB.NET. In VB Classic,
you had to go through the hassle of first creating a circular reference.

> You're using a form of OOP whether you like it or not. Which just shows that
> either you're extremely thick or extremely stubborn.

Ahh, but he's not full of Pure OOP and therefore smells a little better.

> In your mind perhaps. But then again I get the impression you find a form
> with one button fairly complex.

When you have nothing intelligent to say...

> > - is still proprietary
>
> Earth to Mike. So is VB6 et al.

Why tf do you think he said "still proprietary", dumbass?

[inane dribble snipped]

--
Joe Foster <mailto:jlfoster%40znet.com> L. Ron Dullard <http://www.xenu.net/>
WARNING: I cannot be held responsible for the above They're coming to
because my cats have apparently learned to type. take me away, ha ha!

[Ian R]

"Joe "Nuke Me Xemu" Foster" <joe@bftsi0.UUCP> wrote in message
news:3b956a9b@news.devx.com...
>
> Things like deterministic object finalization, right?
>

In most cases for the average developer this is not an issue.

> >
> > That has nothing to do with OOP. It like anything, including procedural
> > code, can be abused. For those who do understand it, it can make
development
> > easier, faster and more scaleable.
>
> Yup, you can leak resources much more quickly in VB.NET. In VB Classic,
> you had to go through the hassle of first creating a circular reference.
>

What does OOP have to do with leaking resources ? And on the subject of
resources, it's pretty near impossible to leak resources in .NET, the GC
will clean up after you. The issue *can* not *is* that you may not *release*
resources *quickly* enough. That's why there's a Dispose method for those
objects that require it. And circular references don't exist anymore in
..NET.

>
> Ahh, but he's not full of Pure OOP and therefore smells a little better.
>

No he and you smell of something worse. Stupidity comes to mind.. among
other things. OOP has nothing to do with it.

> > In your mind perhaps. But then again I get the impression you find a
form
> > with one button fairly complex.
>
> When you have nothing intelligent to say...
>

I'll leave that up to you....

> > > - is still proprietary
> >
> > Earth to Mike. So is VB6 et al.
>
> Why tf do you think he said "still proprietary", dumbass?
>

Read the post again sh*t for brains.

> [inane dribble snipped]
>

Time for your medication again Joe.

[Phil Weber]

> But in VB.NET the underbelly of the language is now exposed.
> No longer is it sufficient for a programmer just to use it. They
> have to understand how the intestines fit in the underbelly.

Mike: You are mistaken. VB.NET is no more difficult to learn than previous
versions of VB were. (In fact, with the help of IntelliSense and the copious
context-sensitive help provided by the .NET IDE, I'd argure that VB.NET is
easier to learn than the VB2 with which I started.) In prior versions of VB,
you had to learn VB's statements and functions, and the properties, methods
and events of its various controls. You must do the same with VB.NET. It's
different, but not any more difficult. And because the .NET Framework is
more internally consistent than the VB Classic runtime, once you've become
familiar with one aspect of it, you can pick up others quickly.

> Let's look at its selling points:
>
> - more complex
> - needs a huge framework
> - is still proprietary
> - only available along with C#, C++ etc etc
> - not backward compatible
> - needs more memory
> - won't run on Windows 95

OK, I'll grant you "not backward compatible," and I'm not sure it's true
that VB.NET will only be available with the rest of Visual Studio.NET
(cite?) With those two exceptions, the same list could have been applied to
VB for Windows in comparison with the DOS BASICs that preceded it:

- more complex
- needs a huge [runtime]
- is still proprietary
- needs more memory
- won't run on [DOS]

Yet, in spite of these "drawbacks," VB for Windows has been an overwhelming
success. There's no reason to suppose that VB.NET will not someday be
similarly successful. I don't think it will happen with version 1.0, but as
Microsoft makes future releases of VB.NET more accessible, perhaps
implementing such "lost" features as edit-and-continue and a design-time
method to simulate control arrays, and as the .NET Framework becomes
ubiquitous, developers may flock to VB.NET just as they have to VB/Windows.
---
Phil Weber

[Gary Nelson]

Phil,

> - more complex
> - needs a huge [runtime]
> - is still proprietary
> - needs more memory
> - won't run on [DOS]
>
> Yet, in spite of these "drawbacks," VB for Windows has been an
overwhelming
> success.

True, but look what we got in exchange: The ability to make programs in
Windows easily. From a user's viewpoint look at the difference between a DOS
program (made in PDS) and a Windows program (made in VB). The difference is
so huge that it almost jumps out and bites you. It made it worth our while
to do all of the extra work.

> There's no reason to suppose that VB.NET will not someday be
> similarly successful.

If VB.NET can change the user's experience in the use of a program the same
way VB changed the user's experience in the transition from DOS to Windows,
I'll agree with you.

The problem I see here is a similar amount of work to make the transition,
but not an equivalent result.

> I don't think it will happen with version 1.0

Nor do I.

> but as
> Microsoft makes future releases of VB.NET more accessible, perhaps
> implementing such "lost" features as edit-and-continue and a design-time
> method to simulate control arrays, and as the .NET Framework becomes
> ubiquitous, developers may flock to VB.NET just as they have to
VB/Windows.

Time will tell.

Gary

[Patrick Steele]

In article <3b956a9b@news.devx.com> (from "Joe \"Nuke Me Xemu\" Foster"
<joe@bftsi0.UUCP> <"Joe \"Nuke Me Xemu\" Foster" <joe@bftsi0.UUCP>>),
> Yup, you can leak resources much more quickly in VB.NET.

Do you have an example of this we could download? Or a URL where we
could see the results of the leaking? Since DF is gone, I'm trying to
keep up-to-date on the workings of the GC and I'd like to know how these
leaks can occur quicker.

--
Patrick Steele

[Joe \Nuke Me Xemu\ Foster]

"Patrick Steele" <psteele@ipdsolution.com_> wrote in message <news:MPG.15ffeddb55b520bf989845@news.devx.com>...

> In article <3b956a9b@news.devx.com> (from "Joe \"Nuke Me Xemu\" Foster"
> <joe@bftsi0.UUCP> <"Joe \"Nuke Me Xemu\" Foster" <joe@bftsi0.UUCP>>),
> > Yup, you can leak resources much more quickly in VB.NET.
>
> Do you have an example of this we could download? Or a URL where we
> could see the results of the leaking? Since DF is gone, I'm trying to
> keep up-to-date on the workings of the GC and I'd like to know how these
> leaks can occur quicker.

Surely you haven't already leaked your memory of that "Little GC test"
thread on microsoft.public.dotnet.languages.vb?

--
Joe Foster <mailto:jlfoster%40znet.com> On the cans? <http://www.xenu.net/>
WARNING: I cannot be held responsible for the above They're coming to
because my cats have apparently learned to type. take me away, ha ha!

[Patrick Steele]

In article <3b97a7a9@news.devx.com> (from "Joe \"Nuke Me Xemu\" Foster"
<joe@bftsi0.UUCP> <"Joe \"Nuke Me Xemu\" Foster" <joe@bftsi0.UUCP>>),
> "Patrick Steele" <psteele@ipdsolution.com_> wrote in message <news:MPG.15ffeddb55b520bf989845@news.devx.com>...
>
> > In article <3b956a9b@news.devx.com> (from "Joe \"Nuke Me Xemu\" Foster"
> > <joe@bftsi0.UUCP> <"Joe \"Nuke Me Xemu\" Foster" <joe@bftsi0.UUCP>>),
> > > Yup, you can leak resources much more quickly in VB.NET.
> >
> > Do you have an example of this we could download? Or a URL where we
> > could see the results of the leaking? Since DF is gone, I'm trying to
> > keep up-to-date on the workings of the GC and I'd like to know how these
> > leaks can occur quicker.
>
> Surely you haven't already leaked your memory of that "Little GC test"
> thread on microsoft.public.dotnet.languages.vb?

I went back and re-read that whole thread. The timeframe (late March)
makes me think it was Beta 1. Are your tests of the resources leaking
"much more quickly" done on Beta 1 or Beta 2?

Also, it seems that the Cursor class Keith Franklin wrote wasn't doing
exactly what he intended it to do (see followups from Jeff Peil). The
issue of using Dispose came up again also. Were your leak tests
properly disposing of objects? If we could have the URL to download the
code, that would help answer these questions.

--
Patrick Steele

[Phil Weber]

> Were your leak tests properly disposing of objects?

Patrick: I think you know as well as I do that Joe has not personally
conducted any such tests. But, if I may presume to speak on his behalf, the
issue you raise above is precisely Joe's point: in VB Classic, the user of
an object doesn't HAVE to worry about properly disposing of it; the object
cleans up after itself when VB tells it to.
---
Phil Weber

[Patrick Steele]

In article <3b97b03a@news.devx.com> (from Phil Weber <pweber@devx.com>),
> > Were your leak tests properly disposing of objects?
>
> Patrick: I think you know as well as I do that Joe has not personally
> conducted any such tests.

Then perhaps he should not make such statements?

> But, if I may presume to speak on his behalf, the
> issue you raise above is precisely Joe's point: in VB Classic, the user of
> an object doesn't HAVE to worry about properly disposing of it; the object
> cleans up after itself when VB tells it to.

Assuming you don't have any circular references. If you don't, then
yes, cleanup is automatic.

But, let's assume we have a VB Classic example with circular references
(so the object isn't cleaned up properly) and a .NET example where
Dispose is not called (so the object isn't cleaned up properly). Does
the .NET version leak memory "much more quickly"?

I don't want to debate "if" memory can be leaked, I was simply looking
for a code example of how memory is leaked "much more quickly".

--
Patrick Steele

[Joe \Nuke Me Xemu\ Foster]

"Phil Weber" <pweber@devx.com> wrote in message news:3b97b03a@news.devx.com...

> > Were your leak tests properly disposing of objects?
>
> Patrick: I think you know as well as I do that Joe has not personally
> conducted any such tests. But, if I may presume to speak on his behalf, the
> issue you raise above is precisely Joe's point: in VB Classic, the user of
> an object doesn't HAVE to worry about properly disposing of it; the object
> cleans up after itself when VB tells it to.

**** straight. Furthermore, I think that every one of you who demands
that I "personally conduct" any such tests should "personally conduct"
experiments with, say, high doses of "black tar" heroin. You dislike
heroin? Why? You cannot know unless you've personally taken the time
and effort to get to know it. Intimately. And have the scarred and
chronically infected "tracks" to show for it.

For us "trust fund baby" programmers, VB.NyET looks to have about the
same effect on productivity and project schedules as a smack habit but
nevertheless seems to inspire similar advocacy as from Trainspotting
junkies. Now kindly point that new new "silver bullet" elsewhere.

--
Joe Foster <mailto:jlfoster%40znet.com> Greed = God? <http://www.xenu.net/>
WARNING: I cannot be held responsible for the above They're coming to
because my cats have apparently learned to type. take me away, ha ha!

[Patrick Steele]

In article <3b97beff$1@news.devx.com> (from "Joe \"Nuke Me Xemu\"
Foster" <joe@bftsi0.UUCP> <"Joe \"Nuke Me Xemu\" Foster"
<joe@bftsi0.UUCP>>),
> You cannot know unless you've personally taken the time
> and effort to get to know it. Intimately.

Exactly. So when you made the statement "you can leak resources much
more quickly in VB.NET", I assumed you had done some testing and maybe
would provide us with some sample code so we could review what caused
the leak.

--
Patrick Steele

[Joe \Nuke Me Xemu\ Foster]

"Patrick Steele" <psteele@ipdsolution.com_> wrote in message <news:MPG.16018134a135559a989853@news.devx.com>...

> In article <3b97b03a@news.devx.com> (from Phil Weber <pweber@devx.com>),
> > > Were your leak tests properly disposing of objects?
> >
> > Patrick: I think you know as well as I do that Joe has not personally
> > conducted any such tests.
>
> Then perhaps he should not make such statements?

Have you ever made statements about, say, heroin or heroin addicts?

> > But, if I may presume to speak on his behalf, the
> > issue you raise above is precisely Joe's point: in VB Classic, the user of
> > an object doesn't HAVE to worry about properly disposing of it; the object
> > cleans up after itself when VB tells it to.
>
> Assuming you don't have any circular references. If you don't, then
> yes, cleanup is automatic.
>
> But, let's assume we have a VB Classic example with circular references
> (so the object isn't cleaned up properly) and a .NET example where
> Dispose is not called (so the object isn't cleaned up properly). Does
> the .NET version leak memory "much more quickly"?

Let us assume that VB Classic programmers are unable to code their way
out of a wet tissue paper bag while we're at it, mmmkay? Do you claim
that Five Forking Years was not enough time for programmers to learn how
to cope with and/or avoid circular references? Will five years be enough
time for them to learn how to handle resource management in B# code?

> I don't want to debate "if" memory can be leaked, I was simply looking
> for a code example of how memory is leaked "much more quickly".

That's easy enough, since VB.NyET avoids the "obscenely higher" overhead
of refcounting altogether, right? Or was Brian Harry lying out his ***
after all? http://mvps.org/vbnet/dev/vb7/vbdotn...management.htm

--
Joe Foster <mailto:jlfoster%40znet.com> Sacrament R2-45 <http://www.xenu.net/>
WARNING: I cannot be held responsible for the above They're coming to
because my cats have apparently learned to type. take me away, ha ha!

[Rob Teixeira]

"Joe \"Nuke Me Xemu\" Foster" <joe@bftsi0.UUCP> wrote:
>> I don't want to debate "if" memory can be leaked, I was simply looking
>> for a code example of how memory is leaked "much more quickly".
>
>That's easy enough, since VB.NyET avoids the "obscenely higher" overhead
>of refcounting altogether, right? Or was Brian Harry lying out his ***
>after all? http://mvps.org/vbnet/dev/vb7/vbdotn...management.htm
>

What does ref counting overhead have to do with memory leaking or sample
code? Or do you not have a sample demonstrating this behavior? I think Pat
is right here - if you want to have an objective discussion about this issue,
we're going to need some code.

-Rob