Red Hat is letting Novell’s Mono software only into its noncommercial Fedora product line, the Linux seller said Tuesday. Red Hat has no plans at this time to include the Novell software in Red Hat Enterprise Linux, company spokeswoman Gillian Farquhar said, meaning that there are no plans right now to make it a standard part of the commercially supported product from the Linux leader.
Red Hat: Mono in Fedora, not Enterprise Linux
About The Author
Eugenia Loli
Ex-programmer, ex-editor in chief at OSNews.com, now a visual artist/filmmaker.
Follow me on Twitter @EugeniaLoli
I’m looking forwared to mono support in Fedora. I use Beagle and Muine and installed mono manually in Fedora Core 4. It will be nice to have built in support so updating will be easier. Mono is used by Gnome more and more so this makes sense that a Gnome-centric distribution would include it.
The two topics I am predicting people will come up with:
1) Mono is Microsoft based and including it is a patent violation.
2) Java should be used instead of C#
1) Mono, the C# compiler, and the C#/GTK# libraries are all released under the GPL2. The Windows.Forms Microsoft libraries are patented and couldn’t be inlcuded.
2) Java is closed sourced and Sun completely owns all the implementation and controls what is added, removed. C# is a cleaned up clone of Java but developers can add to and contribute freely just as they can to other open source languages released under the GPL.
3) Python should be used instead.
Oh no, I didn’t…
The problem with Python is that it breaks compatibility with each version not only code-wise, but also regarding the path of the modules and stuff. That was a major roadblock for Gnome when it was discussed on d-d-l a few months ago.
Miguel specifically told me the other day that from Mono 1.2 onwards there won’t be any binary/source incompatibilities in it and that it is a priority for his team to keep compatibility as much as possible.
Isn’t Python already part of GNOME? My experience with Mono and Mono applications has not been rosey. I don’t think Mono is as stable as Python for desktop application development. But perhaps my experience is skewed.
>Isn’t Python already part of GNOME?
It is part of the bindings platform, not directly into the core Gnome. Many OSes/distros don’t ship with pyGTK by default, even if they might use Gnome.
Pygtk is a dependency of the GNOME desktop already.
(gnome-menus depends on pygtk, and gnome-panel on gnome-menus).
You are right there is some instability in Mono. Python is more mature. Python is a good choice for small desktop applications but C# and Java are better for larger, more complicated applications.
I’ve heard a lot of people say that, but nobody seems to back the statement up? Why is Python inelligible for large scale software development?
All three languages are VM based. All three languages supported garbage collection. All three languages support OO paradigms, supposedly good for large scale development. Python goes even one step further by being multi-paradigm and liberal.
The only major difference between Python and the other VM based languages you mentioned is that Python is dynamically typed. And many developers even consider this to be a productivity boost or advantage over Java or Mono(C#).
So what makes Java/Mono better than Python for larger, more complicated applications? Is this a conclusion reached based on your experience?
A lot of people like statically-typed programming languages. They also like programming-languages with access specifiers, and explicitly declared member variables. Binary compatibility between releases of the compiler/runtime/whatever is also often highly-prized. I’m sure there are even a few people that will suggest that using whitespace to delimit scope is an impediment to large-scale development or some such.
That’s fine. But personal preferences does not suggest a programming framework is bad for large-scale development. If the criteria is based on personal preferences, I could argue that statically typed languages leads to unnecessarilyy verbose code and thus code that is difficult to maintain and decipher. Access specifiers are boiler plate bureaucratic redundancies that results from the rigidity and inflexibility of said language, binary compatibility is overrated and delimiting scope based on weird characters does not lead to consistent, maintainable and easy to read code. But those are just preferences nothing more.
You can dismiss anything and everything that you want. Short of meaningful scientific study on what language features or what absence of features translate into efficient large-scale development, all you’re doing is arguing over subjective material. No matter what someone tells you, you’re going to dismiss it because you’ve already determined that it’s not helpful for the development of large-scale applications. Whatever you dismiss, someone else is going to have determined that it’s beneficial for the construction of large-scale programs.
You could always point at some large pile of efficiently-constructed large-scale programs written in Python if you prefer.
My opinion is that developing large scale programs has very little to do with static versus dynamically typed languages, or delimiters based on spaces, or even binary compatibility. It has more to do with how the languages and their frameworks provide developers with tools and constructs to design programs on such a scale. And so far, I have very little reason to believe Python does not scale as well as Mono or Java for large scale developments. Of course, if there are scientific well researched studies that prove me wrong, then I stand corrected.
Not that I’m aware of. All programming language studies I’ve seen have flawed methodology that makes their results rather useless for making any definitive statements.
“large scale programs has very little to do with static versus dynamically typed languages”
Dynamic typing can result in a lot of unpredictable bugs what can be avoided in static type system and of course it has a much lower performance.
Can you give examples?
Dynamic typing can result in a lot of unpredictable bugs what can be avoided in static type system and of course it has a much lower performance.
The fact that dynamic typing causes more bugs is a myth, there is no research which backs this up. As for speed, there is no reason why a dynamic language can’t use the same JIT techniques as Java does giving it the same speed. As a matter of fact, it was a dynamic language (Smalltalk) which first used a JIT. Hotspot was originally a Smalltalk JIT which Sun bought in order to make Java run at some type of reasonable speed.
Dynamic languages rely on a superset of the techniques a JVM JITC would need to obtain similar levels of execution performance. This is because of the differences in message resolution as well as the differences in the presence of type information. Most research in JITC was done for dynamically-typed languages, namely Self as it pertains to Java, to make it “run at some type of reasonable speed.” Animorphic applied the research its members had done in Self in the development of a SmallTalk-dialect environment called StrongTalk, which Sun later acquired and adapted as HotSpot.
I’ve read your comment 5 times now and am completely unable to figure out if you’re agreeing or disagreeing with me.
Either way, for many dynamic languages (Python and Smalltalk included) this statment is false:
“This is because of the differences in message resolution as well as the differences in the presence of type information.”
There is no difference in the amount of type information available since both Python and Smalltalk are strongly type languages. And, last time I looked Java, Python and Smalltalk all have the same message passing semantics, they’re all dynamic dispatch (or if you prefer, all methods are always “virtual”). So for any of those languages method dispatch would work indentically from the perspective of the JIT.
Edited 2006-01-12 22:53
There is more type information available in Java than can be inferred statically in a dynamically-typed language with similar polymorphism, requiring more instances of generated runtime specializations. While Java does have polymorphic dispatch, the semantics of message resolution and dispatch are different.
There is more type information available in Java than can be inferred statically in a dynamically-typed language with similar polymorphism, requiring more instances of generated runtime specializations.
And what extra type information is it which is available in a statically typed language then in a strongly dynamically typed language? You seem to be confused between a strongly dynamically typed language and a weakly typed dynamic language like PHP. A strongly dynamically typed language has all the same type information available at runtime as a statically typed language has at compile. But all a JIT cares about is the rumtime type information.
You’re also going to need to actually explain why the message resolution and dispatch semantics are different. In any language with all virtual methods, the JIT needs to check the currently known type and then, if the method isn’t found, iterate over supertypes till it finds the method.
If you honestly think that dynamically typed languages with a JIT aren’t as fast as statically typed languages with a JIT you need to download Cincom’s VisualWorks Smalltalk and run some benchmarks, you’ll be in for a surprise.
I1 :
{
f : T1 -> T1 -> T2
g : T1 -> T3
h : T2 -> T0
}
C1 :
{
foo : I1 -> T1 -> T2
}
C2 :
{
tbl : T2[100]
con : C1
populate : T1 -> T0
}
vs.
C1 :
{
foo : ? -> ? -> ?
}
C2 :
{
tbl : ?
con : ?
populate : ? -> ?
}
In order for the latter, in the general case, to remain competitive with the former type feedback and type prediction will be necessary. That’s not entirely true since there’s some more complexity involved, but if you really want to study the matter there’s copious amounts of literature. It has jack all to do with “strong typing” vs. “weak typing.” You’re the one acting confused here.
Take class C3 to implement I1. Have C2 take an instance of C3 and pass it as the first argument to con.foo. Then compare resolution and dispatch with Python. What would you have to do in order to remain compatible with the semantics of Python with respect to the resolution of members, to remain competitive with the inlining possibilities presented by the type information provided in the other example?
As I said, the techniques used for a dynamically-typed language are a superset of those necessary for statically-typed languages. Java is a somewhat mediocre example of this because it throws away type information in certain stupid places, requiring its own added complexity to reduce type checks and improve inlining.
Java and C# type applications scale well and can be managed easily to create a large application. There is a reason why the majority of python applications are small.
I can give loads of examples at large Python applications and frame works. Zope comes to mind.
One obvious reason is that what they accomplish is easily expressed in a relatively small code base.
4) Common Lisp is all you really need.
“Java is closed sourced”
Not only can you view the Java sourcecode, you can also contribute bugfixes. Sun even provides development snapshots every few weeks.
“Sun completely owns all the implementation “
Sun owns their *own* Java implementation only! They don’t own GCJ, Jikes, J9, JRockit, Harmony ….the hundreds of other implementations. Anyone that has the talent/time can go, download the full Java specs, and make their own implementations.
“C# is a cleaned up clone”
You have never used C# before then. It is a complete mess and C# 3.0 is going to be even worse ( eg/ support for XML/SQL in the language WTF!!??)
“but developers can add to and contribute freely”
Show me where I can contribute to .NET. Atleast with Java there is the JCP. They might not take individual developers seriously but alteast its not a monarchy like .NET
Ah, but I have used C# with GTK# and I like it. It is easy to use and I find it faster to program in than Java.
You are getting confused about .Net and Mono. Anyone can contribute to C# and GTK# efforts. The .Net part which most people associate Windows.Forms part of .Net is proprietary and won’t show up probably on linux distributions. For end user development though C# and GTK# works great. Try it before you dismiss it.
“They might not take individual developers seriously but alteast its not a monarchy like .NET”
Have you ever noticed Java developers are always making excuses for the way Java is: sure it takes up half my systems memory to run my server, yes it loads slowly but once it gets up to speed it runs at near C++ speeds! What a lot of yah-but excuses. When it comes down to it Sun controls java not the community. You can create open source runtimes but they just support the Java classes. You can look at the Java source code but you can’t add to it unless the Sun developers decide it goes in. It is still very close sourced.
Have you ever noticed Java developers are always making excuses for the way Java is: sure it takes up half my systems memory to run my server, yes it loads slowly but once it gets up to speed it runs at near C++ speeds!
Well, this seems to be largely true. JDK is often faster, but needs more memory:
http://shootout.alioth.debian.org/sandbox/csharp.php
In many situations memory usage is not as bad as Java opponents suggest.
When it comes down to it Sun controls java not the community. You can create open source runtimes but they just support the Java classes.
I fail to see your point. .NET is closed, JDK is closed. Mono is open, Classpath + gcj/jikes/kafe/sablevm/… are open. I don’t see much difference in this situation.
Both are good languages, both have good opensource runtime environments, class libraries, and compilers. Pick what is appropriate for a project or your taste.
Edited 2006-01-11 20:13
“Anyone can contribute to C# and GTK# efforts.”
C# is based on a specification created by Microsoft. You can aid, as in, fullfiling the specification but you can’t diverge from it. In this repsect, its the exact same as Java, you can go ahead and “contribute” to the many, many FreeJava projects just as you can Mono.
[Slightly OT] I don’t know the current situtuaion with Mono, do you still need a seperate compiler for generic support?
“Have you ever noticed Java developers are always making excuses for the way Java is”
And your still ignoring the issue that Microsoft owns .NET. No one except for Microsoft has a say in its direction
“When it comes down to it Sun controls java not the community.
No, just take a look at JCP and see that there were instances where Sun was overruled by the other members. Sun does not have total control over Java.
“You can create open source runtimes but they just support the Java classes.”
WTF are you talking about? Projects like Harmony are drop in replacements for J2SE 5. Theres also already projects like Geronimo that are fully J2EE 1.4 compliant and Sun’s Glashfish which is an implementation of J2EE 5 which is also opensource. What are you trying to say?
“You can look at the Java source code but you can’t add to it unless the Sun developers decide it goes in.”
I guess you would prefer random people having commit privilege without any sort of QA?
C# is based on a specification created by Microsoft. You can aid, as in, fullfiling the specification but you can’t diverge from it. In this repsect, its the exact same as Java, you can go ahead and “contribute” to the many, many FreeJava projects just as you can Mono.
Wrong. You can diverge from anything you want. You might not end up with the language C# anymore, but nobody is stopping the Mono developers from diverging C# from the ECMA spec.
And your still ignoring the issue that Microsoft owns .NET. No one except for Microsoft has a say in its direction
True in practice, even though HP, IBM, and others are part of the spec committe.
WTF are you talking about? Projects like Harmony are drop in replacements for J2SE 5. Theres also already projects like Geronimo that are fully J2EE 1.4 compliant and Sun’s Glashfish which is an implementation of J2EE 5 which is also opensource. What are you trying to say?
WTF are you talking about? Harmony is vaporware.
“You can look at the Java source code but you can’t add to it unless the Sun developers decide it goes in.”
I guess you would prefer random people having commit privilege without any sort of QA?
Good one. Or you could have said, “You sure can add to it. Download the source code and add all you want to your copy of it.”
Wrong. You can diverge from anything you want. You might not end up with the language C# anymore, but nobody is stopping the Mono developers from diverging C# from the ECMA spec.
There’s a slight confusion in there. Sure, you can diverge from C#. You can create your own mmm… C## (or whatever you want to call it). But that is quite different from being able to contribute to C#, to add or modify something and introducing it into the standard.
Wrong. You can diverge from anything you want. You might not end up with the language C# anymore, but nobody is stopping the Mono developers from diverging C# from the ECMA spec.
He, he, he, he. Nice bit of double-dutch there. If you diverge so you don’t have C# anymore then what’s the point? Not that that’s a bad thing, but in no way is that different to Java. In fact, at least there’s a process for getting changes into Java officially rather than stuff being submitted to a standards body by Microsoft that people just are expected to accept.
WTF are you talking about? Harmony is vaporware.
Harmony is a wider thing involving gcj and Classpath. Red Hat actually have software they’re going to sell as part of a package running on it.
Good one. Or you could have said, “You sure can add to it. Download the source code and add all you want to your copy of it.”
That’s what you’ve basically said for the above. However, that applies for Sun’s version of Java. There are other implementations you know.?
Judging by the Harmony subversion repo, it’s not vaporware, as there is code in there. It’s just not got a release out yet, afaict, but judging by the latest mailing list traffic, they are planning on releasing some snapshots soon.
cheers,
dalibor topic
You can create open source runtimes but they just support the Java classes. You can look at the Java source code but you can’t add to it unless the Sun developers decide it goes in. It is still very close sourced.
I don’t see gcc developers adding new language constructs to C or C++, and if they did, I doubt that they would be widely used. Doing things like that would render the code using such extensions unusable on other compilers.
In the same way java classes need to contain what people expect them to contain, or the whole point of using Java will get lost. It would simply not be Java.
However there is nothing that prevents FOSS developers from developing faster or less memory hungry implementations of the java class libraries or of the JVM implementations. Neither is there anything that prevents them from adding new class libraries of their own. I really don’t see why som many FOSS people have a problem with Java.
Of course it would have been nice if Sun had opensourced their implementation, but that is another matter. Of course Sun still have some control of what should be part of java. Seriously, how much more control do you think an idividual developer would have had if Java had been controlled by some standards group like ISO or ECMA?
I don’t see gcc developers adding new language constructs to C or C++, and if they did, I doubt that they would be widely used. Doing things like that would render the code using such extensions unusable on other compilers.
http://gcc.gnu.org/onlinedocs/gcc-4.0.2/gcc/index.html#toc_C-Extens…
http://gcc.gnu.org/onlinedocs/gcc-4.0.2/gcc/index.html#toc_C_002b_0…
And at the very least, Linux uses the C extensions in GCC which is why the Intel compiler tends to support the GCC extensions as well. Whether Linux’s use fits your definition of “widely used” or not, I’m not sure.
Have you ever noticed Java developers are always making excuses for the way Java is: sure it takes up half my systems memory to run my server, yes it loads slowly but once it gets up to speed it runs at near C++ speeds! What a lot of yah-but excuses.
And this is different from .Net and Mono how?
“You have never used C# before then. It is a complete mess and C# 3.0 is going to be even worse ( eg/ support for XML/SQL in the language WTF!!??)”
Care to explain how it’s a complete mess? Millions of developers (including myself) would beg to differ. As far as the “built in” XML/SQL support, it’s not built in. LINQ will be released as seperate libraries with providers for sql/xml/objects/the ability to write your own for ANY type of data store…the underlying stuff is still encapsulated away and is by no means baked into the language itself. If you’d actually do some reading up on LINQ you’d understand that this is an incredible step forward to get the OO and relational programming paradigms to mesh.
Not only can you view the Java sourcecode, you can also contribute bugfixes. Sun even provides development snapshots every few weeks.
There is a difference between being open source and being source visible and you know it.
Sun owns their *own* Java implementation only! They don’t own GCJ, Jikes, J9, JRockit, Harmony ….the hundreds of other implementations. Anyone that has the talent/time can go, download the full Java specs, and make their own implementations.
Well, that’s actually somewhat debatable. No doubt Sun doesn’t own the runtimes but for at least Jikes and JRocket they certainly own the class library. Since there is no specification for the class library, it’s questionable if it’s even really possible to write a clean room implementation of the Java class library that is fully compatible with the one Sun ships.
You have never used C# before then. It is a complete mess and C# 3.0 is going to be even worse ( eg/ support for XML/SQL in the language WTF!!??)
You should keep up with your Java news: http://www.javalobby.org/java/forums/t61406.html
Looks like Sun wants to include XML support in the language with Java too.
Show me where I can contribute to .NET. Atleast with Java there is the JCP. They might not take individual developers seriously but alteast its not a monarchy like .NET
Have you read the JCP rules? Sun has complete control over what goes into J2SE. Sure the JCP can create various specifications but only Sun gets to decide what is distributed with the JRE.
“1) Mono, the C# compiler, and the C#/GTK# libraries are all released under the GPL2. The Windows.Forms Microsoft libraries are patented and couldn’t be inlcuded. ”
Actually it doesn’t use the GPL2, but another (GPL-compatible btw) license.
The patent concerns are not about Windows.Forms, they’re about the Mono core.
While I think Mono is quite nice, it’s still fairly immature. It has a nice GTK# implementation, and a good JIT runtime, and C# is fully implemented. But that’s about it.
And for me, full MS .Net isn’t even in the picture – it’s one platform only (Windows), which completely defeats one of the purposes of VM/interpreted languages – write once run anywhere. Also, in my experience (your miliage may vary, yada yada), I’ve found .Net to be slow and memory intensive. Visual Studio .Net (written in C#, using the CLR) is a complete hog compared to Visual Studio 6.
Java, by contrast, is very mature, and very full featured, better optimized (for a VM language), and has numerous and huge and powerful and easy APIs. And, very importantly, Java is (mostly) write once run anywhere, and fully cross platform, and has many different corporate and open source implementations.
All that said, I would still prefer C or C++ for desktop apps, or anything where speed and low memory consumption are important.
Neither Visual Studio .NET nor Visual Studio .NET 2003 are written using C#. They use more resources than than VS6 because they have more functionality.
This is is not true:
“The Microsoft’s not using Managed Code Myth
One of the biggest challenges in my old job was that customers didn’t think Microsoft was using managed code. Well, the truth is that we have a good amount of managed code in the three years that the .NET Framework has been released including operating systems, client tools, Web properties, and Intranet applications. For those of you that refuse to believe, here’s an estimate of the lines of managed code in Microsoft applications that I got permission to blog about:
Visual Studio 2005: 7.5 million lines
SQL Server 2005: 3 million lines
BizTalk Server: 2 million lines
Visual Studio Team System: 1.7 million lines
Windows Presentation Foundation: 900K lines
Windows Sharepoint Services: 750K lines
Expression Interactive Designer: 250K lines
Sharepoint Portal Server: 200K lines
Content Management Server: 100K lines
”
from http://blogs.msdn.com/danielfe/archive/2005/12/16/504847.aspx
What I said is correct. Neither Visual Studio .NET nor Visual Studio .NET 2003 are written with C#. If you want you can inspect every DLL in the IDE.
There, I’ve done just that. The assemblies it ships with include interop classes and project wizards.
While I think Mono is quite nice, it’s still fairly immature.
Ok, we can also call Java immature too, and LISP, and C++, and anything else to suit our agenda.
It has a nice GTK# implementation, and a good JIT runtime, and C# is fully implemented. But that’s about it.
And a nice class library, but that’s about it for Java too.
And for me, full MS .Net isn’t even in the picture – it’s one platform only (Windows), which completely defeats one of the purposes of VM/interpreted languages – write once run anywhere.
Yeah, if Mono didn’t exist, but it does, so you’re wrong there too.
Java, by contrast, is very mature
Oh, I’ll just claim it’s immature like you claimed .NET is immature
and very full featured,
as is .NET
better optimized (for a VM language),
Completely false. Java wasn’t designed for JIT off the bat like .NET
and has numerous and huge and powerful and easy APIs
as does .NET
And, very importantly, Java is (mostly) write once run anywhere, and fully cross platform
Except for J2ME
and has many different corporate and open source implementations.
There is no complete open source implementation of J2SE5.
Ok, we can also call Java immature too, and LISP, and C++, and anything else to suit our agenda.
We could, but it would be a huge stretch. Java’s APIs are huge, and very powerful. Mono’s, and even MS .Net’s, aren’t even in the ballpark. Java has made mistakes, and learned from them, and has been continually improved. C++ is very powerful and mature and very full featured.
And a nice class library, but that’s about it for Java too.
Mono’s class library is pretty good. But it does not touch Java’s. There is no comparison.
as is .NET
Many (not all) of .Net’s features are geared towards specifically running on Windows, and taking advantage of Windows functionality.
Completely false. Java wasn’t designed for JIT off the bat like .NET
No, Java didn’t have JIT off the bat. But it’s been there for quite a while, and .Net was able to “stand on the shoulders of giants”, and take what Sun and others already worked on and perfected.
Except for J2ME
Due to resource constraints (small cell phones and hand held devices) J2ME is a subset of J2SE out of necessity. So of course you could not do everything in J2ME that you would with J2SE, and especially J2EE. Nevertheless, if you use only the subset of J2ME APIs, you could run your J2SE stuff on a J2ME enabled device. It’s still WORA, but with limitations (which have to be there). By the way, Mono doesn’t even have a micro edition, and .Net’s micro editions faces the same limitations J2ME does.
There is no complete open source implementation of J2SE5.
Technically speaking, that statement is correct. But for all intents and purposes, there really is a full open source Java stack, even though it does not include all of the new Java 5 features. GNU classpath just anounched 98% compatibility with J2SE 1.4. And there are very high quality open source compilers and VMs, such as gcj, gij, Jikes, Kaffee, and Sable. Then there is Fedora’s highly functional and powerful open source Java stack that includes gcj/gnu classpath, Eclipse, Tomcat, Ant, Junit, and (with download) JOnAs. Open source Eclipse is practically the defacto standard for Java IDEs. NetBeans is fully open source, and an extremely powerful (and easy) IDE. SWT is a very powerul open source Java GUI API. Then there’s the open source J2EE app servers, such as JBoss, Glassfish, and Geronimo. Then there are the open source frameworks, like Struts, Hibernate, Spring, and many others.
So, open source Java is a very highly powerful and functional reality.
Plus, my original post was not meant to knock Mono. I think it’s pretty good and has lot’s of potential. Also, MS .Net has it’s upside (ease of development on Windows). But IMHO, Java is much much much better, for many reasons, including the ones I’ve mentioned in this post and the previous one.
And one more thing. It’s pretty safe now, and I congratulate Miquel and his crew for their great Mono work, but in the long run MS will use it’s patents against Mono. With MS’s “declaration” to not use it’s C#/CLI patents against any implementers of the ECMA standards is exactly like the scorpian that promies the turtle that he won’t sting the turtle as the turtle gives the scorpian a ride on it’s back across the river. And the argument that Java is proprietary and holds the same risk does not hold water, for the following reasons:
1. Sun, warts and all, has much better record as a good corporate citizen.
2. Sun’s best business interests are in favor of having many Java standard compliant implementations (proprietary and open source)
3. Implementations/huge business interest in Java from huge corporations like IBM, HP, BEA, Oracle, Borland, and many others, all of whom have patent/IP arsenals, and most of whom have deeper pockets than Sun. If Sun ever wanted to play hardball with it’s Java IP, it wouldn’t stand a chance.
4. The Java Community Process. Everything is ultimately Sun’s call, but everyone who wants it has a say in the direction of Java.
Thus, there is no IP risk in implementing Java. With C# and the CLI, there is.
Ok, we can also call Java immature too, and LISP, and C++, and anything else to suit our agenda.
We could, but it would be a huge stretch. Java’s APIs are huge, and very powerful. Mono’s, and even MS .Net’s, aren’t even in the ballpark. Java has made mistakes, and learned from them, and has been continually improved. C++ is very powerful and mature and very full featured.
No, it would be a stretch for someone who hasn’t evaluated the two libraries closely. .NET learned from Java’s class APIs mistakes. Java has tons of baggage that it has to carry with it over the years
Mono’s class library is pretty good. But it does not touch Java’s. There is no comparison.
More unsubstantiated claims based on some vague personal opinion of yours.
as is .NET
Many (not all) of .Net’s features are geared towards specifically running on Windows, and taking advantage of Windows functionality.
Wrong again. There are only APIs. Just like at some point, Java has to use native code underneat a crossplatform API.
There is no complete open source implementation of J2SE5.
Technically speaking, that statement is correct. But for all intents and purposes, there really is a full open source Java stack, even though it does not include all of the new Java 5 features.
Technically speaking, you would have to put the open source Java stack in the same place as Mono (as in it’ll never be 100% compatible with the real deal). Open Source Java will always be irrelevant to production server code because you can get the real deal for free on the major platforms.
So, open source Java is a very highly powerful and functional reality.
Except, as stated above, it’s irrelevant to anyone except for those that are open source zealots because there are already official stacks for the important platforms. And Classpath complete coverage is not a reality yet, if ever.
With MS’s “declaration” to not use it’s C#/CLI patents against any implementers of the ECMA standards is exactly like the scorpian that promies the turtle that he won’t sting the turtle as the turtle gives the scorpian a ride on it’s back across the river.
We’ve been through that mess before. You’re just wasting keystrokes. Everybody has already formed their opinions on the matter and most people aren’t running under the covers because of some hypothetical “what if” scenario. By the way, Fedora will now ship Mono (as stated on the front page
1. Sun, warts and all, has much better record as a good corporate citizen.
Meaningless and if it did nobody would care. People just want tools to do their jobs.
2. Sun’s best business interests are in favor of having many Java standard compliant implementations (proprietary and open source)
Why doesn’t Sun just open source it if it’s in there best interests? And unless you have some special insight into Sun corporate strategy, then you wouldn’t know that anyway.
3. Implementations/huge business interest in Java from huge corporations like IBM, HP, BEA, Oracle, Borland, and many others, all of whom have patent/IP arsenals, and most of whom have deeper pockets than Sun. If Sun ever wanted to play hardball with it’s Java IP, it wouldn’t stand a chance.
I never claimed that Sun would bait-n-switch Java. You need to discuss that with the open source zealots.
Thus, there is no IP risk in implementing Java. With C# and the CLI, there is.
Totally false. The ECMA specs for the CLI and C# are open and there is no danger. There could possibly be a danger for certain class libraries – but even that is a stretch. C# and the CLI itself are in no danger.
.NET learned from Java’s class APIs mistakes.
Like what?
Java has tons of baggage that it has to carry with it over the years
Like what? But a daresay .Net will have a fair bit of baggage as Microsoft ramp up the versions. Good luck with that compatibility Miguel.
Wrong again. There are only APIs. Just like at some point, Java has to use native code underneat a crossplatform API.
Ha, ha. Some vague chin-wagging and painting over going on there as to how .Net is not cross-platform and relies on Windows for it’s implementations. Java runs completely in it’s own VM, and that was one of the things James Gsling has been most insistent on. The VM is written in native code (duh) but Java does not go off P/Invoking everthing like .Net does.
Open Source Java will always be irrelevant to production server code because you can get the real deal for free on the major platforms.
Nope. There are distribution problems with that, and it will be on production systems because that’s what Red Hat are committed to.
Except, as stated above, it’s irrelevant to anyone except for those that are open source zealots
Everyone’s a zealot baby! It is relevant because it means you’ll be able to freely distribute a Java implementation with a Linux distribution. Is Mono irrelevant because you can just use .Net on Windows? Well, let’s not go there ;-).
Everybody has already formed their opinions on the matter and most people aren’t running under the covers because of some hypothetical “what if” scenario.
Nope. Those patents, specific to .Net and implementations using the CLR, do exist.
By the way, Fedora will now ship Mono (as stated on the front page
To get two or three applications that don’t work very well because people don’t have very many applications to start with.
Meaningless and if it did nobody would care.
Nope. Sun uses open source software, and contributes to it, Microsoft really, really wants to get rid of it. Hence, Sun has a batter track record.
Why doesn’t Sun just open source it if it’s in there best interests?
No idea. It doesn’t stop an open source implementation happening though.
I never claimed that Sun would bait-n-switch Java. You need to discuss that with the open source zealots.
You’ve got this thing about zealots for some reason. His point was that because there are multiple implementations, users and developers of Java then it would be very difficult for Sun to throw their weight around more than they do at the moment. All they have is the Java trademark really. Contrast that with Microsoft’s control of .Net……..
The ECMA specs for the CLI and C# are open and there is no danger.
Wrong. Microsoft’s patents specifically apply to and mention .Net implementations and anyone who implements C# and the CLR to the ECMA specifications laid down.
There could possibly be a danger for certain class libraries – but even that is a stretch. C# and the CLI itself are in no danger.
Nope, that’s totally wrong and is something the Mono people have been keen not to get into. Regardless of whether it has been submitted to a standards body it is still Microsoft’s IP, which is why they like using the ECMA.
Microsoft, the Mono people and the ECMA people have not made it exactly clear what Microsoft holds over those specifications. The fact of the matter is that Microsoft has not given an explicit free-for-all grant to use them, and nothing in their submission to the ECMA says they have done so or compels them legally to give anything up. The alleged, wishy-washy and legally undefined grant only applies as long as Microsoft and the specification remain a part of the ECMA – which Microsoft can invalidate at any time at no loss to them but to everyone else. The ECMA standards guarantee you absolutely nothing.
Edited 2006-01-12 12:10
Sun Microsystems will not release their implementation under an open source implementation for the same reason, say, Microsoft will not release their .net implementation under an open source license: their management does not see how they would be making more money then they currently are, if they did that.
cheers,
dalibor topic
Ok, we can also call Java immature too, and LISP, and C++, and anything else to suit our agenda.
Well your own agenda maybe ;-). You only need to look at the way an application like Beagle drops your machine through the floor, or the relative overall maturity and performance of other Mono apps, to tell you that Mono is just not mature.
Yeah, if Mono didn’t exist, but it does, so you’re wrong there too.
.Net is not a cross-platform technology. Will there be Indigo support some time soon? I smell some deja vu there.
Oh, I’ll just claim it’s immature like you claimed .NET is immature
Java has been around an awful lot longer than .Net, and in application servers in a lot of companies (Java’s biggest usage area) .Net just doesn’t register. That’s probably what he’s referring to.
Completely false. Java wasn’t designed for JIT off the bat like .NET
Not that that actually means anything because JIT support is just there.
Except for J2ME
Wow.
There is no complete open source implementation of J2SE5.
And? Open source J2SE5 is a work-in-progress, as Mono consistently is. It’s like me saying that Mono doesn’t support all the features of .Net 2.0 and won’t have Indigo support.
Edited 2006-01-12 11:44
If you want to see Python being used for all sorts of Gnome apps and utils, then simply install PyGTK and start writing them.
Java is fairly nice IMO, but it just tends to be easier and quicker to get most jobs done with Python. As far as the argument goes about dynamic typing leading to weird hard-to-debug runtime bugs, I think that good test suites may go a long way to help with that. But you were already writing unit tests anyway, right?
One of Python’s greatest strengths is getting stuff together and working, fast. If you’d rather see a Python Gnome app come together before a Mono (or Java) Gnome app — start coding. Seriously. You’ll likely beat the Monos (Monoers?) to the punch
But if you do decide to go with Java or Mono, it seems wisest to stick with a free (as in libre) Java like GCJ. Then again, maybe Mono’s success could help force software patent issues to be dealt with sooner than later. Dunno.