MS To Release Source Code to .NET Framework Libraries

“One of the things my team has been working to enable has been the ability for .NET developers to download and browse the source code of the .NET Framework libraries, and to easily enable debugging support in them. Today I’m excited to announce that we’ll be providing this with the .NET 3.5 and VS 2008 release later this year. We’ll begin by offering the source code (with source file comments included) for the .NET Base Class Libraries, ASP.NET, Windows Forms, ADO.NET, XML, and WPF. We’ll then be adding more libraries in the months ahead (including WCF, Workflow, and LINQ). The source code will be released under the Microsoft Reference License.”

Yeah. In their dreams, maybe… if you release code, it’s going to be used by someone else.

I predict, in one year’s time, several “competing” versions of .NET will be released, whose sole change will be to occasionally launch advertisements. They will have no technical advantage over vanilla .NET, but they will get broadly advertised, and will be widely adopted by the 50% of the Internet composed of the MySpace generation. These flawed copies will make MS scramble to explain why their cross-platform .NET programs don’t work on Imperfect .NET Implementation XYZ, damaging their reputation, and they’ll only have themselves to blame for releasing the code in the first place.

…damaging their reputation, and they’ll only have themselves to blame for releasing the code in the first place.

Which side of their reputation are you talking about?

The side that is known for keeping interoperability information under lock and key so they can continue to monopolies their position as the world’s no1 desktop?

The side that is known to invite partners to develop for their platform only to release a competing product and bundle it for free with their OS?

The side that bullies OEMs into offering systems with only their OS preinstalled?

The side that is known for trying to take over the internet with an inferior product, then providing operating systems without the security mechanisms needed to securely connect to said internet there by leaving the door open for scrip kiddies to run riot causing millions of dollars in downtime and damages?

How about the side that bankrolls other companies to threatens the only thing it can’t buy, steal from or muscle out of the IT industry, i.e. Linux, and when that fails, starts threatening with bogus IP violation charges it is unwilling (read unable) to provide any evidence for?

These flawed copies will make MS scramble to explain why their cross-platform .NET programs don’t work on Imperfect .NET Implementation XYZ, damaging their reputation, and they’ll only have themselves to blame for releasing the code in the first place.

How does this differ from any OSS project? Forks happen all the time. That’s the risk of releasing source code.

So what if you look at the code? In most parts of the world the only problem is copyright, and it’s not an issue unless you copy and paste the code. Or, to make absolutely sure, you use “clean room” development, where one developer looks at the original code, tells another what it does and the second developer writes new code from scratch, with the same functionality.

Software patents or reverse engineering are an issue only in some countries.

Yes, but all Microsoft have to do is make the allegations. They don’t have to back them up, or prove them conclusively. Microsoft can claim that such and such app is breaking the licence, and it’s up to the app writers to prove otherwise, not Microsoft. MS fires off some cease and desists to the ISP, and before you know it, Microsoft have spun an allegation into an anti-open source, anti non MS-vendor bit of PR.

There’s only so many ways you can make a simple function return an answer. Making other programmers have to tip toe around Microsoft’s specific implementation will slow down development and increase administration. Just look at the audit that had to be done on ReactOS because of Microsoft allegations.

Just look at the audit that had to be done on ReactOS because of Microsoft allegations.

At least spread correct information please. The audit wasn’t done because of MS allegations, but because of allegations of people from inside the project and from related projects. MS never ever approached ReactOS about it.

Microsoft’s track record means they are going to have to prove they don’t have those kinds of nefarious goals.

However, I think some good could actually come out of this. If there are any perceptible people in charge over there, they may start to notice better bug reports, maybe even receive a few high quality patches, and some of the other benefits that come from open source, and begin to really understand the advantages.

Again, they are going to have to demonstrate that they are not evil though. There’s just too much history.

was immediately skeptical about this being some sort of submarine type license, but looks okay..

From the FL

2. Grant of Rights

(A) Copyright Grant- Subject to the terms of this license, the Licensor grants you a non-transferable, non-exclusive, worldwide, royalty-free copyright license to reproduce the software for reference use.

“Reference use” means use of the software within your company as a reference, in read only form, for the sole purposes of debugging your products, maintaining your products, or enhancing the interoperability of your products with the software, and specifically excludes the right to distribute the software outside of your company.

