Miguel de Icaza of Ximian tells all about Mono, .NET and dotGNU, Gnome and its relationship to KDE, and much more.
1. The Mono project has certainly come a long way since the last time we talked, please tell us what were the major milestones you hit the last 8 months and what new features are the priority for the near future?
Miguel de Icaza: Most importantly the Mono community has grown tremendously: today 150 developers have CVS commit access to the Mono source code repository, and a lot of the community’s effort has been focused in making Mono more reliable, more feature complete, and most importantly we have
been doing work to make Mono a good development toolkit on Linux/Unix.
Mono would not be possible without the day-to-day work of hundreds of developers that make it happen. I suggest for those interested in a particular area in Mono, to check the ChangeLogs and the mailing list to identify the developer that has created this technology. Since Mono is a large community effort, I could not list the responsible developers on each section in the following answers as I would have liked to, because it would have taken me another week to reply.
There are of course major developments that have occurred in the past few months which are worth mentioning:
* Mono can now run ASP.NET web applications, we have demonstrated IBuySpy running with Mono, and we are polishing it every day to make it better and support more applications.
* The ADO.NET universe in Mono has matured quite a bit: not only we have the standard classes as found on the Microsoft .NET Framework, but we have added a number of providers ourselves, so we have a pretty good coverage for the databases available on Unix: Postgress, MySQL, SqlLite, Sybase, SQL server, Oracle, DB2, Odbc and more.
* Robustness and completeness: this is just a side effect of Mono being used on a day-to-day basis by developers.
* IKVM.NET support: IKVM is a Java Virtual Machine that runs on top of .NET. It essentially translates java classes into Common Intermediate Language (CIL) code at runtime, and uses the .NET/Mono JIT compiler to execute the code.
What this means is that it is possible to run Java applications on Mono. The IKVM.NET for example is able to run the IBM Eclipse IDE editor with the CIL runtime.
* A Debugger Framework: we started our debugger effort about eight months ago.
We have a set of classes to produce and consume debugging information. Today our compiler for example generates debugging information (which is conveniently stored as a resource withing the executable) and our runtime engine can use this information to produce stack traces that contain line information.
The debugger proper is written in C# with a little support library written in C for the low-level access routines, and it is relatively portable to various systems.
Mono requires a pretty featured debugger. The debugger supports multi-threaded application debugging, multi-language debugging as well as managed and unmanaged code debugging, including the debugging of the runtime and the JIT themselves.
The debugger is still being worked on and it is not ready for production use. Although the command line version is useful, most people will want to use the GUI version, and that will require some more usability work.
* Gtk# maturity: The Gtk bindings for Mono/.NET have reached a level of maturity that has enabled people to write various graphical applications with it.
For instance, our debugger and documentation browser are written with Gtk#.
Gtk# provides bindings to various libraries from the Gnome world, it is not limited to Gtk+, but includes support for Gnome, Libart, Rsvg, Atk, Pango, Glib and Gstreamer, with more features being added by the developers.
One nice extra of C#’s overloaded method mechanism is that we can have multiple routines with the same name, and we can afford to provide a simpler to use Gtk than the native C binding. Also accessors have been mapped to C# properties, and signals to C# events, so the binding reflects the .NET spirit. Other features include the attribute-based Glade support.
Since .NET allows applications to bundle various extra bits as “resources” of an executable or library, developers can ship a single binary that contains all the supporting data an application might need, as opposed to scattering images, glade files, resources and configuration files all over the file system.
Bindings for OpenGL and GtkMozEmbed (the Mozilla bindings for Gtk) exist as well.
* Documentation effort: A very important step has been undertaken to produce free documentation for the class libraries. Both .NET class libraries and the class libraries that we have produced in Mono or around Mono.
We have a documentation browser, and a documentation compiler. The documentation system is designed so multiple providers can be used, a feature that we will be using to integrate various kinds of documentation: ECMA XML documentations, C#-compiler generated documentation, our own HTML tutorial, C# language reference documentation, compiler reference, tools references and anything else that a developer would need to become productive on this environment.
A set of tools have been produce to maintain and track libraries as they evolve, a fundamental part of keeping our things documented.
* Remoting platform: various developers have stepped up and have implemented the remoting framework for .NET, a remarkably large task, as well as documenting the Binary formatter.
Remoting is a general purpose framework for building RPC systems that takes advantage of the .NET Framework’s runtime introspection facilities to simplify the development of clients and server, and create stub-less and skeleton-less RPC endpoints.
* Apache integration: The System.Web classes can be hosted in any web server, and in particular a new Apache Module for Apache 2 does this. This is a frequently asked question.
Also, more and more commercial developers have been running their code
on Mono, and we frequently get feedback on missing features or bugs in
our implementation. With their help, the team has been addressing
those issues, and making Mono a good choice for re-targeting their
applications to Linux/Unix.
There are some missing components in Mono today though:
* System.Windows.Forms is still on its early development stages. Although some sample applications are starting to run, and the issues we had with the Wine integration have been sorted out, there is still a lot of work left to be done.
* EnterpriseServices and DirectoryServices are essentially non-existent today.
* Web Services: the client and server support is missing, although some of the infrastructure pieces they depend on have been implemented.
Regarding our future directions for Mono, we are aiming for feature
completeness and robustness first, so far the team has done a great
job here. We routinely bootstrap the Mono environment from scratch and
run our regression test suites, but more would be of course welcomed.
We have been working on a new JIT engine that will replace the current engine. The objectives for the new engine are outlined here:
* Ahead-of-time compilation.
The idea is to allow developers to pre-compile their code to native code to reduce startup time, and reduce the working set that is used at runtime in the just-in-time compiler.
Although in Mono this has not been a visible problem, we wanted to pro-actively address this problem.
When an assembly (a Mono/.NET executable) is installed in the system, it would then be possible to pre-compile the code, and have the JIT compiler tune the generated code to the particular CPU on which the software is installed.
This is done in the Microsoft.NET world with a tool called ngen.exe
* Have a good platform for doing code optimizations.
The design called for a good architecture that would enable various levels of optimizations: some optimizations are better performed on high-level intermediate representations, some on medium-level and some at low-level representations.
Also it should be possible to conditionally turn these on or off. Some optimizations are too expensive to be used in just-in-time compilation scenarios, but these expensive optimizations can be turned on for ahead-of-time compilations or when using profile-guided optimizations on a subset of the executed methods.
* Reduce the effort required to port the Mono code generator to new architectures.
For Mono to gain wide adoption in the Unix world, it is necessary that the JIT engine works in most of today’s commercial hardware platforms.
This new JIT engine should be released shortly, still working out on the release issues for it.
We are also tracking the new submissions of Microsoft to the ECMA group, and we will be publishing versions of our tools that provide the new features like Generics, anonymous methods, partial types and iterators.
Screenshots probably speak better, we have some at our site.
2. Portable.NET and dotGNU is keeping close to Mono’s advancements as much as possible. What do you think about their progress? Which implementation do you see to be the most-used alternative to .NET?
Miguel de Icaza: I think they are doing good progress, and am glad that there are other implementations of the ECMA standards available. They are free to use our class libraries as they are licensed under very liberal terms (the MIT X11 license, which is even laxer than the original BSD license).
Mono is probably going to be the most used alternative .NET
implementation, but only time will tell.
3. When you started Mono about 2 years ago, a lot of people were angry at you feeling… betrayed that you chose to embrace a Microsoft technology. However, I heard someone saying that these very same people will thank you for your work when the right time comes in a few years, when Mono will be obvious of its importance on keeping Linux “current” in the technologies of this future time. What do you think about this public outcry you had back when you started Mono and do you agree with the above said person about the future?
Miguel de Icaza: I do not particularly mind the outcry. It is important to have a dialog and
discuss the pros and cons of every approach, and the early discussions
were good in that they helped crystallize the vision for Mono. The
situation was obviously not helped by the fact that the name `.NET’
had been overloaded to mean different things.
Today I think the situation has changed as people understand that Mono
is an implementation of the .NET framework and that the scope of the
project is well defined.
If you like the .NET framework or you happen to have code written for
it (GUI, server based or web based), then Mono is a tool you would
use. The Mono team obviously believes that this is a great
technology, and you have to try it out, but if you prefer to use PHP,
Java, C++ or any other technology, that is fine with us. In fact,
some developers are already working on bridging these worlds
together (there are PHP bridges and Java VMs for .NET/Mono in existence today)
Two years ago Mono was only a vision, today people can write code for
it, and run it, so the perception obviously changes.
4. How do you feel about Mono on cell phones and other mobile devices? Any thoughts on this?
Miguel de Icaza: Mono is already running on the iPaq, here is a screenshot.
We hope that the new JIT engine will soon be ported to this CPU.
It would be extraordinary to see Mono running on more embedded
devices.
You might want to compile a subset of the class libraries when running
on machines with limited resources, and am sure that when the time
comes, we will see patches that will conditionally compile out parts
of the class libraries.
5. I read a long discussion about D-BUS on the Gnome mailing list. What’s the deal with D-BUS, what is it, what it will offer and what will it replace (if anything)?
Miguel de Icaza: D-BUS does not replace anything, it is a new addition to the desktop.
D-BUS is a message bus, think of it as a broadcast system for sending
messages to applications on your computer. A bus is a useful
abstraction, and it would obviously be useful to have this thing done
in an very desktop-neutral fashion.
The debate on the mailing lists was not about whether a bus was
important, but what technology should be used for the bus plus other
tangential topics.
6. What do you think about KDE and Gnome interoperability/compatibility/common standards? Are you for some kind of technological/standards unity between the two DEs, or do you prefer the two DEs to be separate?
Miguel de Icaza: You have to look at the larger picture. Gnome and KDE are not the
only players in the desktop: Gnome, Java, KDE, Mozilla, OpenOffice,
Real, and Wine are all citizens of the desktop, and from our point of
view, to make the desktop succeed and integrate, we should work on
getting all the players to agree in as much as possible where in the
areas where there is an overlap for the sake of the user.
I have not been involved in these efforts, mostly because I have been
busy with Mono which is a universe on its own, but the people
implementing and promoting the interoperability are key to the success
and future of Gnome as a competitive desktop.
7. Is there any serious attempt so far to port Mono on MacOSX and without the use of X11?
Miguel de Icaza: Mono works on MacOS X without X11.
You only need X11 if you are using X11 libraries, for example Gtk+. I
am sure that eventually a native version of Gtk+ will be done for the
MacOS, very much like the WIMP version of Gtk+ that makes Gtk+
applications blend and adopt the user interface of Windows.
8. How’s Gnumeric development these days? How is the application holding against all these office suites available for Linux, and when it is going to be completely ported in GTK+ 2.0 as a stable release?
Miguel de Icaza: Gnumeric is being maintained by Jody Goldberg, I am no longer involved
with the project.
Gnumeric has a number of unique features, and it is still one of the
nicest code bases to work with. Gnumeric’s code was designed to be
maintainable and clean, and this has paid off. But Gnumeric is still
far from being a drop-in replacement for Excel, although it has
features that are unique to it (like the spreadsheet conversion tool)
which will guarantee its continued development.
From Ximian’s perspective, we are focusing on improving Open Office as
it presents a complete office suite that has the functionality and
integration that users demand today. You can see some slides of the
work that Ximian has been doing on Open Office here.
Gnumeric will still have a market for smaller systems, or even for
embedded situations like PDAs or whenever the engine has to be reused
on special situations: Gnumeric is also very easy to modify and adapt,
so its pieces can be reused in other setups.
Answering your question about the Gtk 2 availability: I believe that
Gnumeric has already been ported to Gtk 2.0, but I would have to
differ to Jody on the precise answers.
9. Which part of Mono was the most difficult to implement, and which one you think you might get you some trouble in the future? How many people are in the “core team” of Mono today?
Miguel de Icaza: All of Mono has presented various challenges, and I have only hands-on
experience on a few parts, but I know that various areas of Mono have
proven to been challenging at times, and as such fun at times, and
hard at others.
* The JIT engine is obviously non-trivial work.
* The Windows API emulation layer was required to provide matching implementations for the IO and threading subsystems on Windows for Unix. This code is non-trivial, and its functionality not given the credit it deserves.
* The second-generation JIT is obviously non-trivial work.
* Application Domains and MarhsalByRef objects and the whole infrastructure for Remoting I know was complicated, but I could not say how much.
* Metadata handling: reflection and reflection.emit: I know these were tricky, because they were part of our chicken-and-egg problem when initially bootstrapping the compiler. The compiler was written in C#, and required extensive functionality from the runtime and the class libraries to be there. Getting this working in such a short amount of time was a miracle.
* Threading and thread pools.
* The C# compiler is the part am most familiar with. I have to say that writing a C# compiler in C# was both fun and challenging. I wish I had more time to work on tuning the compiler speed.
It is hard to estimate how many people are in the “core”. 150
developers have CVS commit access, but like every other open source
project, contributors are not working full time on Mono, they come and
go, depending on their spare time and their current obligations. I
would say that roughly 40 developers are actively involved on a given
week in the project. This number I draw from the Mono Weekly News.
Anyways, there are plenty of fun activities in the Mono world, it is
definitely the most fun project I have done, and it is also
interesting because as an open source project, we get to work with the
Windows developer community, a community that we have been
historically isolated from.
10. I hear rumors… a new JIT for Mono, ‘they’ say. If this is true, why is the new JIT being developed in secret? And why the need for a new JIT?
Miguel de Icaza: I already talked about the new JIT properties and objectives before.
An article with the details about the new JIT engine will be available
at the time of the release.
The new JIT began as a research prototype, on a `minimally’ new
infrastructure that would plug into the current JIT (that is why it is
internally called `mini’). And it kept growing until today’s JIT, it
grew out of a prototype.
The new JIT development has never been a secret, but it has been
developed internally. It will be released when we feel that we can
support it and answer questions about it. We have already given early
copies of the JIT engine to a few individuals that have been actively
involved with the JIT engine.
11. How about performance? How Mono stacks up speed-wise against the .NET and dotGNU implementations?
Miguel de Icaza: It is hard to answer this question, because a complete benchmark is hard to build: it has to test raw performance, garbage collection, threading, scalability, features, modes of operations and more.
A complete benchmark suite is difficult to build, and so far, nobody
has created a comprehensive one that could be used to compare it.
The JIT from Mono is obviously faster than PNet’s interpreter, and the
Microsoft JIT compiler is a well tuned engine that is better than
Mono, something that we hope will change with our new JIT engine.
But even if we get better raw speed from code which is pre-compiled, scalability issues, thread pools, application domains and many more factors will play into competing performance wise with the Microsoft CLR.
UPDATE: The Gnumeric maintainer, Jody Goldberg, emailed us about some info regarding Gnumeric:
1) Gnumeric’s distance from being a ‘drop-in replacement for Excel’ This is a matter of perspective. MS Excel does have features that Gnumeric lacks. However, they are not features that are necessary in most common use cases. The quality of what we do have is high. Especially the analytics (statistical tools, and worksheet functions). These implement almost a complete superset of MS Excel. We’re missing 2 out of 400 odd functions in MS Excel, and have added an additional 50.
2) The projected use case for Gnumeric in ’embedded situations like PDAs’. Our target audience are spreadsheet users. Its true that Gnumeric is light and fast in comparison to OpenOffice. However, that is far from the main claim to fame. As mentioned previously
our analytics are in good shape. We also have better quality support for some of MS Excel’s trickier calculation mechanisms. Additionally we support things like encrypted or protected xls files.
In short we’re still developing Gnumeric. For people that need an Office Suite, OpenOffice is a good choice. However, if someone is looking to use a spreadsheet, and wants easy extensibility and solid analytics, then I think Gnumeric is the way to go.
I think that it is very interesting that the GNOME people (most importantly Ximian) are making such huge promises, and making huge leaps to make a truly integrated and useful replacement for Windows. I really wish that KDE would start making this type of move, they seem to embrace the commonly held idea of replacing everything with there own software to compete directly with Microsoft, and the others. While GNOME has began to make the move to be the king of interop, embracing the technologies that OSS is often seen as competing against. It will be interesting to see the results of this “friendly” competition.
He quotes out of Trolltech’s FAQ. However, he have fail to realize that Trolltech wrote that to *sell* Qt. Besides, in the beginning of the slide show, everything was about Free Software and the likes. However, I wonder, why are you so concern about pricing? Is it because there would be a closed source version of it? Windows and Mac Qt libraries are available for non-commercial (meaning open source) purposes. And since Ximian is probably using LGPL for their code, and OOo uses LGPL for their code – I see no legal problem here.
Why is MS placed as the *default* format? I doubt people (or companies) moving to Linux are dimwits (or have staff that are dimwits)? A lot of things OOo do that doesn’t translate by the filter – for example, the 3D objects.
Mono is probably one of the best things that has (recently) happened to Linux, and will further help promote it.
Mono will help to run Windows applications on Linux. (Something a lot of companies want.)
Also, Mono helps bring (Windows) software developers to Linux. (Thus increasing Linux’s popularity.) Since Mono has a C# compiler ( http://www.go-mono.com/c-sharp.html ) and a VB compiler ( http://www.go-mono.com/mbas.html ).
Also, Mono makes it easier for software developers to choose Linux as a platform to develop for. (Since, with Mono, you only have to write your application once, to have it work on both Linux and Windows [and anywhere else Mono gets ported to].)
I think that the Mono developers has really been doing a great job. I’m just plain amazed how far the environment has gotten so quickly. It seems like I just heard about the project the other day. Heck their news archive only goes back to 2002
My feelings about Mono as a whole, though, are mixed. On one hand, I think its important that Linux has a degree of transition functionality to help developers transition to Linux development. On the other hand, I’m reminded of the OS/2 problem, where developers didn’t write OS/2 native apps because it could run Windows apps. I don’t really like Windows apps. I don’t find them as nice to use as my KDE ones. It’s probably the sheer force of habit, but I would prefer it if Linux stayed Linux instead of becoming Windows. And honestly, I don’t like .NET because it is a Microsoft technology. Call me unreasonable, but one of the nice advantages of being a Linux user is that I get to let my ethical viewpoints influence my choice of software.
Nice scoop OSNews. I salute Miguel and others for their efforts, but personally I think that .NET (and therefore MONO) are a passing fad. Even Microsoft with all its influence has been unable to convince ‘world+dog’ to adopt .NET. The whole problem with .NET is – why bother? At the moment, you can only run it on a Microsoft platform (x86), so why not compile apps to ran natively on that platform anyway, hence skipping the whole JIT performance hit. Look at Java – frankly, a large portion of the world doesn’t even know Java exists, and they couldn’t care less. You dont need it. And Java had a mighty head start (which is an equivalent to a millenium in the IT world), and ran on more platforms from the early days than .NET, and what has it brought us? Diddly squat.
The same story with .NET Yawn.
I personal usually don’t _really_ like anything to be bindings. Don’t ask why, but I just do. 😉 However, is it good idea for Mono to create its own GUI (toolkit) for platforms? Will this cause the slowdown or use too much memory?
Are you sure this is the best thing for linux.
Also, Mono helps bring (Windows) software developers to Linux. (Thus increasing Linux’s popularity.)
Didn’t I hear this one before: Codewaver will bring windows office users to linux thus increasing Linux’s popularity.
Since Mono has a C# compiler ( http://www.go-mono.com/c-sharp.html ) and a VB compiler ( http://www.go-mono.com/mbas.html ).
This is asuming that you strip away the Window API calls right?
Seriously as a developer, do I have a guarantee that developing programs for mono will not put my company in legal trouble. Until microsoft blesses the mono project, no thanks.
What is there to bless? Microsoft has submited .NET as a standard…
All the core technologies of .NET that Mono employs are now part of the ECMA and ISO standards. ECMA requires that the standards are at least RAND. On top of this Microsoft made the `reasonable’ in RAND be zero.
There is also a statement from Jim Miller at Microsoft, one of the
inventors listed in the patent: https://mailserver.di.unipi.it/pipermail/dotnet-sscli/msg00218.html
Somehow I must haved missed this part in his answers. Wrong headline? Wrong interview?
“Microsoft has submited .NET as a standard.”
Maybe you should READ the standard. Then you’ll come to the insight that .NET is not standardized, but a tiny tiny tiny fragment only (of which C# is a part).
Unix was seriously missing this the past 30 years. Without MONO Unix and it’s derivates will probably not continue to exist. And I like all the *.exe and *.dll files in my ‘usr’ and ‘lib’ directories they really give me the impression to use a real Unix like system with a touch of Microsoft’nism. Thank you.
On top of this Microsoft made the `reasonable’ in RAND be zero.
RAND = reasonable non-discriminatory licensing framework which give Microsoft and others the rights to charge user for IP.
For how long?
Until .NET is everywhere and Java stands for coffee.
They’ll start charging like the bitch that Microsoft is.
Typical embrace and extend.
I too old and been fool too many times to fall for this shit.
Miguel you are very smart man, very clever. I guess years at Ximian have taught you well the business side of programming.
Why do I fuckin care if users get screw in the long run, it’s all the same.
Miguel you should really stop this OS shit and go work for Microsoft. I heard managers can stop smiling like a bitch when they hear your name.
Mono a competition to .NET? Hardly.
Those sons of bitch will kill their competition rather than smile like a fool just to please Billy Gates.
just link write a script that links $dllname.dll to $dllname.so and $appname.exe $appname…. and if you want to really make it feel link Unix, spread your .dlls out over no less than 4 dll directories(/dll, /usr/dll, /usr/local/dll, /usr/X11R6/dll) and spread your .exes out over no less than 7 exe directories… oh, and feel free to spread your configuration files out over the entire filesystem…
I know that Mono is supposed to be “truly” multi-platform, but from what I managed to gather on the Mono website, anything that is not Linux (FreeBSD / Solaris / AIX / etc) is under “TODO. Any volunteers?”…
as I remember it, MS said they would be porting .NET to FreeBSD. at the time, MS was attacking the GPL pretty heavily, so their choice to port to FreeBSD seemed to mainly be a slap in the face to Linux. if they do go ahead with porting, then Mono might not be necessary.
of course, that’s if MS does port and if they keep up with development afterwards.
> Miguel you should really stop this OS shit and go
> work for Microsoft. I heard managers can stop
> smiling like a bitch when they hear your name.
<sarcasm>
That’s the point – He wanted to work for Microsoft but they rejected. That’s why he went into competition to them with Ximian now. Same budget, same amount of developers, stockmarket, same powers, same skills and now they control the OS community with .NET technology and Microsoft will soon cut their dick off and pay Ximian licenses to get their business software running on OS MONO
</sarcasm>
I’m really looking forward to this, I played with the demos of Mono and Wine together the other day, there is a lot of potential there.
I think if people compare .NET to Java for desktop apps they are missing something, namely that .NET doesn’t really suck for desktop apps, whereas Java always has. I know a lot of Windows developers that are looking at .NET and are very interested, so it’s only a matter of time before we start seeing killer apps written in it, at which point Mono will be as essential as Wine is today.
Oh, and it IS possible for Windows compat projects to catch up. Wine has been around for ages because it grows along with Linux on the desktop…. Mono has >100 developers with CVS commit access, and it’s only a few years old! Back in ’91 when Wine was started, 100 developers was unthinkable! The whole free software movement is much larger than it once was.
I started a sceptic about this project, but the Mono teams persistantly rational arguments have convinced me this is a good thing.
i think that Mono cannot compete with neither Java or MS’s .NET for the reasons quite apperent. thinking that MS programs will run on Linux via Mono is a dream. Java, on the other hand, is accepted and backed by the masses including thousands of commercial firms and open source people, and already become a cross platform application development standard as Eclipse etc shows. but, Mono, i think, may be useful in the future. especially for research. the time will tell.
I know that Mono is supposed to be “truly” multi-platform
Eventually. Right now I think it’s just supposed to work.
from what I managed to gather on the Mono website, anything that is not Linux (FreeBSD / Solaris / AIX / etc) is under “TODO. Any volunteers?”…
If you’re using FreeBSD, did you try installing the port (lang/mono)? Worked fine last time I used it, around 0.19.
—-
as I remember it, MS said they would be porting .NET to FreeBSD.
FreeBSD has had it packaged (as lang/cli) for more than a year. I was using it for a while before that. It isn’t actually a port of .NET, it’s a reference implementation of the Common Language Infrastructure and C#, done by Corel I believe. AFAIK it includes less of .NET than Mono does.
if they do go ahead with porting, then Mono might not be necessary.
FWIW, I actually repressed my memories of working with cli. I cannot fathom why anyone would prefer it over Mono.
Back to the interview with Miguel.
I’m heavily interested to see how all this comes to an solution.
a) on the one side we have SUN supporting GNOME with ATK and various other stuff.
b) we have Ximian who want’s MONO to get into GNOME and who offers Evolution.
Doesn’t this cause a lot of interests conflicts between such a big company as Sun who are interested into their own business and GNOME and between Ximian with MONO also interested into GNOME ?
It’s like bringing petrol and fire together really close. Someone here that could explain what happens ?
Not to mention that there where various news and articles on the whole net where microsoft spokesmen clearly stated that they gonna protect all their rights on .NET and things that are related to it.
CroanoN, why are you starting a java versus .NET debate in response to an article about Migel de Icaza…
stop trolling, we don’t need an argument about which is better because when it’s down to it, no one cares which one is used except people like you with bullshit “ideals” about how Java’s portability makes it the world’s greatest development environment
well I’ve got news for use CroanoN, there’s better alternatives out there which are faster, smaller, nearly as portable, and don’t require a massive run-time framework. plus the code is easier to maintain. it’s called C++ and Qt, and will use native widgets instead of java’s swing crap.
java is worthless and terrible, and will soon die in the wake of .NET’s onslaught. i await that day with anticipation, when Microsoft finally abolishes all the competition and everyone can finally use a single, unified standard without idiots quibbling about how their 3rd party solution is “better” for some reason
I don’t know if this was part of your sarcasm, but fact is,
Miguel did work for Microsoft once. During his study time, if
I right remember.
Where does this idea that .NET is somehow cross-platform come from?
The only important difference from old Win32 (as far as portability is concerned) is the VM, and that will only help with portability between different hardware architectures (i guess it will come in handy for MS with the upcoming itanium transition).
If your just using x86 everywhere, it buys you nothing in terms of portability. So far i haven’t seen any non-x86 JIT from either Mono or MS.
.Net defines a set of required libraries, and that helps with portability a lot, but it’s really no different from POSIX or win32. The problem with those libraries is that they expose a lot of windowsisms (e.g. threading model, i/o model, security model), so they require some “shoe-horning” to fir on linux (miguel mentions this in this interview).
They also expose win32 window handles (HWND) that can be used to invoke win32 api calls. So the only way to make sure that .NET programs will be able to run is to make sure you have a fully working installation of Wine (such a thing doesn’t even exist yet!). The existance of Mono does not make .NET programs any more portable than Wine makes regular Win32 programs.
Mono could be useful as a companion to Wine for windows emulation but the idea that you should use a windows emulation layer to develop linux apps is just pure crack.
And what’s with the ‘.exe’ stuff? Ever heard of unix permissions? Mono developers are smoking some serious shit, i want to be in on it! And don’t get me started on hungarian notation…
There are nice things in .NET that could be copied and used in Linux, of course, but cloning the whole thing is nothing but crack.
Hungarian notation is disencouraged by Microsoft for C#.
My source is “Programming C#”, written by Jesse Liberty
and published by O’Reilly. Don’t have it handy right now
so you’d have to look up the page for yourself.
“CroanoN, why are you starting a java versus .NET debate in response to an article about Migel de Icaza…”
i didn’t try to. as i stated b4, there is nothing to argue. for the apparent reasons.
“stop trolling, we don’t need an argument about which is better because when it’s down to it, no one cares which one is used except people like you with bullshit “ideals” about how Java’s portability makes it the world’s greatest development environment”
i am not trolling. get a dictionary. my bullshit ideas? oh dear. and get a life.
“well I’ve got news for use CroanoN, there’s better alternatives out there which are faster, smaller, nearly as portable, and don’t require a massive run-time framework. plus the code is easier to maintain. it’s called C++ and Qt, and will use native widgets instead of java’s swing crap.”
also introducing hard to determine bugs, incresing development time, increasing project budgets by requiring gurus, injecting risk to cross development projects by putting the question are we gonna find required libs on different platforms, etc.
“java is worthless and terrible, and will soon die in the wake of .NET’s onslaught. i await that day with anticipation, when Microsoft finally abolishes all the competition and everyone can finally use a single, unified standard without idiots quibbling about how their 3rd party solution is “better” for some reason.”
yeah, that will happen for sure. after the armageddon.
I am not that sure that Mono is even good thing for Linux. I many people’s opinion the ability to run Win32 applications killed OS/2 (OK, not that it was the only reason). The same rule might apply for Linux – why develop native Linux applications if there is Mono. Sadly the same applies to other emulation platforms – for example why develop native Linux games when we have WineX.
btw dear, swing is not the only option for sure. check out SWT by IBM. it roques, and based on native gadgets.
actually, i am mesmerized by the lack of knowledge of people here on OSNews. a good advise for you from the deepest corners of my heart: before telling something, perform a quick research on it eh?
*cough* and not hop on the next sexy technology, maybe he just wants to secure his position when one day he’ll work for microsoft.
I many people’s opinion the ability to run Win32 applications killed OS/2 (OK, not that it was the only reason).
I didn’t know OS/2 supported Win32 without additional software (e.g., Odin).
The same rule might apply for Linux – why develop native Linux applications if there is Mono.
I think that for all intents and purposes Mono applications will be Linux (or ‘nix, anyway) applications. As has been said, .NET software isn’t actually portable to Mono, and the way things are going now probably never will be without some sort of compatibility layer (aren’t they using WINE for winforms?). Mono will probably just provide for ‘nix what .NET provides for Windows: a hardware independent target for doing mostly the same things you’re doing now. I don’t know if that’s especially useful for a platform that already distributes software in a hardware independent format — source code — but I can see some benefits. Unless Mono actually becomes fully .NET compatible, I don’t see it hurting Linux too much.
Sadly the same applies to other emulation platforms – for example why develop native Linux games when we have WineX.
Given the state of the Linux gaming market I don’t think there’s much incentive to do native Linux ports anyway.
Given the state of the Linux gaming market I don’t think there’s much incentive to do native Linux ports anyway.
Will there EVER be a Linux gaming market if there won’t be native Linux games ?
IMO, C# and the .NET framework are (should be ?) an evolution of the C[++] language and its C standard library.
I mean C[++] is getting old, and the standard library lacks functionnalities, the first of those functionnalities being a standard GUI API.
fredde said the System.Windows.Forms is just an externalization of MS GDI, and therefore cannot be ported to other OSes. fredde is probably right.
What about Gtk# ?
“Gtk# (Gtk sharp) is a set of C# language bindings for the Gtk+ toolkit and other libraries that are part of the GNOME platform.”
Well well, did i miss the point, or this brand new framework “gets old and lacks a standard GUI API.” ?
Part of the reason that *nix is one of the first technologies/standards/systems to be considered for mission critical systems is its simplicity, yet power. APIs (C in particular) have been kept simple and sweet. Very little legacy code exists and modularity is one of its first rules of design. This contrasts sharply to the ideas behind the Windows APIs.
The 32bit line of Windows has existed since 1987 (if you count OS/2). During this time, Windows has gathered an enormous API with function after function that has been added to to keep backward compatibility. This is around 15 years. Countless APIs like OLE, ActiveX, Winsock, the many WinForms implementations, implementation of proprietary security (hardly) standards and many others have turned Windows’ core into a giant, bloated mess. To add to this, the Windows API isn’t capable of many common programming tasks, thus, other API toolkits like MFC are used too provide extra functionality. The Windows API consists of many 10s of thousands of calls. Many of them deprecated.
*nix as many of us know has existed for around 30. During its time, the POSIX standard hasn’t changed much but the changes that were made were designed to impact the minimum amount possible on bloating of the API. The POSIX API consists of only a few hundred calls, most of them not deprecated.
I must concede that even though the Windows API controls many of the functions that other libraries like user interaction, authentication and many others, it still can be considered bloat because most of the equivalents used in POSIX environments cannot be considered as bloat (it can be removed). Also, GTK+, GLIB. etc are constantly reworked to remove unnecessary legacy code to avoid bloat.
In half the time, the Windows API has managed to expand to more than 10 times the size of POSIX. If we make mono a standard part of GNOME like Miguel is suggesting, will this really help *nix/Linux? I find it difficult to believe that this bloat would improve performance/stability/maintainability or elegance of the code we write. Is this really what we want? I think not.
Don’t get me wrong, I respect Ximian and I believed that they have contributed a lot to the opensource world with Evolution and Connector. It just makes me concearned how hard they are willing to push mono whether it is for the good or not.
mono is just a layer, take it away you still have linux
Mono will stop being just a layer for many, many people in the desktop if it gets widespread use. As new GUI applications written in GTK# start showing and being used by many, having mono in a linux box will be a must for those many.
Why didn’t the reporter ask about Miguels views about the fact that Microsoft is trying to patent important parts of their API:s for Mono. This could give them a strangehold on all technologies related to .net/C#/what have you and in the long run Mono (and other free implementations).
I’m proud of you, Miguel. You’ve done good work extending my dominion into the realm of Linux. You will be suitably rewarded when the time comes.
With your continued efforts, we will establish a strong base on the Linux platform and then eventually we will be able to co-opt the entire platform. I can’t wait until we fry all those wannabe real coders — I mean Linux developers — like the little trolls that they are.
Please be more circumspect about our arrangement, though. The little trolls get so upset when my name or my company is mentioned with respect to their precious little toy platform. Of course I will continue to fully fund your efforts. It is your job to do a better job stonewalling the little trolls when they ask about it. Silence is a good first step, but some vehement outbursts would be better. Always seems to impress the little trolls.
We are getting close, Miguel. Please extend my thanks to the rest of the Mono team and to all the Mono sycophants as well. I hear this forum is run by one, so do your best to influence her to keep publishing about Mono and how it is going to ‘save’ Linux. She seems like a real sucker, so just lay it on her. Tell her if she doesn’t publish endlessly on Mono, she will be responsible for Linux failing.
Oh, if you need more cash to help people see what really matters, just let me know. I wasn’t too happy about getting her that wretched shiny little notebook, but you’re on the frontlines and I’m leaving the groundwork to you.
Keep working hard.
billg
Just say one day Microsoft decides to charge $40 for each license in a RAND manner – that is entirely possible. Would Mono just go away, crying boo hoo hoo and do nothing and die a painful slow dead with no side effects whatsoever to the whole? Hah! Forget it. On the server side, Linux is increasing in market strenght – and if Mono decides “Hey, why stay compatible with Microsoft?” they can. On the desktop, even though there is no binary compatiblity – it is still loads cheaper and faster to port .NET applications to Linux via Mono than without Mono at all.
And this matters a lot to many companies, who have loads of custom software. Just say they move to .NET for all their stuff from, just say, Java, or maybe Visual Basic. When they move to Linux, it is so much more cheaper and faster doing it with Mono than without Mono.
Perhaps maybe, by a long shot, Mono can control the .NET market… XFree86 did the same thing for X Window System – a open source (more or less) pretty much surpass other implementations in market power.
I doubt Miguel is that stupid/ naieve.
For posting I will probably get moderated down.
I am surprised with all the replies, hardly anyone is talking about the technology behind mono, to see where it could benefit the desktop linux thing.
All I read is Miguel and MS bashing, you sound like the unintelligent people on slashdot has anyone read the article over at Arstechnica about what .NET technology is!
http://arstechnica.com/paedia/n/net/net-1.html
Excellent work, my minions of socialism! Remember, capitalism is evil… it leads to making money and being able to purchase goods and services, like food. We don’t need food! We need Free software. When everything is free, and you are not able to make money writing software, our mission will be complete.
Don’t worry about me, I’ve got a grant that has set me up for life, so I can afford to espouse about how free software should be because I don’t care if I make money!
People often confuse free software with free software (as in no cost) and that’s fine by us! As long as we are getting the message out there that software is free, and destroying the capitalist society we’re living in, our goals are moving forward.
Carry on, my thoughtless minions and don’t forget to tell everyone that Free software helps prevent terrorism.
Gnu forever,
rms.
“We are also tracking the new submissions of Microsoft to the ECMA group, and we will be publishing versions of our tools that provide the new features like Generics, anonymous methods, partial types and iterators.”
This sounds like really good news. I was fearing that Microsoft would not submit the .NET generics mechanism as an ECMA standard. If they do it and mono can produce a good implementation, .NET and C# has everything to completely replace C++.
Generics is really the only thing I am missing in C#.
I doubt C++ will be ever completely replaced, not in the next 10 years at least
But it’s true C# could get enough market share to be a popular language. Time will tell
Microsoft’s CEOs have made it “patently” clear that they intend to restrict competing .Net implementations by cultivating Microsoft’s patents. Patents such as United States Patent Application #20020059425 “Distributed computing services platform” which covers the design and inter-operation of .NET based implementations and United States Patent Application #20030028685, covering .NET APIs that allow actions related to accessing the network, handling XML, and managing data from multiple sources.
Mono also implements parts of .NET that have NOT been submitted to ECMA and ISO standards. Those parts of Mono lack even the protection for IP infringement with re-implementation that ISO documentation licensing implies.
Although there is prior art examples of individual technologies such as the JVM etc, Microsoft patents such as the one mentioned, define and claim the interoperation of the components, in such a way that any re-implementations will be sure to be covered by the patents. There is NO way to work-around the issue, no amount of renaming the API calls or reimplementing the methords used will invalidate the patents.
This remains true even for the Microsoft specs submited to standard, as RAND licensing does not infer fair or uniform licensing terms.
In comparison, Sun has granted the Apache and all open source developers FULL access to the specs, test kits and granted the full rights to develop competing products under the JSPA . Sun has also fully pened up the Java development standards process under the new Java Community Process (JCP) . Even to the point of granting full open source re-implentations of J2EE such as JBoss the opportunity to license a set of testing tools to see if JBoss software adheres to the Sun-sanctioned Java 2 Enterprise Edition (J2EE) specification.
There those that claim that .NET is open to re-implementation, but until Microsoft make a simliar public legal declaration to Sun’s JSPA, any .NET re-implementation represents a pending legal mindfield.
Just sticking you fingers in your ears and yelling “NAR-NAR I can’t hear you!”, is NO defense.
SCO has recently launched an IP lawsuit against IBM on the most tenuous of evidence and hearsay, do you really expect Microsoft NOT to do the same, sometime in the near future?
Miguel de Icaza, and the other Mono developers still COMPLETELY FAIL to address the above issues. Their efforts in coding are commendable, but they are putting everyone who develops or deploys Mono at SEROUS RISK!
C# is already a popular language. But the addition of generics will make it perfect (At least for a C++ derivate). I think C# has the right mixture of power and simplicity. C++ is much too complex for average programmers to master, and java is too restricted.
I really wish the efforts of the mono project would be honoured more in the open source community. They are doing a very important task, and all they get is insults…
Wow. I thought the people on this site were interesting in OS technology. Obviously I was wrong. I quick search on the MONO website FAQ deals with the issue of patents. Additionally, Microsoft has submitted this to be a standard. Just like C and other international standards.
If they play the patent game, they risk losing standard certification as far as I can tell. I’m not an expert on these things, but neither are any of you. Hyperventalating about Microsoft being some big evil company helps nothing. If you want to really argue about the licensing go get educated on the subject.
Your assuming that Ximian is some group of bedroom hackers with no knowledge of the real world. I’m sure that the ximian people have looks long and hard at the patent issue before starting work on Mono.
Also, if you stop screaming about microsoft long enough to look at the .NET technology (as has been mentioned, arstechnica.com has a great article on it) you’ll find that it’s an amazing architecture that just may become an incredibly important part of the industry. To those of you going YAWN to .NET, keep in mind that for the most part it’s been a work in progress. Large technologies take a long time to get deployed. Rest assured, in the next few years you’ll probably be hearing a lot about .NET. Very likely youl will also end up using it.
Please quit being blinded by your hate and actually look around for once.
Is Mono going to be free?
Or programers/companies are gonna need to pay for it?
A.K.H wrote: “If they play the patent game, they risk losing standard certification as far as I can tell.”
Mono also implements parts of .NET that have NOT been submitted to ECMA and ISO standards. Those parts of Mono lack even the protection for IP infringement with re-implementation that ISO documentation licensing implies.
In late 1998, an internal Microsoft stratgegy document about the “opensource threat” leaked out which suggested using software patents alongside with proprietary standards in order to crush competition from free software such as Apache and Linux. In 2000, Microsoft forced a free sofware project to abandon support for its patented video streaming format ASF. In 2001/07, in the midst of an ongoing campaign against free software, Craig Mundie, a leading MS executive challenged opensource companies to keep clear of Microsoft patents or else “Get your money and let’s go to court!”. In 2002/03 Steve Ballmer, CEO of Microsoft, declared that Microsoft’s new standard DotNet was protected by patents and free implementations would not be allowed. In 2003 Microsoft published patent license terms for CIFS which disallow the use or reimplementation by GPL licensed software. In late 2002, Microsoft began dissuade corproporate customers from introducing GNU/Linux by pointing out that if they use free software nobody would protect them from being sued for patent infringement.
A.K.H. and others, Please quit being blind to history and actually look around for once.
Microsoft could solve this fear and ambiguity, by just formally granting MONO and other open sourced projects the right to fully re-implement all of .NET, even the parts not submitted to ISO/EMCA standard. That Microsoft choose not to do so, should leave no-one in doubt of their future intentions.
Until Sun opened up it’s standards under the new JCP, similar concerns were rightly voiced over open source reimplementations of Java’s J2SE,J2ME and J2EE. THat is no loger the case, for the new JCP requires that all contributers to Java standards grant royalty-free license for all patents required to implement the standard.
When will Microsoft do the same?
CroanoN, why are you starting a java versus .NET debate in response to an article about Migel de Icaza…
Did you actually read what Croanon wrote, or are you just invoking an OSNews macro to chastise Croanon for speaking?
stop trolling, we don’t need an argument about which is better because when it’s down to it, no one cares which one is used except people like you with bullshit “ideals” about how Java’s portability makes it the world’s greatest development environment
Actually, Croanon’s comment was quite valid in this discussion. Why not actually read what he/she said before jumping up and down in full-on tantrum mode?
well I’ve got news for use CroanoN, there’s better alternatives out there which are faster, smaller, nearly as portable, and don’t require a massive run-time framework. plus the code is easier to maintain. it’s called C++ and Qt, and will use native widgets instead of java’s swing crap.
No, it’s called Python with wxPython (which also provides native widgets for Win32, GTK and Motif). A neat thing we should notice, however, is that these two comments (yours and mine) are more off-topic and trolly than what Croanon originally said.
java is worthless and terrible, and will soon die in the wake of .NET’s onslaught.
That is nothing more than your wish/opinion. Now who was that trolling again?
i await that day with anticipation, when Microsoft finally abolishes all the competition and everyone can finally use a single, unified standard without idiots quibbling about how their 3rd party solution is “better” for some reason
Well, that statement alone just invalidated any credibility you may have scraped together. Keep on praying to Bill that his almighty wisdom and guidance may be poured out more abundantly upon you and other faithful MS theologians.
Now, let’s get back to discussing Mono shall we?
Dunno about the rest of the things u said.. but this ” In 2000, Microsoft forced a free sofware project to abandon support for its patented video streaming format ASF. ” is sure reworking history. MS sued him because it let u decode ASF files that are encrypted, got nothign to do with it being free software etc.
How many other companys has MS sued for patents?
Compare and contrast to Apple, Sun etc…
http://www.advogato.org/article/101.html
5/12/2000: VirtualDub 1.3d released; ASF support removed at request of Microsoft
Today I received a polite phone call from a fellow at Microsoft who works in the Windows Media group. He informed me that Microsoft has intellectual property rights on the ASF format and told me that, although I had reverse engineered it, the implementation was still illegal since it infringed on Microsoft patents. I have asked for the specific patent numbers, since I find patenting a file format a bit strange. At his request, and much to my own sadness, I have removed support for ASF in VirtualDub 1.3d, since I cannot risk a legal confrontation. This unfortunately means that I can no longer redistribute versions of VirtualDub older than V1.3d. (I did appreciate, though, that I heard this through the programming staff and not the legal department.) However, when I asked, he did say it was legal to convert from MPEG-4 using the DirectShow system. Therefore, I have decided the following about VirtualDub 2.0:
It will have an external input plugin SDK. It will have support for DirectShow ASF input.
Also, let me plead this case to you:
Please, please do not encode to ASF unless you are absolutely sure of what you are getting into. Microsoft claims it is illegal to decode ASF outside of their drivers and does not allow transcoding compressed MPEG-4 to other formats with the Windows Media Format SDK, making it nearly impossible to do so legally. Before transcoding to ASF, make sure you understand that it will be difficult for anyone to decompress your file, even just to MPEG-1 for better viewing performance. By using ASF, you are trapping your content in a less open format and restricting who can view it, even within the Windows platform. You can encode video files in MPEG-4 V2 with comparable quality and you will still be able to distribute in the open, unrestricted AVI file format.
This is the change log for V1.3d:
Build 10803 (Version 1.3d): [thanks to Microsoft] * Support for ASF and MPEG-4 V3 has been removed at the request of Microsoft. I can’t tell you how disappointed I am at this, but Microsoft says they have intellectual property rights, and I can’t do anything about it. This makes me very sad.
5/13/2000: VirtualDub and ASF further explained
I’ve received some email regarding VirtualDub and ASF, and extend my thanks to all who expressed their sorrow. However, I’d like to clarify some things about the current situation.
VirtualDub is GPL. Unless you modify it and redistribute it improperly, redistribution under the terms of the GPL is not piracy; you are allowed to do that. VirtualDub has never been sold in stores, or even online — at least, not by me. I have never made a cent off this program. I cannot request a Microsoft license for two reasons. The first is that I cannot pay for one, if they request money for it. The second, and more important, reason is that any license I request places further restrictions upon the code that are not allowed by the GPL. The code base for ASF would be undistributable under the GPL because reuse of the code by anyone else would require them to obtain a license from Microsoft themselves. This prohibits obtaining even the Windows Media Format SDK, which is licensed freely by Microsoft under certain restrictions. I cannot, and will not, bastardize my program to the extent necessary to relicense it; VirtualDub 1.x has always been released under the GPL with source code, and this will continue through 2.x.
Microsoft most likely had a bone with VirtualDub because its ASF support had two important features that the people in Redmond did not want available. The first is that, since VirtualDub treated ASF essentially as a poor man’s AVI, it was capable of processing ASF files in Direct Stream Copy mode, meaning it could rip the frames out to AVI at over 4,000 frames per second. The DirectShow filters force real-time conversion, and the DirectShow AVI output filter mucks the audio synchronization. The second is that, more generally, it allowed compressed ASF files to be transcoded to other formats. Microsoft is concerned about the rights of content providers, and they see this as prohibited behavior. The individual I talked to over the phone indicated that this would not be allowed under the Windows Media SDK either, although it would be allowed with standard DirectShow linkage (presumably because Windows Media Player has to do this). I consider this kind of restriction to be the rape of fair use and consumer rights in favor of the content producers, but that’s my opinion.
Another fact you should keep in mind is that ASF support in its current form was doomed anyway. Starting with Windows Media Player 7, Microsoft is moving away from standard ACM/VCM codecs and going wholly DirectShow. VirtualDub was never able to use DirectShow codecs, which is why you needed to install Windows Media Tools to get the proper codecs even though Windows Media Player could play the files. ASF content created with digital cameras has been off-limits to VirtualDub due to the lack of a MP4S codec in VCM form, and this trend would only have continued through WMP7. It also would have been trivial for Microsoft to change the linkages between NSREX and the existing VCM codecs, and break VirtualDub’s ASF support that way. Moving to DirectShow is the right way, being legal in the eyes of Microsoft, and more importantly, would require that they break Windows Media Player to break compatibility with the new import filter.
Some of you believe that I was misappropriating Microsoft’s intellectual property in my ASF handler. I don’t see it that way. Remember, we’re not talking about any sort of compression technology — VirtualDub has always used the official Microsoft codecs for MPEG-4 V3 or Windows Media Audio decoding. The problem was that I had reverse engineered the ASF file format itself. This was done legally; I created my own content in both AVI and ASF form and compared the results at the byte level, without disassembling the ASF file format drivers themselves. I don’t see what intellectual property Microsoft could claim in ASF, it being a universally unimaginative and poorly-designed format, but I respected their dubious claim to IP, and therefore removed ASF support at their request. Let them have it; there are better battles to fight than this one, and remember, this is not the end of ASF support in VirtualDub, since DirectShow is still a valid path, by their own admission.
We’re not talking about a codec problem here. Microsoft claims patent protection on the file format. Remember these implications the next time you consider ASF for your content:
A broken ASF file not accepted by the Microsoft parser would be lost; the patent would prevent anyone from writing a byte-level tool to recover the ASF file. A third-party Linux player wouldn’t be legal, since there would be no way to legally extract the file data, even if third-party video and audio decoders were available. Attempting to transcode a compressed ASF to another format would be impossible with any Microsoft-licensed tools, even if you have the permission of the copyright owner, or even if you are the copyright owner, because the Windows Media Format SDK license requires programs to actively block this action. For instance, Microsoft compelled Nullsoft to disable DSP plugin support in WinAmp with Windows Media Audio content because the DSP interface could be used to transcode, even though DSP plugins normally just process the audio.
First, anytime MS submits a standard, watch out. MS usually wants to bastardize existing standards or use it’s standards to marginalize other technologies. .MONO is an attempt to screw the hookers MS is providing and thinking there won’t be a check when you’re done. This is going to go bad eventually, my gut tells me. *NIX’s do not need to legitimize the .NET initiative to exist. In fact, I submit that it’s the very act of legitimizing MS “standards” that is going to hurt them. I would hate to see any of this distributed in a distro because eventually, MS is going to pull the IP card and attempt to tear down Linux with this “standard.”
<<JAV>>
I run a small software company (3 employees). We write custom software and niche software. We originally wrote our software to work completely on a server and used a win32 front-end with the web control. When I found out about the mono project I decided to learn C#. It is truely a fabulous language. We would really like to support linux even though none of our customers are using it (as long as our software isn’t linux compatible they can never switch!) Mono may be one way we can do this without having to completely rewrite our software. We have been able to more in just a few weeks in C# than 6 months in C++. We have all linux servers and currently use PHP and probably will never switch to asp.net (PHP is awesome). Anyway because of mono we may play with GTK# (since its right there in front of us.) We could target GTK# if it was cross-platform and worked well under windows.