News: .NET framework source code available soon...

[Frans Bouma [C# MVP]]

But what does Microsoft say? A lot of people, especially those who
are more inclined to work with open-source and especially with Linux,
have a tendency to view Microsoft as a monolithic, power-hungry,
lawyer-driven company. And as with all great myths, there's probably
at least some grains of truth behind that view.

What's the relevance of what MS says, other than what's in their
reference license? That license has all what MS has to say about it. If
you don't agree with it, don't accept it and don't look at the code.
However if you DO accept it and DO look at the code, you're doomed to
do things on projects you might have been a great help for. I once
looked at the rotor code (very first beta version), actually only the
compiler. However by doing that, I accepted the license it came with
and I can't work on mono stuff now.

But without any evidence that suggests Microsoft's own position is
that looking at .NET code causes a person to be legally unqualified
to work on Mono, it's just rumor-mongering and not necessarily by
people who normally view Microsoft in a positive light anyway.

It's precaution: if you haven't looked at the code, you can't literaly
copy/paste the code: you HAVE TO write it yourself. Changes are that
the code will likely look different from what MS wrote as you have to
solve problems yourself. It's not about 'MS is evil', it's about
protecting the Mono code from lawsuits which they could have prevented.

(Note: at this point it's been well-explained that the Microsoft
license would not permit the legal use of their source code as a
foundation for Mono or similar projects. So at this point, my
original question has been answered and I believe I understand that
answer. I'm just following the subsequent questions that now apply
in that context).

So, no...you can't just port the .NET source code over to other
platforms. But where's the basis for the claim that you can't work
on Mono and also step through .NET code when you're debugging
something else?

because you've access to code which you could copy/paste or learn how
it works inside and reproduce it for mono, which would make Mono look
like it has copy/pasted MS code and thus that it's open for a lawsuit.
It's simple copyright 101. Also, the MS code has a lot of patents on it.

You are already at risk for legal action, if you happen to produce
code that "looks" like their code. Especially if you work on Mono.
Even without source code, it is not difficult to reproduce in
separate source code the same algorithms used in a given piece of
software, if that's your intent and you use the compiled software
you're trying to emulate a as a reference.

that's not that clear, as when you wrote it, you can produce
sourcecode history, design documents etc. which are the foundation of
your code. True, if you implement an algorithm which is patented by the
retarted US patent office, then yes, you're open for a lawsuit, but you
can't defend yourself against that. (e.g. ms has a patent for o/r
mapping which is violated by hibernate)

Working on Mono, you are intentionally trying to reproduce the
behavior of the .NET Framework, and even without inspecting the
compiled .NET Framework code it would not be surprising if you should
happen to on occasion implement things in the same way they are
implemented in .NET. But how are you to prove to Microsoft in those
cases that you didn't actually use their compiled code as a reference?

it's THEIR job to proof you DID copy it. If you have never accepted
the license of this sourcecode, you have never been able to look at it.
Therefore it's harder for them to proof that you did copy it.

They don't have to show you their source code for them to file legal
action on the basis of a copyright violation.

the sco case proofs that they have to. It would also be silly to claim
copyright infrigment without proof that someone indeed copied your
work, aint it?

It seems to me that what puts you at risk for legal action (such as
that risk may be) is the fact that you work on Mono. This is true
even without the .NET source code.

Microsoft didn't need access to the Stacker source code for them to
be sued over DoubleSpace. All they needed was an implementation that
looked sufficiently like Stacker's implementation.

though there's jurisprudence for reverse engineering (compac bios case
if I recall correctly) that you may reverse engineer IF you don't have
the sourcecode.

Anyone may sue you one day, it depends if they have a case or not.
What you and I can do is protect ourselves from losing these lawsuits.
There's no protection possible against a lawsuit being filed against
you, though you can protect yourself (at least try) against losing
these because the other has a strong case against you.

That's also why the license this code comes with is evil and everyone
looking at sourcecode on the internet should REALIZE that you only
should do so if you understand the license the code is distributed
under.