I think you are a bit behind the times, because Java is already free software under the GPL v2 . The source code has been released in the OpenJDK (http://openjdk.java.net) project with some minor binary stubs for those things that cannot be opened up.

The IcedTea project (http://icedtea.classpath.org) attempts to create replacements for these binary stubs with unencumbered free replacements and stubs. It will take some time before it’s complete.

.Net is just a fad that will eventually die out on free software platforms, as there is no reason to come anywhere near it unless you really only strive for Windows compatibility.

Or you could use .NET/Mono because it is likely to be a better runtime since it has the benefits of lessons learned from the Java experience. And having competition allows both platforms to evolve faster.

.Net is not any better than Java except in that it is tied to a single platform (Windows) and can therefore make certain optimizations that are otherwise not available.

It is a lot easier to design something for a single platform/API/processor than it is to try to do what Java does.

.Net has a bit better performance as a result, but it lacks the ability to move stuff between systems – yes, even with Mono which will never be as complete as Microsoft’s .Net implementation is. So your comment is quite a bit off the ball.

I’m not seeing how you get this idea. The .NET class library is tied to Windows, but there is more effort involved in porting the VM runtime between x86, x64, and IA-64 than to other OSes. The VM also runs on ARM.

The singular area in which I could imagine .NET having a performance advantage over Java from being tied to Windows is in exception handling. Java has to be able to deal with Signals from UNIX and SEH in Windows. But SEH isn’t exactly a performance winner and exceptions are… well, exceptional. The underlying OS is not very important to the performance of compiled code except insofar as it calls down to the OS for I/O and gets interrupted by the OS for scheduling and page faults.

Sure, Java has the explicit goal of being portable between OSes. This fact doesn’t prevent Java vendors from writing highly-optimized libraries and runtimes for specific OSes. And they do so. Even Microsoft wrote a JVM that was well-regarded for its performance. .NET is simply an incremental improvement with the lessons of Java in mind.

I’m not seeing how you get this idea. The .NET class library is tied to Windows, but there is more effort involved in porting the VM runtime between x86, x64, and IA-64 than to other OSes. The VM also runs on ARM.

However – all of those are still being written to Windows and the Windows APIs. Where as Java is being written to multiple APIs (POSIX, Windows API, etc.). This can make a big difference in how it performs and the optimizations in the code structure. For example – Signaling (SEH vs. Posix Signals), Error Handling, Threading, Multi-process, Memory models, etc. All of these things change between OS’s, even if in only minor details.

Cross Platform is more than just processor architecture – it is also the Operating System.

Memory models do not change between OSes, AFAIK (I could stand to be corrected if I’m wrong). They’re a facet of the underlying hardware platform. The underlying API might affect the performance of the class library, but the classes that are performance critical are rewritten for each platform anyway, so Java probably uses the exact same mechanisms as .NET on Windows.

As I understand it, Java was designed to be interpreted as well as compiled, while .NET was optimized purely for compilation before execution (and the CLR today doesn’t ever interpret code, AFAIK). The underlying OS shouldn’t make that much of a difference here… and the VMs can be optimized for the target platform anyway. There’s nothing particularly tied into Windows in .NET. In fact, the CLR can be hosted in SQL server which redefines many of the OS primitives to work better for database transactions. In the SQL scenario, .NET does not call directly down into the OS for most important tasks. Instead it calls SQLOS: http://blogs.msdn.com/slavao/articles/441058.aspx.

I have to be honest, though… I do not know if .NET is faster than Java or how much. It may or may not be, but I haven’t done any benchmarking myself, so I’d be hard-pressed to say anything. I’m just trying to argue against your premise that the underlying platform has much of an effect on the speed of executing the Managed Code. I also don’t think a little bit of incremental speed each way makes much of a difference. One would be expected to pick .NET or Java for other reasons than a 10% performance advantage either way. .NET would be chosen for its language independence and Windows support, while Java would be chosen for its maturity and comparative ease of moving applications from one OS to the other (though anyone seriously doing this would need to do significant testing to make sure things really are the same).

#1) Java class library source has been around for at LEAST 10 years, if not since it was first released

#2) The .NET VM is not going to be open, only the API. SUN is just making the move now to open their JVM.

#3) Java needs to watch out more on technical issues, like how .net is language agnostic, C# is java with a bunch of things fixed, and .NET GUI apps don’t suck. MS doesnt need to open their JVM, all they need to do is port it to other platforms (or just get Novell to do it), and that is the final nail in the Java coffin.

1. unlike Sun, Microsoft have a complete system with nice librairies. Microsoft need to keep its gui “modern” against competition (aqua, gtk, qt)

2. Sun is too political. SWT offer a far better alternative (wx in mono/.net/aqua/python), but because it is IBM’s solution, Sun decide not to support it. Yet they fraud their developpers and supporter telling them that people really like swing and that it’s fast.

> Yet they fraud their developpers and supporter telling them that people really like swing and that it’s fast.

Actually sanctus, Swing is quite fast when done correctly. The greatest problem are Swing developers that don’t correctly deal with the event dispatch thread that blocks repainting. With Sun JDK 1.6 update 5 (currently in early release testing) the *entirety* of Swing is rendered in hardware with DirectX on Windows. Pretty hard to get faster than that (unless you continue to block the Event Dispatch Thread).

If we forget the consumer desktop for a moment and consider the corporate/enterprise/government world, Java applications are very widely deployed. I have seen some .NET projects in the enterprises I deal with, and this restricted opening of the .NET libraries is definitely a help for them, but Java is still the “800 lb” gorilla in this space and will probably be for some time.

When SWT came out, swing was slow (even if done correctly) and looked not only foreign, but unappealing. People were complaining about swing for years and Sun just didn’t care a bit. Then IBM creates an amazing alternative that was faster than swing and the interface look native on every platform out of the box. IBM had listened.

It was too late, like Sun often do, before they start improving their product, they wait until customers were frustrated enough and create an alternative. Swing isn’t alone, the whole jvm get nearly stagnant until .net was unveil.

They invest just more money where competition and development effort weren’t needed.

Sun could have work with IBM to make the whole jvm more appealing for developers, business apps as well as end user in one shot. But they didn’t want IBM to receive any credit. They politically played, against java and their customers.

Still today, swing feel foreign even with the nice themes, especially on Linux where it still look crap. Plus, it keeps burden the developer with extra work.

If we forget the consumer desktop for a moment and consider the corporate/enterprise/government world, Java applications are very widely deployed.

That is true, but as a consultant, I work for different clients, big enterprise and government. Java is still being use to develop server application, but when it comes to user interface, .net is becoming the standard. I worked for a government entity with more than 20000 employees that switch officially to .net. The look and feel wasn’t the only issue, but it played big time. What people see is the GUI, if the GUI suck, they entire application/framework get tagged. Sadly, a very large amount of people dislike swing. That’s good for consumer desktop and corporate.

I just hope the open source of the jvm will be more “open” and stop this over political attitude.

It was too late, like Sun often do, before they start improving their product, they wait until customers were frustrated enough and create an alternative. Swing isn’t alone, the whole jvm get nearly stagnant until .net was unveil.

This was because for the longest time Sun tried to have their JVM, which had become the de facto, be nothing more than a reference for others to verify against. Unfortunately for them, it became the de facto standard that everyone used, and they were eventually forced to fix stuff so that it actually worked.

“Reference use” means use of the software within your company as a reference, in read only form, for the sole purposes of debugging your products, maintaining your products, or enhancing the interoperability of your products with the software, and specifically excludes the right to distribute the software outside of your company.

[/blockquote]

So this is nice debugging tool for .net software houses(one of which I work for), but short of some innovative reverse engineering tactics using a third party to review code, useless for mono or dot.GNU

OTOH, since this is “reference” code, some sort of parser could probably be written to extract useful information while shucking any “creative expression”.

The thing is, with tools like Reflector, you don’t really need the source most of the time.

Where this will be incredibly useful is for debugging, now we will actually be able to step through framework classes, which is quite useful, and one of the few things I miss about my Java development days.

This is not open source. At all. It just gives you the right download and distribute copies of the source provided you do not modify it or incorporate it into a product.

Basically, it’s useful so that you can look at how the libraries work to make your own interoperable software (eg Mono).

It is not a submarine patent threat, as the license gives patent rights to anyone using the source, so long as the don’t copy/modify the source. That is, Mono could use it to test compatibility or check how a function works, but they can’t copy the code into Mono. So long as it’s clear that they write the code cleanly, it’s in theory safe.

I have to agree with the conspiracy theories. While I think this will benefit .Net developers I can’t help but think that Microsoft will eventually use this to say open source “stole” from Microsoft. However, the reality is nothing can be done about this. Microsoft has every right to open it’s source code and unfortunately ever right to claim somebody stole from it.

I just hope that if that day comes most people are smart enough to at least smell a rat.

It’s probably true… Microsoft does have a lot of patents, and Linux implements a large amount of functionality. It’s just that Microsoft doesn’t have to show anyone information about this except those from whom it is accepting licensing fees. They don’t want to sue customers and they don’t want to sue end-users, so you won’t see much of this except when they do a deal. The rest will be done quietly in confidential letters to big enterprise customers (the kind who might have a chance of getting Linux “for free” due to their ability to have a large in-house IT staff instead of paying RHAT for support). It is these people for whom the cost of linux must be made non-zero for Microsoft to compete there.

Think of it from Steve Ballmer’s perspective (hard as that may be)… His company gets sued all the time for IP violations. Some are legitimate (the DEC case and the Apple case come to mind), but others are complete junk (cf. Eolas, Alcatel-Lucent). The industry (players like Sun, Novell, RedHat, and IBM) can’t have it both ways: either IP laws apply to everyone or they apply to no one. Open Source does not magically exempt industry players from their obligation under patent law. This was never about individual developers or the independent OSS market… this has always been about big name vendors selling linux to big name customers.

The rest will be done quietly in confidential letters to big enterprise customers (the kind who might have a chance of getting Linux “for free” due to their ability to have a large in-house IT staff instead of paying RHAT for support).

You mean like Google? That strategy doesn’t seem to be going all that well, does it?

It is these people for whom the cost of linux must be made non-zero for Microsoft to compete there.

Microsoft has nothing to do with Linux. Microsoft wrote none of the code. GNU/Linux itself is based on ancient Unix, BSD, POSIX standards and ideas and concepts that can easily be found in old “Unix internals” textbooks. All of this technology pre-dates Microsoft itself.

Linux doesn’t violate Microsoft’s patents. The technology in Linux has nothing to do with Microsoft’s IP.

If anything, Microsoft’s software is more likely to be in patent trouble:

The technology in the Patent Commons in particular tends to pre-date Microsoft.

It is a shame for Microsoft, but the fact remains (despite how much Microsoft try to keep it from being generally known) that for any company that can afford a mildly-competent IT staff, the actual cost of Linux is indeed zero.

We’re talking about patents, not copyright, so it doesn’t matter if Microsoft contributed no code. Are you saying that Linux has not picked up any features since its ancient UNIX roots? Nothing such as an O(1) scheduler that bears a striking similarity to NT’s design from many years before? Or perhaps zero-copy socket APIs that could be a little similar to NT’s versions?

I’m not saying that these are necessarily patent violations (I haven’t even looked up a single patent). What I am saying though is that there could be some core ideas in OS design that NT did first and Linux later adopted. These could be grounds for claiming patent violations… not to mention some features in Linux used to interoperate with NT.

You are right, but then again you, I and MS knows that they don’t have to be believed by the majority. All they need is to plant the seeds of doubt in the mind of one pointy heired manager for them to gain a customer.

Seeming as how they are trying their best to scare of customers as it is (you know, all that WGA and DRM crap), they gotta do something! Right? 😉

I never worked with .Net, so please be patient if I say something inappropriate, but … isn’t this announcement about something you have been used to do for years in Java ?

“offering the source code (with source file comments included) for […] System.Collections” : how many times did you look into java.util.Collection ? maybe a thousand times? How do you manage to understand how your library works if you can’t look into it?

I agree with you. Generally I like to think of libraries as a “black box”. And most Windows and .NET programmers do program that way.

But sometimes you’ll run into a problem that isn’t explained by the documentation. “Why the hell am I getting this exception??” Documentation never covers everything. (Nor would you want it to, as it would unnecessarily bloat the documentation as well as tie it to the particular implementation details of the API, details that may change in future versions of the library.)

And even with the source available, one should not write code that depends on the exact source code since the underlying source can change. But programmers can use their own judgement regarding such matters.

Not sure how much active development you do on .net Molly (you have mentioned your retirement before), but there is a very popular tool called Reflector, which is basically just a wrapper around the reflection apis, that disassembles any dll into very readable code. So, even though we havn’t had access to the libraries, we have had the next best thing for a very long time now.

You covered two very common scenarios, now that we have the source the debugger can actually step through the API. Another one is if you want to extend a control that ships with the framework, you need to know how it works and what to override (extremely common, check out codeproject, codeplex, or any other .net open source site and youll see what I mean.).

(After reading Miguel deIcazas blog, he brings up another scenario I hadn’t thought of, if you use the compact framework, and need some functionality that is in the standard edition, you can just copy the source)

As a side note, I would really like to see MS participate more in cross platform .net. As long as you still need a recompile, they would maintain the application advantage that windows has, while adding significant value to ISVs that are going to be porting anyways.

But this new offering provides the code to a lot of the stuff on top of that lower-level stuff, as well as easily stepping through the .NET code in VS2008. I’m particularly interested in WinForms, WPF, and LINQ.

(I *was* hoping that this would include System.Drawing (it doesn’t appear to), but now that I think of it the System.Drawing code is likely just a bunch of wrapper functions that do little more than call the corresponding GDI+ function, so the source would be of little value there.)

As side note, Microsoft has released code for the purposes of helping developers code and debug before, such as ATL and MFC (and of course, their CRT code).

How do you manage to understand how your library works if you can’t look into it?

The same way people created thousands of applications for Windows (Win32, DirectX, etc) without having the source code for those.. The same way you can use Adobe Photoshop, without having the source code for it – you understand the interface, you don’t really need to see/know the implementation details.

Yes and no. You are very correct as in, if the system has a runtime then the code will run. The only problem with that setup is that only one company, more or less like Java up until recently, has the code and experience to develop and release this runtime (I know that IBM licensed the right to release their own Java runtime, but please bare with me;-). If MS refuses to develop a runtime for competing systems, so that those systems need to provide a reversed engineered implementation of that systems, then it ain’t really a ‘compile once, run anywhere’ solution.

Sun develops give very serious support to as many platforms as they can. Furthermore, these platforms are being given a further bonus by Sun considering opening the source under the GPLV3, thereby attempting to negate any patent infringement issues. Non of these steps have been taken by MS, at least at this time.

The fact remains that, no matter how much verbal help MS gives to Mono developers; If they don’t pitch in with the code, Mono will never be on par.

“The fact remains that, no matter how much verbal help MS gives to Mono developers; If they don’t pitch in with the code, Mono will never be on par.”

I think you will see more actual code coming from MS, especially since Novell and MS are working together on Moonlight. To get maximum value from that partnership, I think MS would be smart to help with Mono

This came out of the blue and I had no inkling of this. I guess it makes sense though because of Reflector. With Reflector (by Lutz Roeder of Microsoft), you can take any function in a .NET assembly and see a pseudo-C# representation of that function (it reconstructs the C# from disassembling the IL). This decompilation ends up being uncannily like the original thing, so it’s about as good as viewing the source without comments. Microsoft isn’t really giving anything away that people couldn’t take before, but they’re bringing the benefits of seeing good .NET code to the average dev who may not use Reflector.

I’ve long thought that Microsoft should release the KMDF and NT Kernel sources under a non-buildable license like the MS-RL. The only reason I say non-buildable is that we don’t want multiple slightly different versions of Windows to get out there (not to mention that Microsoft doesn’t want to lose control of their OS). Maybe if this release doesn’t lead to problems, they will be able to do this.

As Code of Java is already available, MS had to do the same thing to compete. Unfortunately they tend to be “open” only on things where they aren’t holding a de facto monpoly. For that reason we won’t soon see source of directx/3d, win32, network/auth/mail protocols, office formats nor many other API libraries, as those are mantaining their Windows lock-in.

But well, this will be helpful to Mono. Coders won’t have to reverse engineer those libs, they will have help from someone looking at code and feeding them with information on API implementation details and quirks (a clean-room procedure).

But source isn’t everything. It can help, but still much effort is required to reimplement such a huge framework.

This is an important first step in attacking Mono. Making the source available, for all to see, will make it much easier to attack Mono on copyright grounds, either in a court of law, or more likely in the court of legal Fear, Uncertainty, and Doubt. If the code is readily available, it’s easier to convince people that Mono might be full of copyright violations.

Edit: I should clarify that it is likely not the *only* reason for making the source visible. But I imagine it is on their list.

Currently, mono is not even a small threat to them. Being able to tell ISVs that with a recompile, they can port their code to mac or linux is actually quite a plus. Not only that, but we are beginning to see a pattern of genuine cooperation between MS and Novell.

Where mono gets dangerous is when it doesn’t take a recompile to port apps, and anything written for windows also works on Linux. (this is also when WINE would starting getting legal letters too)

Why would you suspect that? Most of the Mono developers work at Novell, with whom MSFT has a interoperability agreement. Mono’s creator, Miguel, frequently meets with Microsoft people and has even been an invited speaker at their conferences.

Furthermore, Microsoft has not sued anyone to date over copyright or patent violations with the exception of Belkin (probably triggered on the complaints of Belkin’s competitors who were paying license fees for the technology in question). I could be mistaken, but I haven’t found any other non-trademark suits with Microsoft as the plaintiff.

I would never presume to play lawyer, and I’d encourage OSS advocates to spend less time worrying about legalisms, so take the following with a grain of salt: if Microsoft is openly allowing Mono implementation to proceed and are even offering technical assistance to its creators, a court of law should IMO consider this as estoppel for any patent claims under these parts.

Miguel stated clearly on his blog that Mono people should not even look at the MS-RL .NET code, so as long as those people are careful, what’s the worry? I think Mono is a fine project and that the outcry against it is a strange allergic reaction within the open source movement.

Open Source advocates need to realize that they have to stop trying so hard to defeat and belittle Microsoft if they really want to gain traction. They should take what they can from Microsoft’s releases of information (carefully verifying that they are not breaking any laws or falling into any traps… which Microsoft is not likely to do these days since they don’t have a very good record of success in the courts). OSS advocates shouldn’t expect or try to force change overnight… instead they should take time to mature their solutions and creep in from their strongholds. Evangelism should be directed at software vendors and hardware manufacturers to increase the strength of the linux developer ecosystem. Evangelizing directly to consumer-level end users does not seem to help in this because they just increase the support burden. Slow and steady is the name of the game in the quest of OSS world domination. (Oh, and ignore ESR and RMS… they are false prophets). Remember, Microsoft doesn’t have to lose for you to win… raging against them is just a distraction.

I can see that I should have made a further edit for clarification. I didn’t say that the lawsuits and FUD campaigns start tomorrow. MS wants to see .net widely adopted. They are willing to see it run on other platforms for now. But in the long term, they want .net to run on Windows and Windows only. (That’s just Business 101, isn’t it?)

That means that they need a kill switch so that they can take over when the time is right.

No. I don’t expect the attacks to begin for some time yet.

Like you say, MollyC, they are buddy-buddy with Novel right now.

Platformagnostic: A campaign based on innuendo about how Mono might not be legally safe would be far more likely than an actual legal attack.

I stand firm against incorporating Mono into our OSS infrastructure. Use Java. Use Python. Use C. Mono is not something that we want to become dependent upon. Too risky. As an incentive for Windows programmers, sure. As a compatibility layer, sure.

One does not have to think MS is the devil to be distrustful of them on this matter.

Besides… I’m not impressed with Mono. I’ve been watching while Tracker, written by a relatively small team of developers in C, has come from far behind, and is currently eclipsing Beagle (one of a small handful of current Mono apps), written in C#/Mono, backed by Novell, and having been handed their core engine on a silver platter in the form of Apache Lucene. (They only had to port it from Java.)

So the “huge” benefits of Mono as a development platform for OSS seem pretty unimpressive, IMO.

It’s really more a matter of “We, The People 101”. Europe has had the balls to *try* to do what we in the US failed to do. I respect them for it. And I wish them luck. They’ll need it. Facing down a whole continent is not beyond the resources of Microsoft. Though it may be cheaper for them to just buy it.

“I can see that I should have made a further edit for clarification. I didn’t say that the lawsuits and FUD campaigns start tomorrow. MS wants to see .net widely adopted. They are willing to see it run on other platforms for now. But in the long term, they want .net to run on Windows and Windows only. (That’s just Business 101, isn’t it?) ”

I gotta disagree with you, as I think the motivation behind this is to keep developers on Windows. They don’t care where the final product actually runs, but if they can sell lots of copies of Visual Studio, then they still win,as every copy of VS needs a copy of Windows.

Being able to say that the code you write will be cross platform, well that’s gravy. One of MSs strengths have always been a strong developer community (MSDN is a great resource), and the recent free versions of VS will only increase the amount of developers on Windows, who hopefully will upgrade to a paid copy when they outlive VS Express’s functionality.

This I believe is one time that MS should, and will encourage the OSS version of their technology, as it is just another conduit to sell VS and Windows.

This is an important first step in attacking Mono. Making the source available, for all to see, will make it much easier to attack Mono on copyright grounds

Much as I think open-source projects should be resisted whenever possible, if Microsoft actually wanted to stop a project they were funding and manning, don’t you think they would just pull their funding and coders first?

You cannot be serious about that statement. If that’s the case, I have no idea how I have been getting a paycheck doing .Net development for the past 5 years. That’s NO VB6, NO classic ASP, NO MFC. Nothing but .Net.

Wrong; in fact, it is in Microsoft’ best interest to promote the use of CLR/.NET technology, even if it’s a third party that makes it possible. It blunts the threat of Java and other competing runtimes. You may not be aware of this, but Microsoft actually works with the Mono team actively on various issues.

I think this provides developers on other operating systems a great insight and the information to make their products interact better in a mixed enviroment while keeping their core beliefs about software.

The read only aspect of this is just as valuable for developers who wish to create cross platform applications to make them interoperable and understand how things are working on the Microsoft side of the software.

This does not mean that Microsoft will go open source or ever for that matter.Here are some things to remember;

1) Microsoft’s stance is Linux and open source are still and always will be direct competition no matter how many agreements they sign.

2) They are trying to follow their antitrust settlement & or satisfy their customers also stay away from any further problems by making consessions.

