-=> David Nugent wrote to John Gardeniers about Portability v efficiency <=-

    Hi David,
    
 >     I think the devotion to an arbitrary standard, which is currently under
 > review anyway, is taken much too far by some programmers. The end result is
 > invariably fatware, which runs very slowly. Windows is a very good example.

 DN> A very good example of what?  :-)  Windows is in no manner or form

   Ok, Windows was probably a lousy choice in this particular instance, it's 
just always the first thing that comes to my mind when I think of fatware, of
which it really is a superb example.

 DN> I also object to your use of the word "arbitrary". And of
course it is
 DN> under review - all standards are, as a matter of course. They simply

    Object all you like, the standard is nevertheless arbitrary, if it wasn't
there would never be a need to review it. 

 >     Another thing I find somewhat interesting is the way some programmers
 > will argue in favour of standards (whatever they may currently be) and then
 > go ahead and write programs which can only be compiled by a specific make
 > and model of compiler.

 DN> I've never noticed a correlation between the two, but I have seen what

    Please note my use of the word "some", I wasn't even hinting at a 
correlation, simply pointing out an inconsistancy of a type I can't understand.
    
 DN> The standard was not invented in a vaccum - it combines both legacy
 DN> aspects of the C language and good software engineering practices and
 DN> design. Besides which, a compliant implementation will offer you a

    "Software engineering" is also quite variable. What's taught one year
can easily be the thing being condemned the next, surely you've noticed?

    My philosophy of programming (any language): As far as practical write
portable code, even if that can only be done in the form of algorythms. In
this way a library of useful code, or coding methods, is built up which can
easily be moved from platform to platform. Under no circumstances should this
result in unnecesarily slow or inefficient code. The definition of efficient 
must be adjusted to suit the particular context. e.g. Slow code doesn't 
matter if the program at that point is only waiting for keyboard input. In 
all cases where speed, or any other machine specific factor, is important 
portability must be placed a distant second. 

    That way of thinking will produce much faster and more compact code than 
would result from placing portability or any standard first, as appears to
be done far too often these days. That way of thinking also used to be the 
*normal* way for a programmer to think. The validity of the method hasn't 
changed. (Maybe some of you blokes are a lot younger and less experienced
than I thought.)

 >  BTW, using Basic it's always been very easy to port most programs from
 > one machine to another, yet it's not hogtied by any standards. Haven't we
 > all done such porting when we first learned Basic?

 DN> "Easy"? Which operating systems and which BASICs are we
talking about
 DN> here? Perhaps you can explain why isn't BASIC being widely used for
 DN> development of software? 

    My experience with Basic is with most versions released on personal 
computers since their invention, as well as earlier versions. Over the 
years I ported Basic to and from many different machines but the target
machines were predominately CBM 8 bit models.

    I had never before come across a programmer who wouldn't simply have
accepted my statement as an axiom. Now, in one week, I've come across two.
I can only assume you are getting the language and the hardware mixed up.
The principle elements of Basic vary extremely little and the "extras" are
quite easily reworked (*that's* what porting is). True, it takes a bit more 
work to adapt a program written for a 64 character screen to a machine with 
a 40 or 80 character screen, but that's a hardware related problem, absolutely 
nothing to do with the Basic language. The hardware aspect will apply just as 
much to a program written in any other language, including strictly complying 
ANSI C. 

    As for why Basic isn't used more for software developement, I'm sure you 
don't really need to ask. Basic, like C, is an absolutely brilliant programming 
language when used within it's intended limits. I think that's probably true
of any other language. Basic was designed to teach principles, not write
applications. The fact that some applications *have* been written with it is
a tribute to the programmers responsible.

    As of this packet I'll be detagging this area (nothing to do with this
thread), so any arguments, comments, insults, etc. addressed to me here won't 
be read by me, although others may find them amusing. 

        John

--- FMail 1.02