Some think it will.
Up untill now, Java has never been standard across different versions
of Linux and Unix. Some think that is one reason that some developers
have avoided Java in favor of Python. Now that Java has been GPL'd that
might change.
IMO: it won't make much difference. But I don't really know.
29  1866 
walterbyrd wrote:
Some think it will.
Up untill now, Java has never been standard across different versions
of Linux and Unix. Some think that is one reason that some developers
have avoided Java in favor of Python. Now that Java has been GPL'd that
might change.
IMO: it won't make much difference. But I don't really know.
The change might also provide an opportunity for further expansion of
jython, eating into Java "marketshare"
"walterbyrd" <wa********@iname.comwrites:
Some think it will.
Up untill now, Java has never been standard across different versions
of Linux and Unix. Some think that is one reason that some developers
have avoided Java in favor of Python. Now that Java has been GPL'd that
might change.
IMO: it won't make much difference. But I don't really know.
Short answer: People use Python instead of Java because people (at
least intelligent people) tend to avoid pain.
Long answer: Changing licenses doesn't magically change Java's
architecture. It is still a closed world of reinvent-the-wheel,
my-way-or-the-highway. Which is antithetical to Python's promiscuous
interface-with-anything approach.
--
Harry George
PLM Engineering Architecture
walterbyrd wrote:
Some think it will.
Up untill now, Java has never been standard across different versions
of Linux and Unix. Some think that is one reason that some developers
have avoided Java in favor of Python. Now that Java has been GPL'd that
might change.
IMO: it won't make much difference. But I don't really know.
I'm hoping for a more optimistic outcome that this may open a
possibility for tigher interoperability between java programs and python
programs. That is, run java class files or java codes natively on python
VM. Is this still a blue sky dream?
maurice
John Bokma wrote:
Intelligent people don't suffer from fanboy sentiments. They just pick a
language that works best for them.
Adding to that, they pick the language that works best for them and the
situation. Python has a significant advantage in many applications
because it is dynamic and can be used for rapid development. IMHO,
usually more rapid than Java. Hopefully Java being GPL'd will make it
easier to deploy applications, especially on Linux. There are many
applications where Java has a significant advantage. I plan to make use
of both.
John Bokma a écrit :
Harry George <ha************@boeing.comwrote:
>>Short answer: People use Python instead of Java because people (at
least intelligent people) tend to avoid pain.
Intelligent people don't suffer from fanboy sentiments. They just pick a
language that works best for them.
Which is *exactly* what Harry said...
walterbyrd wrote:
Some think it will.
Up untill now, Java has never been standard across different versions
of Linux and Unix. Some think that is one reason that some developers
have avoided Java in favor of Python. Now that Java has been GPL'd that
might change.
IMO: it won't make much difference. But I don't really know.
I don't think so. Java and Python don't really belong to the same
"class" of programming languages:
C++, Java: strongly typed, statically typed object-oriented programming
languages... minimal runtime means that these languages can be compiled
to native executables easily (yes, Java can now with things like GCJ
and appropriate libraries)
Python, Perl, Ruby: dynamically typed object-oriented programming
languages... lots of runtime intelligence allows you to do things like
create a new class or function at runtime, or look up a symbol based on
a string of its name, or execute a string containing source code (these
things make the language more flexible but pretty hard to compile to
native code without embedding an interpreter)
The "mindset" required to program effectively in C++ or Java is very
different from that required to program effectively in Python or Perl,
in a way that's quite separate from the syntactical distinctions
between these languages... I think most programmers settle comfortably
into one mindset that fits best with the tasks they do, and try not to
move outside of it.
The ranks of C++ programmers have already been diminished by many of
them jumping to Java, since it offers less complex syntax and better
cross-platform support. I expect that GPL'ed Java will accelerate the
decline of C++. But I don't see Java competing directly with Python...
Dan
Bruno Desthuilliers <bd*****************@free.quelquepart.frwrote:
John Bokma a écrit :
>Harry George <ha************@boeing.comwrote:
>>>Short answer: People use Python instead of Java because people (at
least intelligent people) tend to avoid pain.
Intelligent people don't suffer from fanboy sentiments. They just
pick a language that works best for them.
Which is *exactly* what Harry said...
No, there is a very clear difference if one is willing to see it.
--
John MexIT: http://johnbokma.com/mexit/
personal page: http://johnbokma.com/
Experienced programmer available: http://castleamber.com/
Happy Customers: http://castleamber.com/testimonials.html
"Matimus" <mc******@gmail.comwrote:
>
John Bokma wrote:
>Intelligent people don't suffer from fanboy sentiments. They just
pick a language that works best for them.
Adding to that, they pick the language that works best for them and
the situation.
Yup.
Python has a significant advantage in many applications
because it is dynamic and can be used for rapid development. IMHO,
usually more rapid than Java. Hopefully Java being GPL'd will make it
easier to deploy applications, especially on Linux. There are many
applications where Java has a significant advantage. I plan to make
use of both.
Yes, my point. I program mostly in Perl, use Java now and then, and am
still working on learning Python.
--
John MexIT: http://johnbokma.com/mexit/
personal page: http://johnbokma.com/
Experienced programmer available: http://castleamber.com/
Happy Customers: http://castleamber.com/testimonials.html
On Wed, 15 Nov 2006 22:58:55 +0000, John Bokma wrote:
Harry George <ha************@boeing.comwrote:
>Short answer: People use Python instead of Java because people (at
least intelligent people) tend to avoid pain.
Intelligent people don't suffer from fanboy sentiments. They just pick a
language that works best for them.
Hang on, are we talking about intelligent people, or the sort of people
who like coding in Java? *wink*
Sorry, couldn't resist :)
Seriously though, there is no contradiction between the idea of "people
use Python instead of Java because they prefer to avoid pain" and "people
choose the language that works best for them". They could both be true (or
neither, but that's another story). We're all individuals, with our own
little quirks, but we are all also human beings with a lot in common and
the idea of an objectively "less painful" language is not silly. It may
very well be that Python is objectively easier to use and less painful
than Java for the majority of people. (I have no opinion on whether that
it true, but merely note that it is a logical possibility.)
Ease of use is not the sole reason for choosing a computer language. It is
a virtue, but not the only virtue. I wouldn't like to see video drivers
written in pure Python.
The reality is, most programmers don't so much choose a language as
have one thrust at them. I estimate (and by estimate I mean guess) that
90% of coders have never learnt a second language, and 99% have never
learnt a third. We're spoiled here, because the sort of people who
regularly contribute to comp.lang.* are often those with experience
with three, four, a dozen languages -- hardly representative of the coders
who churn out VB code all day, or those who learn nothing but Java at Uni
and then go straight into a Java job. We often see on comp.lang.*
people who programfor the love of programming. They'd program even if they
weren't paid for it. But being a programmer is also done by those who
program for the pay, not for the love of the job. They don't go home and
night and spend three hours on Usenet answering newbies' questions.
In many universities and schools, the choice is often between Java (in
previous times C++) or nothing. People might choose Java in some sense,
but they can hardly be said to choose Java because it works best for them
if they know no other languages to compare it to!
(The same naturally goes for those who only know Python, or any other
language.)
--
Steven D'Aprano
Steven D'Aprano <st***@REMOVEME.cybersource.com.auwrote:
Seriously though, there is no contradiction between the idea of
"people use Python instead of Java because they prefer to avoid pain"
It sounds like a typical fanboy statement to me, since it implies that
Java is always a pain, and Python is perfect. I can't take such a
statement nor the person writing it down serious at all.
--
John MexIT: http://johnbokma.com/mexit/
personal page: http://johnbokma.com/
Experienced programmer available: http://castleamber.com/
Happy Customers: http://castleamber.com/testimonials.html
Dennis Lee Bieber wrote:
On Wed, 15 Nov 2006 22:41:19 GMT, Maurice LING <ma*********@acm.org>
declaimed the following in comp.lang.python:
>>I'm hoping for a more optimistic outcome that this may open a
possibility for tigher interoperability between java programs and python
programs. That is, run java class files or java codes natively on python
VM. Is this still a blue sky dream?
Most unlikely to happen... I don't really see anyone going to the
effort to change the javac back-end to target a totally different
runtime engine.
I admit that it is very very unlikely. I guess it is just a wild dream
of mine to run Java bytecodes and Python bytecodes on Python VM. I do
have a wild vision that we can import java libraries (as jar files) into
CPython.
ML
I do have a wild vision that we can import java libraries (as jar files) into CPython.
Isnt this being achieved by Jython (python code using Java libraries),
and in future by the Java scripting framework added into Java 6 ?
Maurice LING wrote:
I admit that it is very very unlikely. I guess it is just a wild dream
of mine to run Java bytecodes and Python bytecodes on Python VM. I do
have a wild vision that we can import java libraries (as jar files) into
CPython.
http://sourceforge.net/projects/jpype
</F>
John Bokma wrote:
>Seriously though, there is no contradiction between the idea of
"people use Python instead of Java because they prefer to avoid pain"
It sounds like a typical fanboy statement to me, since it implies that
Java is always a pain, and Python is perfect.
That inference requires as preliminary convention, some clear contrafactual like
"everybody uses Python and nobody uses Java".
IMO, this is a form of assumption that is only legitimate in the purpose of
reaching agreement; while the OP's statement can be read as "those people who
use Python instead of Java do it because..." without recourse to a similar
assumption - what escapes your criticism.
Cheers, BB
I'm using python couse its clean, fast, fast to develop, easy, beauty,
an alternative. Java its a "mainstream" lang, GPL or not... i think
*sorry for my (pooooor) english
walterbyrd escreveu:
Some think it will.
Up untill now, Java has never been standard across different versions
of Linux and Unix. Some think that is one reason that some developers
have avoided Java in favor of Python. Now that Java has been GPL'd that
might change.
IMO: it won't make much difference. But I don't really know.
walterbyrd wrote:
Some think it will.
How so? Just because Java is GPL doesn't mean you can type less while
coding in it.
BufferedOutputStream bos = new BufferedOutputStream(new
FileOutputStream());
is still like that GPL or no GPL, no?
Up untill now, Java has never been standard across different versions
of Linux and Unix.
The last company I worked for has been delivering products on Windows,
Linux, and Solaris for years. We've never had to resort to any
"platform-specific" stuff with Java.
Some think that is one reason that some developers
have avoided Java in favor of Python. Now that Java has been GPL'd that
might change.
Becoming a better Java, maybe. Becoming more like Python? No way. I
have high hopes for Jython though, Charles Nutter from JRuby has been
having an ongoing discussion with the Jython developers in jython-dev.
Interesting stuff!
IMO: it won't make much difference. But I don't really know.
walterbyrd wrote:
Some think it will.
Up untill now, Java has never been standard across different versions
of Linux and Unix. Some think that is one reason that some developers
have avoided Java in favor of Python. Now that Java has been GPL'd that
might change.
IMO: it won't make much difference. But I don't really know.
In my opinion, GPLing Java won't have any immediate effect
on who uses which for what kind of project. Longer term, however,
I see a number of efforts to clean up some of Java's more
egregious syntax problems. I've already seen one proposal,
and there will undoubtedly be others. If any of them fly, they'll
probably be folded into the base in a few years, and that will
diminish the ease of use / large project divide between the
two languages.
John Roth
Fredrik Lundh <fr*****@pythonware.comwrites:
Maurice LING wrote:
I admit that it is very very unlikely. I guess it is just a wild
dream of mine to run Java bytecodes and Python bytecodes on Python
VM. I do have a wild vision that we can import java libraries (as
jar files) into CPython.
http://sourceforge.net/projects/jpype
</F>
Personally, I've never gotten jpype to work. Is it just me, or is it
a troublesome install?
--
Harry George
PLM Engineering Architecture
Dennis Lee Bieber <wl*****@ix.netcom.comwrites:
On Wed, 15 Nov 2006 22:41:19 GMT, Maurice LING <ma*********@acm.org>
declaimed the following in comp.lang.python:
I'm hoping for a more optimistic outcome that this may open a
possibility for tigher interoperability between java programs and python
programs. That is, run java class files or java codes natively on python
VM. Is this still a blue sky dream?
Most unlikely to happen... I don't really see anyone going to the
effort to change the javac back-end to target a totally different
runtime engine.
--
Wulfraed Dennis Lee Bieber KD6MOG
wl*****@ix.netcom.com wu******@bestiaria.com
HTTP://wlfraed.home.netcom.com/
(Bestiaria Support Staff: we******@bestiaria.com)
HTTP://www.bestiaria.com/
I once wrote a partial JVM in Modula-3 (strictly a researchware
effort), so I can imagine it being done technically. But why?
The big problem with Java-and-Python is not the VMs underneath. It is
the fact that Java has layers upon layers upon layers of idiosyncratic
libraries and idioms. When you write bindings to that world (even if
the bindings are generated automagically), you have to *think* in
those same layers. The Python-oriented developer suddenly has to use
a dozen imports in order to do things already done better in
Pythonesque libraries.
--
Harry George
PLM Engineering Architecture
Personally, I've never gotten jpype to work. Is it just me, or is it
a troublesome install?
Harry George
PLM Engineering Architecture
It works fine for me now. However, I do recall having an issue a while
ago (most likely me, rather than JPype).
>
I once wrote a partial JVM in Modula-3 (strictly a researchware
effort), so I can imagine it being done technically. But why?
The big problem with Java-and-Python is not the VMs underneath. It is
the fact that Java has layers upon layers upon layers of idiosyncratic
libraries and idioms. When you write bindings to that world (even if
the bindings are generated automagically), you have to *think* in
those same layers. The Python-oriented developer suddenly has to use
a dozen imports in order to do things already done better in
Pythonesque libraries.
The main use I can see is to be able to incorporate Java applications
into Python. For example, I am using Cytoscape ( www.cytoscape.org) which
is in Java. I do hope that I can control Cytoscape from Python and
manipulate its objects from Python.
Say given cytoscape.jar, I'll like to be able to do this:
>>from cytoscape javaimport cytoscape
c = cytoscape()
And the tighest way I see that this can be done is for Python VM to
execute Java bytecodes like Python bytecodes. That is, Python VM
executes Java bytecodes directly and not through object mapping which I
think is that JPyPe is doing.
I must say that this is part of even a fluffier dream that one day, I
can take any applications and play around with it in Python. Currently,
my collaborators wrote in Perl and Java, so it is not easy for me to use
their work in my work.
ML
Maurice LING escreveu:
I once wrote a partial JVM in Modula-3 (strictly a researchware
effort), so I can imagine it being done technically. But why?
The big problem with Java-and-Python is not the VMs underneath. It is
the fact that Java has layers upon layers upon layers of idiosyncratic
libraries and idioms. When you write bindings to that world (even if
the bindings are generated automagically), you have to *think* in
those same layers. The Python-oriented developer suddenly has to use
a dozen imports in order to do things already done better in
Pythonesque libraries.
The main use I can see is to be able to incorporate Java applications
into Python. For example, I am using Cytoscape (www.cytoscape.org) which
is in Java. I do hope that I can control Cytoscape from Python and
manipulate its objects from Python.
Say given cytoscape.jar, I'll like to be able to do this:
>>from cytoscape javaimport cytoscape
>>c = cytoscape()
And the tighest way I see that this can be done is for Python VM to
execute Java bytecodes like Python bytecodes. That is, Python VM
executes Java bytecodes directly and not through object mapping which I
think is that JPyPe is doing.
I must say that this is part of even a fluffier dream that one day, I
can take any applications and play around with it in Python. Currently,
my collaborators wrote in Perl and Java, so it is not easy for me to use
their work in my work.
ML
What is wrong with the other way around and Jython?
Just curious.
Stephen
Stephen Eilert wrote:
Maurice LING escreveu:
>>>I once wrote a partial JVM in Modula-3 (strictly a researchware
effort), so I can imagine it being done technically. But why?
The big problem with Java-and-Python is not the VMs underneath. It is
the fact that Java has layers upon layers upon layers of idiosyncratic
libraries and idioms. When you write bindings to that world (even if
the bindings are generated automagically), you have to *think* in
those same layers. The Python-oriented developer suddenly has to use
a dozen imports in order to do things already done better in
Pythonesque libraries.
The main use I can see is to be able to incorporate Java applications
into Python. For example, I am using Cytoscape (www.cytoscape.org) which
is in Java. I do hope that I can control Cytoscape from Python and
manipulate its objects from Python.
Say given cytoscape.jar, I'll like to be able to do this:
>>from cytoscape javaimport cytoscape
c = cytoscape()
And the tighest way I see that this can be done is for Python VM to
execute Java bytecodes like Python bytecodes. That is, Python VM
executes Java bytecodes directly and not through object mapping which I
think is that JPyPe is doing.
I must say that this is part of even a fluffier dream that one day, I
can take any applications and play around with it in Python. Currently,
my collaborators wrote in Perl and Java, so it is not easy for me to use
their work in my work.
ML
What is wrong with the other way around and Jython?
Nothing wrong with the other way round - JVM executing *Python bytecodes*.
Cytoscape has a plugin with enables one to bring up Jython interpreter
but it is way too slow - make sure you start to load it up before lunch
if you want to execute a few lines of codes after lunch.
ML
Maurice LING wrote:
>
Say given cytoscape.jar, I'll like to be able to do this:
>>from cytoscape javaimport cytoscape
>>c = cytoscape()
And the tighest way I see that this can be done is for Python VM to
execute Java bytecodes like Python bytecodes. That is, Python VM
executes Java bytecodes directly and not through object mapping which I
think is that JPyPe is doing.
This kind of thing is what I wanted to do with my javaclass experiment,
but I lost motivation/momentum after getting only some of the things to
work. Translating Java bytecodes isn't hard for most of the instruction
set, although exception handling was awkward at the time (before Python
2.5's new-style Exception class), and I'd have to think through the
interpackage referencing problem again (circular references are not
typically a problem in the Java package hierarchy). In the end, I
couldn't justify spending the time in order to use certain pieces of
software that weren't so compelling after all.
I must say that this is part of even a fluffier dream that one day, I
can take any applications and play around with it in Python. Currently,
my collaborators wrote in Perl and Java, so it is not easy for me to use
their work in my work.
There's always Jython, as I tell the occasional person who tries
javaclass expecting it to be better than it is. That Jython doesn't
support the latest CPython features shouldn't be as huge a problem as
people suspect, especially if you just want to glue Java packages
together with Python. Otherwise, the PyLucene approach (gcj + bindings)
might be an acceptable approach: a well performing Free Software
solution even before the recent Java licensing events.
Paul
Paul Boddie wrote:
Maurice LING wrote:
>>Say given cytoscape.jar, I'll like to be able to do this:
>>from cytoscape javaimport cytoscape
c = cytoscape()
And the tighest way I see that this can be done is for Python VM to
execute Java bytecodes like Python bytecodes. That is, Python VM
executes Java bytecodes directly and not through object mapping which I
think is that JPyPe is doing.
This kind of thing is what I wanted to do with my javaclass experiment,
but I lost motivation/momentum after getting only some of the things to
work. Translating Java bytecodes isn't hard for most of the instruction
set, although exception handling was awkward at the time (before Python
2.5's new-style Exception class), and I'd have to think through the
interpackage referencing problem again (circular references are not
typically a problem in the Java package hierarchy). In the end, I
couldn't justify spending the time in order to use certain pieces of
software that weren't so compelling after all.
I take a simplistic view that Java bytecodes is all that is to be dealt
with. And the book "Programming for the Java Virtual Machine" by Joshua
Engel did demonstrated in principle that it is possible to program in
Java bytecodes. There are also other researchware which tried to compile
other languages into Java bytecodes. I am not sure if exception handling
etc are dealt with before bytecode level. I also envision that the core
implementation of JVM is a big switch statement, just like in Python VM
(the bytecode executor).
Will it then be the case of adding the set of Java bytecodes into Python
bytecodes and implementing Java bytecode operations? Or am I just
fooling myself here?
ML
Maurice LING wrote:
>
I take a simplistic view that Java bytecodes is all that is to be dealt
with.
Well, that and things like class loading. You'll need a library
implementing the "standard" Java API, although that's never been hard
to obtain, and the official implementation will be genuinely free to
redistribute before too long as well.
And the book "Programming for the Java Virtual Machine" by Joshua
Engel did demonstrated in principle that it is possible to program in
Java bytecodes. There are also other researchware which tried to compile
other languages into Java bytecodes. I am not sure if exception handling
etc are dealt with before bytecode level. I also envision that the core
implementation of JVM is a big switch statement, just like in Python VM
(the bytecode executor).
It's just an instruction set, but with some fairly "complicated"
instructions, just as you find in the Python virtual machine
instruction set - don't expect them all to be like RISC instructions,
or even traditional CISC instructions.
Will it then be the case of adding the set of Java bytecodes into Python
bytecodes and implementing Java bytecode operations? Or am I just
fooling myself here?
Take a look at the code, although you might want to steer clear of the
import hooks initially: http://www.python.org/pypi/javaclass
Paul
Harry George wrote:
>
Personally, I've never gotten jpype to work. Is it just me, or is it
a troublesome install?
It worked for my purpose (connecting to a 4D database via JDBC over Open4D, as
the ODBC driver for that db is really horrible) until I tried to use this setup
together with cherrypy, what crashed loudly and consistently for reasons I
failed to discern. Some initial [class]path issues, as well.
Cheers, BB
>Short answer: People use Python instead of Java because people (at
least intelligent people) tend to avoid pain.
Intelligent people don't suffer from fanboy sentiments. They just pick a
language that works best for them.
I agree with the previous poster and don't think it's just being a fan
boy. Some projects require Java, or at least are easier in Java, such as
creating browser applets, but in the majority of cases I find Python
much easier to work in. The code is more terse and easier to read and
work with. This discussion thread is closed Replies have been disabled for this discussion. Similar topics
220 posts
views
Thread by Brandon J. Van Every |
last post: by
|
1 post
views
Thread by greg.knaddison |
last post: by
|
4 posts
views
Thread by angel |
last post: by
|
9 posts
views
Thread by F. GEIGER |
last post: by
|
114 posts
views
Thread by Maurice LING |
last post: by
|
2 posts
views
Thread by Hal Vaughan |
last post: by
|
12 posts
views
Thread by Mark Fink |
last post: by
|
4 posts
views
Thread by Magnus Lycka |
last post: by
|
5 posts
views
Thread by Jonathan Sachs |
last post: by
| | | | | | | | | | | | | | | | | | | |
