[EVALUATION] - E01: The Java Failure - May Python Helps?

[Ilias Lazaridis]

"
A cooperation between Sun Microsystems and IBM&Co. in conjunction with
liberal & high evolutive communities would result in an nearly
unbeatable programming platform.

My evaluation has shown: this is a non achievable goal, as stubborness
and egoism rules - instead of reason and cooperation.

Thus I leave all those ridiculous folks behind, which will continue to
do an excellent job in keeping the very promising JAVA platform far
below the technological level it could be
"

-

"
Of course It's a sad day.

Censorship (NetBeans, Eclipse) has forced me to move.

No platform is _really_ open, thus I cannot build on them:

http://lazaridis.com/core/project/open.html
"

-

"I'm sure there is one community out there which will realize immediatly
the benefits of an high-evolutive system. "

-

source: [messages within thread]

[JAVA] [EVALUATION] - The Java Failure (Sorry: The Java(tm) Failure)
http://groups-beta.google.com/group/comp.lang.java.softwaretools/msg/ae6315fda51d50a1

-
-
-

During the 6 months evaluation i've extracted several constructs.

"How it should be to become high evolutive"

-

I don't know python.

Basicly I would like to do everything in C++.

But development must go quicker.

-

I've seen that Nokia has just integrated Python it in a platform.

-

Possibly it's time to structure python projects in a way similar to
Sun's Java, NetBeans and especially IBM&Co's Eclipse (but of course more
efficient and evolutive):

http://lazaridis.com/case/ide/project/index.html

www.osgi.org and similar standards should (whenever possible) be used.

E.g. Nokia should be intrested in an python osgi implementation.

[Note: i've not verified technical and legal applicability]

-

osgi is just a detail.

The goal would be: to make a high competitive andhigh evolutive
programming platform / Rich Client Platform based on Python.

-

My question is essentially:

How many of those constructs are already supported by python (and the
surrounding open-source-projects):

http://lazaridis.com/case/stack/index.html

-

I'll be possibly for some time off-line, as the evaluation has brought
me to my financial limits, thus i'm loosing my phone-line in a few hours.

I'll try to communicate via internet-cafe, but cannot promise this.

-

Please notify the people within the relevant python communities about
this thread.

..

 

[Jeremy Bowers]

My question is essentially:

How many of those constructs are already supported by python (and the
surrounding open-source-projects):

http://lazaridis.com/case/stack/index.html

This post is hard to follow, but I'm going to assume this is the core
question, as it is labelled as such.

The first thing that leaps to mind is that you need to play with Python
for a bit to get a full analysis of it. Due to the nature of Python, some
of the things you have in that list don't really apply.

The most obvious example of this is "code generation": Assuming you mean
what I think you mean, the sort of thing you have in the C++ or Java world
where you click a couple of boxes, push "next" a few times, and have
several hundred kilobytes of impenetrable source code pop out as your
project's "framework", it doesn't generally apply. In Python, you can
actually write frameworks that can be made to do useful things in a small
handful of lines.

For a good example of that, I'd recommend the Twisted tutorial:
http://twistedmatrix.com/documents/current/howto/tutorial/index . In
Python, if a framework makes you write reams of boilerplate... it's
probably because someone just came from Java and isn't thinking in Python
yet. Code generation in Python is generally a non-starter. (Few rare
counterexamples, but it's nothing like the Necessary Crutch it is in the
C++ world.) Generally, every line in that Twisted tutorial, even in the
final program, is *doing something*, not satisfying the framework with
necessary boilerplate.

As for the rest of your requirements, you have specified your "technology
stack" in terms of *goals*, not capabilities, so for quite a lot of them,
there is no answer except, "Yes, Python can do that, and generally easier
than most anything else". For instance, "Use of metadata within the design
(on text level [code file])" can mean a thousand things. For what it's
worth, Python tends to make it so easy I do it all the time, but for any
given way you mean it, I can't promise there exists a pre-rolled framework
for you.

So I can only speak generally. Given your list, you may find that Python
is weak in the "graphical programming" department; drop-and-drop GUI
generation isn't as well-tuned as VB. (I, for one, consider that
development methodology toxic and actively dangerous, but I can understand
why you miss it.)

Skipping down to your evaluation sequence:

* Create a class: Well, I'll show you this one:

class Something: pass

There, a class.

* Simple GUI: You may wish to check out Boa Constructor, as the closest
thing to the GUI generator you probably want. There are at least 3 major
viable GUI toolkits for Python and several other minor (but still capable)
ones.

* Embedded DBs: I don't know, Google for your embedded DB name + Python.
Failing that, there are several ways to wrap your embedded DB such that a
Python program can use it.

* Web GUI: There are more Python web frameworks than you can shake a stick
at, and I don't mean "some guys hacked together templating system" either;
there are a lot of very mature systems out there, expressing a lot of
different philosophies. Given some of your other requirements, for a
web-based application I'd recommend examining Zope.

* Deployment: I don't generally have enough problems with this to be worth
thinking about. I don't know what the state of the remote debugging is on
Python; Google "remote debugging Python".

* For your "complex updates", I see two distinct things there; half of the
depend on the database, not Python. For the other half, it depends on if
you mean "while the program is still running". If so, they are
challenging. If not, they are trivial.

* I'd recommend adding "testability" to your stack, and refer you to the
"unittest" module; others can suggest their preferred testing modules, but
I tend to stick with that as the general framework is available in a lot
of languages that I use. If by evolutive development you are including the
ideas behind "agile software development" (hard to tell if you mean that,
or a community open to change*)

Based on what I see here, I have two basic comments. First, yes, Python is
probably as close as you are going to get in an existing system to what I
think you are looking for. It isn't perfect, but you will also be able to
reasonably extend it for your needs. Second, Python has a different
philosophy; you recognize the need for a different philosophy and I
extremely strongly suggest that you take the time with Python to sort out
what you truly need from what you think you need due to still thinking
with your old philosophy. (For example, given my aforementioned
reasons why code generation isn't an issue in Python, I strongly suggest
you embrace Python and give it a chance, rather than force 'code
generation' on top of it.)

You've got some exciting learning to do, and some interesting philosophy
shifts to absorb, but I think you'll find, as a lot of use have, that even
if it isn't perfect it's a helluva lot better than Java!

*: Community open to change: One caveat, from what I've seen when other
people talk about this. The Python community is open to change, but it is
still a meritocracy, and you will still need to convince others your
change is good. For example, getting something into the standard library
is not something that everybody does routinely. But as it is open source,
if you want to take responsibility for your changes, you can do as you
like. I *think*, based on your reading, that you are focussing on the
latter, in which case you are OK. But do not expect to be able to dump
things off onto "the Python community".

Also, not getting into the standard library isn't that big a deal anyhow;
a lot of very powerful and popular frameworks and modules don't go in,
often because they conflict with the needs of a Python release (slow rate
of change, mature interface, general utility, need to prevent a Python
download ballooning to 250 MB, etc.).

 

[Jeremy Bowers]

I realize your admirable intentions and the fact that you are simply
trying to help (the beauty of this community), but I beg you all
now...PLEASE...do not feed this troll. Any responses to his posts will
simply snowball into the biggest waste of time and energy this newsgroup
has ever seen. I'll let Google fill in the rest of the picture. You
can decide whether or not you want to respond to his posts.

Actually, based on the web pages I had already been thinking that from
this point on out I'd only cover highly specific questions about actual
code; you can smell that in the last paragraph, and the general theme that
what you want exists but you're going to have to put it together yourself.

Thanks for the warning, though.

 

[Markus Wankus]

OH GOD! I cannot believe Ilias has shown up here...

Google his name - he has been banned from Netbeans and Eclipse (and
Hibernate, and others...) for good reason. Can you imagine how much of
a Troll you need to be to *actually* get "banned" from the newsgroups of
open source projects such as those?

I realize your admirable intentions and the fact that you are simply
trying to help (the beauty of this community), but I beg you all
now...PLEASE...do not feed this troll. Any responses to his posts will
simply snowball into the biggest waste of time and energy this newsgroup
has ever seen. I'll let Google fill in the rest of the picture. You
can decide whether or not you want to respond to his posts.

Markus.

My question is essentially:

How many of those constructs are already supported by python (and the
surrounding open-source-projects):

http://lazaridis.com/case/stack/index.html

This post is hard to follow, but I'm going to assume this is the core
question, as it is labelled as such.

The first thing that leaps to mind is that you need to play with Python
for a bit to get a full analysis of it. Due to the nature of Python, some
of the things you have in that list don't really apply.

The most obvious example of this is "code generation": Assuming you mean
what I think you mean, the sort of thing you have in the C++ or Java world
where you click a couple of boxes, push "next" a few times, and have
several hundred kilobytes of impenetrable source code pop out as your
project's "framework", it doesn't generally apply. In Python, you can
actually write frameworks that can be made to do useful things in a small
handful of lines.

For a good example of that, I'd recommend the Twisted tutorial:
http://twistedmatrix.com/documents/current/howto/tutorial/index . In
Python, if a framework makes you write reams of boilerplate... it's
probably because someone just came from Java and isn't thinking in Python
yet. Code generation in Python is generally a non-starter. (Few rare
counterexamples, but it's nothing like the Necessary Crutch it is in the
C++ world.) Generally, every line in that Twisted tutorial, even in the
final program, is *doing something*, not satisfying the framework with
necessary boilerplate.

As for the rest of your requirements, you have specified your "technology
stack" in terms of *goals*, not capabilities, so for quite a lot of them,
there is no answer except, "Yes, Python can do that, and generally easier
than most anything else". For instance, "Use of metadata within the design
(on text level [code file])" can mean a thousand things. For what it's
worth, Python tends to make it so easy I do it all the time, but for any
given way you mean it, I can't promise there exists a pre-rolled framework
for you.

So I can only speak generally. Given your list, you may find that Python
is weak in the "graphical programming" department; drop-and-drop GUI
generation isn't as well-tuned as VB. (I, for one, consider that
development methodology toxic and actively dangerous, but I can understand
why you miss it.)

