Microsoft "Stole Java" to Marginalize Cross-Platform Languages?
andrew.m...@gmail.com
It looks like a new set of "Halloween Documents" have come out, thanks
to a case in Iowa, Comes et. al. v. Microsoft (http://
iowaconsumercase.org/index.html). I'm wondering if you have any
comments on this document in particular, which suggests that Microsoft
management knew full well they were "stealing Java" to intentionally
marginalize the cross-platform language issue.
A select quote from the document, "Screw Sun, cross-platform will
never work. Let's move on and steal the Java language."
Here's the e-mail archives, which was submitted into evidence:
http://www.iowaconsumercase.org/011107/PX_2768.pdf
I'm wondering, given these thoughts from within Microsoft management,
and given the recent news of Sun open sourcing the Java language under
GPL terms, how is it that you can still push for the Mono project on
Linux? Aren't we always going to be fighting an uphill battle against
a monopoly company protecting its biggest cash cow: the Windows
platform?
Miguel de Icaza
> It looks like a new set of "Halloween Documents" have come out, thanks
> to a case in Iowa, Comes et. al. v. Microsoft (http://
> iowaconsumercase.org/index.html). I'm wondering if you have any
> comments on this document in particular, which suggests that Microsoft
> management knew full well they were "stealing Java" to intentionally
> marginalize the cross-platform language issue.
There is nothing new on it, but it seems like you are trying to read
some malice into this text when there is none.
You seem to be confusing the desire of Microsoft to have its own
platform and kick-ass with the desire of marginalizing cross
platformness.
Microsoft wanted to make changes to Java that would allow them to take
advantage of all the APIs that exist on the operating system and that
are not exposed to Java land. It only seems natural (That is the J/
Direct reference).
The reason the open source community would not (and should not) accept
something like the terms that were given for Java is that it limited
our own innovation. Free software requires code to grant four rights:
use, modification, redistribution and right to redistribute
modifications.
This is *key* to be able to plot your own destiny. But if you were
told you are not allowed to innovate and only the inventor will
innovate and you will be forced to do whatever they do, would you not
fork the effort? I know I would (and I know I have).
Lets take a look at some examples: the Gnumeric spreadsheet's goal was
to be as compatible with Excel as possible. Now, should we limit
ourselves to what Excel has to offer? Well, we did not. And since
the early days we added functions that are not present in Excel
because they made sense to our users.
Lets look at C, would you say that forking C is a good or a bad
idea? Adding features that are not in the language and that would
prevent the code from running on other compilers? Are there valid
reasons to do so, yes or no?
And based on your answer, how does that apply to gcc forking C and
having plenty of extensions that are not in the official language? I
personally think that its great, because this drives innovation, makes
gcc have features that help developers and helps explore new
solutions. I do not believe that we should be limited to implement
what is in a standard.
Now, lets take a look at what "J/Direct" did back in the day. It
allowed Java developers to call into a larger body of APIs that were
not available to Java. Had Microsoft waited or hoped that Sun would
add the APIs they needed to get their stuff going for every API they
would have had their hands tied.
J/Direct turned into P/Invoke in .NET. Lets look at the .NET and P/
Invoke world today in .NET.
P/Invoke is necessary because sometimes you need to balance the size
of a class library, with the needs of developers, with the time its
going to take to ship some software. You must prioritize, choose
which features make it and which ones do not.
With P/Invoke Microsoft was able to focus their attention in the most
common scenarios, say address 90% of the needs of developers with the
core class libraries and ship in a reasonable time frame (2003). The
10% that were not satisfied with their API coverage, could still use P/
Invoke directly.
see the Moma reports to get an idea of how much people P/Invoke: not
only into the Win32 API, but also tons of other unmanaged libraries:
http://primates.ximian.com/~miguel/momareports/s-PINV.txt
In .NET 2.0 (released 2 years later or so), they introduced many new
APIs that removed the need to call into native APIs or to call into
ActiveX (again, some sort of "aim for the most important stuff and
ship it"). For example, now there is a "WebControl" which replaces
hundreds of lines of glue code, P/Invoke and COM calls.
> A select quote from the document, "Screw Sun, cross-platform will
> never work. Let's move on and steal the Java language."
Full cross-platformness can be achieved, but it requires a lot of
work.
For example, today you can develop Java applications on MacOS that use
the Cocoa APIs. Guess what, that Java code will not run *anywhere*
but MacOS X. Sometimes there are needs to use native APIs.
In Mono we have /tried/ to make our APIs as cross platform as
possible, but some things will just not work, and developers will have
to manually ifdef or detect at runtime the operating system and use
different code paths (see my comments on Paint.NET for example, or
look at any application using Mono.Posix).
> I'm wondering, given these thoughts from within Microsoft management,
> and given the recent news of Sun open sourcing the Java language under
> GPL terms, how is it that you can still push for the Mono project on
> Linux? Aren't we always going to be fighting an uphill battle against
> a monopoly company protecting its biggest cash cow: the Windows
> platform?
Am not sure that the connection you are trying to make is there.
Why do I push Mono? For a number of reasons:
* It allows Windows developers to move to Linux (with various degrees
of effort, see Moma reports)
* The Windows ISV market is larger than any other market in the world.
* I believe strongly that we can strengthen Linux by bringing
thousands and vertical, IT and shrink wraps apps to Linux, than
starting from scratch.
* In my opinion, that many share with me, the CLR is a better design
for a runtime than the JVM is.
* In my opinion, that many share with me, C# is a better language than
Java is.
* In the opinion of some of us, using Java is painful, while using C#
is a joy.
So based on our opinions, we are doing the right thing. None of the
above points have anything to do with Microsoft and Sun fights. They
can fight themselves all they want. I love what I do, and so do
thousands of developers using Mono.
That being said, Mono is not a "pure" implementation of the ECMA
standards. We have added things that are not available in the
Microsoft platform, for the same reasons Microsoft added things to
Java, because it improves our offering.
We have APIs that are only available to Unix developers, we have
features that only Unix developers will benefit from, and we have
features in the runtime that are unique to Mono. So by that token, I
can not criticize others for what they have done, I understand why
they have done it.
Now, I have been conservative in how much we "diverge" because a large
part of our value proposition is compatibility, but every once in a
while we prototype things that would improve the CLR more. And we
hope that those things eventually would end up in a standard.
Miguel.
andrew.m...@gmail.com
First of all I wanted to say thanks for making such a thoughtful
reply. To address a couple of points:
On Feb 3, 1:58 pm, "Miguel de Icaza" <miguel.de.ic...@gmail.com>
wrote:
> There is nothing new on it, but it seems like you are trying to read
> some malice into this text when there is none.
The text contains the lines, "Screw Sun, cross-platform will never
work. Let's move on and steal the Java language." I don't see how
you could say there isn't "malice" in that quote from a Microsoft
manager on the .NET team. It shows pretty clearly to me that a)
Microsoft doesn't care about cross-platform (in fact, I'm too kind:
Microsoft _wants_ a single-platform software industry, where the
platform is coincidentally theirs!) and b) Microsoft wanted to
marginalize Java not because they wanted to innovate, but because they
saw cross-platform high level languages like Java as a threat to their
single-platform ecosystem.
Now, it may very well be that there was innovation in aspects of the
CLR design, and C# language design. But I believe strongly the
underlying motives for the .NET move were _financial_, not technical
ones, and I think you'd be very naive to believe otherwise, especially
given evidence that has come out during the Microsoft antitrust
trials.
After all, if Microsoft were after pure technical innovation, why
wouldn't Microsoft have made the CLR cross-platform in the first
place? What developer doesn't want a cross-platform CLR (indeed, this
is why many .NET developers are so happy about Mono). Maybe Microsoft
didn't listen to developers here because it's at odds with another
business of theirs to be cross-platform, perhaps? Maybe? Dontcha
think?
> The reason the open source community would not (and should not) accept
> something like the terms that were given for Java is that it limited
> our own innovation. Free software requires code to grant four rights:
> use, modification, redistribution and right to redistribute
> modifications.
So tell me, what part of the GPLv2 that J2SE and J2ME were released
under in November does not allow the basic tenets of Free Software?
What are you talking about, Miguel? The J2SE is now _GPL_. Not Sun
CDDL: pure GPLv2. You couldn't ask for anything more.
I understand that when you started Mono, this wasn't the state of
affairs. But now that Sun has GPL'ed Java, don't you think we, as
open source developers, would be much better off working on Java
projects (or even other language projects that target the JVM, like
Jython), especially since cross-platform support with Windows/Mac OS/
Linux with Java is much less a slipperly slope than the Mono/Official
MS .NET divide is?
> This is *key* to be able to plot your own destiny. But if you were
> told you are not allowed to innovate and only the inventor will
> innovate and you will be forced to do whatever they do, would you not
> fork the effort? I know I would (and I know I have).
I agree -- and I think that's precisely what you did: you took the
EMCA specification for C#, and the design for the CLR, and you
essentially forked from Microsoft's mainline .NET. Good for you:
those of us stuck writing C# applications now have a shot in hell
porting our apps to Linux. But if I had to choose today a language to
write a truly cross-platform open source app in, I think I'd have to
go with Java, because the support is there and always will be. Hardly
anyone will try to run my code under a Microsoft JVM.
> Lets take a look at some examples: the Gnumeric spreadsheet's goal was
> to be as compatible with Excel as possible. Now, should we limit
> ourselves to what Excel has to offer? Well, we did not. And since
> the early days we added functions that are not present in Excel
> because they made sense to our users.
Which is great -- I agree, this is how innovative software gets built
on top of old stand by approaches like MS Excel.
> Lets look at C, would you say that forking C is a good or a bad
> idea? Adding features that are not in the language and that would
> prevent the code from running on other compilers? Are there valid
> reasons to do so, yes or no?
Sometimes it's a good idea to add extensions to the language, but you
have to be aware that you're gonna break something.
> And based on your answer, how does that apply to gcc forking C and
> having plenty of extensions that are not in the official language? I
> personally think that its great, because this drives innovation, makes
> gcc have features that help developers and helps explore new
> solutions. I do not believe that we should be limited to implement
> what is in a standard.
Neither do I, but I still don't see how you're making a case against
GPLv2 JDK/Java as it stands today.
<snipped stuff on J/Direct and P/Invoke>
I agree Miguel, J/Direct and P/Invoke are mighty fine. But though I
agree with you, I don't really see how this is relevant.
>
> > A select quote from the document, "Screw Sun, cross-platform will
> > never work. Let's move on and steal the Java language."
>
> Full cross-platformness can be achieved, but it requires a lot of
> work.
>
> For example, today you can develop Java applications on MacOS that use
> the Cocoa APIs. Guess what, that Java code will not run *anywhere*
> but MacOS X. Sometimes there are needs to use native APIs.
Yea, but if I use a native API from Java, I _know_ I'm breaking cross-
platform. If I use the recommended APIs (e.g., Swing or SWT), then I
_know_ I am using a cross-platform toolkit.
On Windows/C# however, the "one true" GUI framework is the
Windows.Forms. Already, right there, I have a level of lock-in to
Microsoft that I don't like. You guys can reverse engineer
Windows.Forms all you like, and it's an admirable effort, but all it
takes is Microsoft "moving stuff around" in their implementation and
Mono is playing catch up all over again. In Javaland, however, there
are no such problems.
> In Mono we have /tried/ to make our APIs as cross platform as
> possible, but some things will just not work, and developers will have
> to manually ifdef or detect at runtime the operating system and use
> different code paths (see my comments on Paint.NET for example, or
> look at any application using Mono.Posix).
Right, this is always necessary -- true cross platform (i.e., write
once, run everywhere) is hard.
> > I'm wondering, given these thoughts from within Microsoft management,
> > and given the recent news of Sun open sourcing the Java language under
> > GPL terms, how is it that you can still push for the Mono project on
> > Linux? Aren't we always going to be fighting an uphill battle against
> > a monopoly company protecting its biggest cash cow: the Windows
> > platform?
>
> Am not sure that the connection you are trying to make is there.
Let me be clearer: don't you think every effort Mono makes to make
your CLR implementation run unmodified assemblies from Visual
Studio .NET can just be thwarted by Microsoft simply by renaming a few
classes or changing some code a bit? I took that quote as evidence
that Microsoft does recognize, internally, that cross-platform is a
_threat_, and that therefore this practice is totally understood as
"in their business interest."
Even if this level of cross-platform isn't your goal, don't you ever
think you'll _always_ play catch up, so long as Microsoft wants you
to?
> Why do I push Mono? For a number of reasons:
> * It allows Windows developers to move to Linux (with various degrees
> of effort, see Moma reports)
Admirable goal: many developers have C# knowledge due to their work,
and want to play with Linux at home.
> * The Windows ISV market is larger than any other market in the world.
Practical goal, and I think this is a good reason to have a C#
implementation on Linux.
> * I believe strongly that we can strengthen Linux by bringing
> thousands and vertical, IT and shrink wraps apps to Linux, than
> starting from scratch.
Good point.
> * In my opinion, that many share with me, the CLR is a better design
> for a runtime than the JVM is.
> * In my opinion, that many share with me, C# is a better language than
> Java is.
> * In the opinion of some of us, using Java is painful, while using C#
> is a joy.
I don't know if I'd agree with that. I've used both Java and C# for
extended periods of time, and honestly, there isn't a huge difference
between the two languages. C# is certainly a "better Java", but not
an "order of magnitude better Java." As for the CLR design, you may
like it better than the JVM, but guess what: Microsoft hasn't open
sourced their CLR. Sun has GPL'ed the JVM (a JVM which already runs
under Windows, Mac OS, Linux, Solaris, BSD, etc.). The JVM is
actually pretty darn good, but now could be improved even more by F/
OSS enthusiasts, making the cross-platform, open-source development
stack dream a reality.
> So based on our opinions, we are doing the right thing. None of the
> above points have anything to do with Microsoft and Sun fights. They
> can fight themselves all they want. I love what I do, and so do
> thousands of developers using Mono.
And I love that you do what you do. But I asked my question mainly to
warn you that Microsoft is certainly not committed to the dream of a
cross-platform development stack, like Sun was and like we can now all
be thanks to their foresight in GPL'ing the JDK/JRE.
> That being said, Mono is not a "pure" implementation of the ECMA
> standards. We have added things that are not available in the
> Microsoft platform, for the same reasons Microsoft added things to
> Java, because it improves our offering.
And that's good: developing directly for Mono under *nix may actually
be one of the better dev stacks available, especially for teams
transitioning from C# and Windows.
> We have APIs that are only available to Unix developers, we have
> features that only Unix developers will benefit from, and we have
> features in the runtime that are unique to Mono. So by that token, I
> can not criticize others for what they have done, I understand why
> they have done it.
>
> Now, I have been conservative in how much we "diverge" because a large
> part of our value proposition is compatibility, but every once in a
> while we prototype things that would improve the CLR more. And we
> hope that those things eventually would end up in a standard.
Again, I appreciate your response. Let me summarize:
* I love the work you do on Mono, and think it's great for F/OSS.
* I think Mono is very valuable for programmers transitioning from
the "rose-tinted world of Microsoft", with lots of C# code to port.
* Given Sun's GPL'ing of Java and Microsoft's lack of commitment to
the dream of a "cross-platform high level development platform", I
think Java, not C#/Mono, should be the first choice F/OSS developers
think of when they want to write a cross-platform, open-source
application.
* I think we'll benefit much more from F/OSS developers moving en
masse from open source C to open source Java (or even Python, etc.),
than for them to move C#/Mono. This is because the best CLR
implementation for Windows is Microsoft's, and they have way too much
control over it (and way too much reason to mess with the way it works
to thwart cross-platform efforts).
* Like you expressed in your response, the goal is to take a kernel
of an idea and extend it to make it better. In that vein, I hope you
see Mono as COMPETING with Microsoft .NET in the future, not merely
extending it to be cross-platform. In other words, people will run a
Mono CLR on their Windows desktop machines alongside the Microsoft
CLR. The reason is because whether you like it or not, you will _have
to_ compete with Microsoft in the future, so you better be ready to do
so.
Thanks again for the thoughtful response. Keep up the great work, and
for your sake and mine, I hope the Mono CLR beats the crap out of the
Windows one in a couple years' time :-)
Andrew
Miguel de Icaza
> The text contains the lines, "Screw Sun, cross-platform will never
> work. Let's move on and steal the Java language." I don't see how
> you could say there isn't "malice" in that quote from a Microsoft
> manager on the .NET team.
It sounds just like an aggressive PM in a company. This does not
sound any different than the emotions expressed on irc channels for
any project competing with another one, and does not sounds any
different than any proposal that you would hear from companies
competing with another one.
What you got there is a thread between two middle managers, they
wanted to screw Java. Big deal.
I happen to think that Microsoft has executed better with .NET than
Sun has with Java.
> Now, it may very well be that there was innovation in aspects of the
> CLR design, and C# language design. But I believe strongly the
> underlying motives for the .NET move were _financial_, not technical
> ones, and I think you'd be very naive to believe otherwise, especially
> given evidence that has come out during the Microsoft antitrust
> trials.
There is little or no evidence (if the best you have is a document
like this, then you really have nothing).
I like to think that the simplest explanation is probably the most
plausible one: Java was good, but not ideal for Microsoft; Microsoft
makes changes to Java to suit their needs; Suns sees this as a
"fork", sues; Microsoft looses lawsuit, has to return the clothing
and is left naked with crap APIs and crap tools for their platform;
Work starts on a competing system that will satisfy their needs; Java
is the source of inspiration, lots of ideas come from it; A billion
dollars are poured into it, you get .NET.
The financial reasons are clear: they need a development platform that
will keep developers happy. C++, MFC and Win32 are not those
technologies. They have tried the sweetness of Java, and they want
something similar.
For the same reason we tried C# and we wanted it on Linux ;-)
> After all, if Microsoft were after pure technical innovation, why
> wouldn't Microsoft have made the CLR cross-platform in the first
> place? What developer doesn't want a cross-platform CLR (indeed, this
> is why many .NET developers are so happy about Mono).
Microsoft is a business last I checked, not the FSF.
And even the FSF used to have some paragraph a few years ago about
porting software to Windows, something along the lines of "We only
port to Windows when its strategically convenient, but we should try
to get folks over to free software, and not improve too much the
proprietary experience".
Nothing wrong with it, different agendas call for different
approaches.
But Microsoft did release a portable version of the CLR, its called
Rotor. So it is possible to write one (we shipped Mono before Rotor
came out though, so it is obviously possible).
But as that email thread you posted points to: doing cross platform
support is expensive, its hard and it takes a lot of time. It is
their business, and their business decision to choose what to do.
> Maybe Microsoft
> didn't listen to developers here because it's at odds with another
> business of theirs to be cross-platform, perhaps? Maybe? Dontcha
> think?
Absolutely right. So what is the problem?
Ask the Gnome or KDE people why they do not develop on Windows. Why
dont the Gnome and KDE people release packages for Windows, might it
be because its not their core objective?
> > The reason the open source community would not (and should not) accept
> > something like the terms that were given for Java is that it limited
> > our own innovation. Free software requires code to grant four rights:
> > use, modification, redistribution and right to redistribute
> > modifications.
>
> So tell me, what part of the GPLv2 that J2SE and J2ME were released
> under in November does not allow the basic tenets of Free Software?
I was *obviously* referring to the historical open source development
of Java in the context of these 1997 emalis. Not the release of "the
last 3 months". Am obviously aware that the GPL is a free software
license and am aware that java was released under the terms of the
GPL.
Open Source Java efforts have existed since 1996 (at least that am
aware of, when I was involved in the open source implementation of an
AWT toolkit that would run in Kaffe, I believe it was called "sawt").
Blackdown Java was not open source at the time and some people have
been working on those for 10 years at least.
> What are you talking about, Miguel? The J2SE is now _GPL_. Not Sun
> CDDL: pure GPLv2. You couldn't ask for anything more.
Well Duh.
See above.
> I understand that when you started Mono, this wasn't the state of
> affairs. But now that Sun has GPL'ed Java, don't you think we, as
> open source developers, would be much better off working on Java
> projects (or even other language projects that target the JVM, like
> Jython), especially since cross-platform support with Windows/Mac OS/
> Linux with Java is much less a slipperly slope than the Mono/Official
> MS .NET divide is?
No.
Developers that use Java in Windows already can migrate their
applications to Linux. So there is no net gain in applications that
run on Linux. None.
Let me count again, maybe I got it wrong.
Nope, it is still zero.
A .NET compatible runtime on the other hand allows thousands of
applications that are only available on Windows to be available on
Linux without a rewrite.
And of course, there is the issue of the CLR and C# being superior to
the JVM and Java as languages.
> Neither do I, but I still don't see how you're making a case against
> GPLv2 JDK/Java as it stands today.
I was /obviously/ referring to the 10 years of open source java, not
the 3 months we have so far of "GPL but yet incomplete" java.
> <snipped stuff on J/Direct and P/Invoke>
>
> I agree Miguel, J/Direct and P/Invoke are mighty fine. But though I
> agree with you, I don't really see how this is relevant.
You should pay more attention to what I write.
It is relevant because plain Java was not that useful. There were
obvious improvements to Java that made it useful to Microsoft, but
happened to break the language.
You ask in your post about the intentional marginalization of Java;
Well, I would have done the same. The technology had lots of room to
be fixed, it was at best a passable prototype.
> Yea, but if I use a native API from Java, I _know_ I'm breaking cross-
> platform. If I use the recommended APIs (e.g., Swing or SWT), then I
> _know_ I am using a cross-platform toolkit.
And the email thread you posted to starts precisely there, with a non-
cross-platform library.
The whole thread in those PDF scans is about that Microsoft-specific
library. And the comments that come out of it are all about that.
See the point?
I showed you gcc, gnumeric, Cocoa bindings: all of those are "ok"
because we do it; When Microsoft does it "it is not ok".
> On Windows/C# however, the "one true" GUI framework is the
> Windows.Forms. Already, right there, I have a level of lock-in to
> Microsoft that I don't like. You guys can reverse engineer
> Windows.Forms all you like, and it's an admirable effort, but all it
> takes is Microsoft "moving stuff around" in their implementation and
> Mono is playing catch up all over again. In Javaland, however, there
> are no such problems.
Your argument is fallacious (Appeal to Fear) .
Considering Microsoft's binary compatibility track record, compared to
any Linux and any MacOS release, am incredibly amused that you even
try to pull that argument.
So I expect you to come up with an explanation on how Microsoft will
"move stuff around" that will break Mono, but will not break existing
applications. Am sure you probably know more about this than we do.
> Right, this is always necessary -- true cross platform (i.e., write
> once, run everywhere) is hard.
Glad you agree with the email thread from Microsoft.
> Let me be clearer: don't you think every effort Mono makes to make
> your CLR implementation run unmodified assemblies from Visual
> Studio .NET can just be thwarted by Microsoft simply by renaming a few
> classes or changing some code a bit? I took that quote as evidence
> that Microsoft does recognize, internally, that cross-platform is a
> _threat_, and that therefore this practice is totally understood as
> "in their business interest."
Am guessing that its not "appeal to fear" that is the problem here,
but that you do not quite understand how .NET works and thus you draw
conclusions from incorrect premises.
"Renaming a few classes or changing some code a bit" has an externally
visible effect. And this externally visible effect also has the
downside of breaking existing software that has been written against
the originally visible effect.
So, yes, Microsoft can change the code and break Mono, and break every
application that depends on the feature in the process. So as long as
they are not suicidal, Mono will be doing just fine.
> Even if this level of cross-platform isn't your goal, don't you ever
> think you'll _always_ play catch up, so long as Microsoft wants you
> to?
In some areas we play catch up, and in some others we do not.
And there is a tremendous net gain for every inch of progress we make,
every API we implement (we implemented close to 2,000 new APIs in this
last release cycle) brings new applications to Linux. Every single
one of them ;-)
And in the process of doing so, we are having not only a lot of fun,
and we are enjoying every inch of the way doing it.
> I don't know if I'd agree with that. I've used both Java and C# for
> extended periods of time, and honestly, there isn't a huge difference
> between the two languages. C# is certainly a "better Java", but not
> an "order of magnitude better Java." As for the CLR design, you may
> like it better than the JVM, but guess what: Microsoft hasn't open
> sourced their CLR. Sun has GPL'ed the JVM (a JVM which already runs
> under Windows, Mac OS, Linux, Solaris, BSD, etc.). The JVM is
> actually pretty darn good, but now could be improved even more by F/
> OSS enthusiasts, making the cross-platform, open-source development
> stack dream a reality.
Am glad that you found yourself a project to contribute to. Go, hack
and submit patches.
> And I love that you do what you do. But I asked my question mainly to
> warn you that Microsoft is certainly not committed to the dream of a
> cross-platform development stack, like Sun was and like we can now all
> be thanks to their foresight in GPL'ing the JDK/JRE.
It is perfectly fine for Microsoft to focus on making .NET rock on
Windows.
We will take care of making sure that Mono rocks on Linux.
Miguel
Miguel de Icaza
A google cuts long posts, will reply to the last bits:
> * Given Sun's GPL'ing of Java and Microsoft's lack of commitment to
> the dream of a "cross-platform high level development platform", I
> think Java, not C#/Mono, should be the first choice F/OSS developers
> think of when they want to write a cross-platform, open-source
> application.
You seem to be under the mistaken impression that only Sun and
Microsoft can write a VM.
I think that F/OSS developers are better served by all the extra
features that the C# and CLR provides. I do not belong to the school
of self-flagellation just for the sake of using a GPL runtime,
considering that we have a fully working one (which happens to also
use way less memory than the other one does :-)
> * I think we'll benefit much more from F/OSS developers moving en
> masse from open source C to open source Java (or even Python, etc.),
> than for them to move C#/Mono. This is because the best CLR
> implementation for Windows is Microsoft's, and they have way too much
> control over it (and way too much reason to mess with the way it works
> to thwart cross-platform efforts).
You should submit the above paragraph to Wikipedia's "Logical Fallacy"
page to illustrate it.
> * Like you expressed in your response, the goal is to take a kernel
> of an idea and extend it to make it better. In that vein, I hope you
> see Mono as COMPETING with Microsoft .NET in the future, not merely
> extending it to be cross-platform. In other words, people will run a
> Mono CLR on their Windows desktop machines alongside the Microsoft
> CLR. The reason is because whether you like it or not, you will _have
> to_ compete with Microsoft in the future, so you better be ready to do
> so.
Am just not a believer in the scarcity model, and do not believe that
the ultimate goal is to win and have someone else loose. Am happy
myself improving the status quo, and in particular making Linux more
interesting with Mono.
Microsoft has a market, Mono has a market. Mono's open source nature
opens and closes some doors. I am fine with that.
Miguel.
Miguel de Icaza
I just do not consider the PDFs the smoking gun of Microsoft meddling
with Java.
Am sure there is better evidence elsewhere (Google turns out a bunch
of more interesting material than the PDF).
Am personally convinced there was a mix of practicality and
competition involved
Miguel.
andrew.m...@gmail.com
On Feb 3, 8:07 pm, "Miguel de Icaza" <miguel.de.ic...@gmail.com>
wrote:
> It sounds just like an aggressive PM in a company. This does not
> sound any different than the emotions expressed on irc channels for
> any project competing with another one, and does not sounds any
> different than any proposal that you would hear from companies
> competing with another one.
>
> What you got there is a thread between two middle managers, they
> wanted to screw Java. Big deal.
>
> I happen to think that Microsoft has executed better with .NET than
> Sun has with Java.
To be fair, Miguel, Microsoft may have executed .NET better, but I
think it's far easier to execute the design and development of a high
level language and runtime when one has already been built and widely
used in industry. The chief innovation that Microsoft had was
designing the runtime such that multiple languages could target it and
language interop is a breeze. Otherwise, Microsoft learned lessons
from Java, and made essentially a "better Java" in .NET. Good for
them, but unlike Sun, Microsoft never worried about cross-platform --
in fact, from a public company capitalist point of view, they _must_
be against it. This document I sent you just shows that inside the
company, at least a few managers see things this way, so it isn't just
FUD spread by F/OSS enthusiasts. There is no "pretense" of cross-
platform.
That is basically the only thing I am trying to say.
> > Now, it may very well be that there was innovation in aspects of the
> > CLR design, and C# language design. But I believe strongly the
> > underlying motives for the .NET move were _financial_, not technical
> > ones, and I think you'd be very naive to believe otherwise, especially
> > given evidence that has come out during the Microsoft antitrust
> > trials.
>
> There is little or no evidence (if the best you have is a document
> like this, then you really have nothing).
>
> I like to think that the simplest explanation is probably the most
> plausible one: Java was good, but not ideal for Microsoft; Microsoft
> makes changes to Java to suit their needs; Suns sees this as a
> "fork", sues; Microsoft looses lawsuit, has to return the clothing
> and is left naked with crap APIs and crap tools for their platform;
> Work starts on a competing system that will satisfy their needs; Java
> is the source of inspiration, lots of ideas come from it; A billion
> dollars are poured into it, you get .NET.
I think this too is a plausible explanation of why Microsoft went
into .NET. Yet I think the business managers in Microsoft see this as
an enormous opportunity to "homogenize the platform" on Microsoft
technologies. To a degree, they've succeeded: lots of companies moved
to .NET in swarms. They're now using VS.NET to build software that's
only supported on Windows and IIS. How wonderful -- Microsoft all
around.
Mono is changing that, but it must be threatening to them.
> The financial reasons are clear: they need a development platform that
> will keep developers happy. C++, MFC and Win32 are not those
> technologies. They have tried the sweetness of Java, and they want
> something similar.
I agree fully with this, except these _aren't_ the financial reasons.
These are probably the reasons that technical managers inside MS
pushed for .NET: to move away from legacy COM, C++/MFC/Win32
development. The financial reasons would be more like, "If Microsoft
tools are the primary development tools, we'll not only make money off
the tools but tie a whole generation of software to the Windows
platform." Microsoft knows wooing developers helps their bottom line
in a big way, for this reason.
> For the same reason we tried C# and we wanted it on Linux ;-)
And you got it on Linux. Great work :-)
> > After all, if Microsoft were after pure technical innovation, why
> > wouldn't Microsoft have made the CLR cross-platform in the first
> > place? What developer doesn't want a cross-platform CLR (indeed, this
> > is why many .NET developers are so happy about Mono).
>
> Microsoft is a business last I checked, not the FSF.
I agree, you're using my own point against me :-) Precisely because
Microsoft is in the OS business, they don't care about cross-platform.
> And even the FSF used to have some paragraph a few years ago about
> porting software to Windows, something along the lines of "We only
> port to Windows when its strategically convenient, but we should try
> to get folks over to free software, and not improve too much the
> proprietary experience".
I don't agree with everything RMS, or the FSF, says. I think all F/
OSS software on Linux should have Windows/Mac ports on their agenda.
> Nothing wrong with it, different agendas call for different
> approaches.
I guess, except Microsoft's agenda can tie people to the Windows
platform and thus not give innovative software on other platforms a
chance.
> But Microsoft did release a portable version of the CLR, its called
> Rotor. So it is possible to write one (we shipped Mono before Rotor
> came out though, so it is obviously possible).
>
> But as that email thread you posted points to: doing cross platform
> support is expensive, its hard and it takes a lot of time. It is
> their business, and their business decision to choose what to do.
OK, I guess from an argumentative standpoint, now we're at a
crossroads. I agree 100% with this last paragraph.
Microsoft is in the platform business. They're also in the
development tools business. It is in their business interest to tie
their development tools to their platform. That is my worry, and I
think it should be yours to an extent. (I have to believe you do
think about this, from time to time.)
> > Maybe Microsoft
> > didn't listen to developers here because it's at odds with another
> > business of theirs to be cross-platform, perhaps? Maybe? Dontcha
> > think?
>
> Absolutely right. So what is the problem?
>
> Ask the Gnome or KDE people why they do not develop on Windows. Why
> dont the Gnome and KDE people release packages for Windows, might it
> be because its not their core objective?
I think the real reason GNOME/KDE people don't release all their
software under Windows is due to lack of time. I think if you offered
a developer to do Windows ports of software to any of these groups,
they'd say, "Go ahead, dive right in." If I offered a team of smart
developers to Microsoft to make their CLR implementation cross-
platform, they'd say, "No thanks."
> > > The reason the open source community would not (and should not) accept
> > > something like the terms that were given for Java is that it limited
> > > our own innovation. Free software requires code to grant four rights:
> > > use, modification, redistribution and right to redistribute
> > > modifications.
>
> > So tell me, what part of the GPLv2 that J2SE and J2ME were released
> > under in November does not allow the basic tenets of Free Software?
>
> I was *obviously* referring to the historical open source development
> of Java in the context of these 1997 emalis. Not the release of "the
> last 3 months". Am obviously aware that the GPL is a free software
> license and am aware that java was released under the terms of the
> GPL.
<snip>
Okay, sorry. This was just a miscommunication. I was talking about
"truly free Java", and you were talking about the state-of-the-world a
few months ago. Truly miscommunication.
> > I understand that when you started Mono, this wasn't the state of
> > affairs. But now that Sun has GPL'ed Java, don't you think we, as
> > open source developers, would be much better off working on Java
> > projects (or even other language projects that target the JVM, like
> > Jython), especially since cross-platform support with Windows/Mac OS/
> > Linux with Java is much less a slipperly slope than the Mono/Official
> > MS .NET divide is?
>
> No.
>
> Developers that use Java in Windows already can migrate their
> applications to Linux. So there is no net gain in applications that
> run on Linux. None.
>
> Let me count again, maybe I got it wrong.
>
> Nope, it is still zero.
Erm, the _reason_ people didn't write major applications on Linux in
Java a few months ago was because of fear that due to the "Java Trap"
their code wouldn't really be F/OSS. Now that the Java Trap is gone,
this worry is gone. That's the main benefit of GPLv2 Java. To allow
new Linux applications to be written more rapidly, in a high level
language, and then have an easy road to port to Windows/Mac.
I agree with you that a GPL Java doesn't enable more people to move
apps from Windows to Linux. That is very much Mono's greatest
achievement: allowing this movement.
> A .NET compatible runtime on the other hand allows thousands of
> applications that are only available on Windows to be available on
> Linux without a rewrite.
I agree, this is the great benefit of Mono. And the most threatening
one to Microsoft, from a business standpoint.
> And of course, there is the issue of the CLR and C# being superior to
> the JVM and Java as languages.
:-)
> > Neither do I, but I still don't see how you're making a case against
> > GPLv2 JDK/Java as it stands today.
>
> I was /obviously/ referring to the 10 years of open source java, not
> the 3 months we have so far of "GPL but yet incomplete" java.
OK, again sorry for miscommunication on this. But I think GPLv2 Java
does change things for developers, as in above.
> > <snipped stuff on J/Direct and P/Invoke>
>
> > I agree Miguel, J/Direct and P/Invoke are mighty fine. But though I
> > agree with you, I don't really see how this is relevant.
>
> You should pay more attention to what I write.
I read every word, please don't get offended.
> It is relevant because plain Java was not that useful. There were
> obvious improvements to Java that made it useful to Microsoft, but
> happened to break the language.
>
> You ask in your post about the intentional marginalization of Java;
> Well, I would have done the same. The technology had lots of room to
> be fixed, it was at best a passable prototype.
I think given what Java did for industry and for Microsoft (through
inspiration), that's probably not too bad. It's much easier to
produce something that isn't a "passable prototype" when the "passable
prototype" has already been produced and released in the wild :-)
> > Yea, but if I use a native API from Java, I _know_ I'm breaking cross-
> > platform. If I use the recommended APIs (e.g., Swing or SWT), then I
> > _know_ I am using a cross-platform toolkit.
>
> And the email thread you posted to starts precisely there, with a non-
> cross-platform library.
>
> The whole thread in those PDF scans is about that Microsoft-specific
> library. And the comments that come out of it are all about that.
>
> See the point?
>
> I showed you gcc, gnumeric, Cocoa bindings: all of those are "ok"
> because we do it; When Microsoft does it "it is not ok".
I wasn't really intending to focus on the particular library which was
being talked about in that thread. Instead, I was just pointing to
the comments where Microsoft managers see (1) cross-platform as
something "uninteresting" and not in their interest and (2) that they
saw Java as something to be "stolen" and modified, e.g. "embraced and
extended." I think Microsoft .NET is embracing the core tenets of the
concept behind Java/JVM, adding the chief extension that it _won't_ be
cross-platform by design.
That said, I am _very_ happy Mono is "fixing" this Microsoft bug. I
just wish the company that created the Windows platform weren't the
same one that created .NET, because if it weren't, then .NET would
have cross-platform as a business interest.
> > On Windows/C# however, the "one true" GUI framework is the
> > Windows.Forms. Already, right there, I have a level of lock-in to
> > Microsoft that I don't like. You guys can reverse engineer
> > Windows.Forms all you like, and it's an admirable effort, but all it
> > takes is Microsoft "moving stuff around" in their implementation and
> > Mono is playing catch up all over again. In Javaland, however, there
> > are no such problems.
>
> Your argument is fallacious (Appeal to Fear) .
>
> Considering Microsoft's binary compatibility track record, compared to
> any Linux and any MacOS release, am incredibly amused that you even
> try to pull that argument.
>
> So I expect you to come up with an explanation on how Microsoft will
> "move stuff around" that will break Mono, but will not break existing
> applications. Am sure you probably know more about this than we do.
if (CheckVM.isMono()) {
Environment.Exit()
}
in some core CLR library.
:-)
No, sure, I don't know more about this than you do. See my comments
below about "tying" certain .NET libraries to Windows, which is a
subtler but equally effective way of making cross-platform hard for
you.
> > Right, this is always necessary -- true cross platform (i.e., write
> > once, run everywhere) is hard.
>
> Glad you agree with the email thread from Microsoft.
>
> > Let me be clearer: don't you think every effort Mono makes to make
> > your CLR implementation run unmodified assemblies from Visual
> > Studio .NET can just be thwarted by Microsoft simply by renaming a few
> > classes or changing some code a bit? I took that quote as evidence
> > that Microsoft does recognize, internally, that cross-platform is a
> > _threat_, and that therefore this practice is totally understood as
> > "in their business interest."
>
> Am guessing that its not "appeal to fear" that is the problem here,
> but that you do not quite understand how .NET works and thus you draw
> conclusions from incorrect premises.
>
> "Renaming a few classes or changing some code a bit" has an externally
> visible effect. And this externally visible effect also has the
> downside of breaking existing software that has been written against
> the originally visible effect.
>
> So, yes, Microsoft can change the code and break Mono, and break every
> application that depends on the feature in the process. So as long as
> they are not suicidal, Mono will be doing just fine.
OK, I concede that my example above wasn't exactly thought out. It's
not really moving classes around that worries me.
With Windows.Forms, Microsoft essentially made a lot of controls that
just call the underlying Win32 API natively. "No pretenses of cross-
platform", as the e-mail thread says, but for a different context.
This means that in order for you to support Windows.Forms "truly", you
essentially need to support the Win32 API.
By the same token, all it takes is for Microsoft to tie some
"important" piece of .NET to some platform-specific thing in order to
make it more and more difficult for you guys. Let's say in a few
months Microsoft ties certain .NET libraries to some special new
programs/libraries only available in Vista. Suddenly, cross-platform
becomes harder, because you need to support underlying Vista feature X
or Y, which is much tougher to implement, especially since it's closed
source and not necessarily released under some EMCA standard, and
maybe tied to Windows in certain ways.
You see how this kind of stuff has the potential of getting
exponentially harder over time? And I'm not appealing to fear.
Microsoft has a track record of binary compatibility, but they also
have a track record of taking the kernel of a good idea and then
writing the Microsoft stamp over it so many times that you can never
divorce it from Microsoft technologies at all. Which is, after all,
the point of the business.
> > Even if this level of cross-platform isn't your goal, don't you ever
> > think you'll _always_ play catch up, so long as Microsoft wants you
> > to?
>
> In some areas we play catch up, and in some others we do not.
>
> And there is a tremendous net gain for every inch of progress we make,
> every API we implement (we implemented close to 2,000 new APIs in this
> last release cycle) brings new applications to Linux. Every single
> one of them ;-)
I 100% agree with this. I think you guys are making a strong,
admirable effort, and the gains for Linux are real.
But I'm not talking about existing Windows apps, for which Mono is the
obvious cross-platform choice. I'm talking about writing a new piece
of F/OSS today, and wanting to ensure it's cross platform. I have a
few choices: Java, C#/Mono, Python, etc. Unless I target Mono on all
platforms, then the C#/Mono choice can potentially be dangerous. If I
do target Mono on all platforms, than Mono is now competing with
Microsoft's CLR. Which was my point above: if developers target Mono
on all platforms, you're competing with Microsoft, so be prepared to
fight.
> And in the process of doing so, we are having not only a lot of fun,
> and we are enjoying every inch of the way doing it.
Awesome :-) Always great to love what you do.
Wow, we've written a lot. Sorry to chew up so much of your time (I
feel embarrassed for doing so). I'll reply to the next post soon, but
I just want to make a few things clear:
* I think what you're doing with Mono is great for Linux and great
for Windows developers. A great, heroic effort overall. And lots of
benefits for everyone.
* I am not just trying to FUD about Mono. I am only worried about
Microsoft becoming increasingly threatened by it over time, especially
the more popular it gets.
More to come, and again, I really appreciate you taking the time to
respond to these. I think you've definitely made a strong case and
certainly destroyed many of mine. I can see you're committed to
expanding the ISV market for Linux and giving Windows developers an
exit strategy. It's really great work of which you and your team
should be proud.
Andrew
Miguel de Icaza
> > I happen to think that Microsoft has executed better with .NET than
> > Sun has with Java.
>
> To be fair, Miguel, Microsoft may have executed .NET better, but I
> think it's far easier to execute the design and development of a high
> level language and runtime when one has already been built and widely
> used in industry.
Exactly.
As you have noticed Mono's original goal was not to implement the .NET
APIs, we were too small a group to even think about it. We started
small: we only wanted the VM, the core libraries and the compiler.
And we chose those because they were a technologically better solution
than Java was (there are plenty of interviews where we describe Mono's
genesis).
Now, many years later, the effort has grown, and we can actually go
beyond the original goals and offer cross platform compatibility. It
is plenty hard, but in addition to the original goal ("Get the best
developer platform available in Linux") we now have a new one ("Bring
Windows applications and developers to Linux").
> The chief innovation that Microsoft had was
> designing the runtime such that multiple languages could target it and
> language interop is a breeze. Otherwise, Microsoft learned lessons
> from Java, and made essentially a "better Java" in .NET. Good for
> them, but unlike Sun, Microsoft never worried about cross-platform --
> in fact, from a public company capitalist point of view, they _must_
> be against it. This document I sent you just shows that inside the
> company, at least a few managers see things this way, so it isn't just
> FUD spread by F/OSS enthusiasts. There is no "pretense" of cross-
> platform.
And that is fine with us. They have their goals, we have ours.
Now, even if .NET 1.0 was incrementally better over Java, Microsoft
has continued to execute release after release (2.0, 3.0 and the
upcoming Orcas/3.5) and each one has gotten many times better than
Java.
Sun could have done something, but instead rested on their laurels and
have not managed to get much new stuff in Java. And when they have
(like Generics) the approaches that they took were shortcuts and are
in no way comparable to what .NET offers (and Mono offers).
It just seems badly managed, and badly run from the outside.
> I think this too is a plausible explanation of why Microsoft went
> into .NET. Yet I think the business managers in Microsoft see this as
> an enormous opportunity to "homogenize the platform" on Microsoft
> technologies. To a degree, they've succeeded: lots of companies moved
> to .NET in swarms. They're now using VS.NET to build software that's
> only supported on Windows and IIS. How wonderful -- Microsoft all
> around.
Exactly, but who is to blame? .NET started from a position of
weakness, Java was the 800 pound gorilla.
You can not say it was the "bundling" of .NET, as .NET was not bundled
with the OS until some XP "Service Pack" release or as an update.
Sun and Sun's arrogance is to blame. In 199x they had the "best"
developer platform, they commanded the kmind share, people saw Java as
the heir to the throne. Developers said "This is fine, but we need X
and Y". Back in the day I kept wondering "Where are my enums?".
But since Sun had the best platform, and had control over it, it did
not feel like they needed to pay attention to their users. They
allowed Java to bloat, to stay slow, and to barely move. I guess
they though nobody could ever compete with them and catch up.
So the solution is very simple: you take Java, you take all of its
criticism, you take the developer suggestions, you listen to what
people are complaining about you pour a billion dollars in development
and you produce a competitor. Voila!
Then you keep improving, iteratively, get people's feedback until you
get a great product.
Now, I think that Microsoft has also botched a number of APIs in .NET
3 (and you can google my opinions on them) but they still executed
better than Java. Java has had 6 years to catch up, and they have
barely done so.
> Mono is changing that, but it must be threatening to them.
I think we need to build bridges with Microsoft, because they are here
to stay, just like many other players, and my goal, as I said before,
is to grow the software world and we can do this better as a team.
So am sure some people at Microsoft do not like Mono, but we should
try to explore how they complement each other. I have some good
theories that I should blog about.
> > The financial reasons are clear: they need a development platform that
> > will keep developers happy. C++, MFC and Win32 are not those
> > technologies. They have tried the sweetness of Java, and they want
> > something similar.
>
> I agree fully with this, except these _aren't_ the financial reasons.
> These are probably the reasons that technical managers inside MS
> pushed for .NET: to move away from legacy COM, C++/MFC/Win32
> development. The financial reasons would be more like, "If Microsoft
> tools are the primary development tools, we'll not only make money off
> the tools but tie a whole generation of software to the Windows
> platform." Microsoft knows wooing developers helps their bottom line
> in a big way, for this reason.
Absolutely.
People make fun of Balmer for that video the "Developers, developers,
developers, developers". What people do not realize is that Window's
major strength today is precisely that: developers.
> Microsoft is in the platform business. They're also in the
> development tools business. It is in their business interest to tie
> their development tools to their platform. That is my worry, and I
> think it should be yours to an extent. (I have to believe you do
> think about this, from time to time.)
People could be tied to Microsoft's APIs, but it turns out that the
majority of the managed APIs can be supported incredibly easily in a
cross platform way.
>From the hundreds of Moma reports we have received, we know that 30%
of the apps will run unmodified, 30% will require the original
developer to spend a couple of hours to a week of work to support two
platforms; 15% will require a month to port; 7% multiple months to
port and the rest I would not even port.
Why so? Because not every app exercises all of .NET; And only a
fraction of apps are very tied to the platform.
> I think the real reason GNOME/KDE people don't release all their
> software under Windows is due to lack of time. I think if you offered
> a developer to do Windows ports of software to any of these groups,
> they'd say, "Go ahead, dive right in." If I offered a team of smart
> developers to Microsoft to make their CLR implementation cross-
> platform, they'd say, "No thanks."
Exactly, so lack of time and no business need for them. Fine.
Btw, I think that there is a strong business case for the CLR on other
platforms, but am happy for Mono to be the "Portable CLR" ;-)
> > Developers that use Java in Windows already can migrate their
> > applications to Linux. So there is no net gain in applications that
> > run on Linux. None.
>
> > Let me count again, maybe I got it wrong.
>
> > Nope, it is still zero.
>
> Erm, the _reason_ people didn't write major applications on Linux in
> Java a few months ago was because of fear that due to the "Java Trap"
> their code wouldn't really be F/OSS. Now that the Java Trap is gone,
> this worry is gone. That's the main benefit of GPLv2 Java. To allow
> new Linux applications to be written more rapidly, in a high level
> language, and then have an easy road to port to Windows/Mac.
You are missing the point again.
The only people that cared about "The Java Trap" are a minority in the
open source community (the minority that did not even want to touch
open source Java). And the open source developer community is in
itself a minority in the developer world. So the 5% of the %5, a
completely irrelevant number. But that is not the point *anyways*.
The point I was making is that developers that cared about going
beyond Windows chose Java regardless of what Stallman said (ie,
developers outside the 5% of the 5%). And those developers already
could move their apps to Linux or any other system.
Working on Java will bring zero new applications and zero new
developers, we already "got them" (specially considering Sun's
execution problems in making Java interesting in the first place).
Working on .NET will bring many more applications.
Now that Java is GPL, you could argue that the open source community
could fix Java and make it competitive. It is a long-term plan to fix
Sun's mistakes. Godspeed to you.
Java at this point needs more than good intentions, it needs a lot of
work.
> I agree with you that a GPL Java doesn't enable more people to move
> apps from Windows to Linux. That is very much Mono's greatest
> achievement: allowing this movement.
Exactly.
> > A .NET compatible runtime on the other hand allows thousands of
> > applications that are only available on Windows to be available on
> > Linux without a rewrite.
>
> I agree, this is the great benefit of Mono. And the most threatening
> one to Microsoft, from a business standpoint.
Again, scarce/zero-sum game mentality.
The message I want to get out is that a better developer world is
possible with cooperation with all involved parties. Sun finally
realized that, and I hope that Microsoft one day will embrace it.
Again, Google groups did not quote the entire message, I will have to
continue on the next.
miguel
Miguel de Icaza
Continuation, I must learn to use Google groups the next time.
> > You ask in your post about the intentional marginalization of Java;
> > Well, I would have done the same. The technology had lots of room to
> > be fixed, it was at best a passable prototype.
>
> I think given what Java did for industry and for Microsoft (through
> inspiration), that's probably not too bad. It's much easier to
> produce something that isn't a "passable prototype" when the "passable
> prototype" has already been produced and released in the wild :-)
I already covered this on the previous post, but I agree.
But Sun still has managed to ignore developers for the longest time.
It was not until .NET came out that they started to make serious
changes into the Java language. It is arguably a case of "too
little, too late".
> I wasn't really intending to focus on the particular library which was
> being talked about in that thread. Instead, I was just pointing to
> the comments where Microsoft managers see (1) cross-platform as
> something "uninteresting" and not in their interest and (2) that they
> saw Java as something to be "stolen" and modified, e.g. "embraced and
> extended." I think Microsoft .NET is embracing the core tenets of the
> concept behind Java/JVM, adding the chief extension that it _won't_ be
> cross-platform by design.
I do not think that you can draw conclusions on what .NET is based on
a 1997 exchange between two middle managers.
I would argue that Microsoft probably has internal cross platform
builds of .NET that one day might come in handy. But they have also
built a multitude of CLRs for different setups: the regular one, the
"Compact" one, and now the "micro" one.
And we know that the CLR is portable to Unix (Rotor is basically the
CLR, where they stripped the high-end JIT and some other high-end
features and inserted some joke of a JIT instead).
> if (CheckVM.isMono()) {
> Environment.Exit()
>
> }
>
> in some core CLR library.
>
> :-)
You have just proved that you do not know what you are talking about.
So we can scratch your entire fear-based argument based on it.
Explanation: you might have missed the part where "Mono is a fully
open source implementation". We do not use any "core CLR library"
from Microsoft. It is not legal for us to distribute it. We have
complete re-implementations from scratch.
The *best* they could do is to insert that code into *their software*
to prevent it from running on Mono. But they can prevent that today
more easily with their licensing terms "This software must run on
Windows". Done.
Whatever *they* do, does not mean that the ecosystem of third party
developers *will* do. It is not in a third-party interest to limit
its customers artificially.
> With Windows.Forms, Microsoft essentially made a lot of controls that
> just call the underlying Win32 API natively. "No pretenses of cross-
> platform", as the e-mail thread says, but for a different context.
>
> This means that in order for you to support Windows.Forms "truly", you
> essentially need to support the Win32 API.
Yes, you cant support anything that P/Invokes into the Win32 API.
Luckily you can replace most of those win Linux specific calls, or
port the software.
In my previous post I addressed the percentages of portability. It is
not any harder than porting from the BSD API to the SysV API or back.
And as I stated on my blog entry about the EU, Avalon is actually a
lot easier to support than Winforms precisely for this reason. Unlike
Windows.forms which was a thin wrapper for Win32, with Avalon you wont
benefit in having any Win32 access.
> By the same token, all it takes is for Microsoft to tie some
> "important" piece of .NET to some platform-specific thing in order to
> make it more and more difficult for you guys. Let's say in a few
> months Microsoft ties certain .NET libraries to some special new
> programs/libraries only available in Vista. Suddenly, cross-platform
> becomes harder, because you need to support underlying Vista feature X
> or Y, which is much tougher to implement, especially since it's closed
> source and not necessarily released under some EMCA standard, and
> maybe tied to Windows in certain ways.
You seem to be drowning in a glass of water.
Sure, some applications will not port (based on our Moma reports, 7%
of those apps today are not even worth attempting to port). So what?
It is 7%.
If you really care about portability in that case, you will swap out
the pieces that are incredibly OS-specific.
And btw, this applies equally to Java on say MacOS. If you use the
Cocoa APIs there is *no way* you can port that software unless you
swap out those pieces with something else.
And for that matter, with Java, if you needed a feature that was OS
specific only, and you had to resort to JNI to access it, you have the
same *identical* problem.
Yes, some applications *will* need to be tied to an OS (.NET, Java,
Python, C or *anything else*), but as our reports show, those are a
minority
> But I'm not talking about existing Windows apps, for which Mono is the
> obvious cross-platform choice. I'm talking about writing a new piece
> of F/OSS today, and wanting to ensure it's cross platform. I have a
> few choices: Java, C#/Mono, Python, etc. Unless I target Mono on all
> platforms, then the C#/Mono choice can potentially be dangerous. If I
> do target Mono on all platforms, than Mono is now competing with
> Microsoft's CLR. Which was my point above: if developers target Mono
> on all platforms, you're competing with Microsoft, so be prepared to
> fight.
Lets keep our arguments grounded on earth, shall we?
You can develop with Mono or with Visual Studio, and like Java ("write
once, debug everywhere") you write it, debug it, test it, and Q&A it
on every platform you are going to deploy.
Open source projects can simplify this (ie, other people contribute
the testing on many other platforms and any changes that you might
need), commercial developers still have to test on every platform they
will support.
If people want to use Mono on Windows (and many people do and ship it
as part of their products, for myriads of reasons) that is just fine
with us. And if they want to use "the real .net" instead of Mono in
Windows, that is also, surprisingly, fine with us.
> * I am not just trying to FUD about Mono. I am only worried about
> Microsoft becoming increasingly threatened by it over time, especially
> the more popular it gets.
And I think that there is much more to achieve with Microsoft by
building bridges, discussing overlapping areas, discussing
complementary areas, work together, than taking a fighting position.
Microsoft is changing, it is evolving, it is even embracing open
source in some core projects (See ASP.NET Ajax).
Cheers,
Miguel
andrew.m...@gmail.com
> > * Given Sun's GPL'ing of Java and Microsoft's lack of commitment to
> > the dream of a "cross-platform high level development platform", I
> > think Java, not C#/Mono, should be the first choice F/OSS developers
> > think of when they want to write a cross-platform, open-source
> > application.
>
> You seem to be under the mistaken impression that only Sun and
> Microsoft can write a VM.
Of course I don't think so. For example, I think Python is another
great cross-platform language with no proprietary encumbrances, but
for better or worse Python is hardly ever supported at big firms.
> I think that F/OSS developers are better served by all the extra
> features that the C# and CLR provides. I do not belong to the school
> of self-flagellation just for the sake of using a GPL runtime,
> considering that we have a fully working one (which happens to also
> use way less memory than the other one does :-)
As I said before, I don't think C# provides an "order of magnitude" of
improvement over Java, the way Java provides an order of magnitude
over C. I think Java and C# are in the same "class" of languages,
with C# being perhaps a "more polished" Java. At their core, they are
both garbage-collected, OO languages, and have very similar designs,
with C#'s design being an "evolutionary refinement" of the Java
"passable prototype" you mentioned above.
I don't think it's self-flagellation to write/run Java applications.
I think this a bit of FUD on your part. I like Java about as much as
I like C#, and I've worked on large scale projects on both. The Java
runtime isn't standing still, either: it continues to improve, and
again, continues to do so in a consistently cross-platform way (as
well as making improvements to memory usage/performance). In the
typical software industry two-way feeding frenzy, Java is "stealing"
lots of ideas from C# and has integrated them (e.g., generics,
annotations).
> > * I think we'll benefit much more from F/OSS developers moving en
> > masse from open source C to open source Java (or even Python, etc.),
> > than for them to move C#/Mono. This is because the best CLR
> > implementation for Windows is Microsoft's, and they have way too much
> > control over it (and way too much reason to mess with the way it works
> > to thwart cross-platform efforts).
>
> You should submit the above paragraph to Wikipedia's "Logical Fallacy"
> page to illustrate it.
Fighting words :-)
Perhaps I should have clarified: "F/OSS developers _who care about
cross-platform_".
With Mono, the two possible outcomes are: (1) Microsoft plays nice
with Mono, and code written targeting Mono (or a certain subset
thereof) runs cleanly in the Microsoft CLR, or (2) F/OSS C# developers
target Mono on all platforms, in which case Microsoft sees it
increasingly necessary to treat Mono as competition to .NET, and sees
it in their interest to make interop between Microsoft .NET stuff and
Mono stuff a nightmare. Perhaps the forgotten (3) is the same as
(2), except Microsoft actually believes Mono to be useful and
beneficial to Microsoft, and therefore doesn't try to thwart the
effort. If (3) is true, I'll be very happy because it will show
Microsoft to be a company with much better ethics than hitherto shown,
and it will make the Mono developer's life much easier. I'm skeptical
of (3), however.
> > * Like you expressed in your response, the goal is to take a kernel
> > of an idea and extend it to make it better. In that vein, I hope you
> > see Mono as COMPETING with Microsoft .NET in the future, not merely
> > extending it to be cross-platform. In other words, people will run a
> > Mono CLR on their Windows desktop machines alongside the Microsoft
> > CLR. The reason is because whether you like it or not, you will _have
> > to_ compete with Microsoft in the future, so you better be ready to do
> > so.
>
> Am just not a believer in the scarcity model, and do not believe that
> the ultimate goal is to win and have someone else loose. Am happy
> myself improving the status quo, and in particular making Linux more
> interesting with Mono.
Not a believer in winners or losers either. I do think you are
improving status quo, and you are making Linux more interesting. I'm
very grateful for that -- Mono actually "breathed some life" into a
lot of Linux desktop development efforts.
> Microsoft has a market, Mono has a market. Mono's open source nature
> opens and closes some doors. I am fine with that.
Me too. My fear is that Mono's market and Microsoft's market will
become the same at some point, or at least will be perceived by
Microsoft as being the same.
---
Enjoyed the spirited discussion, and sorry if you took offense to
certain points I raised. I do think Mono is great for Linux and
Windows (and other platforms, lest I forget!), and I think your
arguments here are some of the strongest ones for Mono.
I, for one, have now come to understand where you perceive Mono's
place in the software ecosystem. I sympathize with your pragmatic
view. It's refreshing to have F/OSS developers thinking about the
business side and ISVs rather than lofty speeches about software
Freedom.
Most importantly, I didn't mean to come off as claiming that Mono was
a waste of time, which is where you seem to be getting offended. I
understand perfectly well why Mono was started, why Java wasn't good
enough at the time (both technically and from a licensing standpoint),
and I understand very well the great innovations Mono has made on
Linux, and will continue to breed.
My brand of skepticism comes from years of watching Microsoft embrace
certain competitors only to marginalize them later on. Be aware of
this. Microsoft doesn't always do the Right Thing. In the best case,
when Microsoft evolves .NET they just won't think about "Is this going
to make it hard for Mono?" They'll just implement what works for
them, without thinking about Mono at all. In the worst case, they
_will_ think about it, but the answer will be "Yes, it will make it
hard for them, and _therefore_ it's in our interest to do it."
I think the most important thing is that Mono is good for Linux,
period. Mono is offering a way for Windows apps to get on Linux with
minimal changes, as well as a target for high level development on
Linux itself. This is a Good Thing. Again, you and the other Mono
developers should be proud. I'm certainly proud of you guys! :-)
I only wish I could have made my original post express how much I
appreciate the Mono project, rather than just playing the devil's
advocate and drawing a pro-Mono argument out of you. OTOH, I'm glad I
did so, because you provided a _very_ strong argument for Mono, as
well as shooting down mine, whether they were strawmen or not.
I hope we can end this amicably; I'm not out to make enemies. We're
on the same side, here -- I may be a Mono developer one day! :-)
Andrew
andrew.m...@gmail.com
on :-)
Everything I sent in my last post (which I posted around the same time
you wrote _your_ last post) pretty much still stands.
(I'm keeping my posts in Tomboy so that I can refer to them before
they get moderated/accepted -- how about that for eating your dog
food!)
Your last posts express that you see Microsoft as a changing company
which will embrace Mono, rather than taking a fighting posture. I
think if this is true it's great not just for Mono but for the entire
software industry. And as I said in my last post, Mono is itself
great for the software industry, so well-done on that score! :-)
And I think your MOMA (I can't help thinking Museum of Modern Art :-))
reports do show that perhaps the fear of MS "cross-platform breakage"
is a red herring on my part. So thanks for pointing those out for me.
I guess I should actually be quite happy: with GPL Java and GPL Mono,
we have two strong platforms for "industry-grade" high level
development in the F/OSS community (not to mention hundreds of
scripting language alternatives which have always been there). The
ecosystem is healthier now than it ever has been! Thanks for helping
that happen, and for continuing to improve it.
Andrew
Miguel de Icaza
> I don't think it's self-flagellation to write/run Java applications.
> I think this a bit of FUD on your part. I like Java about as much as
> I like C#, and I've worked on large scale projects on both. The Java
> runtime isn't standing still, either: it continues to improve, and
> again, continues to do so in a consistently cross-platform way (as
> well as making improvements to memory usage/performance). In the
> typical software industry two-way feeding frenzy, Java is "stealing"
> lots of ideas from C# and has integrated them (e.g., generics,
> annotations).
Well, my comments come from people that have had to move from C# to
Java and regret being forced to.
Generics in particular seem to be incredibly poorly done.
> With Mono, the two possible outcomes are: (1) Microsoft plays nice
> with Mono, and code written targeting Mono (or a certain subset
> thereof) runs cleanly in the Microsoft CLR, or (2) F/OSS C# developers
> target Mono on all platforms, in which case Microsoft sees it
> increasingly necessary to treat Mono as competition to .NET, and sees
> it in their interest to make interop between Microsoft .NET stuff and
> Mono stuff a nightmare. Perhaps the forgotten (3) is the same as
> (2), except Microsoft actually believes Mono to be useful and
> beneficial to Microsoft, and therefore doesn't try to thwart the
> effort. If (3) is true, I'll be very happy because it will show
> Microsoft to be a company with much better ethics than hitherto shown,
> and it will make the Mono developer's life much easier. I'm skeptical
> of (3), however.
You keep making these leap of faith conclusions.
(2) if F/OSS developers use C# to target Mono on all platforms, in
Windows this effectively means ".NET", there is no competition
there. With some exceptions there are few reasons to use Mono on
Windows.
You can either run "program.exe"or "mono program.exe" to choose your
runtime, there is really no competition there. Just like you can
choose your JVM on Linux (Sun's or IBMs or someone else's).
> Enjoyed the spirited discussion, and sorry if you took offense to
> certain points I raised. I do think Mono is great for Linux and
> Windows (and other platforms, lest I forget!), and I think your
> arguments here are some of the strongest ones for Mono.
No offense taken.
But you have to work on your premises and your conclusions.
Plenty of your arguments seem to be based on unsubstantiated fears, I
suggest you examine them and deconstruct those. There is no reason
to drown in a glass of water.
> My brand of skepticism comes from years of watching Microsoft embrace
> certain competitors only to marginalize them later on. Be aware of
> this. Microsoft doesn't always do the Right Thing. In the best case,
> when Microsoft evolves .NET they just won't think about "Is this going
> to make it hard for Mono?" They'll just implement what works for
> them, without thinking about Mono at all. In the worst case, they
> _will_ think about it, but the answer will be "Yes, it will make it
> hard for them, and _therefore_ it's in our interest to do it."
That is *OK*. Am glad that Microsoft is doing the right things
with .NET, but if they ever screw up, there is no reason why we should
follow. Whenever they do, we will have to weight the pros and cons.
But preemptively panicking is hardly useful to make decisions.
> I only wish I could have made my original post express how much I
> appreciate the Mono project, rather than just playing the devil's
> advocate and drawing a pro-Mono argument out of you. OTOH, I'm glad I
> did so, because you provided a _very_ strong argument for Mono, as
> well as shooting down mine, whether they were strawmen or not.
heh.
> I hope we can end this amicably; I'm not out to make enemies. We're
> on the same side, here -- I may be a Mono developer one day! :-)
Same here.
Miguel