3) They will always try to create innovative products that will outsell or out preform other venders solutions.

4) They want to progress the computing industry in general while protecting their IP rights to new technology they develop. Why do you ask so the company will be alive & viable in the future no matter which way the industry turns.

Is Microsoft evil because of this? No they are doing anything any other company would do to survive.

“…But like Rotor, the license under which this code is released is not open-source. People that are interested in continuing to contribute to Mono, or that are considering contributing to Mono’s open source implementation of those class libraries should not look at this upcoming source code release…”

“…Sun and Java: it is possible that some customers were getting cozy with the ease of access to Java source code to the class libraries and this had some mounting pressure on Microsoft…”

“…Am still hope that one day Microsoft will open pieces of this under more liberal licenses that would allow those pieces to be used for any purposes, including Mono…”

When trying to assess what Microsoft may intend, I never listen to what they say, instead I look at what they actually do.

The .Net framework includes a new programming language form Microsoft, the C# language. This language is similar to many others in that programs written in the language are not easy to translate into other languages.

When C# and .Net first appeared, the framework and the language could both only be used on Windows platforms, to write programs for Windows platforms. C# is the second language from Microsoft that was designed to be a Windows-only language, the first such language was Visual Basic.

If a compiler and/or runtime environment for a language is available only for Windows, and programs are difficult to translate from one language to another, then both Visual Basic and C# represent a fantastic lock-in opportunity for Microsoft. Programs written in these languages can effectively be constrained from ever becoming cross-platform … there is potential here to have a whole class of programs that are forever tied to being released only for Windows.

