Mono Outpaces Java In Linux Desktop Development

dp619 writes "Mono, a framework based on Microsoft technology, has become more popular for Linux desktop applications than Java, but recent changes could strengthen Java's hand, SD Times is reporting. The story also touches on the failure of Linux distros to keep pace with Eclipse."

Comments

What is strengthening Java according to TFA?

[Jugalator]

but recent changes could strengthen Java's hand, SD Times is reporting

OK, I've glanced over the article twice now, and can't see anywhere where they bring up what could be strengthening Java's position in the future?

I'm assuming it's updates to Eclipse, but they never state it explicitly, just that some Linux distros have weaker IDE support compared to MonoDevelop? *shrug*

Re:What is strengthening Java according to TFA?

[rdean400]

It isn't helpful that TFA is wrong on at least one point. It said that Eclipse 3.1 lacks code completion, refactoring, and debugging features. Unless the build in Debian is horrifically broken, it has all of those, including thread-level debugging, which it's had since before Eclipse 3.x. My assumption has always been this is because the progenitor of Eclipse -- IBM -- was more interested debugging server-based Java applications than standalone ones).

Re:What is strengthening Java according to TFA?

[owlstead]

If it says that it doesn't understand anything about developing and we might as well regard the entire article as trash. The one difference between Eclipse is the AST which enables model-oriented programming and refactoring. This has been in there since 2.0 at least (which is when I started to use Eclipse). Of course it already had debugging abilities build in (duh). Java (with its relatively small set of keywords and complexity) and Eclipse make for a very fine development environment, imho paling MS VS. MS still does not seem to understand that adding features is not always progress.

Re:What is strengthening Java according to TFA?

[TheNarrator]

Yeah after I read that enormous whopper of a lie, followed by the other lie that no other languages were developed by sun for the JVM, I pretty much figured this guy is just a Microsoft shill and has no interest in actually providing any useful information.. Best way to spot a sock puppet or shill by the way is when they receive a counter argument they either ignore it or repeat their initial argument over again. Since they are getting paid and you are not they will repeat this behavior until you get bored and leave the conversation paving the way for them to preach to the naive without any counter-argument.

Re:What is strengthening Java according to TFA?

[modmans2ndcoming]

VS is many times better than Eclipse as far as usability goes. I hate debugging programs with eclipse, inspecting objects is a pain, diving down into all the execution layers sucks. Eclipse may be flexible, but there are some serious usability issues they have to deal with. (I do like Junit and Emma though)

Re:What is strengthening Java according to TFA?

[deadkennedy]

I think Python is indeed much more popular on Linux desktop distros. From a deployment standpoint, as opposed to comparing the languages themselves, which is easier to do on a large scale?

Re:What is strengthening Java according to TFA?

[rednip]

It isn't helpful that TFA is wrong on at least one point. It said that Eclipse 3.1 lacks code completion, refactoring, and debugging features.

Also, Eclipse is at 3.5 (3.2 debutted a couple of years ago), and I've used all of those features since 2.[something]. This was only on Windows, but I think that the only thing that is different are the interface drivers, not any of the functionality, so it would be hard for me to understand why he would have had the experience that he claims to have had.

Mono is spreading on desktop Linux machines?

[ChoboMog]

But...but...but we never get viruses. =P

Re:Good

[Anonymous Coward]

Of course not. Java hasn't improved over time. It is exactly the way it was in version 1. All you can build with it is very slow animated buttons and stuff for web pages.

Are you kidding me? Comparing Java 1 with .NET (which is a copy of Java 1.4 without maintaining backwards compatibility)?

I don't think there ever were any

[itomato]

This is like saying touch-enabled applications have made great gains in iPhone application share.

Or that there are more MFC apps than Java equivalents for Windows productivity.

Heh? Someone bought tickets to the spin train.

Re:Good

[turgid]

A lot has changed in the last 10 years. Your comment is very telling, and not very helpful. It's so bad, it's not even wrong. I'm sorry that's what you think.

With .NET, there is loads of stuff built in so I am not doing a lot of low level coding.

There are orders of magnitude more stuff "built-in" to Java (the platform), 3rd-party stuff, independent implementations, and it's had a good decade and a half of hardening in real-world situations (top businesses etc.)

gcc even has a java (the language) compiler now (OK for about 5 years) that generates native machine code (what everyone used to whinge about) and there are independent implementations of the Java libraries (e.g. GNU Classpath).

Mono needs to die a death. Please ignore it and hopefully it will go away.

Re:Eclipse is stagnating

[Anonymous Coward]

The difference between Eclipse 3.4 and 3.2 is night and day when you actually use it.

Just because it looks the same (a shock to people who might want to change their hentai GTK theme every week) doesn't mean it is the same.

It's like those idiots that uses Java 1.1 in 1998 and think that Java 6 is pretty much the same.

No mention of X-platform

[Twillerror]

Cross platform is a huge reason why I've been loving Mono.

I've used java for years because it took common programming tasks and made them not only cross platform, but some what standard. .NET/Mono borrowed from that.

Think of network sockets, file access, threads, and a bunch of other things that quite frankly are annoying to do in C or C++. Even worse they are way different on Windows and Linux and so you end up writing big chunks of code twice...for really no reason. Apache portable runtime hopes to do it for C++ apps...but it's quite frankly a pain.

Bottom line if you want to write a GUI based type app Mono is better than Java Swing and better than playing around with C++ and GTK+...unless you need something to the scale of Firefox or openOffice. Even then I think Mono could scale.

The Java VM was a good idea, but Sun never bothered to port other languages to it. With Mono you get a choice of languages, a common library, and apps that really can run anywhere without a whole lot of extra work.

Re:No mention of X-platform

[Jugalator]

Keeping themselves on the Swing train instead of evolving things like SWT was among Sun's greatest mistakes IMHO. :(

It looks horrible on all platforms, because it needs to work on all platforms without using native controls.

Sure, it's *hard* to make native controls work out well in cross-platform apps, but with enough thought put into it, it can be done pretty well after all. Qt is quite successful, for example. There have been apps I've thought was native using Win32 or GTK, when they were built on Qt. And then I'm a nitpicking guy that often notice when the pixels are off. Running Swing is like watching a puke dry in comparison. For no special reason, because it's shown that native-like controls can be done quite successfully.

Re:No mention of X-platform

[Anonymous Coward]

My biggest reason for C#/.Net instead of Java?
Visual Studio

Re:No mention of X-platform

[DragonWriter]

The Java VM was a good idea, but Sun never bothered to port other languages to it.

Well, except that in reality there are lots of implementations of non-Java languages for the JVM, several of which (Jython and JRuby, among others) have Sun resources behind them, and some of which are even Sun created (Fortress, JavaFX Script.) There were non-Java languages for the JVM before .NET existed.

Re:No mention of X-platform

[WeirdJohn]

The Java VM was a good idea, but Sun never bothered to port other languages to it. With Mono you get a choice of languages, a common library, and apps that really can run anywhere without a whole lot of extra work.

You mean copying the Smalltalk VM was a good idea. And there are many dynamic languages that run on the JavaVM now.

Re:No mention of X-platform

[pherthyl]

>> Think of network sockets, file access, threads, and a bunch of other things that quite frankly are annoying to do in C or C++.

You're just using the wrong C++ libraries.
Using Qt I can do all the things you mentioned and just about everything else in the C# and Java class libraries. Cross platform, without the performance and resource penalty of a virtual machine. Also the final product will appear more native on more platforms than C# or Java.

Also because of Qt's design, I barely have to bother with memory management in my GUI apps. So far I'm averaging one delete statement per 1000 lines of code. Everything else is cleaned up automatically. If I thought a bit harder about my design I could probably get rid of most of those deletes as well.

Re:No mention of X-platform

[rdean400]

You might want to research before posting next time. There are more JVM-based languages than there are CLR-based languages.

Re:No mention of X-platform

[SpinyNorman]

Think of network sockets, file access, threads, and a bunch of other things that quite frankly are annoying to do in C or C++.

Not if you use Qt which has all of those and more in addition to the GUI stuff.

Qt is a cross-platform library, not just a GUI library.

Qt-based apps run on Linux, Windows, Mac, Solaris, Symbian S60 ...

What are you using for the GUI in Mono? Windows Forms? You could have the full power of Qt via Qyoto...

Re:No mention of X-platform

[swilver]

If your idea of Cross Platform is API's designed for Windows with all other platforms being an afterthought...

Re:No mention of X-platform

[ADRA]

Swing used the abstraction from the OS -because- of the inter-OS incompatibility between widgets. AWT uses native OS widgets throughout if that's your bread and butter. They subsequently added OS theme engines back into Swing due to the inconsistencies between everything. I don't have a problem with swing as it is at this point. Since 1.5's metal, the platform agnostic look and feels have really come upon their own. SWT has a few bases filled in by containing a larger set of widgets, and arguably better set of API's for some of them. I'd consider myself a java guru, and I still run into roadblocks extending existing swing components to add some new crazy behaviour. I can't even say if that's possible in other toolkits, but its not trivial in Swing.

Re:No mention of X-platform

[koutbo6]

I think its going to be interesting over the long run to see which platform gains the upper hand.
I would put my money on java since its open. I know mono is too, but it only follows microsoft's lead,

Re:No mention of X-platform

[EvilRyry]

Have you actually used Qyoto? It's not very pleasant. At all.

Connect(m_ui.messageLineEdit, SIGNAL("textChanged(QString)"), this, SLOT("TextChangedSlot(QString)"));
Connect(m_ui.sendButton, SIGNAL("clicked(bool)"), this, SLOT("SendClickedSlot()"));
Connect(m_ui.actionChangeNickname, SIGNAL("triggered(bool)"), this, SLOT("ChangeNickname()"));
Connect(m_ui.actionAboutQt, SIGNAL("triggered(bool)"), this, SLOT("AboutQt()"));
Connect(qApp, SIGNAL("lastWindowClosed()"), this, SLOT("Exiting()"));

Magic strings galore. It's completely out of place in CLI land.

Re:No mention of X-platform

[shutdown -p now]

The problem with Swing is that the "native look and feel" it offers is still crappy. Its non-native file/open save dialogs are missing a lot of features, its text boxes miss a lot of advanced stuff in the context menu (try opening one on a native Win32 textbox and have a look at what is there to see what I mean), and it's font anti-aliasing doesn't use UniScribe and/or ClearType, and therefore looks noticeably different than native Windows applications - and generally more blurry or otherwise crappy.

Re:No mention of X-platform

[SpinyNorman]

That does look ugly, but is it that just for making signal/slot connections, or do stringified method names get used elsewhere in Qyoto too?

I've got to say that, even as a Qt fan, moc and the signal/slot implementation in Qt don't feel so great in C++ either. I wish they'd deprecate it in favor of a pure C++ alternative (like Boost Signals, for example). Presumably there are better ways of implementing something similar in C# too.

Re:No mention of X-platform

[brantondaveperson]

Use boost as well as Qt and you'll never see another delete statement again.

Re:No mention of X-platform

[ClosedSource]

I think if cross-platform is the goal, the JVM is the best VM for languages to compile down to. On the other hand, the JVM wasn't designed with the idea of supporting other languages, so it has some weaknesses there.

The .Net CLR was designed from the start to support multiple languages, so it's stronger at it than the JVM. There's nothing that prevents it from being cross-platform except licensing issues.

All this could change: Java could abandon the principle of a backward compatible JVM and thus improve it's multiple-language support and MS could fully open up .Net so that it would compete better against Java on the cross-platform issue.

Re:No mention of X-platform

[miguel]

Both the JVM and the CIL engines can be used to run any programming language you want. They are both turing complete systems, so there is not really anything that will prevent you from targeting any language to run on top of either one of them.

The difference is that the JVM was designed for Java, and Java only.

The CLI originally ran a variation of C++ (they internally called it SMC, or "Smack") and later they created C# and retargeted VB to run on top of it.

But even before this went public, they launched an effort called "Project 7". The goal of this group was to port 7 proprietary languages and 7 research/open source languages to the CIL engine and learn from the exercise what changes were required to make the implementation more efficient. A large number of changes went directly into .NET 1.0, and they allowed the CIL to be a more efficient runtime for running C, C++, Eiffel, Fortran and Cobol than the JVM could. Direct memory manipulation, arbitrary vtable layouts, tail call optimizations all went into .NET 1.0

With .NET 2.0 a new round of languages was tried. The research on ILX and OCaml (mostly using F#) was introduced into the virtual machine, making generic types first-class citizens in the VM, not just entities that were emulated (as they remain to this day in Java). The feedback from Eiffel lead to the introduction of covariance and contravariance in the virtual machine, another feature missing from Java.

The work from Jim Hugunning on IronPython also drove the adoption of new low-level APIs that assisted the runtime in better supporting dynamic languages, all of these features appeared in .NET 2.0 and 3.5.

So certainly, you can target anything into anything else, at the end of the day, everything is running on top of some CPU. The difference is that with .NET you have to jump through less hoops, and the runtime is richer for language developers.

So in Java you can certainly emulate pointers and malloc for building a C compiler. The emulation will tkae the form of "Allocate big array, and emulate pointer operations there". Possible, but not very efficient.

Generics is another area that helped languages like C# get generics that actually make sense, and do not require a PhD to understand. This is an important difference: in Java generics are emulated, in C# they are native to the environment.

That being said, if you like Java, by all means, keep using Java.

Re:No mention of X-platform

[IBBoard]

Strangely, I do Java work as my day job in Eclipse and C# in my spare time using Visual Studio (2005 Express) and MonoDevelop. While I prefer C# as a language overall, I'd much rather have something like Eclipse for C#! There's so much more power to it in terms of refactoring and other features that it puts the minimal functionality that Visual Studio always had to shame.

Re:No mention of X-platform

[IBBoard]

Really? Are you sure? The Wikipedia pages give a different impression.

Re:No mention of X-platform

[mythz]

My biggest reason for C#/.Net instead of Java? Visual Studio

+ ReSharper.

Re:No mention of X-platform

[fredrik70]

not rto be forgotten in the language department:Scala and Groovy

Re:No mention of X-platform

[Alex Belits]

I guess if I was forced to use crappy buggy tools in Linux I would think that too. Thank god for the MS monopoly ! Your opinion is worthless, I have a hotter girlfriend, a bigger cock and more money than you. Reminds me, time for my evening romp with some female swimsuit models..

Translation: "I am Anonymous Coward, so I can make shit up and argue with people who actually accomplished something".

Re:No mention of X-platform

[ardor]

Moc is a comparably small price to pay for the excellent and powerful API. Typically, the connect() lines sum to up to 1% of the code. Once the build system is set up properly, moc is no longer a concern either. Also consider that Moc signals/slots allow for introspection and adjustable behavior (direct emitting, delayed emitting etc.), which is especially useful for thread-safety and cases where the emitting widget ultimately ends up deleting itself.

Re:No mention of X-platform

[ardor]

I put my money on C#/Mono, since it is technically the better platform with MS behind it.

Re:No mention of X-platform

[IBBoard]

Pay for a copy for my personal use and I'll compare the professional version ;)

I've used the full version of 2003 because we got it free through University for non-commercial use and it was terrible. 2005 Express is a definite improvement, but I'd still rather have the power of something equivalent to Eclipse, if only it wasn't written in Java for doing C# work.

Re:No mention of X-platform

[dna_(c)(tm)(r)]

Generics is another area that helped languages like C# get generics that actually make sense, and do not require a PhD to understand. This is an important difference: in Java generics are emulated, in C# they are native to the environment

When emulated means "checked at compile time". So, in that sense, C is a simulated language?

Sorry, but there are some philosophical choices being made in both cases. In the Java case, they went for the type erasure style. That's fine with me, but if you really need runtime type information, pass the class literal as a parameter:

public T doIt(Class type){ T t = type.cast(object); ... }

and then

String s = instance.doIt(String.class);

Re:No mention of X-platform

[Adam Jorgensen]

Not just many languages, many GOOD languages :-)

Re:No mention of X-platform

[dkf]

Moc is a comparably small price to pay for the excellent and powerful API. [...] Also consider that Moc signals/slots allow for introspection and adjustable behavior [...]

So... they've reinvented Objective-C?

Re:No mention of X-platform

[remmelt]

Jetbrain IntelliJ IDEA. Once I learned the shortcuts, it's the best IDE I've ever worked with. Integrates nicely with all kinds of Java framework stuff, like Maven, Struts, Spring, Hibernate, etc. Highly recommended.
Does javascript, html, all kinds of other stuff. Refactoring is a breeze, most stuff works with shortcuts or intellisense like behaviour, where IntelliJ suggests adding methods, parameters, getters/setters, pulling up of members, stuff like that. Loads of plugins. Integrates very nicely with SVN.
Runs on OSX, Linux and Windows. It's a native Java app, but quick, with decent memory management and no crashes (running on OSX here). Personal license is nice too, install anywhere, and you're allowed to have one copy open at a time. This has helped me out when programming on-site at a client's office.

Re:No mention of X-platform

[quadrox]

"your retarded opinions are quite easy to ignore..."

Which you showed brilliantly by replying with your aggressive post. Yeah it didn't bother you the slightest...

Re:No mention of X-platform

[quadrox]

Do you know whether there is a decent tutorial for IntelliJ? The JetBrains guys seem pretty clever, but I tried IntelliJ like a year ago and it was a horrible experience.

I have a long time experience with Visual Studio which I think is simple and intuitive to use. I would like to get away from MS though if I can.

Re:No mention of X-platform

[eric-x]

try intelliJ

Re:No mention of X-platform

[LizardKing]

The Java VM was a good idea, but Sun never bothered to port other languages to it.

What, languages like Groovy, Scala and Python? Sun may not have ported all the languages that run on the JVM, but there are plenty of them.

Re:No mention of X-platform

[mcvos]

The Java VM was a good idea, but Sun never bothered to port other languages to it.

You're kidding, right? The JVM is one of the most important platforms right now. Lots of languages have been ported to it (JRuby is one of the fastest Ruby implementations at the moment), and it's also had newer languages specially designed for it. Look up Scala if you ever feel it's time to catch up with modern technology again.

Re:No mention of X-platform

[JAlexoi]

That was a long post that all comes down to:
CLR is a general purpose VM (Shocking, since it's name is Common Language Runtime)
JVM is a highly specialized VM
Let me guess, you must be either a consultant or an "architect".

Re:No mention of X-platform

[modmans2ndcoming]

Pay attention to the next MS release event (probably windows 7) you will be able to pick up a copy of VS 2008 (Probably also a preview copy of vs 2010) for free.

Re:No mention of X-platform

[modmans2ndcoming]

uhh... Try that again because you are wrong.

Re:No mention of X-platform

[mR.bRiGhTsId3]

You do realize that connect takes a const char * for its signal and slot parameters right? The C++ macros just hide the stringified names. I guess there wasn't a clever way of doing that in C#.

Re:No mention of X-platform

[SpinyNorman]

I guess you could call him an architect - that's Miguel de Icaza you just tried to insult.

Re:No mention of X-platform

[Late Adopter]

Ack! No! If you're writing C++ you don't want to use deletes (as counterintuitive as that sounds). Exceptions could cause breaks in code blocks before deletes (not to mention outright bugs like forgetting deletes, or having an if() {return;} before a delete), leaving allocated memory hanging around. The best way to do it is to embrace RAII and encapsulate pointers in objects like auto_ptr, so that regardless of how your object goes out of scope, it's properly destroyed and memory is reclaimed.

Re:No mention of X-platform

[bonefry]

Also because of Qt's design, I barely have to bother with memory management in my GUI apps. So far I'm averaging one delete statement per 1000 lines of code.

Yeah, but you have to miss just one of those deletes, and boom, you've got yourself a memory leak.

Using Qt I can do all the things you mentioned and just about everything else in the C# and Java class libraries.

Not everything is in Qt. And when you'll want to import other libraries in your code, then you've got yourself a shiny new string library to convert back and forth to QString, and a shiny new hashmap that you'll convert back and fort to QDict.

Re:No mention of X-platform

[miguel]

Right, "Type Erasure" means that none of the semantic information is preserved in the produced bytecode or metadata.

This has several problems, for example, the following is invalid in Java:

class Stack {
        T [] storage;

        Init ()
        {
              storage = new T [20];
        }
}

You might want to read "Generic Gotchas" for Java. There is no such problem with the C# version as they are first class citizens:

http://www.ibm.com/developerworks/java/library/j-jtp01255.html

The implementation is so arcane that it requires documents like this encyclopedic FAQ:

http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html

Or even Sun's Ken Arnold stating that "Generics are a mistake":

http://weblogs.java.net/blog/arnold/archive/2005/06/generics_consid_1.html

None of this problems happen in C# and .NET.

Re:No mention of X-platform

[ClosedSource]

There's a reason why the Java Virtual Machine starts with the word "Java". The JVM can run other languages, but that's not the same as being designed to support it. If you look at Sun's initiatives over the years, it's been all about Java, not about supporting multiple languages. It's only in the last few years after seeing that Java wasn't going to take over the world that Sun has adopted this plan B.

As for C/C++ running on the JVM, I wasn't even thinking about that. The limitations of the JVM affect all languages that want to run on it. There's no advantage in having C/C++ run on the JVM - it would just limit C/C++'s portability.

As far as legacy support and the ability to call C/C++ code is concerned, Java has it's own "unsafe" mode called the JNI. In fact you can even call assembly language using the JNI.

Re:No mention of X-platform

[SpinyNorman]

I've seen the connect() declarations, but never really wanted to look at all the Q_OBJECT related macros. It works...

It is possible to use a 3rd party signal/slot libary, like Boost Signals, with Qt, but there's not much benefit in terms of prettyness since it still requires Q_SIGNAL/SLOT/EMIT preprocessor pseudo-keywords. I'm not sure what it'd take to ditch the entire Q_OBJECT meta-object approach... designer obviously needs some form of inspection and property support.

Still, given the enormous benefits, functionality and pleasure of use of Qt, this is really a minor gripe.

Re:No mention of X-platform

[Mongoose Disciple]

Sorry, no.

I've written code in Emacs in the past and probably if the occasion calls for it I will again, but that doesn't mean I don't want to use a good IDE when I can. I also use a hammer to pound nails in when I'm working on a home improvement project even though I've discovered that, in a pinch, I can pound them in with a shoe.

Writing code with simpler tools that require either more time or more esoteric knowledge to do the same job does not make your coding penis bigger.

Re:No mention of X-platform

[dna_(c)(tm)(r)]

"Right, "Type Erasure" means that none of the semantic information is preserved in the produced bytecode or metadata."
I understand, and I can live with that.
It is not is if you can not do something, it just requires a more verbose approach e.g.

class Stack {
                private T[] storage;

                public Stack(Class type, int size) {
                        storage = (T[]) Array.newInstance(type, size);
                }
        }

But if it was just making an object do something instead writing libraries, why not simply:

class Stack2 {
                private List storage;

                public void init() {
                        storage = new ArrayList();
                }
        }

I've given lots of programming courses, and sometimes all this syntactic sugar is nice but when learning a language, these constructs can make it very difficult see the overall picture. I find that Java has a very clean set of language features that can be taught/learned easily.

I understand that you are a very gifted, above average intelligent programmer. But the average programmer is, by definition, well, average.

Well, there aren't that many people that start things like Gnome (my current desktop of choice -thank you) and Mono and can make such things work.

Re:No mention of X-platform

[Slime-dogg]

FWIW, the CLR only has to process .NET bytecode once before it's converted to native code. The argument about VMs killing performance is pretty bunk.

Re:No mention of X-platform

[A.K.A_Magnet]

Being myself a Scala fan, I agree with you that it is painful that Sun did not make the JVM with language agnosticism in mind, and that is the main superiority of .NET over the Java platform (the very fact that the best I can call it is "the Java platform", while .NET is not called the "C# platform", is a good hint).

Concerning type erasure, as it has been pointed out by my sibling-thread, it's a design choice. Scala also has adopted type erasure with generics. The other choice could have been made, that is encode type annotations for generics in the bytecode. There is nothing in the JVM preventing it to be done, since it can be done manually, the [alternative language] compiler can add the required info. In Scala, the choice has been made to mimics Java (and I guess, the more the generated code will look like Java, the more we will benefit from runtime optimizations). Thanks to Scala's very powerful syntax, there is a library called Manifest that automatically adds the type information and easily allows you to code as if there were no type erasure.

Still, I agree this feels like a weird rule, especially the first time you run into it. It is not the expected uniform behavior. The same goes will tail-call optimization that should be in the JVM (and should be in OpenJDK7), closures, etc. Generally speaking, the JVM should be a generic platform for languages exactly like the .NET framework is.

But I am one of those guys who wouldn't run Scala on .NET, the general anti-NET guy (not anti-Mono). Even if some legal doubt surrounding free .NET implementations remain (even with the recent community promise, but there's always a legal risk with any software you use anyway), this is purely an emotional and political decision. It's fashionable to call my kind "freetards" :). Yet, I've been using and enjoying free software for a long time now, and I remember your stories (notably how you were interviewed by Microsoft and told them you would join them if they changed their business model and developed free software) so I feel you're not the last to take emotional and political decisions. Please note that I appreciate the existence of a Free .NET runtime.

You have done an impressive work with Mono. Don't you think the same effort could have been to make the [renamed] Java platform as generic and powerful at the .NET environment? Sure, there is a lot of inertia with Sun, but if someone could have achieved it, that would have been you. At the end of the day, you are still bound by Microsoft standards, are they so much better than Sun's that it justified starting a free .NET implementation from scratch (granted, neither HotSpot nor the JDK were free at the time, but there were already free partial implementations) ? I have read your reasoning at the time of creation of Mono. Of course, after all this work it is late to have second thoughts and regrets, but in retrospective, was it such a good idea?

We both know the linked article is a joke and Mono doesn't seem to be gaining any real share. Sure, C# and .NET are strong, but from what I see here Mono is only marginally used even for server-side solutions, and there is a lot of rejection on the desktop from the free software community (which I agree with, even if I have had F-Spot and Tomboy, I do think running Mono for two apps is excessive).

At the end of the day, I just regret the Mono vs Java situation created yet another division in the community. Of course, and I thank you for it, you are very much responsible for OpenJDK becoming free. And I agree that Sun's strategy regarding both licensing, evolution and genericity of the Java platform has been awful. Yet, right now, between the two, most free software enthusiasts would choose Java. There is no way to rewrite the past, but maybe there could be a way for a better outcome.

Re:No mention of X-platform

[VGPowerlord]

I suggest you look at System.IO.FileAttributes enumeration before you tell someone else that .NET's APIs aren't designed for Windows first. This enumeration contains values not only specific to Windows, but specific to NTFS.

I'm sure there are lots of other Windows specifics as well... places like System.Security.Policy would be a likely place to start...

Re:No mention of X-platform

[Alex Belits]

No, all it requires is understanding of the code that you are writing -- if you need crutches because you can't keep in your mind the structure of your own code, then what else slipped out of it?

For the same reason Hungarian notation is bad -- if you need to be reminded of the type of a variable, you must have already forgot its role and purpose in your project.

Re:No mention of X-platform

[True Grit]