Well, that's true of any published source code that carries an
attached license. Even regular "open source" stuff generally
includes various license requirements that can form the basis of a
lawsuit of someone believes you misused the source code.

So, for example, either you cannot look at any source code covered by
the GPL, or you must provide all of the disclosures and other
requirements made by the GPL, even if you did in fact not actually
intentionally reuse the source code you looked at. If you want to
follow the legal liability philosophy you're stating, that is.

Only if you copy the code. The GPL doesn't grant patents to be upheld
by the copyright holder if I'm not mistaken.

Granted, in your specific case dealing with an open-source project
your own work may naturally already comply with the GPL, even if you
don't have a need to. But the more general "problem" still exists;
it's certainly not unique to Microsoft's publication of source code
here.

As far as the question of actually being sued goes...

Not having any legal expertise, I wouldn't even try to make a claim
as to the reality of the situation. However, I suspect that fears of
legal action are highly over-inflated for a given individual,
assuming no actual misuse of the code happened (that is, assuming you
didn't actually copy the code or some non-obvious technique, that
sort of thing).

Granted, there's a lot of gray area, but I think an individual
worried about being sued by Microsoft has, in most cases, a
perception of their value to Microsoft that is probably too high.

You'll never know if that might change in the future. Most developers
are most of the time simply not thinking about licensing issues when
they write code. That's utterly stupid, IMHO, but reality. I think
people should wake up and realize that reality is different: if you
write code and it WILL be successful, it might be that MS will sue you,
or maybe another company will... Protect yourself from losing these
lawsuits.

Also, if MS does something bad to YOU, you can't win a lawsuit against
them if they have a strong case against you in another area.

FB

