Linked by Thom Holwerda on Wed 7th Mar 2007 22:27 UTC
Java "Although the .NET vs. Java war is basically over for control of the Windows desktop, where .NET is sure to become the managed language of choice for new Windows desktop applications, there is a new battle brewing. That battle is for the Linux desktop. Now that Java has been open sourced under the GPL, even the most strict of the 'free software only' distributions can start bundling it and integrating it into their Linux distributions out of the box."
Thread beginning with comment 219490
To view parent comment, click here.
To read all comments associated with this story, please click here.
RE[2]: Only Two Choices?
by ma_d on Thu 8th Mar 2007 01:29 UTC in reply to "RE: Only Two Choices?"
ma_d
Member since:
2005-06-29

Python is strongly typed, it's not statically typed. And I agree, I also believe it poses a problem when developing complex software. However, a lot of desktop software doesn't appear to be entirely complex in the way that static typing helps but in other ways where rapid changes help (user interactions are complicated because of users, not the nature of the calculations or data so an easily modified code base is more helpful than a statically typed one).

Obviously mileage will vary from programmer to programmer and problem to problem.

It is good to hear that Swing will be moving forward and making use of that extra hardware for drawing where possible, that's encouraging news. As I tried to communicate before, I didn't have the feeling that Swing was moving forward (other than trying to act more native). Maybe my feeling is wrong.

Start an app with only one display connected. Connect the display. Move the app to the second display. Try to use a combo box. The combo box should fail to display a menu (it does here).
Also, menu's don't do the proper animation after selecting (really minor).
I'm sure I'll find more as time goes on though, I'm new to Mac.


If you've watched Microsoft's take over of application software you should note one thing: It's not about what you can do, it's about what you can promise to do and if you can make people believe you'll get there. In a sense, it's about momentum (or at least perceived momentum) and not about assets.
Java is more mature, that's for sure and that's a great asset. Mono is new and shiny and partially due to its newness and partially due to its openness (not just the source, but the developers talking openly) it appears to have a lot of momentum.


Patent traps are probably going to hurt Mono as well. But I believe that's actually a much smaller group of developers than the group who doesn't think a lot about it; and I'm only talking about Linux application developers (the ones we're concerned with).

Reply Parent Score: 5

RE[3]: Only Two Choices?
by Mystilleef on Thu 8th Mar 2007 04:45 in reply to "RE[2]: Only Two Choices?"
Mystilleef Member since:
2005-06-29

>
>Python is strongly typed, it's not statically typed.
>And I agree, I also believe it poses a problem when
>developing complex software.
>

How do we define complex software? How does static typing make developing complex software easier?

http://pygtk.org/applications.html

On that page you'll find a list of applications ranging for UML editors, auditor editors, video editors, audio streamers, to full blown games all written in Python. Python is excellent for written any kind of software regardless of complexity. The whole "dynamically typed languages is not good for writing 'complex' software" is a silly myth.

Reply Parent Score: 4

RE[4]: Only Two Choices?
by ma_d on Thu 8th Mar 2007 19:06 in reply to "RE[3]: Only Two Choices?"
ma_d Member since:
2005-06-29

Static type checking makes developing complex software easier because it establishes statically (compiler) checked contracts at all of your interfaces.

On a local level it makes software a bit more clear by defining what types of inputs and what type of output a function has. With dynamic type checking you can receive any type of object into your function and pass it down the line until it gets to a point where the duck typing (this is runtime now, and it's usually duck typing as it is in python) causes an error (it can't find some attribute on that object that it expected).

Static type checking forces you to think these things through before you can even compile your program. Some people can do entirely without it and many people substitute extensive unit tests (which do a lot more than check type issues, which is why they're used in static type checked languages as well). But the errors still leak through and you end up doing a lot of work to figure out at what point you're really sending an invalid object into the mix.

To state that static type checking doesn't aid in writing software is to call dozens of prominent language designers wrong... I doubt even Guido would argue that static type checking isn't helpful.
In fact, I do believe Guido agrees with me ;) .
http://www.artima.com/weblogs/viewpost.jsp?thread=86641

There's actually a tool for doing some static type checking in Python: http://pychecker.sourceforge.net/

Static type checking is much more difficult in a language like Python, which is why so many modern statically typed languages add syntax to aid in the enforcing. The difficulty of the check, coupled with Python's "run from source code" workflow, is likely why it's not in the compiler itself.

Reply Parent Score: 3

RE[3]: Only Two Choices?
by Stubbs on Thu 8th Mar 2007 14:51 in reply to "RE[2]: Only Two Choices?"
Stubbs Member since:
2007-03-08

As Ma_d already pointed out python is strongly typed. One point I would make is that a combination of unit testing and pyDoc gets rid of many of the "risks" that a non statically typed language may introduce.

Also python now has the option of using Windows Forms or Swing Via IronPython or Jython respectively

Reply Parent Score: 1