The open discussion about how the future of desktop development for Linux should look like is continued between Novell’s Miguel de Icaza and Red Hat’s Havoc Pennington with multiple posts in their blogs.
The Future of OSS Desktop Development, Part II
About The Author
Eugenia Loli
Ex-programmer, ex-editor in chief at OSNews.com, now a visual artist/filmmaker.
Follow me on Twitter @EugeniaLoli
This is mainly about Novell (Suse) Vs. SUN and Redhat.
I think their “positions” in the cummunity are really going to their heads.
Does anyone care? Or will the “future of OSS” be the same as the past of OSS… Like evolution.. hard to predict.. impossible to dictate.
Who said it was?
It’s good to get the attitude of the Rasterman in there too. href=”http://www.rasterman.com/news.html
And therefore, it makes it more difficult to say “Hey, I agree with HP/Miguel. Regardless of what we might think about their opinions, HP did essentially get what he wanted, a discussion with regards to the future of the Gnome DE, and how applications will generally be written for it.
My own opinion is a bit twisted. I have written GTK/Gnome apps in C, Python, Mono, and even Java (though, I won’t claim that I am an expert in all of them). I will admit that Mono (along with MonoDevelop), made it very easy to develop applications. And couple that with Glade – Glade, the GUI builder for Gnome, which is actually really easy to learn once you get off the Visual Basic mindset of GUI Development – it becomes really easy to develop applications.
But most of what they talk about has less to do with the technical merits, and more to do with fragmentation and politices, and legal issues.
Obviously, if Gnome does the way of supporting a Mono-esque, Java-central, etc. form of development, they will basically piss people off. Keeping it the way it is will also probably piss people off (this is really a damned if you do, damned if you don’t type of thing).
HP makes an interesting statement here, however:
“As I understand it nobody is advocating C# plus .NET platform, as this is widely understood to be legally and strategically out of the question.
It’s unclear that everything I’ve enumerated here is viable. We don’t know yet whether C# in any form (even just the ECMA core) can get broad acceptance. We don’t know for sure that Java can either. The only thing we know for sure to be viable is the status quo: Stick to C/C++. To me, I would rather accept that than see the current trend toward fragmentation. However, I do think it would be better if we can find a way to move forward.“
Maybe I am not understanding the whole debate, but from what he is saying, and what I read, the idea of Mono (in the realm of this topic) is that it would be the syntax of C# on top of the Mono classes, and things like GTK#. We aren’t talking about using .NET here.
What I also find interesting is that Novell is Mono focused, and Sun is Java focused (obviously). Both are Gnome supportive (Novell, mostly because of Ximian, and Sun because of the Java Desktop).
So, when all is said and done, will supporting one over the other lead to a split from either vendor? Most likely. But then again, I believe this will happen regardless (and pretty much already has, IMO, with Ximian Desktop and Java Desktop).
But I don’t care about that. Sun and Novell’s marketshare mean little to me, as an end user of the Gnome Desktop, and part time developer of applications for it.
Anyways, I am rambling…
I would love to read all what this Rasterman has to say, but man that font he uses really kills my eyes. I had to stop on the 5th line.
@Jason:
It’s kind of funny though that Sun uses the Java Desktop, which is really SuSE in disguse, which Novell now owns. Kinda makes a weird loop, huh?
It sounds to me like he makes more sense than the rest of them combined.
a good read…
My personal take: code reuse is a nice thing, as long as it doesnt create more problems than it solves (legal nightmares with patents , licence issues, etc), however there is a point where it becomes EASIER to “reinvent the wheel” and write your own.
Each person’s cut off point would be different, yet it seems like many people consider it better to weather any storm for the sake of saving the effort of writing a few extra lines of code.
Personally, I would rather use a language im happy with… and use the libraries that do what i want.. or else if i cant find any appropriate, write new ones.
@Jay:
Yup. And consider that SuSE was primarily KDE-centric, it gets even more twisted. Of course, I like the fact that Novell acquired SuSE. Hopefully, Gnome support will grow (me being a Gnome on SuSE user and all).
Many of these problems are really deployment problems.
One of the reasons that C was chosen as the platform language for Gnome is that it’s easy to create bindings for it compared to C++. This is really a double-edged sword though. Historically, the bindings for Gnome and Gtk+ have either been behind the current version, buggy, or probably worse yet in that it relies on a feature of previous version of Gnome or Gtk+ that is supposedly binary upward compatible, but the language binding relied on the quirkiness of a previous binary compatible version of the library.
Not only is the aforementioned a problem, but when you use one of these language bindings then you run into dependency problems. It’s not that app installers these days don’t solve dependency problems, but not everything is nice and neatly packaged into some distros repository. That’s really a problem with all distros in general, in that unless you compile your own stuff and its dependencies your pretty much stuck in your distros universe. Compare it to windows, where you download the installer from some random website and it just works. So the depenedency problem does matter.
Bring in Mono. Mono solves the dependency/bindings problem for languages that target CLR. Any language that targets the CLR will automagically get the bindings for free. There is no other work involved. I don’t think it’s that easy for Java, if it’s possible at all right now, because Java just doesn’t have the interop mechanisms that .NET/Mono does.
I think Gnome’s first class language will continue to be C for a while unless attitudes change.
An interesting debate, but it presumes that the “community” can “pick” a technology. Python, Perl, and C++ folks are still going to do their thing. You can induce/incent etc in one direction, but the free desktop is not going to have one application toolkit.
Miguel is saying that native widget sets are the way to go. Thats true. I don’t think anyone sees a real future in Swing. Don’t reply with quotes and example about how Swing can be made to look as good as native widgets – Swing is ugly. But Java-Gnome approaches this problem as good as Gtk# does. So I’m not sure if this is a big issue. In this world you cannot run apps across OSs with consistent UIs, but is there really strong demand for this anyway? A few key apps have filled the cross platform holes with native layers (Mozilla, OO.org, Abiword)…its not clear further demand is there.
Native widget sets are not going away. Not while desktop computing is a viable paradigm. That I treat as self-evident.
Havoc wants to see Sun be kept in the loop on Linux, presuming that a nod towards JAva would do this. I’m not sure Sun is an important of an ally as Havoc presumes. They are still pressing Solaris as their solution of choice, and it isn’t clear they represent a key innovator or marketshare leader in the linux world. How many people do you know who run Redhat/Fedora? How many people do you know who run JavaDesktop? I rest my case.
Let Sun and the Java-Gnome people continue pressing Java. Let Novell and Miguel continue to press Mono. Its not clear there would be any key benefit to one side “surrendering”. At some point programmers will pick and we will get a majority vote. It may take time but the market-based approach will likely help hash out issues we can’t think of yet.
As an interesting aside, at the very least we can determine which toolkits have little future:
1. Perl/Parrot. I say this as a person who has made his living writing Perl programs. I love the language but I have to concede too many people loathe it. Parrot is also untested tech that is still in a very early stage. Perl6 could potentially even be more baroque in some ways than Perl5. Perl will always be in my toolbelt but in many ways this project has lost its way.
2. Python. Cool language but it lived in Perl’s shadow for too long. Also the whitespace thing does not appeal to many.
3. Ruby. A great language that, like Python, could never crawl out of Perl’s shadow.
4. C++. Too complex. Too easy to misue. Too easy to shoot your own feet off. Just too much. In a perfect world with perfect programmers, C++ would be the only language. But we live in a world where programmers who are really good often feel a desire not to program anymore. This languge should die.
5. sh. Not in the running for a development language but I have always wondered why the default shell language is so lame when we have so much better available.
Why can’t Java, .net, and a host of other technology coexist? It will keep the owners of the technology innovating and keep them from flexing their muscles.
These are all languages, not toolkits. GTK+ has bindings for all these languages (even Ruby I think). I really don’t see what the huff is about – just make the APIs the best you can, and the binding authors keep up-to-date, and the developers should be kept happy. Does the GTK+/GNOME IDE handle all these languages? It should if it does’t yet do so.
From Icaza’s web log:
“If I were Sun, I would be retargetting my JVM code generator on Windows to generate CIL and making sure they can use every single Longhorn API.”
I don’t understand. Is he saying
prog.java->prog.class->JVM->(CIL->)MVM->cpu e.g. 2 VM’s? Or is he saying prog.java->prog.class->MVM->cpu. But in the latter case Java looses it’s reason e.g. write once – run everywhere.(I’ve used MVM for Microsoft VM – don’t know it’s acronym).
>GTK+ has bindings for all these languages
Well, yes, the issue isn’t only bindings. But component
technology. On *nix you write(or generate) bindings/glue code
for each language to a specific library. On windows you
make the language understand COM. Voila, you got instant
access to heaps of libraries/components.
These days Microsoft are favoring the .NET CLR as the “binding” factor between languages and components.
Make your app/library/language compile to CLR, voila.. instant access to lots of things again. Well, thats the hope atleast.
The thing is, wouldn’t it be nice for *nix to have something similar ? (maybe/mabe not..)
Miguel things we should go the MS way, with CLR.
I’m not so sure about that, while it might be a great
thing for Windows, what makes it so good for other platforms ?
I think what he means is that the JVM should, for example, use .NET Windows Forms or Avalon for Swing Java apps.
My two pence: the OS community programs mostly for fun, so they won’t contribute to a project whose language they don’t like. Therefore .NET seems a better solution (due to language interop).
Swing is not ugly, on Mac OS X it has the look and feel of aqua, on Windows it has the Windows look and feel, on WindowsXP it has the WindowsXP look and feel. It defaults to the ugly Java look and feel on Linux but it does have a GTK+ look and feel which has the ability to read gtkrc files on startup. For some reason it doesn’t have a QT look and feel.
It escapes me why distros, especially commercial ones that focus on one desktop environment, don’t make Java assume a nicer look and feel, it’s pretty easy to do so.
i’ve been wondering about just how cross platform c# really is. if i write an app in mono, would it just take a recompile for it to work on windows and Mac OS X?
I’ve always loved Enlightenment (0.15 and 0.16), and IMHO Rasterman is certainly one of the best C programmers alive (just look at the E16 code!).
After hearing just *nothing*, he writes this innocent blog entry, and — hey — he’s right!
For me languages like Java and .NET are just not perfect / good / mature enough.
Languages like Lisp and C have survived for decades and are *portable*. Heck, even Smalltalk, Scheme, ML, Haskell and other languages are *far* more portable than Java. The BSDs haven’t even had Java until recently! So does BeOS (does it have Java now??). Also the JVM and CLR runtimes are far more complex and bloated than other languages.
This is to say, other languages aren’t perfect (far from it!), but they evolved with their cultures (K&R C to ANSI to ISO C; Lisp to Scheme and Common Lisp (1, 2, and ANSI)).
Why not let programmers choose which language to use, and give them APIs instead? Everyone who says “ONE language to rule them” all should read a book about Component Software (like Szyperski), which is exactly where I hope we will be going.
Give me interfaces to hack, not unportable platforms that support some companies’ lock-in strategies.
I think I might be missing the point here.
The discussion isnt about language or what toolkit to use. Gtk will still be the toolkit, and there will still be bindings to all the different languages. The question is, if there can be a unified VM backend to avoid fragmenting users between the .NET VM and the Java VM. Even the Parrot or Python VM are possible, but they do not offer the range of power that the .NET and JAVA VMs have to offer.
OK, C++ is not easy but is powerfull and it is mature now. I think that it would be easy to build powerfull multiplatform libraries for common tasks like GUI, database connection, memory recicling, etc.
A combination of a multiplatform compiler like gcc, libraries like wxWindows (for GUI), STLport (STL), ACE (for networking), Zeoslib (database connection), etc would result multiplatform applications with better performance.
Interpreted languages are better to rapid development but I think it is madness to use Java or C# to general development.
We need a superset of C++ (a C++++ ou C+=2) that would be self-sufficient to build complete multiplatform applications.
You don’t mind uncovering where his blog is , for others to read ?
>We need a superset of C++ (a C++++ ou C+=2)
Its called (ofcourse) ‘D’ (http://www.digitalmars.com/d/index.html)
Seriously, take a look at it, it has powerfull features.
Moreover, it gets translated to C which means nothing to the programmer except it compiles to native.
Well, as far as I know, SUN want to move away from the use of SuSE linux, I think a new release is due sometime in June which I am told is the last release with SuSE at its core, I may be wrong. Now on the subject of JDS.
JDS is not suse, JDS is a customized version of GNOME which happens to sit on top of SuSE Linux, they have also ported it Solaris.
I think that Miguel is wrong about the use of C# in Linux, even from an ISV stand point. C# and Java are almost identical, infact Java 1.5 overtakes it, this is the start of a war, I am very scared of the fact that if Mono gets wide spread adoption, then we have lost against Microsoft, I mean hell, why can’t we reimplement an opensource version of Java, or create our own runtime like .NET CIL.
Don’t hand GNU and Linux to Microsoft on a silver platter, and to think… The community would have learnt about how vulnerable linux is with all this crap with the SCO Group, they may not have a case, but whats to stop more and more poeple. In fact whats stopping MS, they are leaving out the bait and we are definatly bloody biting, all they have to do is strike and real us in!
My 2 cents
C’mon face it: .net if a ’60 approach.
yet, another ALGOL. Yet another FORTRAN.
Devs have been trained to think in static strong manifest typing.
Nobody needs that, the rise of XP and agile techinques like tdd shows this. The sooner people understand it, the sooner we’ll be happier.
I would opt for mono for several reasons.
1). Mono is a lot more GNOME centric than Java
2). Mono is language agnostic. You can use Java, Python, C, C++, Perl etc.
3). Mono already has all the GNOME APIs available for developers to use.
4). Mono already has GNOME applications available for it.(i.e Blam, Muine, Gfax, MonoDevelop, etc) and many more on the way.
5). Mono is a platform agnostic development environment.
6). Mono is free software and GPL compatible, a fundamental requirement for any development framework to be a part of GNOME.
I think Mono already has the infrastructure in place to enable GNOME developers switch to a higher language development framework if they wish to. Java at present doesn’t. And SUN is not interested in make Java free software or GPL compatible.
I think some people are missing the point. Havoc clearly points out that this is not about 3rd party apps at all, and libraries will still be available for any language that someone wants to write bindings for. The issue is what goes into Gnome proper, ala the desktop release. Evolution is now part of Gnome’s desktop. This, if in the future parts written in Mono, Redhat et. al. will have to ship Mono in order to have full Gnome functionality. We see how Redhat treats mp3’s, and they don’t seem to want to be put in a similar position with Mono…
Java is in the exact same place.
So, the question is what becomes acceptable for the desktop release, not what apps are written in…
Chris
LOL…
That might be the truth…
http://www.currentflow.net
Let us disguise business strategy sparring with technical terms.
Let us furthermore ignore the truth that time will tell the best path.
They should have a cage match, and come up with pro/con lists, and weight the bullets on the lists, and let the community score it.
Best platform wins.
Why hasn’t anyone mentioned the Eclipse project with their SWT library in this debate? You can use gcj to compile standalone Java GUI applications for both Windows and Linux/GTK. This method is unencumbered by Sun’s proprietary JDK. It would make more sense to contribute resources to projects like these than try to reimplement Microsofts square wheel.
No! Please don’t give me Java on Desktop. Java should only exist in servers and nowhere. I don’t want my applications’ startup time and responsiveness as “good” as Elipse.
What did he produce the last couple of years? I see nothing… OK, neither HP and Miguel did anything. Maybe Miguel did Mono, that’s about it.
I know Owen Taylor is responsible for GTK+.
It’s not about language but about platform. Using which platform so that every language can access the underlying platform, not just GUI, but also IO, DB, Multimedia, WM…
That’s why both of them focus on VM based languages because it is also a platform. But I hate VM based languages. I simple gtk’s .def file and a swig like program is enough for me. Orbit can do the same thing with extra bonus of remote accessable. Anyway, are you sure Longhorn can delivery what it promised? It promised too much, we will see a win3.1 when it come.
>> Swing is not ugly
IT IS
IT IS
IT IS
Until Java advocates clue in to what the rest of the world has already figure out, they will remain hopeless.
>> Why hasn’t anyone mentioned the Eclipse project with their SWT library in this debate?
Because Java diehards refuse to accept any native widget strategy.
>>> Why hasn’t anyone mentioned the Eclipse project with their SWT library in this debate?
Manual memory management (hint, you have to free all SWT widgets after use AFAIK) anyone?
I am deeply and profoundly concerned about Gnome. Something is terribly amiss within the Gnome community. I used to think that the KDE folks were less fortunate than the Gnome ones because they did not have the same type of corporate (Sun, IBM) backing. Now I am not so sure. And here’s why.
Read Havoc’s entire blog and you will get a good panoramic picture of what’s going on, and the very real problem that a fork may be about to happen, but let me provide a small summary below:
http://log.ometer.com/
The Gnome community is deeply divided. Miguel, an articulate and influential coder, a good one at that, made a leap forward and jumped into C# a couple of years ago. C# is a good technical language, but there are too many legal and business issues that make it unlikely to become the standard technology for Gnome Development.
In the meantime, Sun, rather than work with the evolution folks, is reimplementing a major part of the Gnome desktop in Java and its deploying substantial resources to it. See project Glow: http://groupware.openoffice.org/glow/
Project Glow is Java-based which means that Debian, Red Hat and Mandrake and possibly more will not ship it as it introduces a system dependency for a fundamental building block on a proprietary piece of technology.
What’s worse is that Openoffice.org is integrating more Java into its core leading to a similar problem than the one outlined for Glow. Given that the Gnome community is already split 50/50 between Gnome Office (Abiword and Gnumeric) and Openoffice, this just creates even more confusion and greatly diminishes the changes of desktop success. Why?
Because ISVs that want to build on top of the office suite, do not know which one to choose and even if they choose one they do not know which development language to use to build on top of it.
In the meantime, tons of cool evolution features are on hold because they were developed using Mono and there is no consensus on whether Red Hat and other major Linux distributors want to take on the added legal risk.
Compare this to the KDE side of things. One main language C++, that despite the odds, has already proven its worth both in its breath and quality of applications. KDE 3.2 is to any objective observer a very impressive project.
People that want to develop in other languages can make use of the many bindings to these languages. They have one PIM suite, Kontact that is shaping up very nicely. And they have one Office suite that has gove from being a total joke to being an extremely fast, complete and integrated piece of software. They also have tons of very good apps, Kopete, K3b, JuK, apps that are aesthetically and programmatically consistent.
This is not a KDE vs GNOME thread. Do not misconstrue my comments, for God’s sake. The point is that the Gnome community needs the kind of focus that KDE has and it seems to me that the commercial involvement may have introduced a whole set of very complex business/political/legal/technical issues.
Given all of the above, here’s my bold prediction. Unless some serious soul-searching takes place and people find the needed common ground, KDE will become the default in all business desktops in one to two years. Tons of consistent apps with none of the political or legal issues surrounding Gnome right now.
I’ll place my bet on rasterman’s point. What we need are standard API’s in a low level language on which we can bind higher level languages. The nice thing about .NET is not the language, it is the fact that you can do so much in such a ‘standard’ way.
How often have you tried to develop and application and find yourself using ten different libraries with entirely different memory management or other methodologies that don’t fit nicely with each other?
What we need is a platform not another language. The language is irrelevant as long as it is not restrictive. There is already so much code out there, so much functionality in all the different open source projects. The aim now is to tie this in and make a platform with all the needed functionality. This could reside at freedesktop.
We could start by making a list of what functionality we expect the platform to provide.
About Java/.NET: Rasterman is right that Java is not a language, it is a platform that has a language. .NET is also a platform. The idea of adding GTK to java or .NET or adding GNOME API’s on .NET or GTK does not make much sense IMHO. If we like .NET why don’t we just use it and dump all the GNOME APIs, same goes with Java.
About C++/C: These are languages and not platforms and are the best choice for building a platform. Unless we want to design a new language for that purpose. In that respect we could add in C# (as a language). But the main consideration is — how does this allow for the use of other languages? For this reason *I think* C is the best option. Like miguel said, the idea of write once and run everywhere is just marketting mumbo jumbo.
Just my 2c
I agree exactly.
C, Java, C# *all* give us bindings that can be used with different languages (ok, I’ve heard bad things about JNI).
What Miguel and Havoc want is a _platform_ which is more than just accessing libraries, but includes versioning (which Java doesn’t do, but .NET), a module system (unlike C or its direct descendants which have none) and maybe stuff like garbage collection (though to me this is just a language feature).
BUT the question is if I want the .NET runtime or Java to be the least common denominator platform that everything has to integrate with. I think both are too immature and BIG to use as an underlying platform for _everything_, not to mention that both aren’t developed by just programmers (like most languages that came into being at universities), but by commercial entities that have an interest in promoting THEIR solution no matter how suboptimal it might be.
If we want a platform or component system, there’s nothing to prevent us from just using an enhanced runtime loader (ld.so). The current version basically supports the module-less C (and all languages which interface with that). One could use more complex semantics which include versioning, sandboxing or even transparent RPC. All of this can be done at the OS level, simple and clean. Load time of ELF images is probably a LOT faster than loading (and JITing) Java or .NET classes, as most people noticed.
The problem today is that most people haven’t a clue about how an actual OS works, and how the OS integrates with the programming language (semantically speaking). Because they aren’t able to implement abstractions on top of Unix or Windows they jump on the commercially hyped platform bandwagon and buy a new virtual machine.
I’d rather have fast, lean, native code running on a mobile phone or something (and my “desktop” of course
).
Oh, for those who asked: his homepage is http://www.rasterman.com
Either there or on http://www.enlightenment.org he also writes why it’s been so long since the past (E 16) release. Anyway he _is_ working a lot, and guess what, that guy has a job to do like most people, and probably codes on some projects only in his free time.
that’s a great arguing point, read the first 3 words of my post and shout IT IS! back, pantomime style. you obviously are right.
On language bindings…
Linux is missing an MS COM equivalent, that’s why we have the binding problem. Pick something like XPCOM or CORBA and standardize on it and the binding problem will disappear. XPCOM already handles Java, Javascipt, Python, C, C++.
On VMs…
Sun is going to make the choice for us. If Sun won’t open source Java then RH, etc are going to go with Mono. I think going with Mono is the worst possible choice. It will allow managers to say: I’ll write my app to CLR since it is on both platforms, but the Linux implementation is not really compatible so we’ll get around to it later. Java is way ahead of dotNet right now, let’s capitalize on that. Please Sun, do the right thing!
On toolkits…
GTK and QT are both wrong. There is only one toolkit forced into Linux from external sources and it is the HTML one. Extract the HTML widgets from Mozilla and make that the Linux GUI toolkit. All of the mess with themeing would disappear, just use CSS to style your apps. This is what MS is doing with Avalon – they get it, why don’t we?
On the graphics platform…
MS gets it – GDI is dead; The only API is going to be DirectX. Why can’t Linux see this coming and standardize on OpenGL instead of building dozen of graphics APIs that implement pieces of OpenGL? In two years because of Longhorn every PC is going to ship with good co-processor graphics. Don’t think of this as 2D vs 3D, think of it like IDE vs SCSI – framebuffer vs coprocessor.
It seems to me that what c#/java offers over c/c++ was not a runtime and garbage collection but easier programming because with c#/java:
– primitive/value types (c structs) are allocated on the stack
– objects are allocated on the heap
– single inheritance
Thus pointers cease to be an so much of an issue. I think Delphi got it right – a fast compiled language with objects on the heap and no
garbage collection. Its a pity it had a pascal syntax and not a curly brace C-ish one (and GPL’ed)!
Would it be possible to develop a simplified C++ which compiled to exactly the same code as C++ with the following syntax:
e.g Given a class ‘Window’ :
C++ Simplified
Heap:
Window *myWin = new Window(); Window myWin = new Window();
myWin->draw(); myWin.draw();
delete myWin; delete myWin; // No gc!
Stack:
Window myWin = Window(); Not possible!
or a heap object with stack semantics similar to c# e.g
using( myWindow = new Window() ) {
myWindow.draw();
} // delete myWindow
// called as myWindow goes out of scope
Also with Aspect Orientated Pgogramming (AOP) perhaps the object systems of Mozilla and Open Office could be used easily e.g:
@uno x = new OpenOfficeObject();
@xpe y = new MozillaObject();
@kde z = new KObject();
That is the ‘gunk’ required for these object systems in automatically generated.
COM is hard to learn, hard to use, complex and as well limited in many areas compared to .NET, that’s why Microsoft had to create .NET which can be understood as successor of COM, internally it was called COM 98 I was reading somewhere in a Microsoft blog. For me it’s all clear, after C and C++ being very important and very popular is there really somebody that naive C# won’t continue that success story, no way on earth. I’ll continue to use VB .NET anyway and I like the fact I could do this on systems other than Windows once I decide to leave Windows. Miguel hits the nail on spot with the “Who are we and what are we building?” passage in his blog talking about cross plattform applications and portability. If windows user see more portable open source projects like Open Office or Mozilla they will say to their self that apps are great and they will want to try out a open source OS as well
What I want is a native compiler for C#. C# looks like a great language, but it’s tied to .net/Mono
yes, i know this has been beaten into the ground, but microsoft has said in the past that they will “fight opensource with patents”. what we will do with a gnome/mono solution is give them the power to pull the plug on gnome at any time they choose.
imho, using a technology owned by a company who is both full of money and hostile to what you are trying to do is a very bad idea. considering the pressure ibm has been putting on sun lately over java, i think we can expect a respectable open java implementation from one, or the other, in the near future.