Skipping down to your evaluation sequence:

* Create a class: Well, I'll show you this one:

class Something: pass

There, a class.

* Simple GUI: You may wish to check out Boa Constructor, as the closest
thing to the GUI generator you probably want. There are at least 3 major
viable GUI toolkits for Python and several other minor (but still capable)
ones.

* Embedded DBs: I don't know, Google for your embedded DB name + Python.
Failing that, there are several ways to wrap your embedded DB such that a
Python program can use it.

* Web GUI: There are more Python web frameworks than you can shake a stick
at, and I don't mean "some guys hacked together templating system" either;
there are a lot of very mature systems out there, expressing a lot of
different philosophies. Given some of your other requirements, for a
web-based application I'd recommend examining Zope.

* Deployment: I don't generally have enough problems with this to be worth
thinking about. I don't know what the state of the remote debugging is on
Python; Google "remote debugging Python".

* For your "complex updates", I see two distinct things there; half of the
depend on the database, not Python. For the other half, it depends on if
you mean "while the program is still running". If so, they are
challenging. If not, they are trivial.

* I'd recommend adding "testability" to your stack, and refer you to the
"unittest" module; others can suggest their preferred testing modules, but
I tend to stick with that as the general framework is available in a lot
of languages that I use. If by evolutive development you are including the
ideas behind "agile software development" (hard to tell if you mean that,
or a community open to change*)