--
------------------------------------------------------------------------
Lead developer of LLBLGen Pro, the productive O/R mapper for .NET
LLBLGen Pro website: http://www.llblgen.com
My .NET blog: http://weblogs.asp.net/fbouma
Microsoft MVP (C#)
------------------------------------------------------------------------

 

[Frans Bouma [C# MVP]]

Will I no longer need Lutz Roeder's Reflector? I was going to be
learning that, but now I'm wondering what the value may be of his
Reflector if we can now get right into the BCL source itself.

Thoughts ?

If you don't accept the reference license, you have to use reflector.
Reflector reverse engineers the IL, which makes you less vulnerable for
lawsuits than the reference licensed code makes you.

FB



--
------------------------------------------------------------------------
Lead developer of LLBLGen Pro, the productive O/R mapper for .NET
LLBLGen Pro website: http://www.llblgen.com
My .NET blog: http://weblogs.asp.net/fbouma
Microsoft MVP (C#)
------------------------------------------------------------------------

 

[Frans Bouma [C# MVP]]

That's pretty cool, especially that we can debug into the source code
right from within Visual Studio. I guess that means Microsoft finally
gave up the fight against Reflector.

Doesn't Roeder work for MS nowadays?

FB
--
------------------------------------------------------------------------
Lead developer of LLBLGen Pro, the productive O/R mapper for .NET
LLBLGen Pro website: http://www.llblgen.com
My .NET blog: http://weblogs.asp.net/fbouma
Microsoft MVP (C#)
------------------------------------------------------------------------

 

[Jon Skeet [C# MVP]]

If you don't accept the reference license, you have to use reflector.
Reflector reverse engineers the IL, which makes you less vulnerable for
lawsuits than the reference licensed code makes you.

I'm not sure that it does - I'd be very surprised if the licence
for .NET didn't prohibit reverse engineering. I know reverse
engineering is legal (despite the licence) in some countries for the
purpose of compatibility testing, but I don't think it would help you
if you were accused of copying the code itself.

Jon

 

[Mads Bondo Dydensborg]

But what does Microsoft say? A lot of people, especially those who are
more inclined to work with open-source and especially with Linux, have a
tendency to view Microsoft as a monolithic, power-hungry, lawyer-driven
company. And as with all great myths, there's probably at least some
grains of truth behind that view.

But without any evidence that suggests Microsoft's own position is that
looking at .NET code causes a person to be legally unqualified to work
on Mono, it's just rumor-mongering and not necessarily by people who
normally view Microsoft in a positive light anyway.

What I was stating was the consensus of the Mono developers (as I see it).

From:
http://www.mono-project.com/Contributing

---
Special Note
If you have looked at Microsoft's implementation of .NET or their shared
source code, you will not be able to contribute to Mono.
In general, be careful when you are implementing free software and you have
access to proprietary code. We need to make sure that we are not using
someone else's copyrighted code accidentally.
Do not use the ildasm, reflector or other equivalent tools program to
disassemble proprietary code when you are planning to reimplement a class
for Mono. If you have done this, we will not be able to use your code.
Please stick to published documentation for implementing any classes; when
in doubt, post to the mailing list and discuss the possible approaches with
others.
---

But where's the basis for the claim that you can't work on
Mono and also step through .NET code when you're debugging something else?

Thats a requirement the mono folks has. I believe it is for good reason. You
do not.

It seems to me that what puts you at risk for legal action (such as that
risk may be) is the fact that you work on Mono.

This is well within what is legal in my country. (Denmark).

So, for example, either you cannot look at any source code covered by
the GPL, or you must provide all of the disclosures and other
requirements made by the GPL, even if you did in fact not actually
intentionally reuse the source code you looked at. If you want to
follow the legal liability philosophy you're stating, that is.

And, some companies enforce this policy, actually.

As far as the question of actually being sued goes...
[..]
I think your concerns are overblown. But I'm not qualified to give
legal advice, so I won't try to argue the point. If you feel that
working on Mono and also in other situations using the .NET source code
are mutually exclusive, it's certainly true that that's the safest bet
if your highest priority is to avoid legal trouble at all costs.

The concerns are very real for my management. I work for at company that
deals a lot in copyright (library supplier, books, electronic media, etc)
and it is of uttermost importance, that we deal correctly with any aspect
of copyright.

Lawyers takes these issues seriously, you know.

Regards,

Mads

--
Med venlig hilsen/Regards

Systemudvikler/Systemsdeveloper cand.scient.dat, Ph.d., Mads Bondo
Dydensborg
Dansk BiblioteksCenter A/S, Tempovej 7-11, 2750 Ballerup, Tlf. +45 44 86 77
34

 

[Willy Denoyette [MVP]]

Doesn't Roeder work for MS nowadays?

Sure he does, coming from MS Research and since 2002 on the Blend team.

Willy.

 

[Chris Shepherd]

I hope Microsoft doesn't bundle the licence agreement for access to the
source code with the licence agreement for any other products like Visual
Studio 2008 or others. If they do, they can sue customers who have viewed the
source code for having done so and taken ideas from it. I wouldn't want to
view the source code for such a price. And for that reason, I wouldn't want
to be in a situation where if I had agreed to the licence agreement for, say,
VS2008, I would, by default, be also agreeing to the licence agreement for
the source code.

From what I've seen posted here/read it sounds as though it will be
entirely separate.

I actually loved .NET. Java is so slow doing everything. I haven't bothered
to learn Ruby or Python. I can't stand Linux for being so programmer
unfriendly. And I had left C++ behind for a long time.

I really don't find Java slow for anything but GUI stuff. I've written a
lot of web services and server-type applications in Java though. It also
rocks on cell phones.

As for Linux being "programmer unfriendly" I have to completely
disagree. Your later comment that most stuff has to be done on the
command-line is also really wrong, at least in the more recent versions
of distributions I've used (Ubuntu, Fedora Core, and OpenSuSE). I don't
want to start a holy war at all, but I would just say my experiences of
doing daily development on both platforms, Linux made my life as a
developer far and away easier than Windows did.
Obviously I'm not complaining about Windows dev, I live with it every
day at home and at work.

Chris.

 

[=?ISO-8859-1?Q?Arne_Vajh=F8j?=]

But what does Microsoft say? A lot of people, especially those who are
more inclined to work with open-source and especially with Linux, have a
tendency to view Microsoft as a monolithic, power-hungry, lawyer-driven
company. And as with all great myths, there's probably at least some
grains of truth behind that view.

But without any evidence that suggests Microsoft's own position is that
looking at .NET code causes a person to be legally unqualified to work
on Mono, it's just rumor-mongering and not necessarily by people who
normally view Microsoft in a positive light anyway.

Unless MS put it in writing in a legal binding form, then Mono and
other projects would still be worried.

I can be solved.

Before Java went GPL there was a Java Research License which
allows it.

http://java.net/jrl.csp

Quote:

***
B. Residual Rights. If You examine the Technology after accepting
this License and remember anything about it later, You are not
"tainted" in a way that would prevent You from creating or
contributing to an independent implementation, but this License grants
You no rights to Sun's copyrights or patents for use in such an
implementation.
***

And FAQ answer from same link:

***
18. Does the JRL prevent me from being able to create an independent
open source implementation of the licensed technology?

The JRL is not a tainting license and includes an express Òresidual
knowledgeÓ clause which says you're not contaminated by things you
happen to remember after examining the licensed technology. The JRL
allows you to use the source code for the purpose of JRL-related
activities but does not prohibit you from working on an independent
implementation of the technology afterwards. Obviously, if your
intention is to create an ÒindependentÓ implementation of the technology
then it is inappropriate to actively study JRL source while working on
such an implementation. It is appropriate, however, to allow some decent
interval of time (e.g. two weeks) to elapse between working on a project
that involves looking at some JRL source code and working on a project
that involves creating an independent implementation of the same technology.
***

MS could do something similar.

Arne

 

[=?ISO-8859-1?Q?Arne_Vajh=F8j?=]

No, you are not.


Copyright does not cover duplication of function or even accidental
recreation of the same exact program text, only intentional copying.
Hence "copy"right.

What you are thinking of are software _patents_ which is entirely
different. Patents must be explicitly filed for specific pieces of
functionality, they are not valid outside America and I think Japan,
and they are subject to interpretation by a judge regarding whether
the patented functionality is patentable at all.

No. I think they are thinking of license violation.

Unlike patents, however, such licenses only apply to people who
actually acquired & used the software, and agreed to the license.

Any license that tried to prevent the user from duplicating the
software's functionality, patent-style, would be null and void. The
power of licenses, like copyright, is restricted to the actual product
as it is. They cannot regulate independent recreations.

I don't think I would like to base an important product on that
assumption.

Considering that MS and SUN seems to have a different opinion.

Arne

 

[Brian Gideon]

I'm sure the net will be buzzing with this news fairly soon, but just
in case anyone hasn't seen it yet:

Microsoft are going to make the source code for the .NET framework
(parts of it, including the BCL, ASP.NET and LINQ) available both for
viewing and debugging into.

I won't go into all the details here, as they're covered on Scott
Guthrie's blog:

http://weblogs.asp.net/scottgu/archive/2007/10/03/releasing-the-source-
code-for-the-net-framework-libraries.aspx

Any comments?

That's pretty cool. Just the other day I was trying to figure out the
runtime complexity on one of the methods in the BCL using Reflector.
The code it generates, although good, is still hard to follow so
having the actual code will be helpful.

 

[Chris Nahr]

No. I think they are thinking of license violation.

Who is "they"? If you're talking about me, I can assure you that
judges do have to decide whether a patent is valid. The US patent
office merrily hands out patents for just about anything these days,
which is why patents need to be tested in court.

I don't think I would like to base an important product on that
assumption.

Considering that MS and SUN seems to have a different opinion.

What are you talking about? And would you base your products
exclusively on Microsoft's and Sun's "opinions" even if they are in
conflict with the law? Because that's what you seem to be saying.

 

[Laura T.]

I'm not sure that it does - I'd be very surprised if the licence
for .NET didn't prohibit reverse engineering. I know reverse
engineering is legal (despite the licence) in some countries for the
purpose of compatibility testing, but I don't think it would help you
if you were accused of copying the code itself.

Jon

Well, then this might surprise you. I just installed dotnetfx.exe from the
msdn site, and the only EULA that I must agree does not even mention reverse
engineering. As an end-user, I have accepted only this EULA, and if I
happend to have Reflector on my machine, it's just casual.

The EULA is also here,
http://msdn2.microsoft.com/en-us/library/ms994405.aspx

 

[Willy Denoyette [MVP]]

Well, then this might surprise you. I just installed dotnetfx.exe from the
msdn site, and the only EULA that I must agree does not even mention
reverse engineering. As an end-user, I have accepted only this EULA, and
if I happend to have Reflector on my machine, it's just casual.

The EULA is also here,
http://msdn2.microsoft.com/en-us/library/ms994405.aspx

Note that this is a supplemental EULA , maybe you should read your OS
product EULA first ;-)

Willy.

 

[Cor Ligthert[MVP]]

Frans,

AFAIK do the laws of the EU not allow explicitily forbidding of reverse
enginering.

However it is not so difficult to do that implecitely.

Cor

 

[Peter Duniho]

No, you are not.

Please read the post to which I replied, as well as the last part of my
own post. In the statement you quoted out of context, I am taking as
granted the previous poster's assumption that merely producing similar
code is sufficient grounds for copyright violation.

It is in fact my assertion that concerns of legal action are overblown.
But inasmuch as they may exist at all, the mere act of having seen
someone else's source code is practically irrelevant issue.

Copyright does not cover duplication of function or even accidental
recreation of the same exact program text, only intentional copying.
Hence "copy"right.

I understand that. Please read my whole post.

What you are thinking of are software _patents_ which is entirely
different. Patents must be explicitly filed for specific pieces of
functionality, they are not valid outside America and I think Japan,
and they are subject to interpretation by a judge regarding whether
the patented functionality is patentable at all.

That's not what I'm thinking of at all.

No, what they needed was an implementation that duplicated Stacker's
_patented_ functionality. See here:

http://www.newscientist.com/article/mg14219300.700.html

You are correct that I misremembered that as a copyright case. My
recollection was that Stacker accused Microsoft of actually copying
their implementation. If that recollection is mistaken, fine...it was
just an example anyway, and doesn't change the intent of what I wrote
(though it may have led to your own confusion about what I meant...sorry
if I wasn't clear enough for you).

Unlike patents, however, such licenses only apply to people who
actually acquired & used the software, and agreed to the license.

So? In both scenarios I'm describing, that would be the case. Noting
that all of these licenses include some verbiage that basically says "if
you use our code, you've agreed to the license". It remains to be seen
just how well this sort of "unsigned, imbalanced" contract negotiation
holds up in court; oddly enough, there really hasn't been any strong
test of it, as piracy and other issues have been decided on more basis
legalities.

Any license that tried to prevent the user from duplicating the
software's functionality, patent-style, would be null and void. The
power of licenses, like copyright, is restricted to the actual product
as it is. They cannot regulate independent recreations.

I'm not talking about duplicating functionality.

That is correct. If you merely create _similar_ source code with an
identical purpose you're fine, though.

Not according to Mads, and that's the point I'm disputing.

[...]
For independent individuals that is probably correct. However, Mono
is a fairly high-profile project that needs a public website for
coordination. Microsoft would damn well shut it down if they thought
they're copying the .NET source code wholesale. Why else bother
having any read-only clause in the license in the first place?

I really, _really_ wish you had bothered to actually read my post
completely before you replied. If nothing else, I made it VERY clear at
the very beginning of my post that it is clear that Mono does not have
the option of copying the .NET source code wholesale.

The question is whether someone working on Mono must now avoid even
using the .NET source code for other activities, simply because they are
working on Mono.

It's my opinion that they don't, and I believe I made that clear in my
post. I'm sorry you didn't figure that out from what I wrote, and I
apologize for any misunderstanding. But your entire reply has made some
pretty broad and incorrect assumptions about what I was writing about.

Pete

 

[Peter Duniho]

[...]
Mono requires that developers who submit patches / changes have never
looked at MS sourcecode. So if you have looked at rotor, you aren't
allowed to submit patches,

That may be a matter of policy on Mono's part. But that's a lot
different from saying that it's Microsoft's policy or legal assertion.

precisely because it would make Mono vulnerable for lawsuits.

Define "vulnerable". Practically anyone can be sued for practically
anything, at least here in the US where these licenses are likely to be
enforced. Nothing Mono does makes it invulnerable from that.

On the other hand, for a _successful_ lawsuit to occur, very specific
violations must takes place. It's not sufficient for Microsoft to say
"hey, you looked at our source code and now you wrote something for
Mono" to win a lawsuit. They have to prove actual infringement. As
long as the Mono project doesn't actually include .NET source code or
implementations, they are already not vulnerable in that sense, whether
or not someone working on Mono has also used the .NET source code in
some other context.

I certainly see how the Mono group would feel that having such a policy
might help protect them against legal action by Microsoft. However,
I've seen no indication that they were a likely target by Microsoft
anyway, and there's certainly no justification for claiming that they
are under any legal _requirement_ to avoid looking at .NET source code.

Pete

 

[Peter Duniho]

What's the relevance of what MS says, other than what's in their
reference license? That license has all what MS has to say about it.

So, where in the license then does it say "if you have used the .NET
source code in any way, you may not work on Mono"?

If
you don't agree with it, don't accept it and don't look at the code.
However if you DO accept it and DO look at the code, you're doomed to
do things on projects you might have been a great help for.

Why? What in the license says that you're "doomed"?

I once
looked at the rotor code (very first beta version), actually only the
compiler. However by doing that, I accepted the license it came with
and I can't work on mono stuff now.

Why? What was in the Rotor code's license under which you viewed the
code that specifically precludes you from working on Mono?

It's precaution: if you haven't looked at the code, you can't literaly
copy/paste the code: you HAVE TO write it yourself.

I understand the precaution. But that's VERY different from saying you
are prohibited from performing the work otherwise.

Changes are that
the code will likely look different from what MS wrote as you have to
solve problems yourself. It's not about 'MS is evil', it's about
protecting the Mono code from lawsuits which they could have prevented.

Sure, it is about "MS is evil". It's only because of this fear of
Microsoft that the Mono project is taking such a defensive stance. If
they made the assumption that Microsoft is benevolent and would only
take legal where there's a valid legal case, then they would have no
problem with Mono developers using the .NET source code in situations
unrelated to Mono.

[...]
because you've access to code which you could copy/paste or learn how
it works inside and reproduce it for mono, which would make Mono look
like it has copy/pasted MS code and thus that it's open for a lawsuit.

But that concern only applies to someone who is specifically using the
..NET source code as a reference for Mono (whether copying directly or
using it as a guide). That in no way eliminates the possibility to use
the .NET source code in other contexts.

[...]

Working on Mono, you are intentionally trying to reproduce the
behavior of the .NET Framework, and even without inspecting the
compiled .NET Framework code it would not be surprising if you should
happen to on occasion implement things in the same way they are
implemented in .NET. But how are you to prove to Microsoft in those
cases that you didn't actually use their compiled code as a reference?

it's THEIR job to proof you DID copy it.

True. But the question of whether a license was accepted has nothing to
do with that.

If you have never accepted
the license of this sourcecode, you have never been able to look at it.

That's a false conclusion. Accepting the license has nothing to do with
whether a person has seen the .NET source code. I can accept the
license and never look at the source code, and I can look at the source
code without ever accepting the license. The two are completely unrelated.

[...]

They don't have to show you their source code for them to file legal
action on the basis of a copyright violation.

the sco case proofs that they have to. It would also be silly to claim
copyright infrigment without proof that someone indeed copied your
work, aint it?

No, it wouldn't be silly at all. It's easy enough to duplicate the code
from a compiled implementation. You don't need the source code to
violate the copyright rules.

[...]
Anyone may sue you one day, it depends if they have a case or not.
What you and I can do is protect ourselves from losing these lawsuits.
There's no protection possible against a lawsuit being filed against
you, though you can protect yourself (at least try) against losing
these because the other has a strong case against you.

No doubt. I have said as much. But that's not the issue here. The
question is whether the Mono group has a legal _requirement_ to protect
themselves in this way, and my assertion is that they do not.

They may feel it makes sense to play it safe in this way, but that's not
the same as Microsoft imposing this requirement on them.

That's also why the license this code comes with is evil and everyone
looking at sourcecode on the internet should REALIZE that you only
should do so if you understand the license the code is distributed
under.

Again, the license is irrelevant to the copyright issues, and calling
the license "evil" is just the usual Microsoft demonizing that takes
place in the open-source community.

[...]

Well, that's true of any published source code that carries an
attached license. Even regular "open source" stuff generally
includes various license requirements that can form the basis of a
lawsuit of someone believes you misused the source code.
[...]

Only if you copy the code. The GPL doesn't grant patents to be upheld
by the copyright holder if I'm not mistaken.

But copying the code is the issue here. That's what I'm talking about.
There are some obvious differences between the .NET situation and a
GPL'ed piece of code, but the basic question of adhering to the license
still exists, and the GPL has some of the same features the .NET license
does, particularly in the realm of reusing the code that is central to
this thread.

[...]
Also, if MS does something bad to YOU, you can't win a lawsuit against
them if they have a strong case against you in another area.

That's an absurd statement. The courts do not decide separate issues
together. If you have a case against Microsoft with respect to one
thing, it doesn't matter what other case they may have against you in
some unrelated area.

Pete

 

[Peter Duniho]

[...]
Lawyers takes these issues seriously, you know.

Of course they do. They wouldn't have jobs unless they did, and the
more they promote the idea of suing other people the more money they
make (usually whether or not they win).

Pete

 

[Mads Bondo Dydensborg]

[...]
Lawyers takes these issues seriously, you know.

Of course they do. They wouldn't have jobs unless they did, and the
more they promote the idea of suing other people the more money they
make (usually whether or not they win).

Thats not the point. The point is, for my company, that the companies we
work with expect us to honor these things. Not doing so would seriously
taint our reputation and relations to these other companies.

And, the other companies has a lot of laywers...

Regards,

Mads

--
Med venlig hilsen/Regards

Systemudvikler/Systemsdeveloper cand.scient.dat, Ph.d., Mads Bondo
Dydensborg
Dansk BiblioteksCenter A/S, Tempovej 7-11, 2750 Ballerup, Tlf. +45 44 86 77
34

 

[Mads Bondo Dydensborg]

[...]
Mono requires that developers who submit patches / changes have never
looked at MS sourcecode. So if you have looked at rotor, you aren't
allowed to submit patches,

That may be a matter of policy on Mono's part. But that's a lot
different from saying that it's Microsoft's policy or legal assertion.

We never said that. You assumed that from what was said. Actually I tried
correcting your initial view asap.

Define "vulnerable". Practically anyone can be sued for practically
anything, at least here in the US where these licenses are likely to be
enforced. Nothing Mono does makes it invulnerable from that.

Cue the SCO case.

There is a reason the open source community fears FUD.

Regards,

Mads

--
Med venlig hilsen/Regards

Systemudvikler/Systemsdeveloper cand.scient.dat, Ph.d., Mads Bondo
Dydensborg
Dansk BiblioteksCenter A/S, Tempovej 7-11, 2750 Ballerup, Tlf. +45 44 86 77
34