Then along comes the Mono project and utterly spoils this wonderful Microsoft vision of source code for applications written in a language that can never be cross-platform …

So, even though it does sound like paranoid ramblings, I am left with a distinct impression that there probably is some substance to what the following article is saying:

Interesting. No denial that C# and .Net was strictly a Windows-only development platform, running only on Windows and capable only of producing applications that were constrained to run on Windows platforms, until such time as Mono was developed.

No comment on the fact that the Microsoft reference License is the most restrictive of the so-called “shared source” licenses, and that in fact the Ms-RL actually allows no sharing of the source code at all (in the typical Microsoft-spin fashion of naming something for the opposite of what it really is):

You make it sound like the Mono project was a surprise and Microsoft never saw it coming. They designed .Net open enough* so it could be implemented on other platforms. Don’t think they didn’t know someone would implement it on another platform. They did.

You make it sound like the Mono project was a surprise and Microsoft never saw it coming. They designed .Net open enough* so it could be implemented on other platforms. Don’t think they didn’t know someone would implement it on another platform. They did.

“While Microsoft and their partners hold patents for CLI and C#, ECMA and ISO require that all patents essential to implementation be made available under “reasonable and non-discriminatory (RAND) terms.” In addition to meeting these terms, the companies have agreed to make the patents available royalty-free.

