FM> I think you need to take some time out to understand the object
 FM> paradigm - encapsulation, inheritance and polymorphism, all of
 FM> which should be supported by the compiler. I believe C++ also
 FM> does this (but I've never used it).

  I only learn what I *have* to learn, when I have to learn it. In
fact, Delphi is very much like VB in the way it uses objects. I just
wish they'd cut down on the buzz words and nerd-jargon.

 BL> Compiling is too slow,

 FM> What? What could be quicker than pressing F9 and suddenly your
 FM> application is running? The compile/link happens in a blink.
 FM> And I think your system is faster than mine, n'est ce pas,
 FM> clock-speed wise?

  I press the button, and it takes 2-3 seconds (about the same as
C++). The hard-disc light does not come on, which means it's all in
cache. Of course, once it's in cache and I do it the second time, it
does it in a blink (like BC++ which is also slow), but it's this
first time that's the nuisance. Curiously, Delphi uses more RAM than 
BC++4. I had to give it another meg off RAMdrive. It was right on
the RAM limit of the virtual disc.

  The problem is that is recompiles the *whole* 220K form every rime I
add a space or remove it. Try it for yourself. Compile, add a space in
the code and then remove it, and Run again. I takes 2-3 seconds.

BTW, how the hell do you write code in another thingie that leaves the 
main form and main unit alone? I tried adding a unit, but the first
one doesn't want to know about what I write in there, even though 
the unit has been declared in the program DPR (or whatver they call the 
MAK file).

 BL> and it annoys me when I have to type things in upper and lower case, 
 BL> when the editor should recognise the keywords and do it for me.

 FM> Eh? You can type in whatever case you like!

  The VB editor has a very nice trick. You type in lower case (or
whatever you like), and at the end of the line, the editor corrects
it to what VB wants. This means that you can tell if you've forgotten
to declare a variable (it doesn't change) or if you have used a
protected word (it changes when it shouldn't), or if you misspelled a
function name (it doesn't change when it should). If you change the
case of a variable, it changes right through the code. You don't have
to wait to compile it to find syntax errors; you see it happen as you
type... in the editor itself. This little feature that would take no
more than an hour to implement, saves an enormous amount of time in
writng... plus the fact the VB really is instantaneous because it does 
not compile until you make the EXE file spearately.

 BL> But it's early days yet... maybe I'll fall in love.

 FM> Hopefully, but maybe take some time out to understand what OOP
 FM> really means. I think you'll need to be working in Borland
 FM> Pascal (see how careful I was to say that, Paul), Delphi or C++
 FM> to get the benefits though.

  OOP means trouble. I learned to program in VB, which meant I was
using OOP and event programming from the start (without realising it).
What gives me the shits, is that Borland spend all their time
explaining the visual interface that is so instinctive it explains
itself, but no time on how to order or declare procedures in this new
version of Pascal that uses Units and has the program part somewhere
else entirely! In VB or C, you put the bloody SUBS anywhere you like
and it sorts it out for you. Pascal is fussy, it seems, Delphi is
different, and I've lost the plot.

 FM> I think Paul Markham makes the same point in his message to
 FM> Paul E, directly after this one of yours to which I'm replying.
 FM> Presumably you saw it.

  The way I learn is to distil ideas first. I get around to the actual
thing later. I don't have any troubles using objects, so why bother?

  BTW, I like Pascal's way of handling pointers with the p^. In usual
Borland vein, they call this dereferencing (something like tossing a
Czech out a window, I suppose), but it really means going from the
address to the thing. What a good idea! And I can't make Delphi lock
the computer no matter what I do. I get lots of GPFs but it always
comes back and laughs at me.

  I reckon it's time they rewrote Pascal properly, and called it D.
It's silly mixing Pascal strings and null strings, and it's bloody
stupid too, when the Windows API uses pointers and Delphi objects use
Pascal strings! ROFL! I wonder who thought *that* one up? I guess they
were hoping to keep the dickhead market, but you can't dodge pointers
anyway, so you're stuffed.

  Delphi is still a hotch potch, and I spend half my time writing
conversions. It's a shame, when their pointers work so well, and it
would have been easy enough to write their objects to take pointers.

Regards, Bob
     
___ Blue Wave/QWK v2.12
@EOT:

---