Based on what I see here, I have two basic comments. First, yes, Python is
probably as close as you are going to get in an existing system to what I
think you are looking for. It isn't perfect, but you will also be able to
reasonably extend it for your needs. Second, Python has a different
philosophy; you recognize the need for a different philosophy and I
extremely strongly suggest that you take the time with Python to sort out
what you truly need from what you think you need due to still thinking
with your old philosophy. (For example, given my aforementioned
reasons why code generation isn't an issue in Python, I strongly suggest
you embrace Python and give it a chance, rather than force 'code
generation' on top of it.)

You've got some exciting learning to do, and some interesting philosophy
shifts to absorb, but I think you'll find, as a lot of use have, that even
if it isn't perfect it's a helluva lot better than Java!

*: Community open to change: One caveat, from what I've seen when other
people talk about this. The Python community is open to change, but it is
still a meritocracy, and you will still need to convince others your
change is good. For example, getting something into the standard library
is not something that everybody does routinely. But as it is open source,
if you want to take responsibility for your changes, you can do as you
like. I *think*, based on your reading, that you are focussing on the
latter, in which case you are OK. But do not expect to be able to dump
things off onto "the Python community".

Also, not getting into the standard library isn't that big a deal anyhow;
a lot of very powerful and popular frameworks and modules don't go in,
often because they conflict with the needs of a Python release (slow rate
of change, mature interface, general utility, need to prevent a Python
download ballooning to 250 MB, etc.).

 

[Fredrik Lundh]

Google his name - he has been banned from Netbeans and Eclipse (and Hibernate, and others...) for
good reason. Can you imagine how much of a Troll you need to be to *actually* get "banned" from
the newsgroups of open source projects such as those?

have Pythoneers ever "banned" anyone from a public forum? it's not like
we haven't seen trolls and crackpots before, you know.

</F>

 

[Markus Wankus]

Markus Wankus wrote:




have Pythoneers ever "banned" anyone from a public forum? it's not like
we haven't seen trolls and crackpots before, you know.

</F>

I know - which is why it is even more amazing he can get banned from
other open source groups similarly tolerant as this one...

M.

 

[Jan Dries]

have Pythoneers ever "banned" anyone from a public forum? it's not like
we haven't seen trolls and crackpots before, you know.

Well, we don't have to ban them because we have the PSU eliminate them
alltogether. So much more efficient. Or do you think it's a coincidence
we've never seen or heard Timothy "autocoding" Rue again?

Be afraid, Xah, be very afraid.

Regards,
Jan

 

[Fredrik Lundh]

Well, we don't have to ban them because we have the PSU eliminate them alltogether. So much more
efficient. Or do you think it's a coincidence we've never seen or heard Timothy "autocoding" Rue
again?

he's been assimilated:
True

</F>

 

[Ilias Lazaridis]

This post is hard to follow, but I'm going to assume this is the core
question, as it is labelled as such.

ok

Thank you for your thorought comments.

The first thing that leaps to mind is that you need to play with
Python for a bit to get a full analysis of it. Due to the nature of
Python, some of the things you have in that list don't really apply.


The most obvious example of this is "code generation": Assuming you
mean

[...]

I want to generate things (code, txt, html etc.) out of my object-model,
whilst using with a flexible generator, if possible a standard one.

Does such generator exist?

[...]

"Use of metadata within the design (on text level [code file])" can
mean a thousand things. For what it's worth, Python tends to make it
so easy I do it all the time, but for any given way you mean it, I
can't promise there exists a pre-rolled framework for you.

I want to add metadata to everything within my design (functions, data,
classes, ...), if possible with a standard way.

Does such metadata-functionality (build-in, add-on-library, framework)
exist for python?

So I can only speak generally. Given your list, you may find that
Python is weak in the "graphical programming" department;
drop-and-drop GUI generation isn't as well-tuned as VB. (I, for one,
consider that development methodology toxic and actively dangerous,
but I can understand why you miss it.)

I prefere generic GUI's.

But sometimes there is a need for simple predefined GUI's.

Thus: I want to create GUI's in an generic way, and/or in an standard
way (via GUI editor).

Skipping down to your evaluation sequence:
http://lazaridis.com/case/stack/index.html#evaluation

* Create a class: Well, I'll show you this one:

class Something: pass

There, a class.

ok
-

you've missed:

"declare this class as persistent"

* Simple GUI: You may wish to check out Boa Constructor, as the
closest thing to the GUI generator you probably want. There are at
least 3 major viable GUI toolkits for Python and several other minor
(but still capable) ones.

=> {GUI Generator: Boa Constructor}

* Embedded DBs: I don't know, Google for your embedded DB name +
Python. Failing that, there are several ways to wrap your embedded DB
such that a Python program can use it.

ok

Clarification: standard way to save python objects into an embedded db
(in conjunction wiht "declare this class as persistent")

* Web GUI: There are more Python web frameworks than you can shake a
stick at, and I don't mean "some guys hacked together templating
system" either; there are a lot of very mature systems out there,
expressing a lot of different philosophies. Given some of your other
requirements, for a web-based application I'd recommend examining
Zope.

ok.

Can please someone name some of them?

[they should work together with simple python classes and the standard
metadata]

* Deployment: I don't generally have enough problems with this to be
worth thinking about. I don't know what the state of the remote
debugging is on Python; Google "remote debugging Python".

[I like to avoid interaction with google.]

* For your "complex updates", I see two distinct things there; half
of the depend on the database, not Python.