However, this does not apply for the part of the .NET Framework which is not covered by the ECMA/ISO standard, which includes Windows Forms, ADO.NET, and ASP.NET. Patents that Microsoft holds in these areas may deter non-Microsoft implementations of the full framework.”

Windows forms … “Windows Forms is the name given to the graphical user interface application programming interface (API) included as a part of Microsoft’s .NET Framework, providing access to the native Microsoft Windows interface elements by wrapping the existing Windows API in managed code. ”

ADO.NET … “ADO.NET is a set of computer software components that can be used by programmers to access data and data services. It is a part of the base class library that is included with the Microsoft .NET Framework. It is commonly used by programmers to access and modify data stored in relational database systems”

ASP.NET … “ASP.NET is a web application framework marketed by Microsoft that programmers can use to build dynamic web sites, web applications and XML web services. It is part of Microsoft’s .NET platform and is the successor to Microsoft’s Active Server Pages (ASP) technology.”

OK, so that means you can write .Net programs for other platforms and be safe from being sued by Microsoft so long as your program has no GUI, it makes no database access and it is not a web server-side application.

If your application has any of those elements, then you must write your .Net application for Windows only, according to Microsoft licensing.

Hmmmmmm …

<sarcasm>I suppose that is “open enough” … for vanishingly small values of “enough”.</sarcasm>

