Hi Miguel,

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?

Hello,

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.

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).

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.

Miguel,

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:

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?

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?

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.

Which is great -- I agree, this is how innovative software gets built
on top of old stand by approaches like MS Excel.

Sometimes it's a good idea to add extensions to the language, but you
have to be aware that you're gonna break something.

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.

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.

Right, this is always necessary -- true cross platform (i.e., write
once, run everywhere) is hard.

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?

Admirable goal: many developers have C# knowledge due to their work,
and want to play with Linux at home.

Practical goal, and I think this is a good reason to have a C#
implementation on Linux.

Good point.

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.

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.

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.

...

read more »

Hello Andrew,

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.

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 ;-)

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.

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 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.

Well Duh.

See above.

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.

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.

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.

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".

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.

Glad you agree with the email thread from Microsoft.

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.

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.

...

read more »

Hello,

    A google cuts long posts, will reply to the last bits:

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 :-)

You should submit the above paragraph to Wikipedia's "Logical Fallacy"
page to illustrate it.

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.

My own follow-up.

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.

Hi Miguel,

On Feb 3, 8:07 pm, "Miguel de Icaza" <miguel.de.ic...@gmail.com>
wrote:

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.

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.

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.

And you got it on Linux.  Great work :-)

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.

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.

I guess, except Microsoft's agenda can tie people to the Windows
platform and thus not give innovative software on other platforms a
chance.

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.)

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."

<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.

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.

I agree, this is the great benefit of Mono.  And the most threatening
one to Microsoft, from a business standpoint.

:-)

OK, again sorry for miscommunication on this.  But I think GPLv2 Java
does change things for developers, as in above.

I read every word, please don't get offended.

...

read more »

Hello,

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").

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.

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.

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.

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.

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.

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.

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" ;-)

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.

Exactly.

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

Hello,

   Continuation, I must learn to use Google groups the next time.

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 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).

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.

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.

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

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.

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

Hi again,

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.

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).

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.

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.

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

OK, no more quoting because otherwise the discussion will go on and
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

Hello,

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.

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).

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.

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.

heh.

Same here.

Miguel