It depends on how my python-build system binds to the underlaying database.

For the other half, it depends on if you mean "while the program is
still running". If so, they are challenging. If not, they are
trivial.

You are right.

New Requirements:

a) While the programm in shutted down.
b) While the programm in still running.

* I'd recommend adding "testability" to your stack, and refer you to
the "unittest" module; others can suggest their preferred testing
modules, but I tend to stick with that as the general framework is
available in a lot of languages that I use. If by evolutive
development you are including the ideas behind "agile software
development" (hard to tell if you mean that, or a community open to
change*)

I don't know "agile software development", thus I cannot answer you.

I'll think about to add "testability" to the stack.

Based on what I see here, I have two basic comments. First, yes, [...]
have, that even if it isn't perfect it's a helluva lot better than
Java!

I've not evaluated Java.

Just it's communities.

Thus I can "dive" immediately & fully into python, without any philosoph
switch (if i select python finally).

*: Community open to change: One caveat, from what I've seen when
other people talk about this. The Python community is open to change,
but it is still a meritocracy, and you will still need to convince
others your change is good.

[...] - (standard library etc.)

I understand.

-

A rational change suggestion does not need time to be accepted.

Just rational decision takers (e.g. community).

..

 

[Jeremy Bowers]

* Deployment: I don't generally have enough problems with this to be
worth thinking about. I don't know what the state of the remote
debugging is on Python; Google "remote debugging Python".

[I like to avoid interaction with google.]

OK, this, combined with a reputation that didn't quite precede you, but
came close, leads me to say this: I've given you what you're going to get.
You want more, you're going to have to put some effort into it. Lots of
effort.

But I can give you this: If you aren't already there, you're a textbook
case of somebody heading for analysis paralysis. It's time to stop
researching and start programming; grab Python, do a couple tutorials, and
start acquiring the skills you're going to need to do these other tasks
you want to do anyhow.

Barring evidence that you are taking responsibility for yourself, I'm not
inclined to help much more.

 

[Stephen Kellett]

[I like to avoid interaction with google.]

Well, use a different search engine.

I've not evaluated Java.

That is strange - the title of this thread indicates that you have
evaluated Java. You have posted similar threads in comp.lang.ruby and
comp.lang.java.*.

You are a troll.

Stephen

 

[Terry Reedy]

If you ask too much that other people do your searching for you, answers
will dry up. But here are a couple that you might not find on google
anyway, at least not easily.

I want to add metadata to everything within my design (functions, data,
classes, ...), if possible with a standard way.