Apparently it’s you who can’t even read what I actually said and instead read what you wanted me to say.

You actually said: “They designed .Net open enough* so it could be implemented on other platforms.”

I showed you how that was false ==> “OK, so that means you can write .Net programs for other platforms and be safe from being sued by Microsoft so long as your program has no GUI, it makes no database access and it is not a web server-side application.”

In simpler words, you cannot write any actually useful .Net program targeted for a non-Windows platform without employing some part of .Net which Microsoft has NOT agreed to license even under RAND terms, let alone royalty-free terms.

In simpler terms still, .Net is NOT cross-platform capable, even though people other than Microsoft have written development environments for other platforms that are intended to be compatible with .Net.

Gpremacy is an implementation of the board game Supremacy written in Mono/Gtk#.

iFolder 3 (by Novell) lets you share files across multiple computers and with other users through peer-to-peer or Novell’s groupware server products.

imeem a social networking software. Mac client and servers run Mono while the Windows client uses Microsoft.NET.

libsecondlife is an open source implementation of the Second Life networking protocol written in C# that will run under Mono or .NET.

MindFire is a cross-platform ebook reader designed to facilitate speed reading.

MonoDevelop is an IDE for creating Mono applications. It was originally a port of SharpDevelop to Gtk#, but is today developed on its own. A Windows installer is not provided, but it can be built and run on Windows[10].

Muine is a music player with a user interface designed to be intuitive, developed by Jorn Baayen who also worked on Rhythmbox.

Second Life, the virtual world created by Linden Lab, will in the future be compiling all of the scripts in their own Linden Scripting Language (LSL) to CIL. They will use an embedded Mono runtime to execute the CIL.

SkyNET is a sky chart application.

smuxi is an IRC client for advanced users written with Gtk#/Gnome#, SmartIrc4net and Nini.

Tomboy is a desktop note-taking application which uses a wiki-like linking system.

Unity is a game engine using Mono for game scripting.

Vault, a source control product from SourceGear that works on Linux and Mac with the use of Mono

While Microsoft and their partners hold patents for CLI and C#, ECMA and ISO require that all patents essential to implementation be made available under “reasonable and non-discriminatory (RAND) terms.” In addition to meeting these terms, the companies have agreed to make the patents available royalty-free.

However, this does not apply for the part of the .NET Framework which is not covered by the ECMA/ISO standard, which includes Windows Forms, ADO.NET, and ASP.NET. Patents that Microsoft holds in these areas may deter non-Microsoft implementations of the full framework.

We can tell because even though Windows Forms (as just one example) is part of the .Net framework, it is not part of the ECMA/ISO submission, and is NOT licensed by Microsoft at all (not even under RAND terms). Ergo, according to Microsoft, you can only run any program written to interface via Windows Forms on a Windows platform. Compiling such a program under Mono to run on any other platform is an act that is not licensed by Microsoft.

Any program written in .Net and which uses Gtk#/Gnome# for GUI elements (ie designed to be cross-platform) is OK, it is only programs which use the .Net default GUI API (Windows Forms) that would be a problem.

