Don't look at the sourcecode of .NET licensed under the 'Reference license'
Update: If you think I should be shouting 'awesome' and similar words like most of the .NET community members, please take a walk down the path of 'licenses', something you all should be familiar with in every cell in your body, but by the look of all the different posts about this source release I can only conclude: hardly anyone has any clue whatsoever what licensing, copyright, software patents and related material really mean to a software developer. You didn't really think that by copying a class from the internet you owned the code, did you?
If you do framework development, take my advice and don't
look at the
.NET 3.5 BCL sourcecode. Using reflector isn't the same, you're then looking at IL
being reversed engineered. Looking at sourcecode is
different: it has comments, it has other layout, it has real
variable names etc. etc. Also, use reflector only when you
really have to. Using it is technically breaking the EULA.
Why you shouldn't look at that sourcecode
The reason is simple: software patents. People in the EU,
where software patents are, fortunately, still not valid,
should still realize that in other countries they do exist,
and if you're writing software which could be sold in the
US, don't make the mistake your code is liable to this. The
jurisprudence on 'reverse engineering' is based on the fact
that the people who are allowed to reverse engineer code
have never layed eyes on the real code. As soon as they do,
they can't reverse engineer the code anymore to their own
benefit (whatever that may be, even rewriting code because
it's internal in the BCL) because their case would fall
outside the jurisprudence: it can be assumed they
might have just copied the code instead of reverse
engineered it.
Do realize that you're not allowed to rebuild that code,
you're not allowed to modify it, copy it etc. You're only
allowed to look at it, but also because you're not
allowed to copy it, you have to forget what you saw, because
if you don't forget it, and borrow the ideas in that code,
you likely will step on some patent.
Take for example the new ReaderWriterLockSlim class
introduced in .NET 3.5. It's in the System.Threading
namespace which will be released in the pack of
sourcecode-you-can-look-at. This class is a replacement for
the flawed ReaderWriterLock in the current versions of .NET.
This new lock is based on a patent, which (I'm told) is
developed by Jeffrey Richter and sold to MS. This new class
has its weaknesses as well (nothing is perfect). If you want
to bend this class to meet your particular locking
needs by writing a new one based on the ideas in that class'
sourcecode, you're liable for a lawsuit as your code is a
derivative work based on a patented class which is available
in sourcecode form.
Software patents are evil and the release of this sourcecode
doesn't help one bit, on the contrary. If you take your
profession seriously, if you are interested in learning
ideas about software engineering, instead of looking at that
code,
read scientific papers
and learn from these. Dull crap which is out of touch with
reality?
Yeah
right
(just a few examples to get your appetite fired up
).
It's a red herring
Yes, I'm negative about this move. The main reason is that
doesn't solve real problems at all. Take for example the
case where you detect a bug in the BCL. You plow through the
source-you-can't-touch and you'll discover the place where
the bug originates and see how to fix it.
You can't do a thing about it. You can't fix it
yourself because you can't rebuild it. You can only report
it back to MS and wait for a fix. Well, dear reader, good
luck with that: even if Microsoft is willing to honor
your request and patch it in a short time interval (read:
month or so), you'll be handed a hotfix you can't distribute
to your customers. They individually have to call PSS
to get the fix, or you have to hope MS will release it
publically which they've done with some fixes but hardly all
of them.
Sure, be happy with your shiny sourcecode-you-can't-touch, but it's not something you would want: if Microsoft would have done this for the users of the code, namely the developers, they would have made the license less restrictive, at least that you could re-compile the code to include your own bugfixes till Microsoft would release them themselves.