it still requires Q_SIGNAL/SLOT/EMIT preprocessor pseudo-keywords

That's still a heck of a lot better than what (now-defunct) Borland did back in the good 'ole days of proprietary compilers, they added custom keywords right into the C++ language, not as macros, but hardwired into their compilers...

I think its fair to point out to anyone else that might not know, 'moc' is basically just a "boilerplate C++ code generator", its output is 100% standard C++. Its just doing boring mechanical work so you don't have to. When Trolltech took this approach, this was waaaay back when a typical "C++ compiler" would choke and die a horrible death if it was feed anything like, say, today's Boost source code. All you needed to get a segfault or ICE from your compiler back then was 3 magic words: "partial template specialization". Most compilers would faint dead away upon hearing that...

There *was* no "C++ standard" back then, especially when it came to templates and meta-programming which is the only (AFAIK) way to implement a callback mechanism directly within the confines of the C++ language itself. When the Trolls needed this functionally, there just wasn't any other way to do it in a *cross-platform*, *multi-compiler* manner. When you think about it, it is kinda amazing they managed to pull it off, as they were *essentially* using the **dumbest** platform and the **dumbest** compiler of the time as *their* "standard"! What they did was at least a heck of a lot better than going the Borland route of just saying "to hell with standards, lets go with lock-in!". :)

The only "practical & significant" (obviously IMHO of course!) issue remaining was the namespace pollution issue created by a lot of Qt globals and macros and such. Remember, Qt was started *before* we even had a standard, cross-compiler 'namespace {}' thingie! That has been cleared up now. Besides corralling all of their stuff into its own namespaces, there is now an option to disable the old "signals/slots/emit" macros and replace them with the more appropriate "Q_SIGNALS/Q_SLOTS/Q_EMIT" names, so you can now actually use Boost.signals(2) with Qt if you wanted to.

As for your earlier comment about ugly error messages, what immediately came to my mind was the usual C++ error messages you get when a deeply nested template instantiation goes horribly, *horribly* sideways. Compared to that, those Qyoto error messages look positively tame to me, never mind also looking a little underfed...

Oh please, *please* Santa, bring me C++0x & Concepts for Christmas, if not this coming Christmas then at least one thats within my productive lifetime, pretty please?

Re:No mention of X-platform

[True Grit]

Yeah, but you have to miss just one of those deletes, and boom

For deletes that you can't put in the obvious "proper" RAII place (class destructor), you now just wrap in a tr1/C++0x::shared_ptr and stop worrying...

Not everything is in Qt

Damn close though: Networking (http, ftp, sockets, ssl, etc), SQL, XML, WebKit, OpenGL, SVG, Multimedia... never mind whats in qt-core & qt-gui... have you browsed the Qt 4.5 docs lately?

import other libraries ... string ... hashmap

Just out of curiosity what libraries would these be?

Re:No mention of X-platform

[True Grit]

I put my money on C#/Mono, since it is technically the better platform with MS behind it

Funny how people think, that last bit is precisely why I *wouldn't* put my money on .NET.

Bottom line from reading posts here seems to be this: if you only care about Windows, then .NET rules and the answer is obvious, but if you are on, or are interested in, any other platform, then .NET is irrelevant, thus making the answer equally obvious... but different. :)

Re:No mention of X-platform

[True Grit]

the CLR only has to process .NET bytecode once before it's converted to native code. The argument about VMs killing performance is pretty bunk.

JIT'ing is a one night stand, its the garbage collection that will haunt you for the rest of your program's life...

Re:No mention of X-platform

[True Grit]

if you need to be reminded of the type of a variable, you must have already forgot its role and purpose in your project.

*blink*

.."your" project...

You know, some people actually work on projects that are so big & complex, they require more than one programmer, yea, really, its true!, projects that have too many modules & source files to keep track of, never mind variables... I believe its called the 'real world'. Look it up.

Re:No mention of X-platform

[ardor]

I mentioned MS because of its 800lbs gorilla status. This gives C# a competitive edge over other languages with much less influential and powerful backers.

There are several other languages which are more powerful and interesting than Java or C#, but technology can get you only so far; at some point, marketing has to take over.

Re:No mention of X-platform

[Mongoose Disciple]

I take it you've never worked on a project with millions of lines of code that you didn't write?

Because those kinds of things have been a lot of my career.

Re:No mention of X-platform

[SpinyNorman]

Fundamentally I agree - the Trolls needed to work with what was commonly available at the time Qt was designed.

However, you can do loosely coupled member callbacks in C++ without using anything too sophisticated. All you need is basic template support and member function pointers. The code below compiles and works with gcc 3.4.5 (i.e. a fairly old one).

#include <stdio.h>
 
// Define Signal class, emitting virtual CallBack class callbacks
 
template <typename Param>
class CallBack {
public:
  virtual void operator()(const Param &p) const {}
};
 
template <typename Param>
class Signal {
private:
  const CallBack<Param> *callBack; // Or a list of callbacks, if you want
public:
  Signal() : callBack(NULL) {}
  void setCallBack(const CallBack<Param> &cb) {callBack = &cb;}
  void emit(Param p) {(*callBack)(p);}
};
 
// Now sublcass CallBack to allow use of class member functions
 
template <class Object, typename Param>
class MemberCallBack : public CallBack<Param> {
public:
  typedef void (Object::*MemberFuncPtr)(const Param &p);
private:
  const Object *object;
  const MemberFuncPtr memberFuncPtr;
public:
  MemberCallBack(const Object *o, MemberFuncPtr mfp) : object(o), memberFuncPtr(mfp) {}
  void operator()(const Param &p) const {((*((Object *) object)).*memberFuncPtr)(p);}
};
 
// Example usage
 
class Producer {
public:
  Signal<int> sig;
};
 
class Consumer {
public:
  void slot(const int &i) {printf("%i\n", i);}
};
 
int main(int argc, char **argv)
{
  Producer p;
  Consumer c;
 
  p.sig.setCallBack(MemberCallBack<Consumer, int>(&c, &Consumer::slot));
  p.sig.emit(42);
}

If you don't like the appearance of that setCallBack() call, you could always define a template function that would return this MemberCallBack constructor for you, and thereby let the compiler deducde the template parameter types for you.

Nowdays you could use the new C++ function objects (tr:func), which will be part of the C++00x standard.

Re:No mention of X-platform

[Alex Belits]

It doesn't matter who wrote what -- you still have to understand all code up to some clean and documented interfaces to everything you don't know (and then you have to understand those interfaces). IDE will not help you with that.

Re:No mention of X-platform

[Alex Belits]

I take it you've never worked on a project with millions of lines of code that you didn't write?

Most of the projects I worked on, were like this. See my response above.

Re:No mention of X-platform

[True Grit]

This gives C# a competitive edge over other languages with much less influential and powerful backers.

C# isn't the important part, its the integration into .NET and Windows which makes it useful/compelling, which of course is what MS is pushing hard. The issue with Mono isn't C#/CLR, its Winforms, ASP, ADO, all that proprietary glue code that makes it valuable to a Windows-centric developer. However, that stuff is toxic on a non-Windows system. So again, this is only meaningful if Windows is all that you care about. That was my point.

at some point, marketing has to take over.

At which point the users usually get owned. No thanks.

Re:No mention of X-platform

[True Grit]

However, you can do loosely coupled member callbacks

I'm not an expert on template programming (primarily I'm a *user* of them, not a creator), but first of all, off the top of my head, that 'typename' keyword you use in your example is itself a "fairly recent" addition to the C++ Standard, whereas the Qt library on the other hand was born in 1991. One of the problems they faced was that even basic template support was not "commonly available" back then.

Sometimes I think people don't realize that for a long time C++ was defined by its only implementation, which was just a front-end to the C compiler (AT&T's CFront - can't remember the exact name), but in effect, C++ then was just a "smarter" C compiler, not at all like a "Standard C++" conforming compiler is today. The difference is as night and day.

Also, I don't believe your example really qualifies as "loosely coupled":

p.sig.setCallBack(MemberCallBack<Consumer, int>(&c, &Consumer::slot));

You're passing a reference to c to the callback mechanism that is called from p, so in this case the producer of your signal has to know who its consumer is. However, Qt's signals/slots mechanism allows the producers and consumers to know nothing about one another, while simultaneously being type-safe, which is what makes it so powerful, with the drawback being that it is not *quite* as efficient as the callback method, but in real-world Qt usage this difference is negligible.

Now, to be fair, its the fact that their library is a hierarchy based on a common "smart" object, the underlying (but non-graphical) "QObject", combined with 'moc', which implements their meta-object system, that is what makes their signals/slots thing possible to begin with, thus producers and consumers of signals must inherit from QObject - not an issue for Qt as virtually everything in it does so anyway. It was exactly for this signals/slots mechanism that they made moc in the first place.

So to do what they're doing in "straight Standard C++" will require more boilerplate code than anyone could do in a simple example. Boost.signals2 is doing most/all of what they are in signals/slots, and it is also not at all what you would call "a trivial implementation". :)

Re:No mention of X-platform

[makomk]

Nope, he's right. .Net is tied to the Windows API to the point that Mono has a special layer emulating its behaviour:

The ECMA runtime and the .NET runtime assume an IO model and a threading model that is very similar to the Win32 API.