It is not that Mono cannot implement Windows Forms functions that would be the problem, but rather the problem is that Mono does have a near-complete implementation of Windows Forms, and Windows Forms is not part of ECMA standards ECMA 335 and ECMA 334 nor is it part of ISO/IEC 23271 and ISO/IEC 23270. Microsoft has not licensed anyone to implement Windows Forms.

The reason in turn for that is that .Net programs (using Windows Forms) are supposed to be (as in, intended by Microsoft to be) Windows-only.

I thought this was all clear enough from my previous posts, but apparently not.

“Any program written in .Net and which uses Gtk#/Gnome# for GUI elements (ie designed to be cross-platform) is OK, it is only programs which use the .Net default GUI API (Windows Forms) that would be a problem.”

Some of those apps I listed DO use Gtk#. So your argument is already out the window and you are blatently WRONG.

Some of those apps I listed DO use Gtk#. So your argument is already out the window and you are blatently WRONG.

Not at all.

My point is not that you are unable to write cross-platform applications in .Net but rather my point is that by default you will find you have written a Windows-only application (locked in forever to be able to run only on a Windows platform) if you use .Net unless you go out of your way to use a non-standard GUI library not provided by Microsoft.

The fact that there are a few cross-platform .Net/Mono applications using the non-standard non-Microsoft GTK#/GNOME# GUI libraries is utterly irrelevant to the main point that Microsoft’s .Net offering is Windows-only. Most applications written in .Net will end up being Windows-only application due to the fact that they use Windows Forms rather than the non-Microsoft-supplied GTK#/GNOME#.

My point stands.

Just a hint for you sappyvcv … the trick in debating lies in arguing against what the other person is actually saying, and not arguing against some other similar-sounding line which is not actually their point.

My point is not that you are unable to write cross-platform applications in .Net but rather my point is that by default you will find you have written a Windows-only application (locked in forever to be able to run only on a Windows platform) if you use .Net unless you go out of your way to use a non-standard GUI library not provided by Microsoft.

See, you keep changing what you “meant.” You keep getting more and more specific until your point matters little.

The fact that there are a few cross-platform .Net/Mono applications using the non-standard non-Microsoft GTK#/GNOME# GUI libraries is utterly irrelevant to the main point that Microsoft’s .Net offering is Windows-only.

But perfectly relevant to your original stated point.

My point stands.

Your new point stands.

Just a hint for you sappyvcv … the trick in debating lies in arguing against what the other person is actually saying, and not arguing against some other similar-sounding line which is not actually their point.

I think you mean “the trick in debating lies in knowing what the other person meant to say and not what they actually said”, because that’s what happened here.

Actually, I didn’t. I just tried to explain it to you. I know I need to be patient with you, because it is clear you are a bit slow and have limited reading comprehension.

But perfectly relevant to your original stated point.

How so?

Here is what I actually wrote (and which you even quoted).

“We can tell because even though Windows Forms (as just one example) is part of the .Net framework, it is not part of the ECMA/ISO submission, and is NOT licensed by Microsoft at all (not even under RAND terms). Ergo, according to Microsoft, you can only run any program written to interface via Windows Forms on a Windows platform. Compiling such a program under Mono to run on any other platform is an act that is not licensed by Microsoft.

Any program written in .Net and which uses Gtk#/Gnome# for GUI elements (ie designed to be cross-platform) is OK, it is only programs which use the .Net default GUI API (Windows Forms) that would be a problem.”

Before that post, I said this:

In simpler words, you cannot write any actually useful .Net program targeted for a non-Windows platform without employing some part of .Net which Microsoft has NOT agreed to license even under RAND terms, let alone royalty-free terms.

In simpler terms still, .Net is NOT cross-platform capable, even though people other than Microsoft have written development environments for other platforms that are intended to be compatible with .Net.

Before that I said this:

If your application has any of those elements, then you must write your .Net application for Windows only, according to Microsoft licensing.

