[Zope] Zope and Java

[sean.upton@uniontrib.com]

I think this sums it up pretty well; something else I might add: in addition
to tools like pychecker, for a dynamically-typed language like Python with
strong support for different unit-test frameworks and type checking
mechanisms in the standard library, I'm not sure that you need to rely on
the crutch of static typing, compiler warnings, etc, like you would in
C/C++/Java - these would never buy you what automated unit-testing will
(provided that you do it), and create a large amount of overhead that, while
good at catching a small percentage of certain errors before runtime, make
you jump through hoops to get there.

Besides that, Java code is ugly (like all Cish languages and Perl).  The
thing I don't understand about people who might prefer Java to Python is why
they are willing to let the complexity of the language obscure the problem
being solved, especially when you have to read someone else's code.  Python
lets your code get straight to the point and just solve a real problem,
IMHO.

Sean

-----Original Message-----
From: dman [mailto:dman@dman.ddts.net]
Sent: Friday, May 24, 2002 8:04 AM
To: Zope@Zope. Org
Subject: Re: [Zope] Zope and Java


On Fri, May 24, 2002 at 10:32:55AM +0200, Oliver Marx wrote:
| Well, we are choosing framework for our future web-applications.
| So far it has boiled down to:
| 
| 	- Zope
| 	- Zope-like Java framework
| 
| We prefer strongly typed languages, so Python would normally not be our
| language of choice.

You've fallen into a common misconception wrt type systems.  The
static/dynamic and the strong/weak axes are independent.  Here's a
short list of some lanaguages :
    C, C++      static,  semi-strong
    Java        static,  strong
    Perl        dynamic, weak
    Tcl         dynamic, weak
    Sh          dynamic, weak
    Python      dynamic, strong

In python you can not perform string operations on non-string objects,
you can't perform list operations on non-list object, you can't
perform integer operations on non-integer objects and you can't
perform an operation on a class instance that it doesn't support.
Python checks types very strongly and doesn't have a tendency to
automagically convert objects into different types.  It is, however,
dynamically typed because it does the type checking at runtime rather
than compile-time.  This is helpful because it reduces the amount of
up-front effort a developer must exert while coding and allows for
greater flexibility in the future when types of objects may change in
compatible ways.  In addition, there is a tool called "pychecker" that
performs many of the same sanity checks a C/C++/Java compiler
performs.

There are longer explanations available on the web somewhere.

| And in our opinion Perl is a write-only language :)

:-).

| So
| it would have been cool if we could have used Java with for our Zope
| objects. Are there any Zope like frameworks for Java?

J2EE.

It is many orders of magnitude more complex than zope, and requires
you to write lots of pointless boiler plate code and it is much harder
to get a j2ee server up and running, and is harder to debug the many
obscure problems you'll run into.  However, having beat my head into a
wall over j2ee in school, when I started reading the zope book
everything "clicked" and I wholly understood what was going on.

HTH,
-D

-- 

Pleasant words are a honeycomb,
sweet to the soul and healing to the bones.
        Proverbs 16:24
 
GnuPG key : http://dman.ddts.net/~dman/public_key.gpg