Request for advice - python, wxpython, Jython, java

Alex Martelli aleaxit at
Sat Sep 8 23:17:14 CEST 2001

Kenneth Tsang wrote (I've cut two of the subgroups: I think 
no msg should be posted to as many as *five* groups in all!):

> Hi, I am currently working on an applications that has the following
> criteria, please advice what's the most effective use of the above
> technology, Python is on the list because of the amazing capability, and
> 'battery included' features (i think this is the best description)
> a)multiple language support
> b)cross-platform support
> c)ease of deployment - as it has to be used in different countries
> d)short development time

Looks like a good choice to me.

> Could someone advice the best architecture of using Python, 'cos it seems
> to be one of the best choice here.
> a)wxPython has used for building some windows GUI, which is really
> impressive as lots can be done within a day, windows GUI is chosen because
> the application may involve lots of analysis (involve drag and drop..)

It's hard to fault your choice.  Tkinter is more popular, PyQt has some 
enthusiastic fans, but wxWindows/wxPython is truly excellent.

> b)should part of the code be in Java, for future expansion (esp. on
> integration with other systems), and for scalability!?

If I were you, I would go either all-JVM, or no-JVM -- mixing JVM bytecode 
and native code is trouble you can do without.  If you choose JVM, forget 
wxWindows -- you'll have to use Swing (or AWT, but Swing's nicer).  
Integration with other systems cuts both ways -- it depends on what you 
have to integrate with (as long as you mean, on the same box; across the 
net, solutions such as SOAP, XML-RPC, and others, make it rather 
indifferent whether each system is pure-Java or no-Java).  Do notice that 
one of your criteria is "cross platform, ease of deployment".  With JVM, 
you get that _except_ on Windows XP -- XP will not have a JVM, so your 
deployees would have to download and install it separately -- very easy if 
they're tech-savvy, not so easy otherwise.  With no-JVM, i.e. CPython, you 
need to prepare stand-alone executables -- so far that's easy for Windows 
and Linux (with py2exe or Installer), doable under most unix-like 
architectures (with freeze), but I'm not sure where you'd even start if you 
needed that for, e.g., OS/2.  So it depends on HOW MUCH of cross-platform 
ease you need -- *widespread* platforms, or also very rare ones?

> c)if b) is chosen, how about the choice between Jython and CPython? I have
> to go with Jython!? But will this imply that I can't use wxPython!?

Right.  There's a Tkinter port for Jython, I hear, but clearly not 100% 
pure Java, so there would start your trouble.

Of course, you could and should separate the part of your code that is 
strictly about GUI's (maybe 10% to 20%, depending on what your programs do) 
and the "engine" that is the rest and should be coded independently from 
the GUI -- so switching GUI's should be anything but traumatic.

Depending on your schedules (and your desire to get involved and help the 
project move faster), you might like to look at -- code to 
that, and your code should move between (e.g.) Jython+SWING and 
CPython+wxPython (and others) with no effort.  Of course, anygui will never 
support the full richness of your chosen toolkit's possibilities, but if 
you can do 80% of your GUI with anygui and only access the backend toolkit 
for the remaning 20%, the effort of supporting several GUI toolkit backends 
becomes really minimal.

> d)If I chose a thin client (browser based) approach, what is the
> configuration required? Pls advice, as I haven't gone into this
> area...(And will it has deployment issue!? need lots of IT support)

Needs _least_ IT support -- each client only needs any good browser -- but 
may need lots of good bandwidth, depending on the application.  The server 
side could use Apache and, e.g., mod_python -- or Zope.

> The concern is that though Python is powerful? should we code everything
> in Python? (even you have to choose between CPython and Jython)

Python is the most productive way to code, in my opinion, particularly with 
the "Extreme Programming" methodology.  However, when you come to 
tuning the system for performance you may find that some bottleneck needs 
recoding in C to achieve maximum speed (similarly you could recode in Java 
if starting with Jython, but the performance gain is nowhere as large) -- 
unless your performance bottlenecks all come in areas for which Python can 
already offer good speedy extensions, such as numeric computation, image 
processing, unlimited-precision arithmetic, databases, networking, 3D 
modeling, PDF formatting, and so on, but that covers only about 90-95% of 
applications -- yours might be somewhere in the other 5-10%!

Similarly you could add native-coded extensions to JVM code with the JNI, 
but if you lose the 100%-pure-Java quality I think you lose much of JVM's 
potential advantages.  I hear that coming JVM's are rivaling native-coded 
abilities in terms of speed -- but I've been hearing that for six years, 
and it's not really true as yet, alas.  Still, if you're willing to bet on 
this, then there's little to choose between a pure-JVM and non-JVM approach 
in this case -- CPython and Jython are basically the same apart from speed 
(CPython tends to be 6-8 months ahead in terms of development), Jython lets 
you use the huge amount of Java libraries and CPython has lots of its own 
extensions and ease to wrap any existing C library, etc, etc.


More information about the Python-list mailing list