(Note that GTK#/GNOME# is not licensed by Microsoft, and it is not .Net but rather it is a 3rd party extension to .Net).

In other words, it was my position all along that .Net on its own (that which was supplied by Microsoft) is not cross-platform capable. You have to get extensions to .Net (supplied by FOSS developers, not by Microsoft) before you are able to write cross-platform applications.

I think you mean “the trick in debating lies in knowing what the other person meant to say and not what they actually said”, because that’s what happened here.

Nope. No change to my position the whole way through. You just chose to misread it that way. You are wrong yet again … you must be getting very used to that by now.

Actually, I didn’t. I just tried to explain it to you. I know I need to be patient with you, because it is clear you are a bit slow and have limited reading comprehension

Sorry kid, but you keep slightly modifiying your statement.

1.

OK, so that means you can write .Net programs for other platforms and be safe from being sued by Microsoft so long as your program has no GUI, it makes no database access and it is not a web server-side application.

[We know this to be false]

2.

In simpler words, you cannot write any actually useful .Net program targeted for a non-Windows platform without employing some part of .Net which Microsoft has NOT agreed to license even under RAND terms, let alone royalty-free terms.

[Here you added “actually useful” (which I showed to be false anyway).]

3.

My point is not that you are unable to write cross-platform applications in .Net but rather my point is that by default you will find you have written a Windows-only application (locked in forever to be able to run only on a Windows platform) if you use .Net unless you go out of your way to use a non-standard GUI library not provided by Microsoft.

[Here you add in that if you write for Windows using Windows-specific libraries]

I’m done with you. You’ve already proved in the past that you have no skills for critical thinking.

Microsoft cannot be trusted, ever. This has trojan horse written all over it and the Mono devs on the OSS side better steer clear of this at all costs. Excellent article by Steven Vaughn-Nichols on this subject over at eWeek.

Complete and unfettered access to .Net symbols and source code files equals a much better debugging experience from within Visual Studio. No more just watching your call stack disappear into the bowels of .Net only to have it reappear with values that don’t seem correct to you. Now it’ll be simple to trace your application execution from beginning to end without just having to guess what the framework is doing with your data structures.

” Novell picked up the 39 important business-to-business electronic commerce and Web services patents from bankrupt Commerce One, and the company has declared its intention to use them to protect its open-source offerings.”

Mutually assured patent destruction (at least in the US), it looks like. At least, that is what Microsoft seems to be wanting to initiate. The end of the IT industry in the US, no less …

Your “Another viewpoint” is yet another article with no credibility. The reason I say that is that it starts right off the bat with the insinuation that Microsoft is pretending that this code released under MS-RL is being released under an “open source” license in order trick devs into believing that, when Microsoft has NEVER claimed that this was “open source” code, and has NEVER claimed that MS-RL is an “open source” license.

Microsoft is not laying any “trap”. They make no claims that this is “open source”. They make no pretense that this is “open source”. Those that accuse them of such, either explictly or implicitly, have ZERO proof.

Anyone that is working on an alternative implementation of .NET or a .NET-like thing should be leary of looking at this MS-RL code, just as one should be leary of looking at ANY code that is not licensed under terms that allow said code to be used in another (particularly competing) project, but that doesn’t mean that the party that released the code is laying a “trap”. Those that would fall into such a “trap” by using code in an unauthorized manner have only themselves to blame, not those that released the code in the first place.

Note that Mono is not allowing any of its contributors to look at this code, because Microsoft makes it clear that the code is NOT open-source.

Microsoft is not laying any “trap”. They make no claims that this is “open source”. They make no pretence that this is “open source”. Those that accuse them of such, either explicitly or implicitly, have ZERO proof.

Microsoft call the Ms-RL reference license one of its “shared source” licenses.

To be fair, Microsoft describe the Ms-RL as a “non-open source shared source license”. This is a classic case, once again, of Microsoft naming something for the opposite of what it really is.

Shared Source means MS sharing the source with you, not the source being sharable in a more general sense.

It is very enlightening to compare the terms of this Ms-RL license with the terms of Java.

I assume you aren’t talking about before the very recent reliscencing of the JDK, because before november of last year, the source code for the java class library was available under more or less the same terms for more or less the same reasons, and those reasons were not to trap open source implementations into viewing it.

Clearly, anyone wishing to do anything cross-platform should avoid the .Net framework like the proverbial plague.

because the class libraries for the windows implementation are not open source? I am a bit confused by how this announcement relates negatively to the Novell implementation of ECMA-335….

“Funnily enough, the Ms-RL does not actually allow the source to be shared at all. “

Oh please.

They are sharing the code under terms that you can use it as a reference (which includes browsing through the code and stepping through it with a debugger). It’s still sharing the code.

If I wrote a short story for my own enjoyment and then decided to give you a copy to read, then I’m *sharing* the story with you, even if I retain the copyright on that story (and use the copyright powers to prevent you from altering it and/or redisitributing it without my authorization).

BTW, Miguel has responded to both of the articles you cite, and ridicules both for claiming that Microsoft is laying “traps”.

They are sharing the code under terms that you can use it as a reference (which includes browsing through the code and stepping through it with a debugger). It’s still sharing the code.

Oh please yourself.

Most programs written using .Net are written to utilise Windows Forms as the API for the GUI interface.

Mono has a partially-complete and independent implementation of Windows Forms that allows people to make versions of many of their applications from the same source code such that the application can now run on platforms other than Windows.

As the Mono version of Windows Forms improves, more and more applications written using the .Net framework will be able to be compiled and work properly on other platforms.

Microsoft has not licensed the Windows Forms technonlogy to anybody, and has deliberately excluded Windows Forms from being part of .Net-related standards submitted to ECMA and ISO.

So, as Mono nears completion, with only the curly bits of Windows forms left to go, Microsoft suddenly releases source under the “look but don’t even think about using” Ms-RL. There can be no doubt at all that the hope here from Microsoft is that some Mono developers will actually look at the .Net code to get ideas on how to finish Mono.

Even if the Mono developers don’t even look at .Net, Microsoft will still have a viable “attack vector” for Mono (claiming that the developers copied ideas if not literal code from .Net) for any piece of Mono that is submitted from this time onwards.

Microsoft will be able to tie Mono up in FUD (if not in the courts) for years, even if Mono does nothing at all wrong. Alternatively, Microsoft will be able to insist that SuSe Linux is licensed to run Mono and applications made using Mono, but no other Linux version is. This is a sound tactical move from Microsoft. Microsoft are getting quite good at these underhand sorts of tactics by now, having practised them diligently for over a decade.

Personally, I’m wondering if Microsoft will release their networking code under the Ms-RL soon as well. This would perhaps have (in Microsoft’s thinking anyway) the dual purpose of perhaps appeasing the EU, while at the same time providing a similar “attack vector” against Samba. It would have no real downside, because under the Ms-RL no competitor can use the source, even though Microsoft call it a “shared source” license just to confuse the issue.

Didn’t Microsoft already offer up source code to the EU in place of specifications, but the EU wisely rejected it?

I’m fairly certain that most of Microsoft’s patent allegations would turn out to be so much bluff and bluster if the actual allegations ever came to light. This is the real reason why Microsoft does not reveal what patents it is talking about, and it is also the reason why Microsoft will not sue over these alleged patent violations in Linux.

Since Microsoft will not sue, and since also there is a patent portfolio at the ready for any required counter suit, I believe that sooner rather than later this particular patent rumblings tactic by Microsoft will fade away into nothingness.

On this thread, the point has been raised that vital parts of Microsoft’s .Net framework are not licensed by Microsoft to anyone else, raising the spectre of Microsoft being able to make a patent claim against any program using say Windows forms (part of .Net) but running on a different platform (ie. compiled with Mono).