Gnome devs too lazy for python?

I love Python.. so I would personally use Python over any language for a Gnome based app..

In any case, I would shy away from Mono / C# just based on the fact you don't know how much of MSFT's IP you are using when implementing programs based on the Mono stack.

Wow, that's really sad that they rely on compiling to fix their bugs. I know some people who work in java shops - testing is every bit as important there as it is anywhere else. Actually, didn't unit testing hit java before it hit python? WTF.

Compiling (in this case static typing) catches one kind of error, and if you are a decent programmer it's not an error you make often. The REASON i can't use beagle is because of their poor language choice. Mono is huge and unwieldy, and I don't have the space or memory to install it. Maybe it's gotten better since I tried it a few years ago, but I just don't like the platform.

I am very leery of their software if they aren't properly testing their code.

For the record, I have written several "real" applications in Python and they do not have unit tests. (I've been lazy too.) They run just fine and the people that rely on them are happy.

I'm not saying that testing is unnecessary. I think it is very important. What I am saying is that you don't need to be so incredibly disciplined to program in Python.

Compiling is a implementation detail. And an annoying one at that. I've been burned just as often (or perhaps more so) when I used to code in C++ and Java. Static typing does not buy you anything.

Just my $0.02. But he seems to make it out to be some monumentally huge ordeal to not get burned in Python. And that is simply not true.

Anyway, to each his own.

Of course, Joe also replied to Thomas's posting and explained his position a bit better.

For what it's worth, I use Python (and several other dynamically typed languages) a lot, and still enjoy using static typing for projects where it's suitable and think that it does actually help quite a bit in catching errors. Not to say you can't catch those errors with unit tests too or that it doesn't have its downsides, especially if the type system isn't good enough.

I don't think there's a simple easy answer.

Bruce Eckel's article Strong Typing vs. Strong Testing is very relevant here. Static type checking alone is a very poor substitute for comprehensive unit and functional tests.

Hi,

As I've mentioned elsewhere, there is no substitute for writing tests for your application. The blog post wasn't principally about Python or development methodologies, so I didn't think it was necessary to say that testing is important in all cases. Are there really people out there who believe that?

I don't disagree with anything that Thomas said, in fact I agree with him wholeheartedly. My experience with that project (incidentally, my first ever with Python) has vividly reinforced the importance of code coverage and unit tests.

In rereading my original post, I see that the parenthetical statement "including myself" implies that I presently don't think this is important. That was a mistake. I didn't have that discipline on that previous project; I definitely do now.

I've had a bit of a back-and-forth in the comments over at Lennart Regebro's blog about this. Hopefully it does a better job of explaining my position:

http://regebro.wordpress.com/2007/11/01/the-compiler-doesnt-help-you-find-b ugs/

Thanks, Joe

wmix- there's still some uncertainty (perhaps it's FUD) around IP issues and Mono. I was hoping Joe would post the reasons he chose C#. I'm not convinced of the static typing argument yet....

patrick- Testing is good for all software. You'd be surprised how much software out there lacks tests... (or maybe you wouldn't)

krys- Thanks for admitting that it's possible to be a lazy programmer. I've also programmed (in python) without tests and said programs tend to run. I'm not buying that python takes more discipline to program than C#/Java. Certainly there isn't a IDE to hold your hand (perhaps that is THE benefit of static typing), but the core language is so succinct you don't really need an ide... (ok emacs perhaps is an IDE).

juri- But aren't the errors your compiler is finding going to be found through basic testing?

menno- Yes, The Eckel's article is sort of a must read. Especially as it's coming from a very respected C++/Java guru.

joe- Thanks for your clarification. I'm still waiting on good reasons for static typing. I'm not buying the compilation argument yet. (I'd like to think that I'm open to being convinced of it...)

Hi again,

Also, you're rather selectively quoting me, which I don't really appreciate:

• They choose C# for their app (Beagle) because " wanted a strongly typed language"

(You are right about my mistake of "strongly typed" rather than "statically typed".) That was but one of the reasons, and not even the major one. Which is why I listed it third of the three I posted, although I didn't mention that they were in order of preference. The biggest reasons were (a) that we wanted to use Mono because we thought it was a fun, interesting, and new thing to use (and Miguel is very good about getting people excited about things) and (b) because more of the supporting code was there. We used the frequently renamed once-and-again Lucene.Net for indexing, which was a straightforward C# port of the Apache Lucene in Java. At that time, Lucy (the Python port) wasn't as functional, although I think it has caught up now.

For the record, at Novell we were never forced into using Mono; we were free to choose whatever technology we wanted and thought was best. I quite enjoy Python and I tend to use it as my normal "go to" language.

Regards,

Joe

Joe- I didn't mean to selectively quote you. I apologize for any offense. My interest (and reason for the blog post itself) was because of the typing/compilation issue, which wreaked of FUD to me. It's fine (and quite reasonable) that you don't to use C for desktop apps. I like using new technology too, so I applaud you for living on the edge.

> Miguel is very good about getting people excited about things

What a shame they are invariably the wrong things.

Mono/Miguel/MS are worse than a nuisance: They're downright dangerous.