You can annotate, by adding attributes to, modules, functions, classes, and
class instances. You can not directly do so with 'basic' types: numbers,
sequences, and dicts -- and some others. You can, however, either extend
or wrap anything with your own classes to get something you can annotate
(but don't ask me for the details).

I want to generate things (code, txt, html etc.) out of my object-model,
whilst using with a flexible generator, if possible a standard one.

One standard way to generate text from objects is to use custom classes,
each with a custom __str__ method. Assuming you have a hierachical model
without loops, each such method can recursively call each data attribute
object of the instancefor it to generate its substring. (With loops you
need a loop-cutting mechanism to prevent infinite recursion.) I know this
has been done for html (but again, I won't google for you). Define a class
for each type of element and give each instance a list of element instances
it contains. Then 'print html_doc_instance' can print the html doc
corresponding to the object model.

Like others, I recommend you spend a day with Python if you wish to learn
more.

Terry J. Reedy

 

[Courageous]

Well, we don't have to ban them because we have the PSU eliminate them
alltogether. So much more efficient. Or do you think it's a coincidence
we've never seen or heard Timothy "autocoding" Rue again?

Foolish, man! You said his name! It's almost like you said C'thul'hu, ...
you ... ah.... no, no, NO! N'YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH

*insert ripping and splashing sounds*

 

[Ilias Lazaridis]

If you ask too much that other people do your searching for you, answers
will dry up.

I don't ask people to search for me.

I ask people for their specific knowledge about specific python language
constructs.

This is a simple cooperation.

I've spend very much time to extract this specifi evaluation template:

http://lazaridis.com/case/stack/index.html#evaluation

Python community can 'fill' it quickly with the relevant technology (if
it exists).

The evaluation result can serve as a fundamental part for a _practical_
showcase how Python beats Java.

But here are a couple that you might not find on google
anyway, at least not easily.

thank you.

You can annotate, by adding attributes to, modules, functions, classes, and
class instances. You can not directly do so with 'basic' types: numbers,
sequences, and dicts -- and some others. You can, however, either extend
or wrap anything with your own classes to get something you can annotate
(but don't ask me for the details).

=> {annotation via attributes on modules, functions, classes and objects}

=> {not available with basic types (numbers, sequences, dicts, ...) }

=> {unconfirmed: possibility to extend/wrap basic types with own classes}

I want to generate things (code, txt, html etc.) out of my object-model,
whilst using with a flexible generator, if possible a standard one.

One standard way to generate text from objects is to use custom classes,
each with a custom __str__ method. [...]
Then 'print html_doc_instance' can print the html doc
corresponding to the object model.

I understand this procedure.

I would like to use a standard way, which uses the standard metadata
[implicit/explicit defined].

Does such standard exist?

Like others, I recommend you spend a day with Python if you wish to learn
more.

I am spending "a day" with it's community.

..

 

[Terry Reedy]

Then 'print html_doc_instance' can print the html doc corresponding to
the object model.

I understand this procedure.

I would like to use a standard way, which uses the standard metadata
[implicit/explicit defined].

Does such standard exist?

I am not sure of what *you* mean by 'standard way'. That is probably
because Python and the community is not big on 'standard ways' other than
what is specified in the two reference manuals. And even then, Python is
intentionally flexible in various ways (though not all). So the answer to
your question is probably 'no'.

Terry J. Reedy

 

[Alex Martelli]

have Pythoneers ever "banned" anyone from a public forum? it's not like
we haven't seen trolls and crackpots before, you know.

I don't see how banning is technically possible in unmoderated groups.
Shunning, or pelting the troll with abuse whenever he shows up, etc,
etc, sure. But, banning?


Alex

 

[Ilias Lazaridis]

Then 'print html_doc_instance' can print the html doc corresponding to
the object model.

I understand this procedure.

I would like to use a standard way, which uses the standard metadata
[implicit/explicit defined].

Does such standard exist?

I am not sure of what *you* mean by 'standard way'.

a formal standard (like e.g. ODMG for OODBMS).

a quasi standard (e.g. an widely accepted definition/inpementation etc.)

That is probably
because Python and the community is not big on 'standard ways' other than
what is specified in the two reference manuals.

I would say this is a "standard".

Can one please point me to a downloadable version of the 2 reference
manuals (did not found them)?

And even then, Python is
intentionally flexible in various ways (though not all).

Flexibility is of course always very positive.

So the answer to your question is probably 'no'.

Terry J. Reedy

..

 

[Stephen Kellett]

Can one please point me to a downloadable version of the 2 reference
manuals (did not found them)?

Well, there is an obvious website address to visit and you can see the
word "documentation" on that website without scrolling.

Use Google or a different search engine to find the obvious website.

Stephen

 

[Ilias Lazaridis]

Well, there is an obvious website address to visit and you can see the
word "documentation" on that website without scrolling.

which leads to:

http://python.org/doc/

which leads to:

http://docs.python.org/download.html

The conviently downloadable documentation-pack contains 4 "reference"
type manuals.

I assume the mentioned "2 reference manuals" were contained therein.

Use Google or a different search engine to find the obvious website.

Thank you.

I prefere interaction with the community.

..

 

[Ilias Lazaridis]

I want to add metadata to everything within my design (functions, data,
classes, ...), if possible with a standard way. [...]
I want to generate things (code, txt, html etc.) out of my object-model,
whilst using with a flexible generator, if possible a standard one.

Example: ArcheTypes, autogeneration of forms and pages

"The creation of a new Type using Archetypes involves a main text file
(python) that defines the fields and other objects within your type,
their properties, and their behavior. Archetypes uses this information
to auto generate on demand all forms and pages needed to add, edit, and
view your types data. When you have written this file, you then have a
product that you would install just like any other CMF/Plone product."

source: http://plone.org/documentation/archetypes/

-

Archetype is defined within a python file.

Does this include metadata?

If yes: in a standard way (e.g. usable in other developments, too)?

Archetypes uses a generator.

Is this a standard generator (thus I don't have to learn/use another one
in another context)?

..