Dick Porter has developed WAPI: the Mono abstraction layer that allows our runtime to execute code that depend on this behaviour, this is called the `io-layer' in the Mono source code distribution.

Re:No mention of X-platform

[SpinyNorman]

that 'typename' keyword you use in your example is itself a "fairly recent" addition to the C++ Standard,

There are two totally unrelated usages of the "typename" keyword. In this usage it's 100% synonymous with "class". I just used it for clarity - I don't like calling things "class" unless they are classes.

In other words - just substitute the old "class" for "typename" and it will work the same.

Also, I don't believe your example really qualifies as "loosely coupled":

Huh? The connection is made entirely external to, without modifying and without the knowledge of producer or consumer! How could it possibly be any more loosely coupled? You obviously don't understand what the term means.

Re:No mention of X-platform

[True Grit]

I just used it for clarity - I don't like calling things "class" unless they are classes.

I understand that and know why you did it, just trying to point out the kind of problems TT had when they started: a lot of what we take for granted now didn't exist back then.

Huh? The connection is made entirely external to, without modifying and without the knowledge of producer or consumer!

How can the "consumer" establish the callback:

p.sig.setCallBack(MemberCallBack<Consumer, int>(&c, &Consumer::slot));

without access to the producer, the 'p.sig.' part?

Both Qt and Boost.signals2 have their 'connect' (your 'setCallBack') and 'emit' mechanisms as standalone operations(*). You made 'sig', your callback mechanism, part of, e.g. owned by, the producer. Your 'sig' needs to be separate, so the consumer can set the callback without needing to know who the producer is.

Your example is a valid example of a callback mechanism, just not, it looks to me, a "loosely coupled" one, and with Qt and Boost.signals2, the producer and consumer aren't coupled at all.

(*) Although technically, Qt implements part of it in QObject, which both producers and consumers must inherit from, with the rest of the magic provided by moc.

Re:No mention of X-platform

[modmans2ndcoming]

sounds like a translation layer rather than an emulation layer.

Re:No mention of X-platform

[SpinyNorman]

No, all Qt does is put a string lookup table inbetween producer and consumer. You could modify the example I gave to do the same if you want to (without modifying either Producer or Signal) just by creating an appropriate CallBack subclass, similiar to the method delegate one I demonstrated.

Making a connection in Qt takes the form: connect(producer, signal, consumer, slot), and it goes without saying that making a connection between two things is always going to require specifying what those two things are!

You apparently not only don't know templates, but you can't even read basic C++ code. The Producer class knows **zero** about what, if anything, is going to connect to it, or how they are going to do it. All it knows is that to emit a signal it calls Signal.emit(). The Signal class also knows **zero** about what and how anyone is going to connect to it - only that they will do so by providing a CallBack subclass that somehow does it. It has no way to know that we're going to pass a member delegate (as I demonstrated), or hook it into a lookup table at Qt does, or maybe send a TCP message across the world to a receiver object.

Too bad that as a beginner you arn't better aware of what you know and don't know. I've been programming professionally for almost 30 years. Being using C++ for the last 10 years. I do, unlike you, actually know this stuff.

Re:No mention of X-platform

[True Grit]

Qt takes the form: connect(producer, signal, consumer, slot), and it goes without saying that making a connection between two things is always going to require specifying what those two things are!

producer & consumer are 'const QObject*', so no, the consumer doesn't need to know *exactly* what the producer is, as long as its derived from QObject (which it must be in Qt). All Qt's connect needs is a *pointer*. The signal and slots are wrapped by macros, so moc will take care of them, without the consumer and producer needing to know the details of each other (except for the *names* of the signals and slots of course).

'p.sig.setCallBack()' is a method call *into* the producer, but connect(ptr,SIG(sig),ptr,SLOT(slot)) is a method call provided by the consumer's QObject base class, the equivalent of 'this->connect(...)'. Can't you recognize the difference between 'p.sig.X()' and 'this->X()'???

For the consumer to be able to call 'p.sig.X', you'll have to give it the producer's class definition so it knows about 'sig'. Put your Consumer and Producer in separate files and see what kind of #includes you'll end up needing to make it work.

Anyway, agree or not (let me guess, you don't), the appearance of insults means I'm done here. Flame away.

Re:No mention of X-platform

[kaffiene]

I prefer Netbeans personally... and I've been a VS user for over a decade.

Re:No mention of X-platform

[SpinyNorman]

For the consumer to be able to call 'p.sig.X', you'll have to give it the producer's class definition so it knows about 'sig'. Put your Consumer and Producer in separate files and see what kind of #includes you'll end up needing to make it work.

Yeah, to use QButton I'd have to #include qbutton.h in myWidget.cpp ...

If you want to salvage anything out of this, I suggest you go read up on C# delegates, and then ponder if Qt's signal/slot mechanism would be needed if C++ had such a mechanism when Qt was designed (it still doesn't), then come back and reread this thread. Rename MemberCallBack as DelegateCallBack if it helps...

Re:No mention of X-platform

[Mongoose Disciple]

I guess we'll have to agree to disagree. I think a good IDE is [b]immensely[/b] helpful with that.

Re:No mention of X-platform

[makomk]

In the same sense that Wine is a "translation layer", perhaps.

Microsoft shill

[El_Muerte_TDS]

RedMonk analyst Stephen O'Grady, the guy being quoted in the article, is a Microsoft shill. And the whole article is filled with FUD.

Re:Microsoft shill

[Anonymous Coward]

Maybe Microsoft needed someone to quote as saying "... Mono/.NET development has leapfrogged Java development on Linux, by a long shot" for yet another "Get The Facts" campaign ?

Re:Microsoft shill

[Freetardo Jones]

You mean other than the fact that he didn't denounce Microsoft, Steve Ballmer and Bill Gates as satan spawn on every line of the article?

Re:Microsoft shill

[TeXMaster]

He's probably assuming malice in TFA comparing an old version of Eclipse with the last version of MonoDevelop, and claiming Eclipse 3.1 is lacking features it actually has.

Re:Microsoft shill

[Jah-Wren Ryel]

If anyone needed any proof that Slashdot's moderation system is a failure, here it is. One of the few "+5 Informative" posts, and it's a baseless attack using the words "shill" and "FUD".

Dunno if the shill accusation is true or not, but by their own admission (bottom of the page), Microsoft is a client of Redmonk.

Re:Microsoft shill

[miguel]

Other customers of Redmonk include:

Tier 1:
IBM, Sun, Adobe, Canonical

Tier 2:
Dell, Eclipse, HP, Red Hat, Intuit, Microsoft, Nortel.

From:

http://redmonk.com/clients/

But I guess fact finding might have ruined a perfect rage moment.

Porting other langauages :

[Anonymous Coward]

  Please see this.

Yours In Parentheses,
Kilgore Trout

One sentence that summarized it all for me

[bogaboga]

...Packaging has also been a detriment to Java on Linux, said O'Grady...

To this, [Linux] zealots will defend the status quo saying choice is working for Linux as if there are no draw backs.

This same problem is being reflected on the choice of desktop environments. No wonder after a decade of "Linux on the desktop", we in the Linux world still command a very small percentage of active users of desktop Linux. Some say we are irrelevant. It's sad.

Re:One sentence that summarized it all for me

[jipn4]

To this, [Linux] zealots will defend the status quo saying choice is working for Linux as if there are no draw backs.

The problem with Java packaging on Linux has been Sun and their insane requirements, not Linux.

we in the Linux world still command a very small percentage of active users of desktop Linux

And you know this... how? As far as I can tell, there are probably as many Linux desktop users as there are OS X users. Is OS X irrelevant, too?

Re:One sentence that summarized it all for me

[at_slashdot]

Do you really think that Linux adoption has anything to do with the number of desktop environments choices? If that would be the problem I will know and tell my parents "use THIS desktop environment". Problem solved, right?

Re:One sentence that summarized it all for me

[jedidiah]

As far as the status quo goes: why would a Linux user want to bother with Windows software?

That's the thousand dollar question. Why bother with what Microsoft or even Apple has to
offer? The fact that there are two competing desktop environment is just a side show for
trolls that want to fixate on stuff that ultimately doesn't really matter.

If you want one and only one of something with no choice and no alternative if your
requirements are a little different there has always been Windows and the Mac.

Re:One sentence that summarized it all for me

[dbcad7]

Ok, I'll play Linux zealot and say that yes choice is better.. The distro I use has Java available in the package manager.. If there are distros that don't have it so easily available, at least users have the choice to use what I use... As to the desktop, pretty much all distros give you a choice of what you want to use.. Some people prefer Gnome, some prefer KDE, some prefer XFCE, there is no exclusive desktop.. so what ?.. some people prefer pictures of naked women as their wall paper, some prefer flowers.. Some people like the way programs in one language or the other runs.. others see a difference they don't like, and so choose to use something else.. Thanks to choice.

Re:One sentence that summarized it all for me

[angel'o'sphere]

The problem with Java packaging on Linux has been Sun and their insane requirements, not Linux.

All my Linux systems I ran the last years had a full fledged Sun Java distro (either included or installed later) no idea what your point is.

Linux is just an OS like Windows, Un*x, Mac OS X etc. .... Java has nothing to do with the OS as Sun, HP, IBM, Oracle and others offer Java distros for multiple OSes ...

Regarding the main article: how can a sane developer chose Mono over Java?
Answer: he can't.

People choosing Mono are Students that use .Net in university and use Mono at home on Linux.

It only shows that Linux is making ground and students use it instead of Windows.

angel'o'sphere

P.S. yes ... .Net (and Mono included) is more than 10 yeas behind state of the art. Java probably is only 3 to 5 years behind.

Re:One sentence that summarized it all for me

[xant]

> If you want one and only one of something with no choice and no alternative
> if your requirements are a little different there has always been Windows and the Mac.

Argh!! Another choice!

Take one away. How about just Windows?

Re:One sentence that summarized it all for me

[RaymondKurzweil]

we in the Linux world still command a very small percentage of active users of desktop Linux.

Whatever. I never started using Linux to try to help some "movement" or organization of yours become the next Microsoft.

Some say we are irrelevant. It's sad.

What is sad is that you think that "some" saying this is sad.

Re:One sentence that summarized it all for me

[bootup]

Mac barely exists outside of the USA and like one other country which I forget. So even though your perception is GNU/Linux desktop doesn't exist it simply isn't true. What the situation really amounts to is that it isn't visible to you with the people and places you go. You can't even use Google's statistics and expect a decent estimate. Here is why: Google dominates in the USA and Germany mostly. Everywhere else it is a lesser player in the market. As a result you are seeing GNU/Linux desktop statistics for those countries. It is no wonder nobody develops for GNU/Linux. The numbers are skewed and then "tests" end up testing the populations which use it the least. Expanding the numbers to places where companies don't operate primarily would changes things drastically. You'd see Mac market share fall and GNU/Linux rise.

Re:One sentence that summarized it all for me

[timmarhy]

mono is as much a windows piece of software as java is. that you don't grasp this concerns me.

Re:One sentence that summarized it all for me

[jipn4]

All my Linux systems I ran the last years had a full fledged Sun Java distro (either included or installed later) no idea what your point is.

The GP was complaining that Java packaging on Linux sucked. If you don't think it has ever sucked, then move right along. But Sun really has caused a lot of problems with packaging Java on Linux in the past. Now that it's GPL'ed, that's less of a problem.

P.S. yes ... .Net (and Mono included) is more than 10 yeas behind state of the art. Java probably is only 3 to 5 years behind.

Sorry, you got it backwards. Both C#/CLR and Java are pretty pedestrian platforms, but Microsoft fixed a lot of technical problems with Java when they embraced and extended it. Many of the problems Microsoft fixed with Java were problems that Sun itself had promised to fix but never delivered.

It only shows that Linux is making ground and students use it instead of Windows.

Good. That's the only way Sun got big: people got introduced to it at university and then picked it in their jobs, despite resistance. That's why Sun and Solaris got in trouble. Java is still widely used for teaching, but it's turning into the 21st century Pascal: used for teaching but loathed for real work by people who have a choice.

Re:One sentence that summarized it all for me

[molnarcs]

So it's not the hideous hw support - up until the past 1-2 years - that makes linux unsuccessful. And still today, if you have PC preinstalled with linux, you can't just pick up any ... scanner, for instance, pop in the driver cd, press next next next than have it working after a reboot.

It's not that I can't get my laptop's LCD and my Samsung LCD working in dual mode properly - and they work fine in windows.

It's not that if you want to do anything CAD you have don't have much of a choice but to run Windows.

It's not that 99% of all computers come with Windows preinstalled, and if they not there is a 99% chance that a friend, a classmate, a colleague or a family member will do it for you.

It's not that 90% percent of the population haven't even heard of linux, and when you ask them what operating system they run, they'll say Microsoft Office.

It's not that people generally prefer what they are already familiar with if it works in a reasonable way. Mind that by now, viruses and *wares became so entrenched, that most people believe that it falls within reason having to protect against them.

No, it's because we have choice. Right.

Can someone please shoot down the "lets ditch X in favour of Y because we should have ONE" trolls? Educating them will fail, they'll never understand that programmers in a free software world work on what they LIKE. You can't get a mono enthusiast to use QT just because you want everything mono. Same with GTK vs QT and so on.

Re:One sentence that summarized it all for me

[bogaboga]

So in your opinion, Linux's fragmentation helps matters? What was insinuated is this: Packaging and the whole way the ecosystem of Linux is does not help, and is not helping at all.

People do not change easily and they will not change easily from Windows. What Linux does is to even make it more difficult to effect change. I do not understand why this is so hard to grasp.

By the way, even for supported hardware, one might have to use the command line depending on distro. You want examples?

Re:One sentence that summarized it all for me

[Jonboy X]

Java is still widely used for teaching, but it's turning into the 21st century Pascal: used for teaching but loathed for real work by people who have a choice.

Beg yer pardon?

Re:One sentence that summarized it all for me

[True Grit]

the whole way the ecosystem of Linux is does not help, and is not helping at all.

What kind of of EULA did you agree to when you started using Linux? Because I certainly don't remember signing up for any crusade...

You didn't read the GP's last para did you? The part about FOSS programmers working on what *they* liked, not what you like? I hate to break this to you, but quite a few of those programmers aren't interested in crusades either.

Linux is not a monolith, its not an entity, its not a herd, its not a movement, its just an OS. An OS with a lot of users, all with *wildly* *different* *motivations*. That's it. Nothing to see here (for now), move along.

Anyone thinking of rebellions, castle stormings, and the guillotining of the arrogant nobles of our time need to snap out of their daydream and get back to work... or at least count me out, its way past my bedtime.

Java still rules server side

[sprins]

Oh give me a break. For server-side development Java is still king in the performance and feaure department. Perhaps Mono/.NET/MS it catching on, but that's only due to comprehensive copycatting of Java technology.

Although I agree we shouldn't underestimate MS copycatting...

Re:Java still rules server side

[what about]

Yes, Java rules on server and can rule on client too
Having built client side apps in Java that really are cross platform and works well I can say that astroturfing is king in this thread.
Reality check ? You can do it by yourself !
- Java is either smaller or as big as .NET (have you looked at how Mb is a .NET install ?)
- Java is really cross platform, it amazes me ho people can be both against cross platform and complaining that there are no cross platfrm applications, or even more amazing complaining that maintaining different paltforms is "costly" and there should be a cross platform system.
- Java is fast for today standards (yes you may write assembler, but do you really want to ?) anyway c#/.net is the SAME thing as Java, with different name, so if you camplain that Java is slow then why is .net fine ???

I am positively sure that Microsoft is behind this, it must be, there is no logical explanation for all the negative astroturfing.

Re:Java still rules server side

[wasabii]

I have worked on far more .Net server-side code bases in the last few years than Java. Far more. I get Java offers too, but the .Net ones come in quite a bit more often. .Net web services are super easy to use (basically you just drop a file in a directory and it works). .Net remoting. And now WCF. And of course ASP.Net web sites, which is basically serverside code. It's been ages since I've had a serious project that used servlets come to light. Disclaimer: I work in the small business sector, which massively out numbers the large business sector in terms of number of applications. Maybe not size of individual applications, but certainly totals. Java in this realm is essentially disappearing (in the US).

Re:Java still rules server side

[VGPowerlord]

It's funny that you mention Web Services, as it's one of the places Java has actually moved forwards.

Gone are the days where you need Apache Axis. Java comes with a web service stack right out of the box now. They're really easy to set up in Netbeans, too.

Unfortunately, the Java poster-child, Eclipse, hasn't adopted this web service stack yet. Not that I dislike Eclipse, but it tends to ignore things added to Java in favor of third party implementations... such as Apache Axis 1... and SWT.

Given that SWT is an Eclipse product, Eclipse has exceptionally poor support for it. Eclipse's Visual Editor Project doesn't even work on Eclipse 3.3, 3.4, or 3.5... the latest stable version of VEP being released on January 30, 2007. It finally resumed development a few months ago, but who knows how long it will be until a stable release comes out.

Servlets are downright evil. JSP's tag soup isn't much better. JSF sounds interesting, but until Facelets become more common, it's fairly useless.

Even Oracle is starting to push certain third party products. Oracle's Eclipse distribution (which we use where I work) includes plugins for webapp tools such as the Spring Framework.

Re:Good

[Freetardo Jones]

There are orders of magnitude more stuff "built-in" to Java (the platform),

I don't think you know exactly what that term means. The BCL of 3.5 .NET framework defines 294 libraries which each contain hundreds of interfaces, classes, enumerations, structures, delegates, etc. So now to do the math according to you Java must have at least 2 orders of magnitude more of everything (as you said orders) so if your claim is correct Java contains at least 29400 built-in libraries for a combined total of 2940000 interfaces, classes, structures, etc. I'm sorry, but the facts just don't bear your hyperbole out.

Re:"a certain class of developers"

[Chabo]

Maybe he was speaking in Middle English!

In this context, "Yea" is a perfectly acceptable word to use when starting a sentence.

Re:TFA is poorly written, but...

[Anonymous Coward]

And before you start telling me that it's so easy to download and install a new Eclipse, remember that a lot of shops don't have more than a couple people who know how to do this kind of thing on a Linux desktop

It's a developer tool. Pull down the archive and run it. If it's that difficult for you, you have no business getting paid to develop code.

This is beyond garbage

[Anonymous Coward]

I quota from TFA: "Eclipse 3.1 lacks features that MonoDevelop has, including code completion, integrated debugging, refactoring, and unit testing capabilities"

Excuse me !? That stuff was even in Eclipse 2.0. Claiming a Java IDE without code completion exists is just stupid.

Another quota from TFA "Most Java developers on Linux use JetBrains IntelliJ, he claimed. IntelliJ is a commercial product that is not open source."

Who says most developers use IntelliJ, I personally know NONE. Everybody I know is on Eclipse or Netbeans.

I'm not even going to bother with the rest of the article. This article is written by one bunch of ill informed people.

How much money do I need to pay to get an article on the frontpage ? Do I get a volume discount if I want five of them ?

Re:This is beyond garbage

[hattig]

Why is he talking about Eclipse 3.1 anyway? 3.5 just came out, 3.4 came out a year ago, 3.3 a year before that, 3.2 a year before that...

Does he talk about .NET 1.0? I doubt it.

The only problem Eclipse 3.5 has is the minor hassle of getting SVN working, as it isn't integrated out of the box. I suspect this was because of subclipse and subversive bickering.

Re:This is beyond garbage

[ElMiguel]

I quota from TFA: "Eclipse 3.1 lacks features that MonoDevelop has, including code completion, integrated debugging, refactoring, and unit testing capabilities" Excuse me !? That stuff was even in Eclipse 2.0. Claiming a Java IDE without code completion exists is just stupid.

In fact, Eclipse's code completion, integrated debugging and especially refactoring capabilities are stellar. Can Visual Studio do "extract to local variable" and "extract to method"?

Re:This is beyond garbage

[street struttin']

Do I get a volume discount if I want five of them ?

Only if they are all the same article.

Re:This is beyond garbage

[smartr]

translation: It's too complicated for programmers using Debian to get things like recent versions of Eclipse or NetBeans... It's too complicated to install things on Debian, they need a Windows installer.

Re:This is beyond garbage

[MBCook]

I'm guessing he was referring to using Eclipse to develop Mono stuff, but I'm not sure. I've never done Mono/C# development.

I also agree with the IntelliJ comment. Basically everyone I know tends to use Eclipse. Those that don't use the IDE they were taught in school or that they used before Eclipse was common: NetBeans.

Re:This is beyond garbage

[mctk]

No, no, no. You misunderstand. You know all of those half-finished hobby projects you have laying around? MonoDevelop actually gets them done! It's incredible! My productivity is through the roof!

Re:This is beyond garbage

[hattig]

What? Download from Eclipse website ANYWHERE they like, I like /usr/java/eclipse, but they can leave it on their desktop. Then click the executable and run!

Of course I went this way because Ubuntu has a two release old version of Eclipse in their repository. Another issue actually is that the GTK fonts are too large for Eclipse, I needed to create a custom gtk config to get them looking nice and compact.

Anyway, are modern programmers thick? Do they need hand holding? Did our forebears ask this of us? Oh wait, don't tell me, I've seen .NET weenies suckling the teat of the platform libraries and incapable of writing a basic algorithm. Shame really, C# and F# and some of those languages seem quite cool, the former fixing up Java inefficiencies by taking Java, taking 8 years of experience, and fixing things because backwards compatibility wasn't required. Quite why they call a Map a Dictionary is besides me though, decades of algorithm and data structure theory, and they ignore it.

Re:This is beyond garbage

[Headrick]

Not to mention that Eclipse is ancient, 3.5 is the current version.

Most of the Java developers I know use Eclipse. I got hooked on IntelliJ years ago and use it for most projects but I use Eclipse for my Eclipse based RCP and my Maven Plugin.

Re:This is beyond garbage

[PsychicX]

He's talking about Eclipse 3.1 because the article has nothing to do with what the title says. It's not about Mono vs Java, even though the author thinks it is. He spends most of his time basically talking about how Debian is garbage (which seems obvious to me but reasonable people can disagree). In fact the article seems to imply that Debian IS Linux, which is broken on several levels.

Re:This is beyond garbage

[AndrewNeo]

Yes.

Re:This is beyond garbage

[EvanED]

Can Visual Studio do "extract to local variable" and "extract to method"?

Maybe a Google search for... I dunno... "Visual Studio extract method" would produce an informative result.

Re:This is beyond garbage

[EvanED]

...an informative result.

That's a little egg on my face; a previous clipboard entry that hung around. This is where that link should have gone.

Re:This is beyond garbage

[ADRA]

Just as a side note on subclipse, I must say that the latest branch has some pretty great improvements in the merge department. It makes my life a little easier. The only problem for me is that sometimes (very little testing on it so far), the merge seems to disappear into lala land never to continue progress. It is so locked up that I'm forced to murder eclipse mercilessly.

Re:This is beyond garbage

[setagllib]

To help with the Business types who don't know anything about algorithm or data structure theory, but are familiar with physical objects like dictionaries. Yes, they have no place programming, but just try telling Microsoft that.

Re:This is beyond garbage

[Anonymous Coward]

In Ubuntu at least, the package managers only installs Eclipse 3.1. You have to manually download and install/configure any newer Eclipse versions. It's really a pain. I don't have a clue why it hasn't been upgraded...

On the Eclipse side of complaints, wheres text wrapping? Many 'smaller' IDEs have that.

Re:This is beyond garbage

[Shados]

Yeah it can. Plus there's a fair amount of plugins, some free, some commercials, that will actually outdo Eclipse's abilities (though I wouldn't be surprised if Eclipse had plugins to push it even further...and there -is- IntelliJ.)

Re:This is beyond garbage

[Homburg]

I believe the version of Eclipse in Debian and Ubuntu is so far behind because the packagers haven't been able to produce a package of newer versions that runs using the GCJ native compiler, and they don't want to ship a version that uses the regular JVM. Why they would rather ship an ancient version of eclipse, than ship a java program that uses the JVM, I do not know.

Re:This is beyond garbage

[chroma]

Try the Yoxos Eclipse distribution tool. It lets you easily roll your own version of Eclipse with the add-ons you want. The plugin list is very extensive. I assume that it supports the Subversion plug-in, though I haven't needed it.

Re:This is beyond garbage

[anshumani]

I always avoid the edition from the package manager because: a) it is an outdated version b) it insists on using gcj, when I already have a sun jvm installed its a pain, but I can't help it...! On the subject, Firefox 3.5 was out a week back, but I don't see it anywhere in the Ubuntu reps. Does anybody know why? and how long it'll take?

Re:This is beyond garbage

[Tomun]

On the subject, Firefox 3.5 was out a week back, but I don't see it anywhere in the Ubuntu reps. Does anybody know why? and how long it'll take?

I'm running it now in Ubuntu. Just install Firefox-3.5 from universe.
After that I found the easiest way to make it default was to change the /usr/bin/firefox symlink to point to /usr/bin/firefox-3.5

Re:This is beyond garbage

[anshumani]

Thanks! it worked! but what I got was a beta named Shiretoko...! I don't think the release candidate's there in the reps!

Re:This is beyond garbage

[Tomun]

It is 3.5 despite the name.

If I 'zless /usr/share/doc/firefox-3.5/changelog.Debian.gz' the latest change was this:

* New upstream release taken from tag FIREFOX_3_5_RELEASE

Re:This is beyond garbage

[anshumani]

True! True! True! Hell, I'd be happy with the beta...!

Re:This is beyond garbage

[dna_(c)(tm)(r)]

Actually your link says "No" ("extract to local variable") and "Yes" ("extract to method").

Re:This is beyond garbage

[jopsen]

This semester I completed a beginner course in Java... Now I have developed on .Net using VS.Net, SharpDevelop and MonoDevelop, and honestly I found eclipse to be VERY heavy compared to MonoDevelop...
Now, it's fairly possible that I didn't configure it correctly... Why eclipse under Ubuntu needs configuration after install in order to provide inline help (javadoc) for codecompletion I don't know... But I found eclipse to be so slow that it was unusable for any real purposes... Codecompletion with Javadoc was simply 2 lines slower than I'd usually type :(

Note: I did this using Ubuntu 8.10 on a thinkpad with an Intel Core 2 and 2 GiB ram, so it's hopefully not my system spec that not matching...

Re:This is beyond garbage

[hattig]

It's instant on Windows XP (Core 2 Duo, 2.5G, laptop), and of course code completion works instantly. Clearly nobody would use the software as you describe it.

Which version of Eclipse were you using? Which version of the Java JDK? Are you sure it wasn't running on the gimped Java that comes with Ubuntu by default?

Re:This is beyond garbage

[jopsen]

Which version of Eclipse were you using? Which version of the Java JDK? Are you sure it wasn't running on the gimped Java that comes with Ubuntu by default?

Eclipse 3.2, JRE 1.5 gcj 4.3
Okay... Just tried it again... And I can't write two lines before code completion comes up... but it still drives my fans to 100% and it's still horribly slow...

I confident that it can be configured correctly, but why isn't it so by default?
Also where is the integrated UI-designer, need I download that as a plugin... Does it work with GTK or Qt?

All the bad thing metioned, Eclipse has some seriously nice features, such as showing unhandled exceptions while coding... :)

Re:This is beyond garbage

[VGPowerlord]

What Debian distribution is he using? Even Debian Lenny (the current stable) uses 3.2!

Re:This is beyond garbage

[VGPowerlord]

I believe the version of Eclipse in Debian and Ubuntu is so far behind because the packagers haven't been able to produce a package of newer versions that runs using the GCJ native compiler, and they don't want to ship a version that uses the regular JVM. Why they would rather ship an ancient version of eclipse, than ship a java program that uses the JVM, I do not know.

This is doubly ridiculous when you realize that the Sun JDK is no longer in non-free... as openjdk-6-jdk.

Re:This is beyond garbage

[Yfrwlf]

Why you have to feel tied to using a repository to get your software instead of having the freedom to simply download and install a package like you can on Windows just because Linux distros haven't pushed for a universal Linux packaging system is also beyond me. Some great freedom there indeed.

If developers aren't going to offer an up-to-date repository of their software for automatic updates for Linux, that's fine, but at least offer a normal binary package so Linux users can easily have access to their software.

Re:This is beyond garbage

[Homburg]

At least offer a normal binary package so Linux users can easily have access to their software.

Of course there's a normal binary package for Eclipse on Linux; but, of course, using such a package foregoes the advantages of package management (automatic dependency resolution, automatic updates, QA from the distribution, etc). We use package management systems because they're useful, not because we have to use them; if you prefer Windows' free-for-all installation system, nothing prevents you from managing a Linux system that way.

Re:This is beyond garbage

[Yfrwlf]

Um....yeah, I know that packages are superior. My point was that if you're *not* going to provide cross-distro or distro-specific packages or repositories, at *least* provide straight up binary packages. What should happen though is naming conventions and other problems should be resolved so that Linux can have a universal package management system for all distros. You don't have to limit yourself to one format of package either, you can add new formats to the package managers which exist if you want, but have at least *one* format that can be cross-distro.

Obvious, but some nutcases view good standards as something evil even though they help everyone to have more freedom. Freedom is a feature.

Can Mono/.NET do this?

[bogaboga]

Can an informed authority tell me whether Mono or Microsoft's .NET can stream data over the internet? Very useful in Forex Trading. This is what I mean.

Re:Can Mono/.NET do this?

[Freetardo Jones]

Well of course it can. It has support for sockets and anything else you would need to stream things.

Re:Can Mono/.NET do this?

[iDaZe]

WCF with a Duplex Contract comes to mind. Or just sockets (as somebody above mentioned).

Fact is: Java and .NET can do pretty much the same things and it mostly comes down to prefference. I prefer C# because I still have nightmares from Java 1.3 (not to mention making GUI's in AWT/Swing ... *shudder*). Java 1.5 looked like a big improvement though with some nice stuff I felt was missing.

Re:Can Mono/.NET do this?

[jipn4]

Fact is: Java and .NET can do pretty much the same things and it mostly comes down to prefference

C# and the CLR are a superset of Java and some of the extra features are essential to many people: value types, multidimensional arrays, real templates, unsafe modules, better multi-language support, direct calls to C, and excellent bindings to native libraries. And the fact that C# encourages use of platform specific libraries is a big advantage to many.

So, I think in many cases, it's not preference, it's driven by requirements. I can't imagine doing another big project in Java because on every project, one or another of Java's limitations has ended up causing lots of trouble.

Re:Can Mono/.NET do this?

[dna_(c)(tm)(r)]

Your post reads as a troll. But still:

And the fact that C# encourages use of platform specific libraries is a big advantage to many.

That's probably the worst 'advantage' I've ever seen.

Re:Can Mono/.NET do this?

[cheesybagel]

And the most important Java desktop apps (Eclipse, Azureus) don't even use Swing.

So what? F-Spot doesn't use WinForms either.

Re:Can Mono/.NET do this?

[mR.bRiGhTsId3]

That may definitely be a disadvantage, but the fact remains that P/Invoke is so much better than JNI that it's not even funny.

Re:Can Mono/.NET do this?

[Bitmanhome]

On the contrary, that's an excellent advantage. This gives developers the choice between making software platform independent or dependent. Your platform already contains tons of nice tools; why not use them? Microsoft put much effort into ActiveDirectory, but you can't use it under Java. Apple put much effort into Aqua and the whole flying windows thing, and everybody else spent much effort cloning it, but you can't access any of those features from Java.

With Java you must find a cross-platform solution to almost every problem, but with C# you have the choice.

And also with Python. =^p

Re:Can Mono/.NET do this?

[True Grit]

This gives developers the choice between making software platform independent or dependent

Huh? We've always had this choice. Its not like MS, in .NET, just gave you the ability to do something you couldn't do before. The "platform independent" thing, however, has always been really hard to do, and thats what Java was/is trying to tackle. MS, on the other hand, and for obvious reasons, is utterly uninterested in the cross-platform problem.

With Java you must find a cross-platform solution to almost every problem, but with C# you have the choice.

Your attitude just proves what many have been saying all along: NET, and thus Mono, is all about Windows, and has nothing to do with being cross-platform, which is what Java has *always* been about, whatever its technical flaws.

It also proves a point I made elsewhere in this thread: the people knocking Java here are primarily Windows-centric devs who don't gave a damn about being cross-platform anyway.

And all this leads to the observation that Mono is the step-child that no relative really wants to claim, because it doesn't fit well with the goals of either of the opposing camps. Mono is deliberately standing squarely in the center no-man's land, yet loudly proclaiming that it belongs to both sides, and is thus rightly taking fire from both sides.

The only amusing thing from this sad situation is that some Mono backers seem to be genuinely surprised by that.

Compatibility != Equality (necessarily)

[Ohio Calvinist]

I think the problem is that while Java is cross-platform, it's apps have always been treated like second-class citizens on Windows and Mac platforms. They behaved different, had a very different UI for most of its' life, had a slow big runtime for the dial-up days that every app seemed to have a different version of the VM to run and took forever to load or update.

For that reason, I think a lot of developers have avoided it on Windows and since Windows has such a market share, if you're primarily a Windows developer, Mono is a good choice. Mac development has always been a niche job and learning the specifics library methods to make Java apps "work" like native mac applications I can't see much reason in not just writing it in Objective-C. Apple has always lagged behind Sun in releasing recent VMs and for OS X 10.4, which is still very in use as many Mac users don't upgrade for the sake of upgrading, it still hasn't been given Java 6.

.NET (at least on Windows) has always had a form designer which is very quick to learn and rapid develop over Swing/Eclipse which has been code-based (I know, behind the GUI forms is code in .NET), but for a lot of us (like me) our CS programs focused on CS, not software development/engineering and we've had almost no exposure to the GUI packages in Java or C, which have a bit of a learning curve even for the educated.

Re:Compatibility != Equality (necessarily)

[pak9rabid]

...and we've had almost no exposure to the GUI packages in Java or C, which have a bit of a learning curve even for the educated.

Actually, GUI programming in Java via Swing is really quite nice. There's a little bit of a learning curve (not so much if you're already familiar with the GUI event model), but you can pick it up really quick. C on the other hand...I havn't really had any direct experience with creating GUI's in C/C++, but if I had to I'd probably pick up Qt (especially after Nokia LGPL'd it), as from what I hear it's quite a pleasure to work with.

Re:Compatibility != Equality (necessarily)

[jipn4]

I think the problem is that while Java is cross-platform, it's apps have always been treated like second-class citizens on Windows and Mac platforms.

It's even worse on Linux. Java's cross-platform features are a failure on all platforms.

Re:Compatibility != Equality (necessarily)

[Anonymous Coward]

Excuse me sir, developing in Swing is not nice. It's hell on a stick.

Re:Compatibility != Equality (necessarily)

[Shados]

Swing is nice if you understand GUI programming. What the GP was saying, is that for those who have had very little exposure to GUIs in general, learning a GUI toolkit that requires you to understand event models, widget placement, and the rest of the "theory" of UI, is a bit brutal. Of course, once you grasp the basics, Swings' "everything is really a container when you get down to it, even non-container components" model is quite slick. .NET however has a much smoother learning curve. You can do most basic apps with just drag, drop, double click. Then later on you can move on to the more advanced models. While Java IDEs do have very powerful GUI editors, they still require you to understand much more, not unlike .NET's WPF. And WPF is also brutal on those new to UI.

Re:Compatibility != Equality (necessarily)

[EvanED]

Actually, GUI programming in Java via Swing is really quite nice.

That's... a matter of debate. Admittedly only having a very cursory knowledge of what happened in Java 6 and none of what's due in 7, I'd take Windows Forms any day of the week.

Swing is better than programming in C using the Windows API directly... and that's about as much as I'll grant.

Qt is quite spiffy though. There are some weird integration things with C++ and the STL, and you have to deal with the uglies of C++, but Qt is a damn nice library.

Re:Compatibility != Equality (necessarily)

[falconwolf]

only having a very cursory knowledge of what happened in Java 6 and none of what's due in 7

I'm trying to learn Java 6 now.

Swing is better than programming in C using the Windows API directly... and that's about as much as I'll grant.

Swing is also cross platform whereas Windows APIs are tied to Windows. I can run Eclipse on my Mac to program software in Java that will run on Linux, OS X, and Windows.

Re:Compatibility != Equality (necessarily)

[Antique Geekmeister]

There _IS NO SUCH THING_ as Java 6. It is Java 1.6.0. Look at the software source code and package names, and try typing 'java -version" at the command line.

Sun has been confusing and manipulating software names for years, and I wish they'd stopped back with Solaris and SunOS.

Re:Compatibility != Equality (necessarily)

[Mr2001]

I can run Eclipse on my Mac to program software in Java that will run on Linux, OS X, and Windows.

I can run Visual Studio on my Windows box to program software in C# that will run on Linux, OS X, and Windows.

GTK#: works on all three.
Windows Forms: works on Windows (obviously), largely works on Linux, not sure about OS X.
Silverlight: works on Windows and OS X, Linux is still catching up.
CocoaSharp: works on OS X.

Re:Compatibility != Equality (necessarily)

[EvanED]

I have no idea how SWT's API looks, so I can't comment on that. I do tend to like the results though.

Re:Compatibility != Equality (necessarily)

[dna_(c)(tm)(r)]

it still hasn't been given Java 6.

Java 5 is the default on 10.5, but Java 6 is available. instead of java -version try typing ls /System/Library/Frameworks/JavaVM.framework/Versions/

Re:Compatibility != Equality (necessarily)

[dna_(c)(tm)(r)]

OK, try running your VS on Linux, OS X.

Re:Compatibility != Equality (necessarily)

[VGPowerlord]

.NET (at least on Windows) has always had a form designer which is very quick to learn and rapid develop over Swing/Eclipse which has been code-based (I know, behind the GUI forms is code in .NET), but for a lot of us (like me) our CS programs focused on CS, not software development/engineering and we've had almost no exposure to the GUI packages in Java or C, which have a bit of a learning curve even for the educated.

NetBeans has a nice GUI designer for Swing. Unfortunately, most Java developers tend to use Eclipse, which hasn't had *any* SWT GUI designer for 3 versions now.

Re:Compatibility != Equality (necessarily)

[Mr2001]

On other operating systems I'd use MonoDevelop, or Mono's CLI tools together with joe and make.

Re:Compatibility != Equality (necessarily)

[Mr2001]

GTK# works only on mono.

Not true.

Re:Compatibility != Equality (necessarily)

[dkf]

from what I hear [Qt is] quite a pleasure to work with.

By comparison with coding in raw X11 or GTK, quite possibly. But you should realize that your view of what is possible is still stunted.

Re:Good

[alexborges]

Aw jeeze.... ever heard of figures of speech?

Anyhow, the guy you reply two included 3rd party libraries in that figure. I would say he is not that far of the mark: one order of magnitude is more apropriate, but still, thats "an order of magnitude" larger.

Outpaces?

[popo]

"Outpaces" is one of those sketchy words often used to describe comparative speeds. It is almost a sure sign of a release designed to manipulate public opinion.

e.g.: If Microsoft is growing at 3% annually, and my small one-man software company is growing at 20% annually -- I can put out a press-release saying that I'm "Outpacing Microsoft". But that doesn't mean I'm creating real competition for Microsoft.

Disclosure: I haven't RTFA -- I'm just calling b.s. on semantics...

Re:Outpaces?

[generic.individual]

This is one of those slashdot absurdities that I just can't stand. You are criticizing the story while openly stating you didn't read it. W.T.F.

If you are going to post a comment, at least have the decency to RTFA first. I would give an example of why you should, and show how your statements are false based on the content of TFA, but I haven't read it yet...

Not the kind of articles to get linked by /.

[moria]

From TFA:

Eclipse 3.1 lacks features that MonoDevelop has, including code completion, integrated debugging, refactoring, and unit testing capabilities

Nothing to see here. Move on.

Re:"a certain class of developers"

[alexborges]

Yep..

They "would be" talented, intelligent developers if they had chosen python or whatever the fuck else that has no ties to microsoft patents (or like jjava...).

Re:Good

[Sponge Bath]

...if your claim is correct Java contains at least 29400 built-in libraries

That sounds about right from my last excursion with Java :-P

I don't think so

[jipn4]

Mono is becoming popular for Linux development because it does not try to be cross platform. It feels much more natural than Java programming.

Re:I don't think so

[cryptoluddite]

It feels much more natural than Java programming.

chmod +x ./natural.exe
export DLLPATH=/usr/lib/libmono.dll

Yeah, right. Natural.

Re:I don't think so

[Anonymous Countword]

Java public class Hello { public static void main(String[] args) { System.out.println("Hello"); } } C# using System; class Hello { public static void Main(string[] args) { Console.WriteLine("Hello"); } } I'm not sure how your senses work but both of them look pretty artificial to me. By the way, I think you mean Linux Desktop Development.

Re:I don't think so

[MobyDisk]

huh? They are even taking Microsoft's APIs (like WinForms) and porting that to Mac/Linux/Unix/BSD/Windows. And promoting other APIs like GTK# as alternatives. How is that not trying to be cross-platform?

Re:I don't think so

[csartanis]

But it is cross platform without even trying. Every winforms app I've ever written for Windows worked flawlessly on Linux after minor pathname fixes.

Re:I don't think so

[True Grit]

Every winforms app ... worked flawlessly on Linux ...

A Winforms app working on a non-Windows system is entirely at the discretion of Microsoft because Mono's Winforms implementation is violating MS patents. This is the *reason* for the controversy surrounding Mono.

Re:no mono

[Vectronic]

It rained here this morning, that means it must have rained all over the world.

mono in website programming.

[chode8]

mono is used often in the indie radio programming. www,dflshow.com is one example with the whole livestream thing.

Re:mono in website programming.

[AlexBirch]

I'm not sure what the java equivalent of Master Pages are in java. It's just so nice, I used it for Soltima, Inc.

Re:From a user perspective

[Toonol]

I don't program in either, so I can't speak to the advantages from the development side; but I know that with Mono/.net apps, I've never experienced that 'Oh, crap, this is Java' feeling that I feel about twenty seconds after launching a new program.

I know that, theoretically, java apps are fast, compile well, and so on... but in practice, they just feel like trudging through sludge. Every single time. Perhaps that's just because I'm dealing with them on the desktop, instead of on the server... but still, when I've got dozens of examples and it's invariably true, it eventually stops being anecdotal and starts becoming data.

Re:Good

[Freetardo Jones]

Except if you look at the Java 6 API there are only about 205 packages.

Re:TFA is poorly written, but...

[hattig]

I'm sorry, but Eclipse just runs from the decompressed download, even if it's on your desktop.

If you need help adding a shortcut to your menu when you are a developer, you're in the wrong business. Maybe you need to be using .NET.

Re:Good

[Vahokif]

it's had a good decade and a half of hardening in real-world situations (top businesses etc.)
.NET builds on Java's experiences as well, and according to Miguel they did a better job of addressing Java's main criticisms than Java itself.

gcc even has a java (the language) compiler now (OK for about 5 years) that generates native machine code (what everyone used to whinge about)
Mono has that too.

and there are independent implementations of the Java libraries (e.g. GNU Classpath).
Mono IS an independent implementation, along with DotGNU.

Mono needs to die a death.
No, it doesn't. Please stop talking out of your ass.

Not for me!

[Anonymous Coward]

Java is irrelevant for the desktop at this stage and Mono simply isn't welcome on my machines. Vala is shaping up nicely and has none of myriad issues afflicting Java or Mono. There's nothing worse than Mono zealots, despite plenty of people making it clear that they don't want their software these obnoxious mono people keep trying to push it as a dependency.

No thanks.

Re:Not for me!

[Jahava]

Java is irrelevant for the desktop at this stage and Mono simply isn't welcome on my machines.

If your distribution does a good packaging job, and the licensing is kosher, I'd be interested in hearing a compelling reason why you care what language any given application is written in. My understanding is both are true for major Linux distributions.

Really this kind of end-user snobbery is pointless. Desktop applications should be evaluated on their design, functionality, effectiveness, ease of use, and desktop integration ... not the language they are written in.

Re:Not for me!

[Grishnakh]

It has nothing to do with language or licensing. Mono is a patent trap for Linux: it holds patented MS technologies that, when more integrated into most Linux distros, can then be used against Linux in court by Microsoft who will sue them all for patent infringement.

Re:Not for me!

[Jahava]

It has nothing to do with language or licensing. Mono is a patent trap for Linux: it holds patented MS technologies that, when more integrated into most Linux distros, can then be used against Linux in court by Microsoft who will sue them all for patent infringement.

Please correct me if I'm wrong, but my understanding is that the Mono project itself is segmented. Some technologies (notably WinForms and ASP.NET) certainly fall under MS parent, but the core technologies (C# and the CLI) are to be licensed under the MS Community Promise, which seems to waive MS's ability to enforce its patents on those specific technologies. This is similar to other FOSS-defensive patents/licenses, where technology is patented and then licensed under a patent waiver.

Just using Mono/C#/CLI doesn't open yourself up to any MS claims, provided you don't use the Mono libraries that don't have their patent enforcement waived. But this is the case with every set of libraries. Applications that want to avoid licensing issues need only avoid using the unfriendly technology, which is very doable with the segmented Mono. That's one reason why Linux Mono desktop applications (like Banshee) use GTK# instead of WinForms. I don't believe Banshee is subject to those patent claims.

Mono is just a tool; with Mono itself being GPL/LGPL and the MS-developed core dotNET patents (C# and CLI) being put under a FOSS-friendly license, it's really in the hands of the developers to ensure that individual applications don't link against MS's patent-enforceable technologies. This puts it on par with every other language, though.

Re:who uses mono anyway?

[Freetardo Jones]

The Banshee guys, the Beagle guys, the Blam! guysm the Diva guys, the DotNet BlogEngine guys, the GNOME Do guys, the F-Spot guys, the FusionFall guys, the Graffiti CMS guys, the iFolder 3 guys, the KeePass 2 guys, the Second Life guys, the MonoTorrent guys, the Muine guys, the PHP4Mono guys, the Smuxi guys, the Sky Net guys, the Unity guys and the VistaDB guys. Just to name a few.

Re:Good

[sbeckstead]

actually neither produce executables.

The Wolf Crows at MidAfternoon...

[Tetsujin]

Java is dying. Python is good so is C#. I love attributes, LINQ, Master Pages, etc.
  I'm not an MS fan, but C# is just so nice.

For the record I'm writing this on my debian sid laptop using Iceweasel.

Programming is fun. Did you know that rabbits aren't rodents? Storm clouds are the ones they call cumulonimbus. I forgot to bring lunch today so I ate my hat. In "Transformers: Masterforce" they showed news clippings in which the Destrons were referred to as "Decepticons", that seemed like a nice nod to the Transformers we knew in America... I'm going to write an Emacs clone that uses Brainfuck for its scripting.

Re:The Wolf Crows at MidAfternoon...

[AlexBirch]

I haven't seen any Transformers, if bubble-bee isn't a vw-bug, then it's not real.

Re:The Wolf Crows at MidAfternoon...

[Tetsujin]

I'm going to write an Emacs clone that uses Brainfuck for its scripting.

You realize that if you actually did this, you would become a god. That might prove inconvenient for many of the powers that be.

Yeah, then they'd probably maneuver me from the shadows, hiding their conspiracy with the protective prescience of a Guild Steersman, and make various attempts to either get me under their thumb or turn me into something that I hate so much that I'll die rather than let it continue...

Re:The Wolf Crows at MidAfternoon...

[Tetsujin]

I haven't seen any Transformers, if bubble-bee isn't a vw-bug, then it's not real.

I liked him as a beat-up old muscle car... Can't say much for the movie he was in, though. I hear they made some kind of sequel or something? I don't know...

Re:The Wolf Crows at MidAfternoon...

[gbjbaanb]

Programming is fun

absolutely, that's why people code in C#. Nothign to do with professionalism, fgood code, efficiency, and al the other bits and pieces that have been forgotten in today's rush for "developer productivity" (at the expense of end-user productivity, of course).

that's why, for example, Tomboy leaks memory like a sieve. Who cares, its fun to code note-let apps in the new language that doesn't have memory leaks anymore.

Or as this blog note says: I have to admit, however, that I admire Jo's sincerity when he makes this point: it's not the users who want it, it's the developers. It can't be denied that .NET was indeed instrumental in the development of Gnote

But who cares about the users nowadays?

Re:The Wolf Crows at MidAfternoon...

[AlexBirch]

I haven't seen either one.
They'll mess up my childhood recollections of the original.

Re:The Wolf Crows at MidAfternoon...

[dave562]

There are a lot of nods to the original cartoon. I was having some flash backs to some of the original dialogues while watching the "first" Transformers movie. In fact, when Megatron finally came onto the scene, I was waiting for him to say, "Star Scream, you have failed me for the last time!" And sure enough, he did.

Don't talk yourself into not liking Transformers. It was a good movie. I haven't seen the most recent one yet, so maybe they completely blew it on the second time around?

Re:The Wolf Crows at MidAfternoon...

[AlexBirch]

I'm cheap, that's why I use mono and linux. 10 bucks for a movie is too much. 20 if I take my imaginary, Brazilian girlfriend.

Re:The Wolf Crows at MidAfternoon...

[just_another_sean]

I'm going to write an Emacs clone that uses Brainfuck for its scripting.

Sweet. Let me know if you want some help with that. I'm interested in writing a vi mode for something like that. In Java.

Re:The Wolf Crows at MidAfternoon...

[gangien]

i recall they said they couldn't do that for legal purposes.

Re:The Wolf Crows at MidAfternoon...

[AlexBirch]

bullshit, it was a payoff.

Re:The Wolf Crows at MidAfternoon...

[extrasolar]

I'm going to write an Emacs clone that uses Brainfuck for its scripting.

Why write a clone when you can have the real thing?

Okay, maybe someday.

Maybe?

Re:The Wolf Crows at MidAfternoon...

[Mr2001]

["I have to admit, however, that I admire Jo's sincerity when he makes this point: it's not the users who want it, it's the developers. It can't be denied that .NET was indeed instrumental in the development of Gnote"]
But who cares about the users nowadays?

Er... since when is any project's choice of language driven by user demand?

Is the Linux kernel written in C because users demanded a kernel written in C, or because the developers thought it was a good choice for an OS kernel? Do you choose a web browser, music player, or note-taking tool based on the language it was written in?

I choose to develop in C# because it makes my job easier (although the Visual Studio IDE deserves credit for much of that). When my job is easier, my clients are happier because they get more reliable code and they get it sooner. They don't care whether I'm using C#, C++, Java, COBOL, or manually flipping bits on the hard drive with a tiny magnet and very steady hands. All they care about is how long it takes to turn their requests into a working program that runs on the systems they need it to run on.

Re:The Wolf Crows at MidAfternoon...

[Tetsujin]

are you fucking kidding me? i'd program in sanskrit if they paid me enough. it isn't "fun", it's something to do to keep me from digging ditches. i cannot imagine why anyone gives a minor shit about languages, and features, and blah blah blah...if you care that much about what your piece of shit system that's going to be replaced in 2-6-8-12 months is written in then you're completely missing the point

Whatever one does for a job, however they go about it, becomes a big part of their life... Close to half their waking hours. That being the case, it's preferable to not work in an environment which causes needless frustration.

Re:The Wolf Crows at MidAfternoon...

[Tetsujin]

Programming is fun

absolutely, that's why people code in C#. Nothign to do with professionalism, fgood code, efficiency, and al the other bits and pieces that have been forgotten in today's rush for "developer productivity" (at the expense of end-user productivity, of course).

that's why, for example, Tomboy leaks memory like a sieve. Who cares, its fun to code note-let apps in the new language that doesn't have memory leaks anymore.

In the free software world, much of the software (not all of it, of course) is developed without financial incentive. A lot of useful stuff is written by people who are just in it because they enjoy it. This being the case, giving developers an environment they like is very important.

Also, I agree with what you have to say about efficiency - but at the same time, one can't put too much emphasis on how efficiently a program solves a program until the program is at least at the point of being capable of doing its job. This is why I believe it's sensible for people to write applications in Python or whatever, if that's what they're comfortable with. If their language choice allows them to focus on the problem they want to solve instead of the problems they don't want to deal with, then they can create something that otherwise wouldn't exist - and is thus infinitely more efficient than the alternative.

Your link regarding Tomboy... is less than compelling. The app grows to 80MB. Then what? Does it really continue growing further, or not? If there were a stress test of note creation and deletion which led to a footprint of hundreds or thousands of megabytes, that would be more convincing. It does seem pretty twisted to think we live in a world where that doesn't seem like a lot of storage space to waste any more... but honestly, it doesn't. And there's so many questions. Does the app keep an undo history? Is this a result of running a garbage-collected environment? And of that 80MB "memory footprint" (size of the process's addressable space, or what?) how much of that actually corresponds to actual resource usage (physical RAM or swap space) as opposed to memory mapping, or allocated-but-unused (and thus, unallocated) memory pages? The question of how this measurement was taken is very important, as is the question of whether the growth pattern continues up to values that actually make me care. :)

Re:The Wolf Crows at MidAfternoon...

[Tetsujin]

Don't talk yourself into not liking Transformers. It was a good movie.

No... no, it really wasn't. I'm sorry.

Re:The Wolf Crows at MidAfternoon...

[fredrik70]

>Did you know that rabbits aren't rodents?
Actually no! googled it and they are apparently 'lagomorphs'. how cool is that?!

Re:The Wolf Crows at MidAfternoon...

[Hurricane78]

Will it run in the browser, without any plugins? And if yes, does it support Chrome OS or the Emacs browser? Or do I have to start a virtual machine, that in written in JavaScript?

Re:The Wolf Crows at MidAfternoon...

[makomk]

that's why, for example, Tomboy leaks memory like a sieve. Who cares, its fun to code note-let apps in the new language that doesn't have memory leaks anymore.

Not surprised. OpenSim (a virtual world server written in C#) has the same problem with Mono. If you run it under Mono, it leaks memory like a sieve and the simulator falls over after a few hours. Anyone who needs decent stability has to splash out for Windows and run it under .Net. One problem is that the Mono garbage collector is still fundamentally very poor compared to both .Net and Java. They're still using Boehm, a crude mark-and-sweep garbage collector intended for C and C++ with poor performance and serious memory fragmentation problems.

Re:The Wolf Crows at MidAfternoon...

[gbjbaanb]

Is the problem down to the Boehm GC or is it a more fundamental problem - I've seen too many .NET apps leak memory (some dramatically), I feel its a problem with .NET: not with the GC or technical issues but with human ones.

Its easy to write a .NET application, but its harder to write a good, stable one. The coder is told "don't worry, the GC will take care of that", and so the coder doesn't worry about memory (not that they have much choice in the matter) but they end up getting object lifetime leaks (same difference as memory leaks as far as I'm concerned) because they do not track their object usage and assume they will be cleaned up.

Maybe one day this issue will be a 'known common problem' with .NET that coders will be taught: although you have a GC, you still need to take full control of all your memory allocations. Then MS will replace it with something else.

Re:The Wolf Crows at MidAfternoon...

[makomk]

I doubt it's an object lifetime leak, at least in the OpenSim code itself, since its memory usage is perfectly stable under Microsoft .Net. Now, a leak in one of the Mono libraries, maybe - they're not exactly high quality.

Re:Good

[sbeckstead]

You obviously don't work with .NET on a daily basis. Same crap different syntax, different names on the box..

Re:Good

[jcr]

.NET is an extremely popular platform.

Tragic, isn't it?

-jcr

Re:Good

[Dan667]

I feel that way about Java too.

Re:Re:Good

[Jerry Coffin]

Personally, I don't care one way or the other (I don't care for either one), but I'm left wondering: could anybody honestly consider the "comparison" on the cited site useful in any way, shape, form, or fashion? Even if it provided a comparison that was deep enough to have a hope of meaning something, do you think there's just a hint of a possibility that a web site hosted on "javacamp.org" might have (and provide) a slightly biased view in a comparison between Java and any perceived competitor?

Re:TFA is poorly written, but...

[digsbo]

Yeah, I can do it, have done it, and have found it pretty easy. But as I said in my post, I have VMs ready to go. Most shops employ people who won't go to the trouble of learning how to use a repository installer let alone a tar/gz/rpm install, and I'm in a shop like that now. Last job, no problem--but go to an MS shop and tell me what you find...

Re:TFA is poorly written, but...

[digsbo]

Thanks, this was a big part of my point the other guy didn't seem to understand.

Re:Good

[Freetardo Jones]

You obviously don't work with .NET on a daily basis. Same crap different syntax, different names on the box..

I use it almost every day and in many ways I prefer it to Java (though I use Java often too for certain things it does better). I never get why people cares so much about what languages other people like to code in.

No code completion or debugger?

[Anonymous Coward]

"Eclipse 3.1 lacks features that MonoDevelop has, including code completion, integrated debugging, refactoring, and unit testing capabilities, Hargett claimed. "I've found in my consulting that people who install Eclipse 3.1 through the [Debian] package manager say, 'This is terrible.' " He said that customers that have installed a version of Eclipse beyond 3.1 like it."

Just out of curiosity, I just downloaded a copy of Eclipse 1.0. This build is from November 2001.

http://archive.eclipse.org/eclipse/downloads/drops/R-1.0-200111070001/index.php

For the record, it has code completion and integrated debugging. I do remember back in 2004 thinking IntelliJ IDEA's refactoring support was far better, so I suppose that was roughly the 3.0 timeframe. I guess I could track the JUnit plugin history and see which version of Eclipse started including this, but I think I've already made my point. I've got nothing against Mono, but geeze, what a load of BS...

Re:MS Is Making Fools Out Of The Open Source World

[Anonymous Coward]

After all the years of just how invincible and all powerful open source is it is staggering to look at how easy it was to stop it dead in its tracks:

A simple fork of the current main desktop package and the Linux world has been wasting their time in KDE vs Gnome flamewars for years now.

And then you had Sun performing the thankless task of keeping Java free from destruction by Microsoft while the stupid little kids here on Slashdot were screaming about how Java isn't 'GPL'.

And now the Linux community is actually starting to willingly include a Microsoft patent mess right into the heart of distributions - and for what? A few shitty and poorly written apps that already have faster, lighter, and better C++ versions.

Anyone see Apple fucking around with Mono? Nope.

Anyone see Google fucking around with Mono? Nope.

You would either get laughed at or outright fired if you made such an inane suggestion.

But the Linux community never fails to seize an opportunity to shoot itself in the foot.

Re:Good

[Darinbob]

I don't use either. Back when I was interested in Java it was too much of a moving target. But I get the impression that both today are basically glue languages combined with lots and lots of libraries and frameworks. Knowing the languages seems less important than knowing the libraries and which pieces to glue together.

Miguel de Icaza - How much more damage can he do?

[Anonymous Coward]

You would think that after creating the Linux desktop Gnome versus KDE war and turning 'Year of Desktop Linux' into a joke and now something not even funny anymore, that Linux developers and distro managers would have gotten a clue.

How many more times is Lucy(Miguel de Icaza) going to hold that football out there for you Charlie Brown(Linux community) before you catch on?

What does distros have to do with it?

[H0p313ss]

The story also touches on the failure of Linux distros to keep pace with Eclipse.

What does that even mean? Does anyone ever get their eclipse from the distro?

Eclipse installation is an unzip... I mean WTF does that mean?

Re:What does distros have to do with it?

[ChunderDownunder]

I believe Fedora ships with the latest Eclipse in their repositories. But clearly debian and ubuntu don't. Why? Well a number of reasons.

(1) Until recently OpenJDK didn't exist, so debian and other distros (who wouldn't rely on Sun's proprietary JDK) did the native compilation thing via gcj. Extra complexity.
(2) Eclipse provides its own UI library called SWT. Other applications such as Azureus decided to use it. Upgrade Eclipse and you have to test all the other applications for breakage.
(3) Eclipse is a huge download since it includes a bunch of Java libraries such as ant, junit and many libraries for Java EE development. Many of these are already packaged, so it would seem to make sense to depend on them so you don't have duplicate jars floating all over your system (bloat).

I'm sure there are other reasons but packaging for debian the 'right way' is a little more complex than just unzipping, sticking it on the path and making some shortcuts for the application menu. And while debian is a volunteer project, clearly Eclipse isn't a priority for Shuttleworth to throw some money at ubuntu devs to make it happen in the same way Red Hat values Java (e.g. through JBoss).

Re:What does distros have to do with it?

[H0p313ss]

That doesn't answer my question. WHY would anyone depend on the distro for Eclipse? It's pointless. Does anyone actually do that?

Re:What does distros have to do with it?

[blackpaw]

A lot of people prefer to work through the package management system - its makes install/uninstall and dependencies a lot cleaner.

Re:What does distros have to do with it?

[ChunderDownunder]

Why NOT? I would.

Pretty much everything works via a package manager on Linux. Why should Eclipse be any different if your distro keeps up to date? Easier than manually downloading a new version and unzipping *every time*.

Re:What does distros have to do with it?

[rzei]

With Eclipse having it's own update/upgrade functionality I really think that distros should drop eclipse packaging.

It's damn misguiding though that distros have some antique version.

Re:What does distros have to do with it?

[H0p313ss]

With Eclipse having it's own update/upgrade functionality I really think that distros should drop eclipse packaging.

It's damn misguiding though that distros have some antique version.

I actually felt insulted the first time I tried the pre-packaged Eclipse on Ubuntu (7.04?) ... the damn thing ran with gcj and indeed did make Mono look good in contrast.

Re:What does distros have to do with it?

[H0p313ss]

A lot of people prefer to work through the package management system - its makes install/uninstall and dependencies a lot cleaner.

Different pattern of behavior... as a plugin developer I download Eclipse builds on a regular basis (on average monthly... sometimes almost daily during the June end-game when my patches are being considered), being one version behind is not an option, being four versions behind is unthinkable.

Re:What does distros have to do with it?

[Abcd1234]

I believe Fedora ships with the latest Eclipse in their repositories. But clearly debian and ubuntu don't.

Uh, Ubuntu absolutely includes Eclipse in it's repository (at least it's present in 9.04). I installed it just the other day, as a matter of fact.

Re:What does distros have to do with it?

[Abcd1234]

That's no longer true, at least as of 9.04. In 9.04, Eclipse will run against openjdk or sun-java6, depending on which package you have installed.

Re:What does distros have to do with it?

[VGPowerlord]

I believe Fedora ships with the latest Eclipse in their repositories. But clearly debian and ubuntu don't.

Uh, Ubuntu absolutely includes Eclipse in it's repository (at least it's present in 9.04). I installed it just the other day, as a matter of fact.

Skipped a word there, didn't you?

Ubuntu Intrepid includes Eclipse 3.2.2. The latest version of Eclipse is Eclipse 3.5. Eclipse 3.3 was released just over two years ago, so no, 3.2.2 is nowhere near latest.

Re:What does distros have to do with it?

[VGPowerlord]

Sorry, I meant to say Jaunty included Eclipse 3.2.2. For that matter, Karmic is set to include Eclipse 3.2.2 as well.

Re:What does distros have to do with it?

[Bitmanhome]

IF your distro keeps up to date, maybe. But Eclipse (and for that matter, Firefox) put a great deal of effort into their own plugin and update systems. Using Apt to manage these is mostly silly. (Not entirely silly; it's nice to be able to update everything from one GUI.) But if Debian is not going to keep up with Eclipse, it's pointless to keep it in the repository. It takes time and effort to maintain an app noone wants.

Re:who uses mono anyway?

[Anonymous Coward]

Is this the part where you want us to name all the projects that use Java?

Eclipse and SVN

[Anonymous Coward]

To correct your last point, there is even a specific distribution of Eclipse that includes already-integrated SVN.

Re:Eclipse and SVN

[hattig]

Ah, brilliant. My company just downloaded the massive everything included download, but it didn't have SVN for some reason. Gave it to the DBA, he found BIRT mode and started writing reports for us. Maybe it's not Crystal, but then again it's not Crystal!

Re:Good

[Dr_Barnowl]

Yes they do. A handwritten recipe for cookies is executable, it just runs on a different class of machine.

Re:Good

[Cyberax]

Nope.

C# right now has the following features that are absent in Java:
1) LINQ !!!!
2) Delegates.
3) Anonymous types and type inference.
4) Reified generics.
5) Support for dynamic methods.

C# 1.0 was just a carbon copy of Java. C# 3, not so much.

Re:Good

[cyphercell]

"If you dont like it, dont use it. Why wish for it to go away?"

reduce complexity?

Re:no mono

[just_another_sean]

Actually it did not rain here today so I am highly dubious about you're claim that it rained where you are.

Thank God for astroturf

[Runaway1956]

Don't get me wrong here - I despise Java, primarily because it's a resource hog on all platforms. Only masochists could ever have really liked Java - especially on older and/or low end machines. It blows. But, mono? Microsoft is blowing it's own horn here. Java is already on 100% of *nix desktops, plus or minus a percent. Mono has made it onto 10%? Wow!! Mono growth outstrips Java!!!

Give me a frigging break.

There must be some natural turf somewhere, but we won't find it here.

Re:Thank God for astroturf

[Burnhard]

I agree with your comments but to be frank I'm not sure what all the fuss is about. Mono is a subset of Microsoft .NET technology. Windows Presentation Foundation and .NET 3.5 (including all of the associated namespaces and libraries) are where it's at today on the Windows platform. I don't think you'll ever see a port of those onto Linux unless Microsoft provides them. To be honest with you, I've used Netbeans for a Java project,C++/Win32/OLE (my most recent project) and I've done development work in .NET (VB.NET and C#) and I prefer .NET by a long way. It's head and shoulders above other development platforms out there (in combination with Visual Studio of course). All of this is true of course only on Windows. It seems absurd to try to emulate it on Linux. I can only assume that there are a whole lot of people out there forced to use Linux (perhaps at University) wanting to learn C# to benefit their later careers.

I know a lot of people don't like to admit that Microsoft has got it right, but in this one case I would find it very hard to fault them in comparison with other development environments and platforms.

Re:Thank God for astroturf

[Daniel Dvorkin]

a subset of Microsoft .NET technology

Can we please stop talking about a bunch of APIs as a "technology?" Ever since Intel started pushing "MMX technology" back in the day, every tiny remix of existing ideas and principles, whether in hardware or software, is marketed as "___ technology." It's absurd.

The computer, taken as a whole, is a technology. The personal (desktop, laptop, handheld) computer is maybe a technology. I'll even go so far as to grant that certain features which make modern computing what it is -- the GUI, say, and always-on networking plus worldwide connectivity -- count as technologies. But one particular implementation of the well-explored idea of languages that are JIT-compiled to bytecode, whether from Microsoft or the F/OSS community or anyone else, is not a technology. It's a reasonably clever use of existing technology, and that's all.

Or maybe I should just give up and call every slight variant of Hello World "GNU/iCyberHello Pro Gold Technology Plus Plus Sharp." You know it's coming.

Re:Thank God for astroturf

[Rockoon]

in combination with Visual Studio of course

On windows, this is the biggest selling point hands down. C# and VB.NET in tandem with the Visual Studio IDE has WINNER written all over it.

If this combo had been released 10 years ago, every developer in the world would have creamed their underwear simultaneously.

Re:Thank God for astroturf

[TheTurtlesMoves]

You know the biggest resource hog on my machine is firefox....not eclipse. So does that mean C/C++ is a resource hog?

Vista is a resource hog, MS Office is a resource hog, some games are resource hogs... they are not written in java....

Perhaps the coding has more to do with performance and resource usage the what the code is written in? Honestly if java is a resource hog you coding wrong or using crap code.

Re:Good

[Nesman64]

Ah, so that explains the performance.

Re:Good

[nschubach]

People care about what other people code in if there's a 200+MB download just to be able to run it...

If people coded in native apps that argument would be fine, but if I have to install a huge framework to run a note taking program it's hardly worth my time.

Re:Good

[sbeckstead]

Ok I'll concede that an interpreted code body is an executable capable of running on a virtual machine. But who really cares anyway it was a toss off reply to an AC and it's really irrelevant.

Re:Good

[nschubach]

1) http://www.theserverside.com/news/thread.tss?thread_id=46887
2) http://weblogs.java.net/blog/alexwinston/archive/2005/04/strongly_types_1.html
3) http://www.developer.com/java/other/article.php/3300881 ?
4) http://java.sun.com/j2se/1.5.0/docs/guide/language/generics.html
5) http://java.sun.com/j2se/1.5.0/docs/guide/reflection/proxy.html ?

Absent? (Admittedly, I don't code in Java, but I got those links just by googling all your points.)

Re:Good

[Cyberax]

"C# is VB with C syntax."

Sorry. You don't know a shit about C#.

Minor correction

[KwKSilver]

apps that really can run anywhere without a whole lot of extra work.

Write any app you want with any language you choose. Run it on anything you wish.... But if it is mono-based or has any mono-dependency whatsoever, it's not going to run on any hardware that I own. I avoid mono-apps and won't install any distro in which mono is a part of the default install. I'll believe mono is safe when I see Steve Ballmer, Richard Stallman, Steve Jobs, and Theo de Raadt singing "Koombaya" together on the same stage.

kws@frozenhell~$ man Ballmer+Stallman+Jobs+de_Raadt

kws@frozenhell~$ segfault ... this system is going down permanently ...now

;-)

Re:who uses mono anyway?

[jedidiah]

I've used the GNOME desktop for awhile and I have always used a lot of
KDE apps just because they were better and more mature and more complete.

All the "speed of development" that the Microsoft centric development
process is supposed to enable here doesn't seem to be materializing.

Re:Good

[EvanED]

C# is VB with C syntax. VB is Microsoft's bastardized version of Java.

JDK 1.0: Jan 1996
VB 1.0: May 1991

VB was at 4.0 by the time Java was released.

If by "VB" you mean VB.Net, I would say it's the reverse: C# is Microsoft's "bastardized version" of Java (though mostly better IMO), and VB.Net is C# with VB syntax.

Re:Good

[Cyberax]

>Absent? (Admittedly, I don't code in Java, but I got those links just by googling all your points.)

Yep. Absent.

These are hacks, they are nowhere close to power of LINQ in C#. True LINQ support requires language changes (anonymous types, Expression Tree, Extension Methods).

Admittedly, these are clever hacks and make life somewhat easier (I myself currently contribute to http://code.google.com/p/jaque/ ).

Mono is a good choice

[falconwolf]

if you're primarily a Windows developer

That was part of the problem, .net wasn't cross platform capable until Mono came along. MS ties it's tech to it's own products, or threatens to drop support. I can easily imagine MS Embracing, Extending, and Extinguishing Mono and .net on Linux. Meanwhile I use Eclipse for Java, and can use it for other languages as well, on my Mac. And if and when I finally rebuild my Linux PC I can use Eclipse on it as well.

Mac development has always been a niche job and learning the specifics library methods to make Java apps "work" like native mac applications I can't see much reason in not just writing it in Objective-C.

This has a similar problem, using Mac specific GUIs it's no longer cross platform. And Objective-C isn't cross platform either.

for a lot of us (like me) our CS programs focused on CS

That's how it should be, CS shouldn't focus on specific tools but on general principles.

Falcon

Re:Mono is a good choice

[Mr2001]

I can easily imagine MS Embracing, Extending, and Extinguishing Mono and .net on Linux.

Well, "embrace" is irrelevant since .NET came from Microsoft in the first place.

As for "extend and extinguish", doesn't that rely on the assumption that developers don't test their software on Linux? I don't see how that's supposed to work.

1. Linux developers write software using Mono.
2. Microsoft releases a new version of .NET for Windows containing features Mono doesn't support.
3. ???
4. Linux developers are forced to switch to Microsoft software or stop using Mono.

Could you fill in step 3, please?

Re:Good

[mhall119]

By that definition, both produce surprisingly lean executables.

Re:no mono

[MinistryOfTruthiness]

Actually, it was a precipitation superposition here today, so I find both of your claims highly suspect and extremely plausible.

Re:Good

[jacquesm]

This must be a meaning of the word 'only' that I wasn't previously aware of.

A few questions

[CrashandDie]

How many application servers have you got where you can run C# servlets?

How many companies use C# to write Enterprise-level servers?

What does C# give me that Java doesn't?

Unless all of the above have a positive and constructive answer, I don't see any point why I would learn another language for my Open Source projects/contributions when I'm an expert on Java due to my day-time job. This article is bullshit.

Re:A few questions

[Abcd1234]

How many application servers have you got where you can run C# servlets?

I'm sorry, what part of "Desktop Development" don't you understand?

This article is bullshit.

While that may be true, that's not the only bullshit I see here...

Re:A few questions

[CrashandDie]

I'm sorry, what part of "Desktop Development" don't you understand?

Instead of trolling on the first part of my comment, how about you read the rest of it?

My point was: why would I bother learning another language for Open Source contributions when there is a good chance it's never going to help me on a professional level?

Re:A few questions

[Abcd1234]

why would I bother learning another language for Open Source contributions when there is a good chance it's never going to help me on a professional level?

Because smart developers use the right tool for the job, and in my experience, Java is *not* the right tool if your job is to write a desktop application.

Re:A few questions

[CrashandDie]

Because smart developers use the right tool for the job, and in my experience, Java is *not* the right tool if your job is to write a desktop application.

And I'm sure your experience and point of view are extremely valuable, yet, you haven't swayed me over quite yet.

I agree with you that there are different tools, for a lot of different things. And indeed, smart developers should use the right tool for the job. But programming is just like anything else: it's a matter of personal choice. If I am quick at prototyping / developing using Java, what's to stop me? Hell, if I enjoy using Java, what's to stop me?

What if in my very specific use-case, Java was the best tool for the job?

Your experience is just that. Yours. Don't assume I'm wrong just because we don't share the same.

Re:A few questions

[Slime-dogg]

How many application servers have you got where you can run C# servlets?

ASP.NET runs on mod_mono as well as IIS. Going by definitions, there is no practical difference between the two.

How many companies use C# to write Enterprise-level servers?

Many. This is a bit of a ridiculous question. Live.com / bing runs on an ASP.NET architecture. Godaddy.com runs on ASP.NET. Plenty of companies run both Java and .NET solutions at the enterprise level, mine is one of them.

What does C# give me that Java doesn't?

It's just another language and platform to choose from. In that, it offers choice. Granted, there isn't anything in Java that you can't do with .NET, but the same goes the other way around. .NET does offer many newer things, like LINQ and Silverlight... things that haven't become available in Java.

Re:A few questions

[Abcd1234]

If I am quick at prototyping / developing using Java, what's to stop me?

Nothing, of course. But who the hell said anything about prototyping? We're talking about writing a desktop application in Java. A real product that might get used by real people.

Hell, if I enjoy using Java, what's to stop me?

Well, no one, of course. But don't be surprised if no one uses your app because it's ugly and doesn't integrate well with the rest of the system. That's all I'm saying.

What if in my very specific use-case, Java was the best tool for the job?

Then use it. Duh. I'm saying that when writing *desktop applications*, the odds are against that being the case. And note, I said "the odds are against"... it's certainly possible that for a very specific application, the issues with Java on the desktop are outweighed by its other advantages (more straightforward portability, trivial deployment (JWS), etc). But for your average desktop application, I highly doubt you'll find that's the case.

Your experience is just that. Yours. Don't assume I'm wrong just because we don't share the same.

So your experience is that Java works well for desktop applications? Please, do tell, I'm sure many others would like to hear your positive experiences, as, at least AFAICT, they're exceptions. About the only ones I can think of are Eclipse and Azureus, which notably depart from the Java tradition by using (the oh so horrible, IMHO) SWT instead of Swing in order to build a GUI that users will actually accept.

Java vs. C# is the wrong comparison

[Kihaji]

Java vs C# is the wrong comparison to be making when it comes to what is "better" to develop on. What should be looked at is the JVM vs CLR. This is where the real power of these two languages, and the others that run on them, comes to light. Languages and libraries can be made, but if the underlying VM doesn't support certain features, no syntax will make up for it. And, in my opinion, the CLR is slightly ahead of Java when it comes to power, mostly because of the support for generics at runtime, whereas the JVM doesn't (Java generics are type erased at compile time).

Re:Java vs. C# is the wrong comparison

[JAlexoi]

A) Not all generics are erased.
B) Power is such a misused word. Cycle for cycle JVM beats CLR without any issues.

Re:Java vs. C# is the wrong comparison

[Late Adopter]

CLR also supports true shared libraries, and the notion of a Global Assembly Cache, to prevent the need for mucking around with CLASSPATHs. And there's (hopefully soon) the Dynamic Language Runtime, to provide true dynamic typing in the VM.

I like Java, I really do. (Well, I don't like Swing, but nor do I like Winforms, so...). But as it stands, the CLR is the best technology with the best promise. The only reason I shy away from it is that the Linux implementation of the class libraries never seems to have all the features of Microsoft's (and we'll always be playing catch-up there).

Linux Desktop: Not freakin' Swing!

[Jahava]

A major fault that I've seen in numerous sub-threads is the idea that a Java user interface equals Swing. It most certainly does not. Swing is merely Java's complete pure-Java (i.e. cross-platform) user interface geared towards providing a unified look-and-feel. In this respect, it does a good job. While there's nothing inherently wrong with it from a toolkit perspective, it is absolutely not appropriate for usage on the Linux desktop.

Programming for the Linux desktop means more than producing a windowed application; one must integrate their application, both in terms of user interface consistency and application interoperabililty, with a major desktop distribution. Specifically, I'm talking about Linux's "big two" desktop environments, KDE + Qt and GNOME + GTK+. While each of these environments have their preferred languages (C++ and C respectively), many other languages have no issues whatsoever being tightly integrated into them via bindings.

Java is no exception! In Java, I can program a wonderful GNOME/GTK+ application just fine with java-gnome. Similarly, I can program a Qt4 application with Qt Jambi (although I can't seem to find an equivalent KDE4 bindings library) in Java. An application written in either will appear and operate on par with any application written in other languages, either natively (via C or C++) or via another bindings library (Python has a ton of bindings).

Furthermore, just like GTK+ and Qt have cross-platform capability, so do the bindings, and if the appropriate binding library for a given platform is installed on that platform, the Java application, too, will be able to be cross-platform without modification. This is, of course, the job of the distribution and/or installer software, but operates similar to the Deluge (Python) installer for Windows, installing the client port of the toolkit (GTK+, in this case) and the language bindings (PyGTK) alongside the application.

That's exactly how the Mono desktop applications work: they write their logic in native C# and use GTK+ bindings (GTK#, in most cases) to integrate with the Linux desktop environment.

Any Java application written for the Linux desktop that uses Swing over native desktop bindings is foolish. Each has their place, for sure, but on the desktop integration is everything.

Re:Linux Desktop: Not freakin' Swing!

[miguel]

Additionally, there are some glorious bindings for Qt called Qyoto now.

The Qyoto bindings power the very pretty Synapse IM client, it is worth taking it out for a spin, because the author has gone the extra mile to make his application good looking and very smooth:

http://eric.extremeboredom.net/2009/03/15/336

Re:Linux Desktop: Not freakin' Swing!

[TheTurtlesMoves]

but on the desktop integration is everything.

I hate integration. It means that a single update of a single package can bring the whole thing down. Honestly if i want to play music I don't give a carrots ass if its using the same font as the bloody word pad. I just want to play the friken music... I don't give a flip if it stores the setting in some kde standard place if it has crap playlist editing.... etc...

Whats the point of looking all nice and integrated if it doesn't bloody work? Which is why the bulk of the apps i use and find productive are bad examples of desktop integration.

Re:Linux Desktop: Not freakin' Swing!

[Late Adopter]

Furthermore, just like GTK+ and Qt have cross-platform capability, so do the bindings, and if the appropriate binding library for a given platform is installed on that platform, the Java application, too, will be able to be cross-platform without modification. This is, of course, the job of the distribution and/or installer software

This is not a trivial step. There will always be advantages to pure Java code, the most obvious being it runs anywhere you have a JVM, and installs and behaves exactly the same way with no platform dependent code.

Re:Linux Desktop: Not freakin' Swing!

[VGPowerlord]

Furthermore, just like GTK+ and Qt have cross-platform capability, so do the bindings, and if the appropriate binding library for a given platform is installed on that platform, the Java application, too, will be able to be cross-platform without modification. This is, of course, the job of the distribution and/or installer software

This is not a trivial step. There will always be advantages to pure Java code, the most obvious being it runs anywhere you have a JVM, and installs and behaves exactly the same way with no platform dependent code.

Well, actually, it's because that particular platform-specific code is part of the JVM.

Swing takes this route. SWT probably does in IBM produced JVMs... but not in Sun's, since Sun hates SWT.

Re:Linux Desktop: Not freakin' Swing!

[dkf]

Any Java application written for the Linux desktop that uses Swing over native desktop bindings is foolish. Each has their place, for sure, but on the desktop integration is everything.

You might as well also claim that anyone who has to develop and deploy software across lots of platforms is foolish too. After all, developers have lots of time to reimplement the entire GUI layer for each supported platform.
</sarcasm>

For a great many developers, desktop integration is not and should not be everything. They've got real applications to support, and not just desktop toys or reinventions of the wheel. (Some are commercial developers, some aren't, but those specialist apps are not going to go away soon; there's just not that big a global market for them that they commoditize.)

Re:Good

[Freetardo Jones]

People care about what other people code in if there's a 200+MB download just to be able to run it...

Because anyone forces you to use their app?

Re:Good

[Freetardo Jones]

VB is Microsoft's bastardized version of Java.

So Microsoft bastardized a language that 5 years before it existed? That's amazing even for them!

Eclipse just runs

[falconwolf]

I'm sorry, but Eclipse just runs from the decompressed download, even if it's on your desktop.

No it doesn't. Eclipse runs in my admin account but every tyme I start it in my user account I get error messages. Sure, I could use the admin account but I don't want to screw up things. I can easily delete then create a new user account, if I really needed to, without messing anything else up. I only use the admin account to install hardware and software and to update my system.

Falcon

Re:Eclipse just runs

[setagllib]

I call BS. At a former job I had an account with no admin rights at all, and I installed and ran the JRE and Eclipse from a network share. No special intervention required.

If you install Eclipse to somewhere you can't write, it will automatically detect that and write things to your per-user directory instead, even for installing plugins. It literally couldn't be any simpler.

Re:Eclipse just runs

[falconwolf]

I call BS. At a former job I had an account with no admin rights at all, and I installed and ran the JRE and Eclipse from a network share. No special intervention required.

You can call BS all you want. That does not make what I said, that I get errors when I try to run Eclipse in a user account wrong. I get the error "Could not create the view: An unexpected exception was thrown." The details are:

java.lang.NullPointerException
at org.eclipse.jface.resource.FileImageDescriptor.getFilePath(FileImageDescriptor.java:219)
at org.eclipse.jface.resource.FileImageDescriptor.createImage(FileImageDescriptor.java:172)
at org.eclipse.jface.resource.ImageDescriptor.createResource(ImageDescriptor.java:165)
at org.eclipse.jface.resource.DeviceResourceManager.allocate(DeviceResourceManager.java:56)
at org.eclipse.jface.resource.AbstractResourceManager.create(AbstractResourceManager.java:88)
at org.eclipse.jface.resource.ResourceManager.createImageWithDefault(ResourceManager.java:192)
at org.eclipse.jface.resource.ImageRegistry.get(ImageRegistry.java:212)
at org.eclipse.jface.fieldassist.FieldDecorationRegistry$Entry.getDecoration(FieldDecorationRegistry.java:197)
at org.eclipse.jface.fieldassist.FieldDecorationRegistry.recomputeMaximums(FieldDecorationRegistry.java:401)
at org.eclipse.jface.fieldassist.FieldDecorationRegistry.registerFieldDecoration(FieldDecorationRegistry.java:348)
at org.eclipse.jface.fieldassist.FieldDecorationRegistry.(FieldDecorationRegistry.java:132)
at org.eclipse.ui.internal.views.markers.MarkerColumnLabelProvider.(MarkerColumnLabelProvider.java:39)
at org.eclipse.ui.internal.views.markers.ExtendedMarkersView.createColumns(ExtendedMarkersView.java:409)
at org.eclipse.ui.internal.views.markers.ExtendedMarkersView.createPartControl(ExtendedMarkersView.java:483)
at org.eclipse.ui.internal.ViewReference.createPartHelper(ViewReference.java:371)
at org.eclipse.ui.internal.ViewReference.createPart(ViewReference.java:230)
at org.eclipse.ui.internal.WorkbenchPartReference.getPart(WorkbenchPartReference.java:594)
at org.eclipse.ui.internal.PartPane.setVisible(PartPane.java:306)
at org.eclipse.ui.internal.ViewPane.setVisible(ViewPane.java:531)
at org.eclipse.ui.internal.presentations.PresentablePart.setVisible(PresentablePart.java:180)
at org.eclipse.ui.internal.presentations.util.PresentablePartFolder.select(PresentablePartFolder.java:270)
at org.eclipse.ui.internal.presentations.util.LeftToRightTabOrder.select(LeftToRightTabOrder.java:65)
at org.eclipse.ui.internal.presentations.util.TabbedStackPresentation.selectPart(TabbedStackPresentation.java:473)
at org.eclipse.ui.internal.PartStack.refreshPresentationSelection(PartStack.java:1256)
at org.eclipse.ui.internal.PartStack.createControl(PartStack.java:668)
at org.eclipse.ui.internal.PartStack.createControl(PartStack.java:576)
at org.eclipse.ui.internal.PartSashContainer.createControl(PartSashContainer.java:568)
at org.eclipse.ui.internal.PerspectiveHelper.activate(PerspectiveHelper.java:271)
at org.eclipse.ui.internal.Perspective.onActivate(Perspective.java:968)
at org.eclipse.ui.internal.WorkbenchPage.onActivate(WorkbenchPage.java:2593)
at org.eclipse.ui.internal.WorkbenchWindow$25.run(WorkbenchWindow.java:2873)
at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:70)
at org.eclipse.ui.internal.WorkbenchWindow.setActivePage(WorkbenchWindow.java:2854)
at org.eclipse.ui.internal.WorkbenchWindow$19.runWithException(WorkbenchWindow.java:2171)
at org.eclipse.ui.internal.StartupThreading$StartupRunnable.run(StartupThreading.java:31)
at org.eclipse.swt.widgets.RunnableLock.run(RunnableLock.java:35)
at org.eclipse.swt.widgets.Synchronizer.runAsyncMessages(Synchronizer.java:133)
at org.eclipse.swt.widgets.Display.runAsyncMessages(Display.java:3342)
at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java:3071)
at org.eclipse.ui.application.WorkbenchAdvisor.openWindows(Work

Re:Eclipse just runs

[dna_(c)(tm)(r)]

Yes it does. You did something wrong.

Re:Eclipse just runs

[setagllib]

If you're the only person in the world with this problem, maybe it's because of you or your environment, not the Eclipse project. If you believe you have encountered a real bug, submit a bug report and get it solved. If you don't really believe you've found a bug, then don't troll on Slashdot about it. It's one or the other, so choose.

Re:Eclipse just runs

[falconwolf]

Yes it does. You did something wrong.

No I didn't. I founded the instructions here as well as looked at your link. Notice though how yours does not say how to install Eclipse in OS X whereas mine does. Your instructions are specifically for installing it on Windows. And someone else got a similar error as I did when they installed it in Ubuntu.

Falcon

Re:Eclipse just runs

[dna_(c)(tm)(r)]

Even on OS X it's just untarring (even on the desktop) - I have OS X and Ubuntu. Can't check on Windows.

My point is that 'installing' eclipse is extracting it to a directory of your choice and running the executable. That's it.

Since I have a lot of plugins and projects, I had to increase -XX:MaxPermSize=256m (eclipse.ini) and looking at my history, I found I installed "libstdc++5" manually, a few commands later. My upgrade from 8.10 to 9.04 was aborted halfway due to a cat and power switch incident, so I had to reinstall Ubuntu and some stuff like eclipse :-(

Re:Eclipse just runs

[falconwolf]

My point is that 'installing' eclipse is extracting it to a directory of your choice and running the executable. That's it.

And despite doing that I get errors when I run or try to run Eclipse in my user account, but don't when it's run in an admin account.

Falcon

As a Mono/.NET Fan - Idiotic Article

[blackpaw]

I love C#/.NET/Mono, the platform is excellent and the languages great. I also work a *lot* with embedded java and NetBeans - its ok but I do feel Java is inferior to C#.

However that article was seriously crappy. MonoDevelop is nice and shows potential - but its a toy compared to Eclipse, NetBeans or Visual studio, I would never consider it for enterprise development or a project of any size, I'd rather work with cmake and Kate. When we see C# support integrated into KDevelop4 we might see a decent C# IDE on linux.

And those bizzare comparisons of project numbers - weird. And is it just me or was the grammar and sentence construction erratic and disjointed.

I want to see more mono on the desktop and server in Linux, articles like this don't help.

Re:Good

[mhall119]

You must not be including all of J2EE and J2ME.

Client Profile is 28 MB

[benwaggoner]

200+ is for all the developer goo.

The Client Profile for .NET 3.5 SP1, which is all that's needed to install a .NET app on a machine that doesn't have .NET 3, is 28 MiB.

http://msdn.microsoft.com/en-us/library/cc656912.aspx

And Silverlight is less than 5 MiB if the app can run entirely in the Silverlight sandbox.

Mono is 75 MiB on Windows, 56 MiB on Mac, . Moonlight is (really?) 941 KiB.

Re:Client Profile is 28 MB

[rdnetto]

200+ is for all the developer goo.

Not quite true. The client profile cuts out a lot of useful functionality (e.g. LINQ), to the point where you might as well target .NET 2.0 instead.

That said, the total size needed for an online installation of 3.5 SP1 on Vista is ~50 MB (since it comes preinstalled with 3.0), and mono is less than 20 MB.
The full 200 MB is only required for WinXP systems that don't have any version of the framework installed at all.

Re:Client Profile is 28 MB

[Late Adopter]

Moonlight only supports Silverlight 1, which is basically enough to generate the dialog box that tells you you need Silverlight 2.

Re:Good

[Jerry Coffin]

Regarding your fourth citation: Java's generics aren't "reified". If you care about what the means, here's a short article on the subject. I'm not trying to say I think Java's generics are entirely inferior, or anything like that -- just that what you've cited isn't really exactly the same thing.

Likewise, your fifth citation regards dynamic classes. The other post was about dynamic methods. A dynamic class means you can create a new class at run time. A dynamic method means you can create a new method for an existing class at run time. While there's certainly similarity between the two, they're just as certainly not the same thing.

To give a really simplified (but hopefully not to the point that's it's actively misleading) explanation: for Java, think of a grid with classes along one axis, and interfaces along the other axis. A dynamic proxy class lets you put an 'X' at a more or less arbitrary box in that grid, setting up the connections so that class implements that interface. On the C# side, think of a class as having a row of boxes, one for each method in that class. A dynamic method allows you to add an entirely new box to the row, so it now has a method that didn't previously exist at all.

Unfortunately, if the method for that "box" is really completely new, you won't have other code that knows how to use it, and it won't necessarily accomplish a lot. One obvious use is about like in Java, to add methods that some existing code already knows how to use. OTOH, it certainly is possible to use it other ways. For one example, another program sends some previously unknown message, and you connect things up so that message ends up invoking your entirely new function. Taken to an extreme, you could define your "program" as little more than a tiny framework, for defining functions and connecting them to be invoked by messages (collecting appropriate data from dynamically generated forms).

Re:Good

[Cyberax]

Friend, I _wrote_ a JVM implementation.

I know how garbage collector works in Sun JVM to the level of assembly language generated for write barriers, I know how HotSpot compiles byte-code, etc.

Well, the current C# is not very much like Java. It's actively moving towards functional languages (while Java is not moving anywhere) to the point where you can write purely-functional lazy-evaluated functions as LINQ expressions, something crazy like this: http://blogs.msdn.com/lukeh/archive/2007/10/01/taking-linq-to-objects-to-extremes-a-fully-linqified-raytracer.aspx

VB is not a bastardized Java, it's a separate language (quite powerful in its VB.NET form), related to C#. It even has a few features not accessible from C#.

Re:Good

[guyminuslife]

This sounds like something someone would write under the influence of some serious amphetamines.

Re:Good

[Mr2001]

Excuse me. Java pre-dates VB by a considerable amount.

Visual Basic 1.0 was released in 1991. Java was released in 1995. So, no.

Java does predate VB.NET, however. VB.NET is not compatible with VB versions 1-6 and changes some fundamental concepts (like the object model), though the syntax is mostly the same. Rather than "C# is VB with C syntax", it's more accurate to say "VB.NET is C# with VB6 syntax".

Re:Good

[Cyberax]

"I'm not trying to say I think Java's generics are entirely inferior, or anything like that -- just that what you've cited isn't really exactly the same thing."

Well, I wrote a fair amount code in C# 3.5 and I haven't found an instance where reified generics were a problem. On the other hand, type erasure has bitten me in the ass a few time in Java. And it's also possible to create reified generics with full backwards compatibility (read the comments to the article you've posted).

"A dynamic class means you can create a new class at run time. A dynamic method means you can create a new method for an existing class at run time."

Yup. And C# (or more exactly, CLI) can do both. Java also plans to add invokedynamic instruction, but it's not here yet.

Re:Good

[Inner_Child]

Two comments above, it states that VB came out in 1991, Java in 1996. I'm not sure if time flows backwards for you, but the last time I checked, 1991 was before 1996. Granted, that's for the language. Which is the only fair comparison, as VB is also a language. The Java *platform* began in December, 1990, but wasn't even shown to anyone until 1992. So VB still predates Java.

I'm starting to think it's you who haven't been around very long.

Re:Good

[Captain Segfault]

No it doesn't.

From wikipedia, Java's first release was in 1995 and VB's first release was in 1991.

Re:Good

[Cyberax]

No. Reified generics instantiations create a new instance of a generic class. I.e. a List will be different from List in C#.

While in Java they would be the same. It's pretty efficient in practice, more so because C# allows to parametrize generics with primitive types and structs.

Of course, templates in C++ are way more powerful (they are Turing-complete!!!)

Re:Good

[Lord Crc]

Excuse me. Java pre-dates VB by a considerable amount. You haven't been around long either have you?

The initial project that became Java started in 1991, the same year Visual Basic 1.0 was released. Java was released to the public in 1995, the same year Visual Basic 4.0 was released. How do you figure that Java predates VB by a considerable amount?

Re:Java GUI sucks on Windows

[b4dc0d3r]

I've never seen a Java app on Windows that ran with any decent GUI ever. All of the objects seem to be widgets drawn custom instead of using native win32 functions and objects.

File / Open has its own dialog, which looks ALMOST but not quite like Windows version. It is terrible to operate with a keyboard and is missing features I expect in the dialog. You're recreating things instead of using the native libraries. It would be one thing to create new things, but these are just bad copies.

It's like Java developers and devs who use Java have never seen a GUI, and don't quite know what people expect. Certainly they aren't Windows users. As much as they imitate it, they really seem to have no idea what it's supposed to be like. I get scared when people say things are written in Java.

Re:MS Is Making Fools Out Of The Open Source World

[Korin43]

The beauty of the Linux community is that people can work on whatever the hell they want. Why should I care if someone wants to write a program using Mono? People writing software should use whatever tools they think would be best. And I'd guess that the people complaining about Java not being GPL aren't the same people using Mono. Stop trying to lump all open source users/developers into one group. People use it for different reasons.

Re:Good

[Mr2001]

From what I gathered they pretty work like type erasure in Java, ie. there's no genericity at all for reference types, it's the same code with implicit casts for all instantiations. (Value types are different naturally.)

Not quite. There are no "implicit casts" with .NET generics.

You're probably thinking of the fact that all instantiations of a generic method with different reference type parameters share the same native code. But when you call a generic method, the VM's static type checker knows the actual parameter/return types, so there's no need for any type casting at runtime: sharing the native code is just an optimization since the native code would be identical anyway.

The difference means that .NET generics can have better performance than Java generics, even when the type parameters are reference types, because no runtime casting is needed. The .NET VM can verify that the method call is type-safe because it has access to the type parameters that Java throws away.

Re:MS Is Making Fools Out Of The Open Source World

[Draek]

The fact that posts like yours get modded up here ashames me.

So the facts that Qt and Java's licensing were problematic due to copyright concerns (y'know, those things pretty much the entire world recognizes thanks to the Berne Convention) are just a triviality best ignored, while Mono's alleged "patent threat" is a serious problem despite being at *best* limited solely to the US and Japan?

And somehow the fact that the NIH poster-child Apple isn't using Mono is supposed to support your point, despite the fact that they've got the WORST support for Java in the entire industry, prefering instead to push their own little C fork?

Its obvious you have an axe to grind, but thats no excuse to ignore factual information and logical arguments.

Hardly convincing

[stuntpope]

"Mono is clearly more popular than Java. I've been using desktop Linux as my primary desktop for three to four years, and use just a handful of Java apps day to day," O'Grady said.

Clearly he gives no information about the numerous (more than a handful) of Mono apps he's using day to day on Linux. Oh, previously in the article they mention Tomboy, Banshee, and Gnome Do. So what are all the others too numerous to mention?

On any platform I use (Windows, Linux, OS X), I user fewer than a handful of Java apps each and every day. And you know how many .Net or Mono apps I use (including on Windows)? Fewer than that.

I suppose going from zero Mono apps in popular use to 3 or 4 does represent a "spike" in Mono development, but I'd hardly say it's evidence of Mono outpacing Java development on Linux.

As for outdated versions of Eclipse on popular distros, of all the people who would go to the trouble of updating to the latest version regardless of whether it was packaged with the distro, developers would. Pointing out a lack of code completion or integrated debugging in Eclipse is a laugh.

Re:Good

[arose]

LINQ is a .NET 3.5 feature not a C# (as in the ECMA standard) feature. There is no such thing as C# as far as any sort of standards are concerned.

Horrible thought

[extrasolar]

You comment suddenly made me wonder. What if the world was written in brainfuck?

That... That would explain a lot.

Re:Good

[MrNaz]

Sheesh. Back in my day we got by just fine with "You shithead".

Re:TFA is poorly written, but...

[setagllib]

You have just got to be kidding. For Windows it's just a .zip that you unpack, then run eclipse.exe. Make a shortcut if it helps. For Linux it's a tar and you can use a graphical archiver for that too. If a "software developer" can't work that out, I don't want to be anywhere near their code. It takes more clicks just to create a new project than to install Eclipse!

Re:Good

[tcmatthews_jr]

If by "VB" you mean VB.Net, I would say it's the reverse: C# is Microsoft's "bastardized version" of Java (though mostly better IMO), and VB.Net is C# with VB syntax.

Actual I think VB.Net is more of a VB, C# Frankenstein monster. Microsoft chopped up VB6 and sewed it into the C# Common run-time environment. If you knew Basic you could basically throw together some pseudo code and VB would work. No such luck with the VB.Net monster. I heard that many of the issues I had have been cleaned up, but I still wont touch it. Which is a shame because VB was good if you need a quick prototype of a windows application.

If you have to do .Net programming stick to C#.

Re:Good

[thePowerOfGrayskull]

And as far as the parent is concerned, I have to agree. Java class hierarchy is a big pain in the ass! Trying to find needed classes and having to include things that aren't needed just to use certain features. It's as bad as MFC in that regard.

Wait, parent said there wasn't enough; you're agreeing and saying there's too much. Which is it? (BTW... you don't load anything that you don't use, in the same way that you don't load classes you don't use in .net. "import" statements do not mean "automatic overhead of loading classes"; this is true on both platforms.)

Wait, what?

[thePowerOfGrayskull]

FTA: "

Mono is clearly more popular than Java. I've been using desktop Linux as my primary desktop for three to four years, and use just a handful of Java apps day to day," Oâ(TM)Grady said

I'm sorry... has someone missed the gazillion java applications that are cross-platform? Is this article really based on the opinion of ONE developer?

However, there was a near consensus among the experts interviewed by SD Times that Mono has done a better job at attracting developers than Java. According to O'Grady, Java and Linux are two of the most popular disruptive technologies in open-source development, but they are not intrinsically paired on the desktop: Java can run on any number of platforms, whereas Mono can more effectively target Linux. Mono also runs on Mac OS X and Solaris. "Regardless of what you think of Microsoft, there are nice technologies here," he said.

Yes, yes it seems that it is.

Sooooo...

[QuietLagoon]

Microsoft is still planting articles in the trade press. Oh, what a surprise.

Re:Good

[kabdib]

About seven years ago I went from full-time Java programming to full-time .NET programming.

And after a month or so of being uncomfortable, there came a day when I thought to myself, "Oh thank God, the nightmare is over."

Real async I/O (not faking it by handwaving and mumbling "Well, do that with threads."). A wonderful native code interop story. An IDE that just worked. The ability to do user interfaces that didn't utterly suck and didn't look like they were designed by a misanthropic X-Windows hacker. Oh, it wasn't perfect, but I was spending most of my time writing code and actaully having fun, instead of wading through screwed-up configuration files and figuring out WTF was wrong with the JIT -vs- non-JIT environment.

Say what you want, but the day I left Java behind, I was quite happy.

There _IS NO SUCH THING_ as Java 6.

[falconwolf]

There isn't? You'd better tell the 1.1 million websites that are returned when googling "java 6".

Look at the software source code and package names, and try typing 'java -version" at the command line.

Better yet, I can open the Java Preferences Application. It shows:

Java Applet Plugin

• J2SE 5.0 32-bit
• Java SE 6 64-bit
• J2SE 5.0 64-bit
• J2SE 1.4.2 32-bit

As well as:

Java Applications

• J2SE 5.0
• Java SE 6 64-bit
• J2SE 5.0 64-bit
• J2SE 1.4.2 32-bit

The book I have from Sun is titled:
"Core Java(TM), Volume I--Fundamentals (8th Edition)" and is for Java SE 6.

Falcon

Re:There _IS NO SUCH THING_ as Java 6.

[Antique Geekmeister]

Yes, and I can find millions of hits on "astrology", too. The number of hits doesn't make it real. The reality is that Sun's advertising lies about actual software numbers. "Java 6" is a serious upgrade of Java, but the actual source code says, and I quote from Sun's own "java -version" command, from the installed 'JDK 6u14" off of Sun's own download site:

# /usr/java/default/bin/java -version
java version "1.6.0_14"
Java(TM) SE Runtime Environment (build 1.6.0_14-b08)
Java HotSpot(TM) 64-Bit Server VM (build 14.0-b16, mixed mode)

Sun has been playing strange marketing names with version numbers for _years_. They did it with Solaris "2.4", which was actually "SunOS 5.4" according to their own software ID numbers. And they're still doing it.

Go ahead, download the current "JDK" and all the other stupidly named versions of JDK's and JRE's. Look carefully inside the package: when you pluck apart their "jdk-6u14-linux-i586-rpm.bin", you'll see that what it acutally has hidden inside it and misnamed as 'jdk-6u14-linux-amd64.rpm' is actually 'jdk-1.6.0_14-fcs.x86_64.rpm'. This is, in fact, extremely nasty, because once you've installed their atual RPM it doesn't have that 'jdk-6u14" name anywhere in the RPM listings, and you cannot delete that name.

Re:There _IS NO SUCH THING_ as Java 6.

[JAlexoi]

The VM implementation version is not the product name. Java 6 is implemented by JavaRuntimeEnvironment(a.k.a VM) 1.6...

Re:MS Is Making Fools Out Of The Open Source World

[Blakey Rat]

Jesus Christ the paranoia is thick in here today... what happened? You all lost your tin-foil hats on the same day?

Re:Good

[cryptoluddite]

C# right now has the following features that are absent in Java

Right now Java has the following features that are absent in C#:

1) High performance VM
2) Code that does what it says without hidden conversions, text substitutions, and macros.
3) Other languages that are actually useful like Scala and Clojure.

Mono performance is a joke compared to Java, and MS CLR performance is even pretty bad in comparison. Code that is a one-liner because of lots of magic conversions and macros (like 'extension' methods) collects fanboys, but is counter productive for real, boring, meat and potatoes coding.

And LINQ? Why are you doing database and 'data sources' queries in something like C#? Use python or something like that. You need that super-fast JIT "cc -O0" speed to print out customer numbers and such?

Basically Java:C# :: C:C++. It's the same story all over again, but for typesafe languages instead of the systems code. C# thinks that making the code a concise series of magic conversions and convenient syntax makes it a better language. Java thinks that having code be straightforward and simple, but longer, is better. C has a solid niche, and will for decades. C++ is widely recognized as a byzantine failure in every case. We'll have to wait and see with Java and C#, but I know where I'd place my bets.

In other news...

[bXTr]

The Hustle is now more popular than the Charleston on the dance floor, the Ford Granada outsells the Chrysler Cordoba, and people prefer the taste of Bubble-Up over Moxie.

I came here to ask that.

[pavon]

Does anyone know QtJambi is doing? I heard that Nokia has stopped maintaining it since purchasing trolltech. Is that a big deal, or was it largely community supported to begin with?

Re:I came here to ask that.

[Jahava]

Does anyone know QtJambi is doing? I heard that Nokia has stopped maintaining it since purchasing trolltech. Is that a big deal, or was it largely community supported to begin with?

I'm not really well-versed on the subject, but I did do some research earlier today, so I'll try and post what I found. It looks like you're correct, insofar as that Qt Software says it will discontinue Qt Jambi. However, in the same press release, they mention that they will host and help maintain a community-driven version, which (I'm guessing) is here. The site itself makes no mention of the project halting, and the front page shows very regular updates, including a FreeBSD port.

I really hope Jambi enjoys continued development. In my opinion, bindings libraries like Qt Jambi are absolutely critical, both to unlocking the power of a language as well as fostering a diverse tool set and developer base for FOSS platforms. Furthermore, when you combine a cross-platform toolkit like Qt with a cross-platform language like Java (or Mono, for that matter), the result is pretty cool. Developers just have to overcome the misconception that Java is for applets/J2EE/embedded, and that the UI face of Java is Swing. It's a language, like any other, with pros, cons, and fans, and (in my opinion) exceptionally suited for desktop application development.

Re:MS Is Making Fools Out Of The Open Source World

[dhasenan]

Google decided early on a limited set of programming languages to support. C# didn't exist then.

Jeez.

[cunamara]

Who names an application framework after an infectious disease?

Re:Jeez.

[justleavealonemmmkay]

and then one that is particularly irrelevant to nerds too...

Re:Jeez.

[Marcus Green]

Dunno, neither Java or Mono are the name of infectious disease in my part of the world, where are you from?

Re:MS Is Making Fools Out Of The Open Source World

[MightyMartian]

Could you cite an independent legal opinion that states the "community promise" is binding?

Re:Good

[Anonymous Coward]

If you compare VB.Net to VB, you will find that it's more akin to C# with VB syntax- which is why he probably made the comparison.

Having programmed in quite a bit more programming languages than is healthy (You could count them on your hands and toes and still not get all of them counted...)- and many of those in production settings, I can tell you that it's little different than Java in nature. People claim that there's loads done for you and you can code in a high level. The same can actually be said of Java. Moreover, it can be said that while it's "nice" to code at a high level, this ALWAYS comes at a price.

Keep in mind that LSE was done up with .Net- the full monte. Unfortunately, LSE, even though it's volume isn't the same as NASDAQ or NYSE, cratered under their nifty new toy and deployed back to a Linux based system that could cut the mustard there.

C# isn't the greatest thing since sliced bread and I really, really wish people would QUIT trying to make it out to be that. It's nice. It's suitable as a tool for SOME tasks- though it's debatable that it's better than other tools at those same tasks.

Re:Good

[timmarhy]

i think you need to pipe down - that's 2 comments you have made that have resulted in multiple people ripping you a new one.

As largely a Windows person myself

[falconwolf]

I switched from Windows to Linux and Mac OS X and I want to program cross platform. I figured that at first I could program in Java, but I want to learn to program on Macs and Linux PCs in C/C++ as well as other languages.

Falcon

Re:Good

[Anonymous Coward]

.NET is not a language... .NET is an environment that runs on the CLR which can be accessed through several different languages (Managed C++, C#, J# to name a few)...

Java is a language that runs the JRE on a JVM.

For better understanding,

Java is to C# as .NET is to the JRE as the CLR is to the JVM.

Any questions?

Could you fill in step 3, please?

[falconwolf]

Number 4, "4. Linux developers are forced to switch to Microsoft software or stop using Mono" , is number 3.

Falcon

Re:Could you fill in step 3, please?

[Mr2001]

But that doesn't follow from step 2. Microsoft releasing a new version of .NET does not directly lead to anyone being forced to stop using Mono or switch to Microsoft software.

After all, Microsoft is already up to .NET 3.5. People are still using Mono, and software written for .NET 2.0 still runs fine on Mono. Developers who target Mono simply ignore the features that Mono doesn't support.

So, how exactly is the "extend and extinguish" part of this scheme supposed to work? There's still a big question mark in the middle.

Re:Could you fill in step 3, please?

[falconwolf]

But that doesn't follow from step 2. Microsoft releasing a new version of .NET does not directly lead to anyone being forced to stop using Mono or switch to Microsoft software.

They do if they want to stay current, and I think anyone worth salt would want to stay current.

After all, Microsoft is already up to .NET 3.5. People are still using Mono, and software written for .NET 2.0 still runs fine on Mono. Developers who target Mono simply ignore the features that Mono doesn't support.

And when .net reaches 5.1 or 10.1? By your reasoning people should still be using Windows 3.x. I doubt 1% do today.

So, how exactly is the "extend and extinguish" part of this scheme supposed to work? There's still a big question mark in the middle.

The only thing needed between "Microsoft releases a new version of .NET for Windows containing features Mono doesn't support" and "Linux developers are forced to switch to Microsoft software or stop using Mono" is the need to remain current.

Falcon

Re:Could you fill in step 3, please?

[Mr2001]

They do if they want to stay current, and I think anyone worth salt would want to stay current.

If they're using Mono to write software that runs on Linux, then no, they won't care about staying "current" with Microsoft's releases. They'll care about staying compatible, which means either using the latest version of Mono and all it provides (if they only care about Linux), or using the common subset of features supported by both Mono and .NET (if they're writing cross-platform apps).

Hell, even Windows developers don't necessarily care about staying current. I'm a developer on two commercial apps written in C#, and they both target .NET 2.0. In the case of one of them, that's specifically so that it will be compatible with Mono.

And when .net reaches 5.1 or 10.1?

By then, presumably Mono will have caught up with .NET 4.1 or 8.5.

By your reasoning people should still be using Windows 3.x. I doubt 1% do today.

I don't see how this is relevant. The Windows 3.x API was not submitted to an industry standards group and promoted as a cross-platform standard. No one has piles of Windows 3.x code that they expect to remain compatible with other platforms. No one is writing new code targeted to an open-source implementation of Windows 3.x.

The situation with Mono is different. If you write a bunch of C# code for Mono, using the features of .NET 2.0, because you want your software to run on Linux, you aren't going to give up on Linux compatibility and throw away all that investment just because Microsoft releases a shiny new version.

The only thing needed between "Microsoft releases a new version of .NET for Windows containing features Mono doesn't support" and "Linux developers are forced to switch to Microsoft software or stop using Mono" is the need to remain current.

You really think Linux developers are willing to give up on Linux just to "remain current" with Microsoft's releases? Seriously?

Re:Java GUI sucks on Windows

[mozzis]

Absolutely. I've been involved in development of several major Java desktop apps and this is always the take of most of our Windows user set - things don't look, feel or act quite "right".

Re:MS Is Making Fools Out Of The Open Source World

[daemonburrito]

There is no patent mess.

You were saying that before the "Community Promise". Funny, right?

And yes, the "community promise" doesn't make your statement true. The "Promise" only covers ECMA 334 and 335 (C# language and CLI), as you're well aware.

Astute readers will point out that Mono contains much more than the ECMA standards, and they will be correct.

- Miguel

Indeed, Mono is officially being split in half. But you already knew that.

Re:Good

[binary paladin]

I really, really like C# and I gotta say, I'm a big fan of operator overloading, a feature lacking in Java that always manages to piss me off.

I found my work in .NET to be pleasant and I actually really dig ASP MVC for web development. It's not my favorite, but I'd say it's my favorite statically typed language. I wish people would evaluate .NET beyond the fact that it's a Microsoft creation.

Re:Good

[man_of_mr_e]

Well, I wrote a fair amount code in C# 3.5

Apparently not enough to know that there's no such thing as C# 3.5. There's C# 3.0, and .NET 3.5, but no C# 3.5. Even a casual familiarity with the technogies would make you aware of that.

Re:Good

[man_of_mr_e]

Umm.. what? That comes as a suprise to my copies of the ECMA 335 and ISO 23270, both of which claim to be C# standards.

No, LINQ has not been added to these standards yet (they're in the process of doing that for C# 4) but C# is certainly both an ECMA and ISO standard.

Re:MS Is Making Fools Out Of The Open Source World

[CodeBuster]

Its obvious you have an axe to grind, but thats no excuse to ignore factual information and logical arguments.

You must be new here...

Re:MS Is Making Fools Out Of The Open Source World

[ClosedSource]

Could you cite an independent legal opinion that states "mono faces patent problems beyond the average open source project".

look at the numbers

[jipn4]

Removing the Java runtime engines on my Ubuntu Linux machine results in only one application being uninstalled: azureus.

Removing the Mono runtime results in about a dozen Gnome desktop application being uninstalled.

Java really has little significance on the Linux desktop, and for good reason: Java applications don't look and feel right on Linux.

Re:look at the numbers

[mvdwege]

I call bullshit. There are 4 major Mono applications in the Gnome distribution:

1. Tomboy.
2. Banshee.
3. F-Spot.
4. Beagle.

So care to enlighten me which other 8 applications get removed if you remove Mono?

Mart

Re:look at the numbers

[jipn4]

So care to enlighten me which other 8 applications get removed if you remove Mono?

Here are a bunch of them: Tomboy, Banshee, F-Spot, Gnome Do, Beagle, Blam, Muine, Tangerine, Hipo, gTwitter, Last Exit, Graphmonkey, Giver, Drapes, Cowbell, Bless, gBrainy, autopano-sift.

Re:look at the numbers

[SLi]

Wow. Naming. I'm a long time Debian and KDE user, and I'm surprised that I don't recognize any one of those names. Not that all KDE program names are so much better. But I can't even guess with any certainty what those do, save for gTwitter. I can try: Graphmonkey is graphing software (like gnuplot). Tomboy I'm sure I've heard of (probably many times), and I assume it's something quite hyped, but still no idea what it does :-) (unless I'm confusing it with Tomcat). gBrainy, I'd expect that to be some "brain training" puzzle.

Re:look at the numbers

[mvdwege]

Wow, you're right. There really are a lot more Mono applications nowadays. How did I ever live without them?

Good grief. More than half of that list is half-assed clones of existing C programs. They're proofs of concept, not applications.

Mart

Re:look at the numbers

[True Grit]

Removing the Mono runtime results in about a dozen Gnome desktop application being uninstalled.

Sounds to me like thats Gnome's problem, not Linux's problem. FWIW, I run KDE, so I have nothing on my system that needs Mono, but several things that use Java. That doesn't really prove anything though, as "proof by anecdote" isn't real proof at all.

Java really has little significance on the Gnome desktop

There, fixed that for ya.

and for good reason: Java applications don't look and feel right on Linux.

Oh please, Linux doesn't even have a standard desktop environment, GUI toolkit, or even a standard theme, and you have the audacity to use the phrase "look and feel" in the same sentence with "Linux"?

Troll much?

Re:look at the numbers

[higuita]

tomboy: heavy bloated crap
Banshee: slow and heavy
f-spot: thats ok, a little heavy, bug digikam is better
Beagle: worst slow, heavy crap

most, if not all C# apps are slow and heavy... not very different from java (that at least runs well in more platforms, always! and is now GPL)

Is it delusion or shameless lie?

[alukin]

Or may be it is just joke? How one can compare Eclipse and Netbeans to Mono Develop?

Novel is pushing hard it's half-working Mono in Gnome but it does not mean that we need it. "mononono" pakage is best proof of it. Is there "javanono" package somewhere? Right.

Re:Eclipse is stagnating

[PerlDudeXL]

The last time I tried NetBeans, it was a pure Java IDE.
I run Eclipse at work for C/C++ development.

Re:Good

[benjymouse]

Actually the list is a bit longer

• Unsigned integer types
• Decimal type built-in (the Java one is a second-class library feature without operator and conversion support)
• Unified arrays and collection
• True rectangular (multidimensional) arrays
• Pointers and -arithmetics (in "unsafe" code - e.g. code designed to work with natibe APIs)
• Object oriented, type safe method pointers ("delegates")
• Value types - types with copy semantics
• Closures
• Lambdas (an inline function which can double as a closure or an expression tree)
• Expression trees
• Automatic resource management blocks (the "using" statement)
• Type inference
• Iterators (aka "generator function" or "sequence comprehensions") - the "yield" statement
• Query expressions
• Better boxing/unboxing
• Type lifting (nullable types)
• Verbatim string literals
• Object and collection initializers
• Explicit interface implementation of members - avoiding name clashes and hiding goo
• Versioning support for class design through explicit declaration of intent with "new" and "override"
• Reference and output parameters
• Operator overloading
• Custom conversions - both implicit and explicit
• Indexer overloading
• P/Invoke - much MUCH better than JNI as it allows full fidelity *without* the need for C/C++ glue code
• Reified generics. Javas type-erased generics are just..... bad.
• Partial classes
• Partial methods
• Conditional compilation
• Conditional methods

Re:Good

[melted]

.NET is actually FASTER on Windows than Java. Mono is about 15% slower, which still isn't bad, since it takes up far less RAM than Java in 64 bit mode.

There are no "macros" or text substitutions in C#. You can inspect IL fairly easily using Reflector.

LINQ kicks ass for just the functional aspect of it.

Sorry, dude, you're talking out of your ass.

Re:MS Is Making Fools Out Of The Open Source World

[miguel]

I cant be incompetent and at the same time succeed in derailing Linux application development. Pick one.

Your rage prevents you from making a cogent argument though; I did not "derail" any application development, if anything, I created a project that many people seem to enjoy using.

The fact that you can not tolerate that others do as they please, and that you feel that people need to obey is merely a manifestation of your fascist tendencies.

Comment removed

[account_deleted]

Comment removed based on user account deletion

IDE

[dna_(c)(tm)(r)]

Plus a good IDE helps generate the boilerplate code - e.g. Eclipse's code assist expands "fore" to an enhanced for-loop, parametrized for the closest Iterable...

Re:IDE

[fredrik70]

true,
for c#, you can get the resharper plugin from Jetbrains, whic hmakes VIsual studio behave a bit more like IntelliJ, very nice. Sharpdevelop have some ok refactoring tools as well, but I think the java worlsd still beats dotnet when it comes to good tools / frameworks around the code, maven springs to mind

Having said that al ot of java stuff is finding it's way over to dotnet, like nant, spring.net, nunit, etc.

plagiarism is the greatest form of flattery ;-)

Re:no mono

[Chrisq]

But when we finally get to Gnu Hurd land we will have hot and cold rain at a mouse-click. I don't know why you are so worried about the past - think of the future.

Re:Good

[fractoid]

Yes they do. A handwritten recipe for cookies is executable, it just runs on a different class of machine.

Your mum?

...sorry, I had to. I just had to.

Re:Good

[xtracto]

There is one very important thing that Java has (and C# doesn't) in my opinion:

- A free reference implementation.
- THOUSANDS if not millions of Open libraries available (for ANY kind of task that you want to do)

On my 6 years of Comp.Sci. research I have looked at different (scientific) libraries available. Almost all of them are written in Java (or C++) and are available for free.

In general, the feeling I have from the people who write applications in .NET is a feeling of closeness.

I like C# a lot, I worked with it (in a production environment) when it was just starting (.NET 1) and since then it has progressed quite a lot. However, I still prefer Java or C++/QT4 whenever possible.

Re:Good

[fredrik70]

might have been true with c# 1.1 but now c# is far ahead (unfortunately in a way I might add)

Re:Good

[Sam Douglas]

It is arguable whether piling features and syntactic sugar into a language leads to a better language.

C#'s generics implementation is superior to Java's, but there really wasn't a better way for Java to provide decent binary and API compatibility with the decade worth of code written before generic types were introduced in version 1.5. Implementing generics through type erasure addresses most common use cases. There are ugly cases specifically with arrays. Essential Java has a good explanation of the rationale behind the generics implementation in Java (the chapter is available as a free sample). It's not an ideal implementation, but calling them bad shows a failure to appreciate the design constraints they were under.

Operator overloading makes languages ugly. See C++. The string special case in Java is a little arbitrary, but operator overloading complicates programs far more often than it simplifies them, and in my view (and apparently a view shared by the Java designers) the relatively small number of cases where they can drastically improve readability outweigh the complexity cost of providing them. Additionally it is all too easy to use them in a way that is not consistent with the semantics of the original operators. Vectors, matrices, strings (concatenation) and advanced numeric types can benefit from operator overloading, I struggle to think of other situations where it wouldn't just be misleading.

Value types: this is a powerful niche feature, which is handy for types that you would rather think of as values, for example vectors and matrices. This allows a program to more closely mimic common mathematical expressions of the concepts, which is nice. Unfortunately they are FUCKING UGLY, and arguably encourage non-object-oriented. As a side rant, at the University I attend the introductory programming course taught structs in preference to classes. I couldn't fucking believe this (I was a sessional assistant for the paper. I'm pretty sure this happened because the course merged with a VB course and the coordinator had previous exercises that used VB6-style Types). I got very tired of being asked why this code:

aList[3].name = "Bert";

Gave a compiler error along the lines of "Cannot assign to method return value" when the list contained structs. Stupid cases like this pretty much reinforce my belief that user defined value types have no real place in an object oriented language. They look harmless but they complicate the semantics a lot.

A lot of the other features you list bring C# closer to a functional programming language. I think it is a good thing that people are exposed to ideas of functional programming, but simplicity is also important. Functional programming languages use the function as their primary abstraction -- object oriented languages use the object as their primary abstraction. Many functional languages have very concise semantics which give rise to expressive techniques, for example Scheme -- which was designed as a minimal language with concise syntax and semantics, but gave rise to very expressive programs. Likewise a language that is designed as purely object oriented can have quite clean syntax and semantics. Merging the two is messy.

It should be noted that Java's support for anonymous classes is the object-oriented equivalent of lambda functions, which allows for similarly expressive programs, without breaking into a different programming paradigm.

Reference/Output parameters. A horrible hold-over from C style programming. Normally if you need to return multiple results, or modify input parameters defining a private/package-local class is a nicer way to go. If you really need reference parameters, they can be approximated in Java with something like this:

class Ref { public T value; public Ref(T value) { this.value = value; } }

The lack of unsigned types isnt't a huge deal for most programs, it can get slightly annoying if you are writing low level programs (signed bytes are

Re:Good

[Cyberax]

It's just easier to write "C# 3.5" than "C# 3 under .NET 3.5".

Film at 11.

[Repossessed]

Java is as slow as molasses.

Also, water is wet.

Re:Eclipse is stagnating

[Xest]

It's a similar case for Visual Studio, VS doesn't look that much different since like 2003, but the code completion has come on leaps and bounds, if you go back to 2003 and write code then write the same code in 2008 you'll notice a massive difference.

I agree, most IDE changes now are under the hood, because there's not a lot more you can add to the UI once you've got all the standard features in you'd expect an IDE to have. Most developers end up using keyboard shortcuts anyway once they've inititally got used to the IDE's features.

Re:Good

[Cyberax]

"1) High performance VM" .NET is quickly gaining on Sun JVM. So not for long.

"2) Code that does what it says without hidden conversions, text substitutions, and macros."

So?

"3) Other languages that are actually useful like Scala and Clojure."

And .NET has F# (officially supported now!), Ruby, IronPython and so on. Microsoft has even made changes to the CLR to better support custom languages, while Scala and Clojure have to use horrible hacks to implement closures and continuations.

"And LINQ? Why are you doing database and 'data sources' queries in something like C#? Use python or something like that. You need that super-fast JIT "cc -O0" speed to print out customer numbers and such?"

YES! I need a super-fast JIT to print out customer numbers. Have you EVER written a sizable business application? Do you propose to move all data queries to a separate application and then what, use text files for data exchange?

Also, LINQ is typesafe. You can check at compile-time that your queries are correct and IDE can (and does!) use type information for rich autocomplete and inspections.

Besides, there's also Parallel LINQ ( http://www.ddj.com/windows/212700663 ) which allows me to write parallel queries with nice logical syntax.

Re:Good

[Hognoxious]

Company I work for was recently bought out. [...] Way cheaper for them to hog resources on my machines

Er, whose machines?

Now get back to work!

Re:Good

[fredrik70]

well you can download the dotnet SDK for free if that's what you mean, it ain't open source but it's free.
- true, java beats dotnet here although dotnet is getting there, also lots of java stuff is being ported over to dotnet.

Re:MS Is Making Fools Out Of The Open Source World

[Alioth]

From the horse's mouth itself:

Q: Is this Community Promise legally binding on Microsoft and will it be available in the future to me and to others?
A: Yes, the CP is legally binding upon Microsoft. The CP is a unilateral promise from Microsoft and in these circumstances unilateral promises may be enforced against the party making such a promise. Because the CP states that the promise is irrevocable, it may not be withdrawn by Microsoft. The CP is, and will be, available to everyone now and in the future for the specifications to which it applies.

Personally, I'll still be using Java - you're a "second class citizen" developing C# on Linux, always trailing Windows. But you're a first class citizen on Java regardless of what platform you have on your development machine. And I like Netbeans :-)

Re:MS Is Making Fools Out Of The Open Source World

[w000t]

At what point in history was Java legal situation worst than the current status quo with Mono? Java has been cross-platform from day one (by Sun's choice) so developing Java applications for Linux was never more of a risk than developing Java applications for Windows. Also, there were never copyright concerns with Java so, please, stop spreading lies. The problem was inclusion of Sun's JRE in stock distros and the free implementations, though incomplete, could be distributed just fine (like Mono). Yet, there was never the threat of the platform (or parts of it) suddenly disappearing because of a patents violation. Had Sun sued the free implementations you could have still used Sun's JRE/JDK. This isn't the case with Mono, where at best you have a promise from Microsoft saying they are OK with people implementing C# and the CLI, which is only a very small part of the platform Mono intends to implement. The truth is that despite some people's wishes, the recent events change very little as the promise only covers the parts of .NET already believed to be safe (because of the ECMA stamp); they do bring and extra layer of security (which is a good thing) but that's all. BTW, software patents are definitely and issue outside of US and Japan. Firstly, as long as they remain valid in the US there will be big groups lobbying for them on Europe and elsewhere (the world is bigger than the US, Europe and Japan). Secondly, even if software patents are not valid in Europe, treaties between nations and the fact that the US is the most influencing country in the world makes them hard to ignore in practice.

Re:original article is junk, however fact is

[TheTurtlesMoves]

The company I have worked for developed a bunch of java desktops apps. The comment was often, "glad you didn't use slow java for this...".

Its funny how slow it is if they know its java. And how fast it is if they think its not. Really they never new... cus it was written properly in the first place...

As for C/C++ whatever apps. They also take a long time to load and use all the dam ram are unresponsive and usually as buggy as hell. Its not what they are written in. Its what the writers wrote that make them sux.

Re:Good

[alan.briolat]

WPF requires 3.0 or above, and WPF is so very attractive because it's much less pain than Windows Forms (finally, autosizing of widgets and built-in themability). Problem is, MS has finally released a GUI toolkit worth using but the majority of Windows machines are still running XP and therefore the first WPF application you ever use will require this massive (relative to the size of the application) dependency.

Re:Eclipse is stagnating

[Adam Jorgensen]

This has not been the case since NetBeans 5.5.

The current release, NetBeans 6.7 supports:
Java
C/C++
PHP
Python
Ruby
Scala
Erlang
JavaScript
Scheme

Also, at this point, NetBeans beats Eclipse hands down when it comes to speed, stability and installation size.

Re:Good

[nvivo]

Right now Java has the following features that are absent in C#:
1) High performance VM
2) Code that does what it says without hidden conversions, text substitutions, and macros.
3) Other languages that are actually useful like Scala and Clojure.

You are obviously talking a lot of shit there. I can't give numbers about issue #1, but from experience they are at least equivalent for general use. And its not like if anyone couldn't just open 2 apps in their desktop and compare. Java may be faster here, slower there and vice versa. But you certainly won't find any huge differences in the runtime that makes one seem useless next to the other.

Now, about issues #2 and #3, you are probably smoking something.

What kind of hidden conversions or text substitutions you are talking about? As any language, there are *features* that change the behavior in some way. There are no hidden conversions, there are documented implicit and explicit casts, there is marshalling for interoperability with other platforms that are completely configurable. Any language has this kind of thing to some degree, even java. Also, NET itself have no notion of macros, because macros are a compiler feature, not a runtime one. C# for instance doesn't know what is a macro, it simply has some basic pre-compiler, but nothing like C. It seems you don't understand or don't care about learning how the language works, even though all the reference, compilers and SDK is freely available online. The fact that you can't understand a feature that any VB programmer understands really tells me you shouldn't be spreading shit about it.

As for saying that java has the advantage of having more useful languages than .NET, you must be out of your mind. Simply going from the standard languages that .NET supports out of the box (C#, VB.NET, C++, F#) you have 4x more languages than Java, and they are certainly useful. If you count the other languages that people have created or ported to the CLI, you can even count Java.

You are just a java fanboy that will defend any feature that java implements, and bash any other that java doesn't have, until the day it is implemented. You are no different from the fanboys that love LINQ or extension methods.

The fact is, Java has a lot of benefits over .NET, like *supported* multi-platform runtime from the official vendor, more libraries due to more time in the market, a more open community, etc. You could simply have used them in your argument instead of saying a lot of nonsense shit about stuff you don't want to understand.

Re:Good

[sproketboy]

Not according to my tests. Server Java is a LOT faster.

Re:Good

[ggeens]

Good post. I wish I had mod points right now.

When it comes to generics in Java, the most annoying are the warnings you get when mixing with bare types. (Converting between List and List<T>).

Value types/structs: never really saw the advantage over objects. The JDK team refuses to implement them and I believe they are right.

I consider the fact that .NET people always bring up the native code as a weakness of the CLR: if it is possible in the VM, you should do it there and only call native code if you can't.

Re:Good

[nvivo]

C# is Microsoft's "bastardized version" of Java (though mostly better IMO), and VB.Net is C# with VB syntax.

You are right, I don't know why people are still talking about this. C# was copied from java, as it was from delphi and c++. This is even officially documented in pages, video interviews, books... Just as java was copied from c++, that came from C...

It is impressive that people still don't realize that any thing that are created today will borrow only the good features from things created yesterday, discarding the bad ones. C++ was no different, Java was no different, C# was no different, and if Sun/Oracle decides to create a new java from scratch today, they will surely copy a lot features from .NET and C#.

Re:Good

[turgid]

It's a Microsoft trap and it's a solution looking for a problem. I wouldn't mind if there wasn't the constant, implied threat of Microsoft suing the distributors/users of Mono (patents).

It's yet another platform to maintain and support and more complexity for distributions.

Very importantly, it is confusing in that it appears to make the .NET platform legitimate as a cross-platform, Open Standard. It is neither.

If you buy SuSE Linux, you are probably safe from Microsoft legal action.

With Mono I've had the pleasure of a light (and fun) rewrite of many of my applications for cross-platform compatibility

And with Java, you wouldn't have had to rewrite anything.

What does this mean anyway?

[WWWWolf]

*sigh*

You can either develop Linux desktop applications on C#... or just develop desktop applications on Java that, coincidentally, work in Linux just fine. The reason why no one makes "Linux desktop applications" in Java is that it's much easier to just screw the platform dependence and go cross-platform. What you lack in platform integration you make up with less headaches when you do choose to deploy the applications across different platforms...

Last I checked, I think Gtk+ and GNOME bindings exist for Java too. But with Sun improving the Gtk+/GNOME native look and feel support in JRE itself, and more and more cross-platform desktop application building and desktop integration stuff coming in the future (JSR-296 Swing application framework stuff looks pretty cool, for starters), who would want to tie the app to Gtk+ and GNOME specifically when you can, right now, build apps that can already pretty much pass for GNOME apps?

Re:From a user perspective

[dna_(c)(tm)(r)]

Swing is horrible and instantly recognizable as "Java" when you run one of the apps.

It doesn't have to be. This look and feel (requires java installed) can be used for prototyping (so the boss doesn't think it's done) but mostly shows the power of swing + PLAF (pluggable look and feel). Here's a screenshot and this is the site, those widgets actually work.

Re:Good

[Bill Dog]

actually neither produce executables.

.NET (and it looks like Mono as well) does -- it creates what I'll call an executable stub that invokes the IL code interpreter and tells it where to begin. Java prolly has something similar.

Re:Eclipse is stagnating

[mcvos]

The last time I tried NetBeans, it was a pure Java IDE.

The last time I used it, I used it for Ruby. (I eventually switched to RubyMine, though.)

sure

[dna_(c)(tm)(r)]

In Ubuntu at least, the package managers only installs Eclipse 3.1. You have to manually download and install/configure any newer Eclipse versions. It's really a pain. I don't have a clue why it hasn't been upgraded...

download; tar xzf eclipse-SDK-3.4-linux-gtk.tar.gz; eclipse/eclipse; start coding. Now, was that so hard?

On the Eclipse side of complaints, wheres text wrapping? Many 'smaller' IDEs have that.

in preferences there is a search box, type "wrap", search. You can configure that (it is formatting, so it works when you do Ctrl-Shift-f or when you trigger that on save).

Re:Re:Good

[Bill Dog]

Why don't you just go up one level at that link and read a few of the offered comparisons? It looks pretty even-handed to me (on just the languages themselves), and if there's a bias it's towards painting C# as basically the same as Java. Hence the post (in sarcasm) that you responded to.

Re:Good

[SanityInAnarchy]

Let's see...

On Linux, it's in the package manager. And it's likely to be far, far less than 200 megs worth of dependencies.

On Windows, Java is maybe, what, 30 megs? 50 megs?

And while .NET is huge, "worth your time"? It's right there in Microsoft Update, and it ships with Vista. You are getting your updates, right?

Even if your statement was true, if it was a good note taking program... I'm on fiber. 200 megs is nothing.

Re:Good

[Bill Dog]

So, basically, powerful features are "messy", and having to for example create extraneous classes to work around a Java limitation is "a nicer way to go"?

More popular?

[Alex Belits]

That's like saying that hydrochloric acid is more popular as a drink than hydrofluoric acid.

Both environments are massive messes of overcomplicated languages with even more overcomplicated infrastructure, stuffed with random libraries and lovingly wrapped with overinflated egos of their designers and developers, and wankery of the users who think, it's the second coming of Lisp.

At this point there are five good choices for developing a new non-game GUI-centric application for Linux (or anything except Windows-only or OSX-only applications):

1. C++/Qt (KDE and everything useful in it, Opera, QCad, countless commercial applications).
2. C/GTK (GNOME and everything useful in it, X-Chat, Pidgin).
3. C++/GTK (OpenOffice.org).
4. Python/Qt.
5. Python/GTK.

This covers everything anyone would want in a GUI-centric application -- the five reasons I have seen for other combinations are:

1. As attempt to promote some crappy environment or a "my first application in <crappy environment>" project that got out of hand (Tomboy, Banshee).
2. Out of ignorance (all "enterprise applications" where Java was chosen because it's supposed to be "cross-platform").
3. A minimal update for some old application that was written before the above five choices became available (the only reason why I still have Motif installed).
4. The application IS an environment designed specifically for some set of goals (Emacs, Mozilla).
5. As a wrapper over something someone already written.

Re:More popular?

[Abcd1234]

Wow, you put a lot of work into a post that can be summarized as: I think Python is cool, everything else sucks.

Honestly, for all that writing, you've managed to avoid stating any actual facts. It's almost like you did it deliberately, but I have a sneaking suspicion you just have a strong talent for making vacuous, unsupported statements.

Re:More popular?

[K. S. Kyosuke]

What if I prefer Gambit over Python, does that mean that I am ignorant or that I am trying to promote a "crappy environment"? (Why, restartable exceptions, usable debugger and native code performance sure must count as "crappy" for any kind of development.) No, I really can't agree with your "reasons".

Re:More popular?

[Alex Belits]

That's probably why I have mentioned three combinations that don't involve Python at all, right?

Re:More popular?

[Alex Belits]

When a language comes with environment that includes some easy to use debugger, it usually means that programmer will have to use libraries written by people who NEEDED that debugger to weed out top 20% of the bugs they stuffed into their code.

Of course, being a C preprocessor, Gambit counts as both Scheme and C, and not having GUI library it's not even in the scope of this discussion.

Re:More popular?

[Abcd1234]

You mean C and C++? Those aren't alternatives, they're last-ditch fallback positions, and I think you know it. In the hands of experienced professionals it's difficult to write secure, high-quality code in C or C++, let alone in the hands of your average programmer. Frankly, they should've been relegated to lower-level systems programming and high-performance computing a long time ago.

Re:More popular?

[True Grit]

You mean C and C++? Those aren't alternatives, they're last-ditch fallback positions,

Right, when those shiny "managed code" systems can't manage to run in the time alloted or the ram available, who'ya gonna call?

In the hands of experienced professionals it's difficult to write secure, high-quality code in C or C++

Oh bullshit, *experienced* *professionals* can write high-quality code in any language, just as amateurs can screw up in any language.

Right tool for the job, and use what you know.

they should've been relegated to ... high-performance computing ...

Irony, most delicious it is...

Re:More popular?

[K. S. Kyosuke]

So let me translate it for others:

1) To have a debugger is bad in the first place, because otherwise everyone would start relying on the debugger and not on careful and thoughtful coding. (Did the first C implementation with a usable debugger defeat the purpose of writing any C code as well?)

2) Compilers doing lambda lifting, primitive specialization, type checks elimination, data and control flow analysis, allocation and escape analysis and other advanced stuff count merely as "C preprocessors" today (Stalin, Gambit, Glasgow Haskell Compiler, the list goes on). Seriously - WTF?

3) Just because it's so easy to use, e.g., Gtk+ from Gambit that the author felt no need to include a binding for it (he *did* include a simple, although limited Tk binding) makes Gambit "not having a GUI library", even though "having a GUI library" (Tkinter) does not necessarily mean anything for Python, as you have recommended not to use the included batteries.

Oh well, I get it now. Weirdos are everywhere.

Re:More popular?

[Abcd1234]

Right, when those shiny "managed code" systems can't manage to run in the time alloted or the ram available, who'ya gonna call?

What part of "high-performance" don't you understand? "Time alloted" and "RAM available" are generally not concerns for an average desktop application. Sure, if you're writing a supercomputing application, or something that needs to run on an embedded machine, then you can be damned sure C or C++ will be your best bets. But on the desktop, where security, usability, and time to market are the driving concerns? Hell no.

Oh bullshit, *experienced* *professionals* can write high-quality code in any language, just as amateurs can screw up in any language.

That's just plain naive. Experienced professionals *can* write high-quality code in any language, but C/C++ make it far more difficult, as the developer is forced to take care of far too many details (Is this code safe from buffer overflows? Did I free that pointer a while back? Am I sure this pointer I'm casting is the type I think it is? Etc, etc, etc). Hell, just try writing a safe, secure, fully functional TCP/IP application in C/C++... the code to simply perform a safe read from a TCP socket is enormous. And, on average, most people do it wrong.

Irony, most delicious it is...

I have no idea what your point is. The article was about desktop computing. At what point did the discussion turn to the topic of HPC? Because if that was the topic, my take would be far *far* different (obviously).

Re:More popular?

[True Grit]

"Time alloted" and "RAM available" are generally not concerns for an average desktop application.

They sure as hell are important on *my* desktop. Maybe if we ever see, for example, a desktop environment written in a managed code system that is fast and stable then you might have a point. Until then, "high-performance" is just as important for the desktop as it is for super-computing.

That's just plain naive.

Why? The very next thing you yourself say is:

Experienced professionals *can* write high-quality code in any language

which is exactly what I said! So, naive how, exactly?

(Is this code safe from buffer overflows? Did I free that pointer a while back? Am I sure this pointer I'm casting is the type I think it is? Etc, etc, etc).

True for C, but not for C++. That's my other issue with your post: C++ != C.

Irony, most delicious it is...

I have no idea what your point is

That "high-performance" still matters to all of us?

That C++ is still important because "high-performance" is what it does?

That managed code systems, for all their promise, aren't even close to "high-performance"?

Anyone who's watched a managed code app that, after running awhile, starts to crawl because its GC has gone bonkers will recognize the irony in your post.

"High-performance" isn't just for rich kids and geeks in ivory towers you know.

Re:More popular?

[Abcd1234]

They sure as hell are important on *my* desktop.

Well, that's great for you, but for the rest of the world, and for the software development industry, raw performance is *not* the primary metric used when selecting a toolkit for developing desktop applications. Security, usability, and time to market are.

Hell, that very fact is illustrated in the OPs post. He lists, among his kits, C, C++, and Python. Python! Next to Ruby, the slowest mainstream scripting language out there! But it's popular because it's secure, usable (you can easily bind to wxWindows, GTK, or Qt for a proper native GUI), and one can churn out working code quickly.

So, you may not like the fact that raw performance is no longer the overriding concern for a desktop application, but, well... tough shit. The rest of the world doesn't work that way.

True for C, but not for C++. That's my other issue with your post: C++ != C.

Right. It's worse. The language is more baroque, more confusing, and as a consequence, less predictable (in the sense that, unless you know all the little gotchas and tricks of the language, it may do something you really didn't expect).

As for all those little details, last I checked, people still find buffer overflows and memory leaks in applications developed with C++. The language isn't a panacea.

Anyone who's watched a managed code app that, after running awhile, starts to crawl because its GC has gone bonkers will recognize the irony in your post.

First of all, seriously, look up the term "irony". I don't think it means what you think it means.

Second... huh? Many mainstream apps, these days, run on a VM-based core. Hell, Firefox, which these days performs extremely well, is, in essence, a managed code app, running on its own Javascript interpreter. And those times when it didn't perform so well? Yeah... memory leaks in its non-managed bits. Interesting, that.

Then there's Eclipse, also a managed code app that people seem pretty happy with. Hell, a very large number of enterprise-level web applications perform extremely well on top of that pesky managed code environment, Java.

Frankly, I'm beginning to suspect your information regarding VM-based languages is just wildly out of date.

Re:Eclipse is stagnating

[modmans2ndcoming]

IntelliJ seems to be the only Java IDE worth using. To bad you have to pay for it. maybe someone will fork the MonoDevelop project and make a JavaDevelop project.

Re:Good

[Octorian]

And that official reference implementation is supported on *more* than one OS family.

And there are first-rate development environments (IDEs) available in the F/OSS world, for any Java-supporting platform.

Seriously, on a language-vs-language level, I'll admit that C# is leaping way ahead of Java (which seems far too complacent). But on a platform-vs-platform level, Java has *loads* more of a community of stuff than .NET has. (with .NET, it either comes from MS, or you have to pay some dippy little shop lots of license fees to use it)

Re:Good

[Anivair]

it was coined by the same people that consider java "functional". They're from the society for creative definitions.

Re:MS Is Making Fools Out Of The Open Source World

[Miros]

I still have never understood this great debate. At the end of the day what's wrong with having access to both? Java is indeed a neat language, and I agree with all of your points on that front, but it just never seems to have stuck it when it comes to GUI app development as compared to C/C++, and frameworks like Mono can have fascinating levels of flexibility. Java, also amazing for its own purposes, but I think it's safe to admit that they each have their strengths and weaknesses. It just seems foolish to throw free tools out of the toolbox due to the implied political persuasions of those who crafted their prototypical ancestors.

Re:Good

[ByOhTek]

The Mono packages (including libgdi+) come in at 26MB

Java weighs in at around 57MB (jdk 1_5_0_16 bin and src, required for install on my system, I won't bother adding in the patches required for FreeBSD since they aren't required on other systems.)

Java is 15MB on windows (full install), 20MB on Linux.

Now, here's something that I can say for caring about the language used: Java uses the system regular expression library. I was trying to figure out why an app I was using worked differently in Windows XP, Linux and HPUX. Turns out, it was using the regex based find function. I decompiled the bastard, and added in my own custom find function. It was slower, but identical input provided identical output.

I've not had that issue with .NET/Mono, provided the application wasn't built on the most recent Visual Studios release. Even if it was in the most recent VS release, if it worked, it worked fine, but some apps would only work in Windows.

Neither is perfect. Pick your preferred bugs. At 26MB for mono, it's a better option on FreeBSD, but Java is smaller on Windows and Linux. In either case, unless you are on a system that 8-10 years old, or an embedded system, that amount of disk space isn't really a huge deal.

Re:Good

[slack_justyb]

LINQ kicks ass for just the functional aspect of it.

I hate to bring this up but LINQ isn't protected in Mono. I have a feeling that this is one of the things that are really going to hurt a lot of people when MS decides to sue.

Cheers!

Re:Good

[Hurricane78]

Well, I have an easy answer: They both are crap and can't hold a candle to Haskell. In code beauty, elegance, efficiency, and speed.

Re:Good

[Hurricane78]

Why would you do this crazy madness, when you could just use Haskell, which was designed from ground up with all those cool concepts that now get glued left and right to every second language?
You know, it has a .NET implementation too, including all the APIs.

Re:MS Is Making Fools Out Of The Open Source World

[JAlexoi]

Why did not hey call it a license then?
And we all have learned that misrosoft is soooo trustworthy with their claims on microsoft.com.

Re:MS Is Making Fools Out Of The Open Source World

[modmans2ndcoming]

how is Mono trailing? They are compatible with the core .net 3.0 libraries. 3.5 was a minor upgrade that focused on the MS libraries.

Besides that... 2.0 through 3.5 and 4.0 all compile down to 2.0 IL code so my Mono program will run on Windows and the only difference is that I don't get some of the syntactic sugar like Linq.

Re:MS Is Making Fools Out Of The Open Source World

[modmans2ndcoming]

The core .net libraries are covered by the C# portion. Stop pretending like it is useless, it makes you look like a moron.

Re:Good

[True Grit]

creates what I'll call an executable stub that invokes the IL code interpreter

I'm sure the GP is referring to compiling a program down to 100% native machine code. If there is an "interpreter" involved, then you don't get that.

GCC's gcj will do this for *some* Java apps, but it has limitations (mainly on the GUI side). Don't know about Mono.

Even JIT compilers, which Java has, and I assume Mono as well, can only compile parts of a program to machine code, the virtual machine's interpreter loop is still there, so between that and the overhead of the garbage collector, Java/Mono apps are prevented from approaching the speed(*) of a fully compiled app, like one written in C/C++ for example, because the latter has no interpretation being performed.

(*) speed being also dependent on how well/poorly the app is written, whatever its language, of course.

Re:Good

[Cyberax]

I like IDEs and debuggers :(

Re:Good

[hansamurai]

Java may not be moving anywhere, but languages on the JVM sure are. Clojure, Scala, JRuby, Jython, and of course, Groovy.

Re:Good

[bonefry]

1) High performance VM

When measuring performance, the standard deviation is more important than the average.
The JVM may have lots of performance, but it boots up slowly, it warms up slowly, and when the garbage collector kicks in the world gets frozen.

The CLR may not have such a fancy VM, but its main language (C#) is more efficient on current hardware (structs are allocated on the stack, methods are non-virtual by default), while being better designed.

2) Code that does what it says without hidden conversions, text substitutions, and macros.

This implies that explicit code an 8 year old can read is somehow better. That's not always the case.

One way to tackle complexity is to build layers of abstractions. For a positive example you only need to look at mathematics ... imagine all the theories in analysis, probabilities, statistics, formal languages ... being described and demonstrated in the language of an 8 year old.

And another thing ... in every other profession, simple and abstract is almost always equivalent to concise. Except software engineering, a view shared especially by Java programmers that got burnt with C++. Well, maybe you shouldn't use Java either, since it does weird things to objects that aren't referenced anymore. C++ is a lot more explicit in this regard.

3) Other languages that are actually useful like Scala and Clojure.

F# is an Ocaml clone, and I saw a lot of Ocaml libraries being ported to F#. It also has good VS integration and good tools.
Axum is a language with actor-based concurrency, much like Erlang. It's still experimental, but I've played with it, and it's already solid.

And then there's the DLR which is a framework of optimizations for new languages and a MOP making dynamic languages interop better ... meaning you'll be able to directly instantiate objects written in IronPython from IronRuby or from C# (using "dynamic").

I know of an open-source effort for Java, similar to the DLR, but if it doesn't get adopted as a standard among language designers, then it's all in vain.

Also, .NET has had from day one better integration with C/C++. If I'll have to use JNI again, I'll probably kill myself.

And LINQ? Why are you doing database and 'data sources' queries in something like C#?

You misunderstood LINQ. It is a generic framework for doing interrogations on any kind of collections. Being able to query databases and XML objects is just a side-effect of its design.

And it's really useful too. If you look at any piece of code you wrote, chances are you're looking for some kind of object in some kind of connection or data store. Linq gives you type-safety, a C# syntax for queries (with C# methods and types) and a unified language for interrogations on structured data (instead of having to use SQL (specific to your rdbms), XPath and iterate through arrays, all in the same method ... it does joins on too), and it can be extended to any type of data-store, like CouchDB and HBase.

This seems to me that you're just sorrow because the grapes are out of reach.

So what?

[SCHecklerX]

C, Shell, and Perl work well enough. What is this 'mono' and 'java' you speak of?

Re:So what?

[True Grit]

C, Shell, and Perl work well enough. What is this 'mono' and 'java' you speak of?

You, sir, are a very brave man, I salute you.

Brave not for using C/Shell/Perl (well, except maybe the Perl part), but for saying that in the middle of this thread. That takes cojones... Good luck.

Re:Good

[revlayle]

Wrong, C# and VB have very little in common - except they both can compile into MSIL and use the .NET framework. LIKE EVERY OTHER .NET LANGUAGE.

Re:Good

[revlayle]

(sorry VB.net compiles to MSIL - not classic VB which is absolutely NOTHING like C#)

Re:Good

[Late Adopter]

C++ is widely recognized as a byzantine failure in every case.

Well, I don't know that you can get away with "widely recognized", but certainly you yourself are entitled to the opinion. I used to share it too, even when I was using it professionally.

Two things warmed me up to C++: Exceptions and RAII. Exceptions *cannot* be replicated in C. Throwing an error condition and then aborting block by block until you find one that wants to catch the error condition is just a god-send for writing error-safe code.

RAII is *necessary* given Exceptions, and merely extraordinarily convenient otherwise. You don't want to count on getting to the "cleanup" bits at the end of your functions because (a) you'll forget them occasionally, and (b) exceptions will circumvent them. Allowing cleanup to be associated with the object that needs to be cleaned up, and then having it automatically called when the object goes out of scope, is god-send number 2.

I have yet to see a language that does RAII as nicely as C++. Python is coming close.

Re:MS Is Making Fools Out Of The Open Source World

[miguel]

You do get LINQ, we have supported it for about 10 months now in production (starting with Mono 2.0).

We are missing LINQ to SQL, but it will be bundled with our next release (Mono 2.6) or you can get it from the dbLINQ project today.

Re:Good

[gestalt_n_pepper]

Because it's not about which language is "best." It's about which is most cost-effective. Programming is either about money, or it's masturbation (not that there's anything wrong with that....).
.
When was the last time YOU made money with Haskell?

Re:Good

[DuckDodgers]

The London Stock Exchange example is useless. Yes, it ran Windows Server and an application coded in .NET. Yes, it crashed. But no one can prove whether the problem was the operating system, the database, the .NET platform, or buggy code.

It's my understanding that C# is more popular than Java for desktop applications because of faster startup and lower memory use. I can't imagine many companies would decide to move to C# from Java for server applications for anything more than political reasons.

Re:Good

[DuckDodgers]

Going from a procedural language to a procedural language with functional options is relatively easy. That's cases like C++ to C#, or even older versions of C# to LINQ. It's also true with Java and Scala. Going from a procedural language to a purely functional language like Haskell is far more difficult. I'm a mediocre C and C++ developer and a passable Java developer, and it's taking me a lot of work to learn Haskell. It seems worthwhile, but I can understand why Haskell hasn't taken the software industry by storm.

Re:Good

[DuckDodgers]

Scala is available for .NET too (http://www.scala-lang.org/node/25 - bottom of page).

Re:Good

[Slime-dogg]

As a platform, .NET has far more in common with Delphi than it does with Java. It even shares a common creator.

Re:Good

[arose]

Whoops, that was supposed to be:

There is no such thing as C# 3 as far as any sort of standards are concerned.

Not sure if it's me or slashcode this time, it's certainly been eating some of my spaces so I wouldn't be surprised.

Yes, that probably will change in the future, but as of now listing non=standard is somewhat dishonest.

Re:Good

[RobDude]

I'm not sure why this is marked flamebait....

I've never worked with Java, but I am a full-time .Net developer. The second real job I had was a consulting gig....we did most of our projects in .Net but a few clients either had existing code in Java or wanted to use Java to avoid costs often associated with Microsoft technologies.

Anyway, while I didn't know Java, we had a lot of very sharp programmers who worked on professional, successful projects in both Java and .Net. The general consensus was basically what parent said.

From what I've heard, ASP.Net really makes web development a lot cleaner than the Java equivalent. Go here and check out the graph - http://news.netcraft.com/archives/2004/03/23/aspnet_overtakes_jsp_and_java_servlets.html you can see ASP.Net gaining market share and passing Java technologies, back in 2004.

I believe JSF was supposed to be Java's answer to ASP.Net - but from what I've heard it's not quite on-par.

Visual Studio isn't a requirement of using .Net (and isn't relevant to the Linux development discussion) but in terms of general .Net vs. Java - it really does seem to offer more to the developer than any of the Java IDEs. Yes, you can find plenty of Java programmers with years of experience in Eclipse who use Visual Studio and say, 'Man this sucks because you can't do X, Y, and Z' (but X, Y and Z are available - they just didn't find it). But yeah amongst people who regularly use both, I really believe the majority are going to say that Visual Studio is the way to go.

More recently, LINQ has made a fairly large splash in the development community. There have been quite a few articles/blogs expressing concern that LINQ, along with other .Net developments are giving .Net a clear edge over Java. And some of these are coming from Java developers - which means it's more than just fan-boy crap.

http://tech.puredanger.com/2008/01/31/is-linq-leaving-java-in-the-dust/

I know of, at least two, Java-based implementations of 'LINQ'. But, really, they are just playing catch-up to Microsoft's innovation in that area. And while many of the basic samples given work perfectly, if you dig deeper you'll find that they are lacking, compared to the Microsoft's LINQ. Naturally, people have been programming for decades without LINQ. It's not 'needed' by any stretch of the imagination...but many feel it's an important step forward.

Anyway, I'm *not* saying .Net is better than Java. But, I am saying there are certainly people who would make the argument. And there are certainly people who would argue that Java is better. They both have some real pros and cons....but the parent pointing that out isn't flamebait.

How this gets on Slashdot

[GenomeX]

When I wanna read highly likely baloney articles I visit http://digg.com/ (no offense Kevin, but it happens more often than not nowadays - unlike when digg was still new)
I come to Slashdot because I favor and believe in the system article moderation system.
So how then does nonsense like this reach the Slashdot front page?

MUCH longer list of JVM languages here...

[Osvaldo Doederlein]

Check this, 240 languages and counting: http://www.is-research.de/info/vmlanguages/. Now just die of shame.

Of course not all these "languages" are highly relevant. There are abandoned or not well maintained projects, academic stuff, and several extremely niche languages/tools. But I suppose this can be said at least for a few of the .NET entries as well.

Wikipedia's articles have very different quality. You'd think that the articles used some criteria like only including languages which are current / well maintained, but the JVM article it misses such entries like JESS and Drools, both very "alive" and popular for logic/IA and rule-based programming.

Re:Good

[Thiez]

> Java/Mono apps are prevented from approaching the speed(*) of a fully compiled app, like one written in C/C++ for example, because the latter has no interpretation being performed.

Not really. Their speed may never equal that of a similar program written in C/C++, but it's getting pretty close. Besides, a JIT compiler could compile the complete program when you start it, thereby removing the interpretation completely, introducing only a slight delay before the program can start running (which should be no problem at all for any program that is supposed to run for more than half a minute).

Re:Good

[sbeckstead]

But no one can prove whether the problem was the operating system, the database, the .NET platform, or buggy code
Actually the answer to that question is "Yes"

Re:Good

[sbeckstead]

Gotta love these MS fan bois.

Re:Good

[Anonymous Coward]

a lot of shit there ... probably smoking something ... you don't understand ... you can't understand ... you shouldn't be spreading shit ... you must be out of your mind ... just a java fanboy ... nonsense shit

-1, Flamebait

I can't give numbers

So you base your argument on personal, subjective experience. Nice.

Disassemble a call to an extension method. It doesn't call a method on the same object in MSIL that it does in the source code. It's 'magic', which C# like C++ is full of. Just like the post said.

C++ isn't a supported language any more than JNI/C. So for usable languages you have C#, VB.NET (mostly a different syntax for C#), F#, IronPython. Compared to Java, Scala, Groovy, Clojure, JPython, JRuby, Fortress, etc. Your point?

Re:Good

[Abcd1234]

I really, really like C# and I gotta say, I'm a big fan of operator overloading,

Great... another person who probably overuses operator overloading.

Hint: operator overloading is just like inheritance: it should be used extremely sparingly, and every time you use it, you should think twice and make sure there isn't a better approach you could be using.

BTW, C# has plenty of other features that make it superior to Java, real, honest-to-god lexical closures being the most obvious.

Re:Good

[Abcd1234]

Why would you do this crazy madness, when you could just use Haskell

Because only a masochist would actually want to develop large volumes of code in a lazy functional language? Because the toolset sucks? Because you can't hire people who actually know it and can use it effectively?

Re:Good

[sbeckstead]

I sit corrected.

Re:Good

[binary paladin]

Great... another person who probably overuses assumption.

Hint: Being a douche bag and making assumptions without context is just like being a fucking twirp: it should be used extremely sparingly, and every time you use it, you should think twice and make sure there isn't a better approach you could be using.

But hey, while we're on the assumption train should I just assume your another jack off functional programmer that thinks he knows everything? (Which, in and of itself is an assumption about functional programmers, but hey... most of the vocal functional programmers around here are assholes so with my limited context why not presume that all functional programmers are assholes and so... well... you must be one too.)

There are plenty of instances where operator overloading is legitimate. (You know, like Java internally overloading + for string concatenation.) When I make a method like .add() it's amazing how often that would be more programatically natural to use, oh I don't know, the fucking +. Combining two objects to form a concatenated object is another instance that it seems useful too, particularly if it returns a new instance. (In fact if it modifies either of the objects in question, that's a BAD use of "+".)

And how the fuck is inheritance something that should be used "sparingly"? It should be used--like every other thing in the programming universe--when it makes sense and when you need it. It makes a lot of sense in some projects and none in others. And--like every other thing in the programming universe--it's abused and misused. Shocking.

Abuse of operator overloading is no different than bad naming conventions for methods. Obviously, since you seem to know something about C# you probably also know that no one is forcing you or anyone else to utilize operator overloading at all in any language.

Re:Good

[K. S. Kyosuke]

I'm sure the GP is referring to compiling a program down to 100% native machine code. If there is an "interpreter" involved, then you don't get that.

Unlike Sun's JRE, both Microsoft's .NET Framework and Mono have an AOT compiler - in case of .NET, look for ngen.exe. Mono has an --aot flag, but I ran into problems with it. Both are supposed to generate native binaries that - compared to C/C++ binaries - include additionally just some debugging and runtime data, but everything runs natively from clock cycle 1.

Re:Good

[K. S. Kyosuke]

True LINQ support requires language changes (anonymous types, Expression Tree, Extension Methods).

...or just having an extensible language, like CL, Scheme or Perl 6. :)

Re:Good

[Abcd1234]

But hey, while we're on the assumption train should I just assume your another jack off functional programmer that thinks he knows everything?

Why, because I know what I closure is? That's awfully short sighted... closures are available in most major languages these days, save for some glaring omissions (Java being one of them... and Python, whose closures are somewhat crippled), and are incredibly powerful tools, particularly if you're writing event-driven applications.

There are plenty of instances where operator overloading is legitimate.

Plenty? Hardly. Some (I would say a few)? Yes.

When I make a method like .add() it's amazing how often that would be more programatically natural to use, oh I don't know, the fucking +.

And how often, pray tell, do you actually find yourself doing that? Most people aren't (and shouldn't) be writing their own math libraries, so that's out. So, other than in a setting where you're performing an arithmetic operation, why on earth do you need to implement an operator+?

Combining two objects to form a concatenated object is another instance that it seems useful too

Uh, definitely not. + for concatenation is an excellent example of *stupid* operator overloading. And that's doubly true if the language supports dynamic type coercion (I'm looking at you, Javascript). There's a reason Perl uses the '.'. Most other languages do it because they inherited it from somewhere else.

No, at best, concatenation should get its own operator to indicate you're, you know, concatenating two things together.

And how the fuck is inheritance something that should be used "sparingly"?

Because 99% of the time containment provides the same capabilities while reducing the coupling between the code. Do I really need to spell this out for you?

And--like every other thing in the programming universe--it's abused and misused. Shocking.

Precisely. And your first position should be to *not* use it until you've convinced yourself that it's genuinely the best solution for the problem at hand.

And just like inheritance, 99% of the time, operator overloading is the *wrong solution*. It makes code more difficult to understand and predict, as the overloaded operator can be hiding complex logic behind an expression that, on its face, looks simple. As such, just like inheritance, one should come at a problem with operator overloading at the *bottom* of one's list of candidate solutions, and only use it when you're convinced it really is the best tool for the job above all other options.

Re:MS Is Making Fools Out Of The Open Source World

[Mr2001]

You were saying that before the "Community Promise". Funny, right?

It was true then, too.

And yes, the "community promise" doesn't make your statement true. The "Promise" only covers ECMA 334 and 335 (C# language and CLI), as you're well aware. [...] Indeed, Mono is officially being split in half. But you already knew that.

Indeed. So if you stick to the C# language and core framework, and avoid proprietary libraries (the ones being split off), there is no patent mess, like I said.

But you knew that, right?

Re:MS Is Making Fools Out Of The Open Source World

[cheesybagel]

Don't fret. Google will probably make their own Desktop environment, and it will clobber anything GNOME or KDE can offer. Google has more usability experts than any other company, including Apple and Microsoft.

Or so I hope.

Re:MS Is Making Fools Out Of The Open Source World

[cheesybagel]

Google uses C# in one project. Orkut. It sucks.

Re:Good

[Sam Douglas]

Bingo. Unlike languages where the 'powerful features' are a consequence of the semantics, C# designers apparently feel the need to keep adding more and more constructs to allow non-object oriented programming techniques to be used.

An example of this I think is C#'s handling of events (they are specified as a language feature, or at least treated like one). In order to allow you to call an anonymous method without typing problems (to allow event handlers to be added to an event) the concept of delegates was necessary in the language. Java has neither, instead it is all implemented within the existing object-oriented semantics of the language. There is the concept of listeners which are added to objects that call known methods in the listeners when an event occurs.

This might require a little more code, but anonymous classes (i.e. extend a class/interface, specify methods 'in line' -- like lambda functions but for objects), but is much more flexible and allows the concept to be reused in situations it was not originally designed for -- by making a listener a remote object in an RMI application you can have distributed events.

Re:Good

[Sam Douglas]

In addition to this, complicating the language makes it harder to implement portably -- a higher chance that implementations will be subtly different. Keeping the core language simple is a good thing if you want your language to be portable and implemented by others.

Re:Good

[melted]

Well, they have prudently removed MS .NET tests vs Java (-server) on Windows. .NET was on average 15% faster there. FOSS zealotry at its best - if Microsoft beats us, let's remove the test.

Re:Good

[Bill Dog]

Makes perfect sense then, if you favor language purity and neatness and having to type more boilerplate constructs all the time, over language power and expressiveness and having to deal with complexity and non- beginner-friendliness. I guess hence why Java people hate C++ and call it too complex. And dislike C#. And C++ people hate Java and call it dumbed-down. And tolerate C#. If Mono is outpacing Java in desktop Linux apps, maybe it is this nature of it that is partly why.

Re:Good

[True Grit]

Besides, a JIT compiler could compile the complete program when you start it, thereby removing the interpretation completely,

It could compile all the functions/methods/objects of your app to machine code, but your app is still being "processed in a loop", even if most the normal work of that loop (bytecode interpretation or JIT'ing) has already been done. Instead of interpreting bytecode, the loop just directly executes the native code, but then return passes back to the loop and it goes to the next chunk of code to run, and then the next, etc.

That "control loop" is the "main()" routine of your platform's runtime engine (CLR/JVM) and is still adding some (however small) overhead, in addition to the eval loop, there is garbage collection, the security framework, error checking/handling, dynamic typing, etc, etc. Thats why they call it "managed code", and it applies to both CLR/JVM equally. You can't completely get away from that "managed" aspect, if you could, it wouldn't be CLR/JVM anymore.

However, as you or someone said, depending on the source code, a clever JITC with a highly optimized runtime, can get within 5% of the speed of "unmanaged code" (ignoring garbage collection), I wasn't trying to imply that it was always a drastic difference. For many apps/purposes, thats plenty "fast enough".

Re:Good

[True Grit]

Unlike Sun's JRE, both Microsoft's .NET Framework and Mono have an AOT compiler

Well, there's a switch to the Java runtime to tell it to "compile everything it can *before* running" which is close to the same as "ahead of time". It isn't precompilation though, true. I guess there's a philosophical difference here between CLR & JVM on this, since precompilation *could* turn into "premature compilation" that can actually prevent a JITC from doing the best runtime optimizations its capable of. A JITC that can optimize across the entire program, possibly using runtime profiling information, is best when it can "see" all of the "code", whether in source or bytecode form (CLR/JVM bytecode still preserves semantic information about the code/data an optimizing compiler needs, which is normally lost once the code is compiled all the way to machine code).

Its probably just because of the fact that CLR is now integrated into the OS (Windows), that it made sense to MS to support precompiling it just like any other system library, after all, to them, thats what it is now: a system library.

but everything runs natively

I probably should have been a little more clearer in what I meant by compiling "down to 100% native machine code". I wasn't just referring to any bytecode that would need JIT'ing or interpretation, I was also thinking of the overhead (no matter how significant or not) imposed by the platform's runtime engine (CLR/JVM).

See my response to the other poster.

The upside of "managed code" is that a lot of things are done for you, the downside of managed code is... that a lot of things are done for you. :)

Re:Good

[bar-agent]

They both are crap and can't hold a candle to Haskell. In code beauty, elegance, efficiency, and speed.

Everything I've heard says Haskell is rubbish for general-purpose programming. Haskell has a win because it's pure-functional, but that only matters if you don't have state and you don't need to interact with the outside world. And everything has state, and needs to interact with the outside world. Monads? Don't talk to me about monads. If you pass a state variable everywhere, it's a horrible, kitchen-sink mess.

Re:Good

[True Grit]

It's my understanding that C# is more popular than Java for desktop applications because of faster startup and lower memory use.

Well, its *my* understanding that C# is more popular than Java because its being pushed by MS, the 800 pound gorilla of the PC desktop market, and oh, I would imagine the difference between being integrated with the OS (IE all over again) versus making end users go onto the net to get the other one, is also playing a role...

So which of us is going to blink first and reach for our trusty '[citation needed]'? :)

They'll care about staying compatible

[falconwolf]

which means either using the latest version of Mono

Staying compatible only until Microsoft decides it doesn't want Mono to be compatible.

Hell, even Windows developers don't necessarily care about staying current.

Guaranteed job security by using tech others don't know.

I'm a developer on two commercial apps written in C#, and they both target .NET 2.0. In the case of one of them, that's specifically so that it will be compatible with Mono.

Because you say one will, it's only logical to conclude the other will or may not be compatible. So whoever uses it may be locked into proprietary software then left out in the cold when support for it is dropped. And yes, MS does do that. I bought a brand new PC with NT4 and 3 years later MS stopped supporting downloadable patches. The last tyme I ran Windows Update the MS mothership said it no longer offered the updates online, it further said that if I wanted the latest update I'd have to order it on CD then they'd ship it.

And when .net reaches 5.1 or 10.1?

By then, presumably Mono will have caught up with .NET 4.1 or 8.5.

Unless MS wants to break compatibility, which I had already said they do.

By your reasoning people should still be using Windows 3.x. I doubt 1% do today.

The situation with Mono is different. If you write a bunch of C# code for Mono, using the features of .NET 2.0, because you want your software to run on Linux, you aren't going to give up on Linux compatibility and throw away all that investment just because Microsoft releases a shiny new version.

No it's not different. If a person wanted to they could still write software for Windows 3.x and those who have the OS can run it. But Someone running Vista will not. With Mono, sure something may run on the current version of Mono today, but that does not mean Mono will be current in 5 or 10 years. Anytime MS wants to they can stop supporting Mono and make .net incompatible. Heck MS doesn't even keep compatibility between different versions of Office. I doubt that many people using Office today would be able to view a document created in Office 1997, without some plugin. And I definitely would not be able to open and have rendered properly a document I create in Office 2007 in Office 1997.

You really think Linux developers are willing to give up on Linux just to "remain current" with Microsoft's releases? Seriously?

If they want to remain current but MS stops supporting Mono, and breaks .net so it is not compatible yes.

Falcon

Re:They'll care about staying compatible

[Mr2001]

Staying compatible only until Microsoft decides it doesn't want Mono to be compatible.

What, you think they're going to stop people from running .NET 2.0 applications on Windows? Considering how many such apps exist, that would be suicidal, but even if it weren't a hilariously stupid idea, .NET 2.0 is already out there (and redistributable). Even Microsoft can't change the past.

Because you say one will, it's only logical to conclude the other will or may not be compatible. So whoever uses it may be locked into proprietary software then left out in the cold when support for it is dropped.

The other one isn't compatible with Mono and isn't meant to be, because it interfaces with hardware that doesn't have Linux drivers. I just mentioned it as evidence that even on Windows, no one is being forced to upgrade to newer .NET versions.

If a person wanted to they could still write software for Windows 3.x and those who have the OS can run it. But Someone running Vista will not.

Actually, it's only 64-bit Vista that can't run Win16 apps. 32-bit Vista still can. And running even 32-bit programs on 64-bit Linux is no picnic either, so I'm not sure how this point is supposed to relate to Microsoft.

With Mono, sure something may run on the current version of Mono today, but that does not mean Mono will be current in 5 or 10 years.

Mono isn't even "current" with .NET today, but again, no one cares about that. Everyone who targets Mono is aware of where it sits in relation to the latest .NET. If they just wanted to be "current", they wouldn't be using Mono in the first place.

Anytime MS wants to they can stop supporting Mono and make .net incompatible.

By "stop supporting Mono" you mean "stop supporting .NET 2.0", which they technically could do, but (1) it would be crazy, since there's so much .NET 2.0 software out there, and (2) they couldn't stop anyone from installing an old copy of .NET 2.0 (which is freely redistributable)... or, you know, installing Mono for Windows.

Re:They'll care about staying compatible

[True Grit]

By "stop supporting Mono" you mean "stop supporting .NET 2.0"

No, he means they stop allowing Mono to use their patent-encumbered implementations of Winforms, ASP.NET and ADO.NET. That is the glue code that allows a Mono app to become a Windows app on Windows, and that has always been what the controversy over Mono is about.

Of course, using Mono/GTK# isn't a problem, as I think you pointed out, but judging from Mono's overall popularity in the Linux world, at least outside of Gnome, few people are really interested (for now) in doing that, since there are other ways to build a Linux GTK app, using almost whatever language you want via one of the numerous bindings available for GTK, and never mind that GTK isn't the only GUI toolkit available in Linux.

Re:They'll care about staying compatible

[falconwolf]

By "stop supporting Mono" you mean "stop supporting .NET 2.0"

No, for one thing I mean start threatening anyone who uses Mono for patent infringement. MS has been making noise for years saying Linux and Open Office infringe on 238 MS patents.

Falcon

Re:They'll care about staying compatible

[Mr2001]

No, for one thing I mean start threatening anyone who uses Mono for patent infringement.

In light of the recent legally binding "community promise", this is a non-starter. There is no patent danger from using C# or the CLI. Combine that with open source replacements for Microsoft's proprietary libraries (GTK# instead of Windows Forms, etc.) and patents are useless against Mono developers.

Re:They'll care about staying compatible

[Mr2001]

No, he means they stop allowing Mono to use their patent-encumbered implementations of Winforms, ASP.NET and ADO.NET. That is the glue code that allows a Mono app to become a Windows app on Windows, and that has always been what the controversy over Mono is about.

Well, not always. The more paranoid commenters here have tried to raise a controversy over the use of C# itself, but hopefully the legally binding "community promise" will put an end to that. WinForms, ASP.NET, and ADO.NET are what the controversy should be about.

That said: I don't believe there's any evidence that WinForms, ASP.NET, or ADO.NET are actually covered by patents at all, let alone evidence that the APIs couldn't be implemented in a way that worked around any such patents. There's only speculation: there's no explicit guarantee that a WinForms implementation is non-infringing, but the patent danger is still hypothetical and imaginary at this point.

Of course, using Mono/GTK# isn't a problem, as I think you pointed out, but judging from Mono's overall popularity in the Linux world, at least outside of Gnome, few people are really interested (for now) in doing that

Key words: "for now". I think people would become interested very quickly if Microsoft actually made a move toward stopping Mono from implementing Windows Forms.

Re:They'll care about staying compatible

[falconwolf]

In light of the recent legally binding "community promise", this is a non-starter.

Okay, I didn't know about any community promise. I still wouldn't put it past them to break it though.

Falcon

Re:They'll care about staying compatible

[True Grit]

Well, not always. The more paranoid commenters here have tried to raise a controversy over the use of C# itself

Ok, you got me there. However, I always considered those posters to be anti-Mono and/or anti-MS trolls, and never really counted their posts as legitimate arguments either. :)

There is no question in my mind that what is specifically covered under the ECMA agreements is 'safe'.

but hopefully the legally binding "community promise" will put an end to that.

Maybe, maybe not. Depends on who you ask. :)

Take a look at the top of my other post. That Open Specification Promise reference by the parent is that 'community promise', and I pointed out that it only specifically mentions the XAML scripting language, nothing about the "rest of Silverlight". The actual text of it can be found on MS's site as well as Wikipedia. The first link in that post is to a criticism of MS's 'Covenant to Downstream Recipients of Moonlight' by a para-legal, and that sounds even more problematic to me, nor is this the only place such criticism can be found. I'm not a lawyer, so who to believe? Everybody's got an agenda it seems, especially the shills & trolls (both pro- and anti-) here.

I don't believe there's any evidence that WinForms, ASP.NET, or ADO.NET are actually covered by patents at all,

Right, thats one of the fundamental problems of our patent system. We won't know anything for sure unless MS sues somebody, and if they don't sue, we'll *never* know for sure. :(

I think people would become interested very quickly if Microsoft actually made a move toward stopping Mono

Which is exactly why they'll hold off for as long as they feel they can. They know it would be a PR disaster, not to mention being possible evidence of monopolistic behavior, that could be used against them in a legal proceeding. Right now, Mono doesn't really hurt them, while simultaneously muddying the waters and giving them "good cover", i.e., "See EU, we *are* cooperating with other non-Windows platforms, and even 'supporting' FOSS software!". Those things are probably worth a great deal to them, so they might put up with a lot of internal "concern" about Mono, just to get that positive PR, and, if Mono/Moonlight struggles to keep up, and is always a couple steps behind, they may *never* sue, as the benefits of keeping Mono/Moonlight around as token proof of MS's benevolence to the non-Windows world may outweigh any damage that Mono/Moonlight really does to them.

But as you say, its 'for now'. :)

Re:Good

[dkf]

gcc even has a java (the language) compiler now (OK for about 5 years) that generates native machine code (what everyone used to whinge about) and there are independent implementations of the Java libraries (e.g. GNU Classpath).

It would be nice if gcj would work on modern Java programs as it didn't the last time I checked. Or at least not with the sample of programs that I tried, but this was admittedly some time ago. I didn't explore more because my requirement was for those particular programs (I was revising a course I'd written on them) and I just grabbed a suitable Sun JRE instead.

Re:Good

[makomk]

when the garbage collector kicks in the world gets frozen

Errm... I'm pretty sure this isn't a big problem in Java anymore. Now in Mono, it may be - Mono does freeze the world to GC, and it uses the Boehm garbage collector which is a relatively crude, non-compacting mark-and-sweep collector only slightly evolved from the 1960s. In 2.6, they're planning to move to a generational GC, thereby catching up with Java 1.2 (released 1998). I'm not exaggerating - I've read the docs, and it's the same scheme as Java 1.2's.

Re:Good

[DuckDodgers]

I think those are accurate points.

But Java has been around for years, most PC vendors have shipped their products with the Java Runtime Environment (JRE) pre-installed, and many Linux distributions install the JRE by default or make it an easy option. It all predated .NET by a long period. Java Web Start, Sun's idea for easy web distribution of digitally signed Java applications with fine-grained security, also predates .NET.

Java desktop applications had plenty of time to gain marketplace momentum, the infrastructure and development tools have been free, and the PC vendors sold desktops and laptops with the JVM pre-installed. It still never took off. As PCs get more powerful, Java GUI themes get much more pretty, the JVM continues to get more efficient and lean, Java is moving into a position where it is the technical equal (and source code license superior) of the .NET framework for desktop apps. But the damage is done, the window of opportunity is closed.

Re:Good

[True Grit]

But Java has been around for years, ... Java desktop applications had plenty of time to gain marketplace momentum,

True (although FWIW, the last complete PC that I bought did not include Java), and nor will I argue about the technical flaws of Java, they can and are being fixed, but they exist now and are real. The main difference is what I alluded to, that Java has always been trying to be cross-platform, something which MS obviously doesn't care about.

It still never took off.

Well, besides Java's technical problems that I mentioned, MS also played a role in this as well. They never wanted Java to succeed because they didn't control it. Once the embrace&extend of Java failed, .NET became "Plan B".

the window of opportunity is closed.

On the Windows platform, certainly. That was inevitable once MS released .NET. NET has little to no relevance to the other platforms however, and I don't believe Mono can change that.

Everyone knows why MS created NET, and I believe *most* people on non-Windows platforms know not to touch it, even with a ten-foot pole.

Re:Good

[DuckDodgers]

Microsoft's embrace and extend isn't what stopped Java GUI apps from becoming popular. I'm no big fan of Microsoft, but Java's failure on the desktop really has nothing to do with Microsoft and everything to do with Java.

I don't have a problem with Mono. Nobody is shutting down OpenOffice or Google Docs for interoperability with Microsoft Office proprietary file formats. Nobody is shutting down MingW for compiling code that runs on Windows. Nobody is shutting down Wine for building a Windows API layer. Nobody is shutting down Zimbra and Open Xchange for providing compatible features from Microsoft Exchange. The Samba is even working (finished??) on full interoperability with Microsoft Active Directory.

I ignore Mono because I see no reason to tackle C#'s learning curve when I'm comfortably employed as a Java developer. If I want some of the C# and F# features Java doesn't have, I'll use Scala. But I don't see any problems with using Mono.

It's just like in church.

[h00manist]

But it's quite simple. Dot-Net is for Catholics, and Java is for protestants.