> Agreed, that's very much an issue. And I don't consider having to
> re-learn how to access the serial port everytime Gates & Co rewrites
> the OS a productive use of my time. Of course, with the gradual fading
> of the serial port it's about time to learn how to interface to USB. 

For the moment the co-existence of USB-lacking PCs with serial ports,
and serial-port-lacking PCs with USB I think the best way is to write
for a (possibly emulated) serial port.

> Just how weak is it in run-time speed? And why is it weak for
> large apps? Is that due to runtime speed or some other factor?

Runtime speed can be an issue, but it has not much relation with
application size.

Python is an interpreted language, with all the associated strengths and
weaknesses. Let's say you have an object X, and you use a property Name,
like
   print( X.Name )
In a compiled language the compiler would assure that object X is of a
type that indeed has a Name property, and that it is of an appropriate
type to pass to print(). When any of these conditions are not satisfied
you will be flogged by the compiler, that is: before you can run the
program. With an interpreted program like Python the compiler will
simply tokenise your program, and the mentioned checks take place when
the statement is executed. Note: only when it is executed! So your
program can have errors of a type that are simply not possible in a
compiled program. But on the other hand you have language features that
can not exist in a compiled program, like the ability to decide at
run-time which properties a certain object will have.

This run-time freedom has advantages and disadvantages. Roughly the
advantages are dominant when you write small, frequently changing,
use-once programs, the disadvantages are dominant when you write very
large, relatively static, industrial-strength programs. The interesting
point is of course where the small/large boundary is. I think this will
vary a lot depending on personal coding style and experience.

But all that does not matter much when the difference is using a library
or writing it all yourself. I just changed my website-generating code a
bit, so thumbnails are included for certain products. I had to add lots
of bookkeeping code, but the prodedure for the actual generation of the
thumbnail from the original image is just (note that this includes error
handling!):

def CopyImage( Source, Dest, Height ):
   import os
   try:
      Im = Image.open( Source )
      Im.thumbnail( ( 1000, Height ), Image.ANTIALIAS )
      Im.save( Dest, "JPEG")
   except:
      File_Error( Source )   

Note that is not an argument for the Python language, it is an argument
for using an existing library (and Python just happens to have a *lot*
of usefull libraries).

Wouter van Ooijen

-- -------------------------------------------
Van Ooijen Technische Informatica: www.voti.nl
consultancy, development, PICmicro products
docent Hogeschool van Utrecht: www.voti.nl/hvu
 

-- 
http://www.piclist.com PIC/SX FAQ & list archive
View/change your membership options at
http://mailman.mit.edu/mailman/listinfo/piclist