Reinventing the wheel

This started as something of a comment to a couple of blogs about MS not shipping any open source with their flagship products, but it started getting longer and I didn't want to post the same thing in two places.

I'd be willing to bet that both Charlie (NUnit lead) and Jeff (MbUnit lead) would be more than willing to take a sizeable "donation" (perhaps as little as 10% of what the MsTest devs got paid) to their projects in order to provide a stable source version for MS to review line by line, under whatever license they decided they wanted (as a fork of the projects) in order to include their projects with the release of visual studio. I'd even be certain that both projects would have jumped at a chance to have pre-alphas of visual studio to integrate with (for full compatibility when the first beta hit the market).

The only thing that is stopping this level of cooperation is lawyers inside Microsoft (and the occasional prick of a developer), and for that MS deserves our pity. I think the only thing that will get MS to open up is if they were to come under so much financial stress that they could no longer afford the lawyers (and only open source appears to have that much power).

Some time ago I had a discussion where a developer within Microsoft explained provided myself and the others in the discussion what he felt was MS's viewpoint:

"From the Legal Dept's perspective, it's not merely the license the code was released under, it's also the heritage of the code. If some evil coder had stolen code IP from a source base, added it to a project with an open source, copy-reuse-repackage freely license, and I used it, the original IP owner could still sue me to get me to desist using their IP. So, in the interest of protecting corporate code from this sort of legal attack, Legal usually has to perform some pretty thorough (and thus also expensive) investigation before letting anyone see open source code; you can imagine that there generally has to be a good business justification before that kind of thing happens."

I think that opinion is rather unintelligent, but then again I'm not a paranoid lawyer who thinks everyone is out to get me (certainly I'll concede that there are a few people out there who are).

As far as TFS goes, what little experience I have with it tells me that it is too complex, has too many moving parts (all the more places for bugs to find their way in) and is too constrictive on my working habits. I'll stick with Mercurial, thank you. And wherever that isn't available, Subversion will have to do. I like my environment to be compartmentalized. That is why I'd suggest to use Mercurial, Bugzilla and CruiseControl.NET (all of which integrate nicely with each other or are easy enough for me to write my own integration).

Visual Studio Color Settings

I am using a new color settings file. It is based on Vibrant Jedi that Charlie Calvert linked to a little while ago (here). I'm using it with the Inconsolata font.

I modified it a little bit to work better with Resharper. If you want it you can get it here. It works both when you have Resharper->Options->Code Inspection->Settings->Color Identifiers on and off, with different results in each case. I have it off right now because I think it gets to be a little bit too busy with it on, and when on the ability to have types be a different color from interfaces is lost. I'll probably tweak the settings a little as I haven't really used it outside C# at all (and I don't really like the @"" strings or comments on the current line).

Pex + NUnit + R# + regexes == VS blowup and R# reinstall required

So... I just thought I'd let it out there:

1. Pex doesn't come with NUnit support out of the box (apparently it only has MSTest). I cannot use it until this is fixed. Apparently there is supposed to be an extension project, but I can't find it anywhere.
2. The Resharper release candidate is now available. Definately awesome.
3. If you try using Pex with NUnit and strings that you make into regexes as parameters to the PexMethod, Pex apparently crashes visual studio. Worse yet, after the crash my R# settings are reset (I had the beta installed) and the fonts and colors editor doesn't even have the settings available anymore. As I write this post the release candidate is installing.
4. After updating R# the fonts and color available settings have returned and apparently the settings aren't reset; VS just isn't honoring them. Changing one of them to something else and back again appears to get it to apply my settings.

Wierd day. Needless to say: I will not be trying to do that with Pex again for a while (I'll wait for proper NUnit support first).

Firefox 3 == awesome

Firefox 3 is almost certainly one of the best things ever! In the new url bar (aka the awesomebar I can type random things that I seem to remember from the title or url of random sites that I happen to have gone to and it knows where I want to go. For example, I type "s" and it knows I want the sprint board for work; "l" or "d" bring up my local development pages (l - localhost... d - localhost/dotnetnuke); "a" gets me Oren's blog. And those are just the pages I visit enough for Firefox to figure out that I want to get to them with only a single letter. Some others: "chad" (actually goes to another page in his blog, but that is one where he talks about a post I made), "scot", "guid" (a page I use to generate guids), "pex", and last but not least "still alive".

Also very cool is the star in the url bar: it "bookmarks" whatever page I want. Really all one click does is makes it so that firefox never forgets about a page you have visited (pretty much that is all I ever do, the bar is smart enough to figure out the page I want to visit without using the tag feature). But sometimes I need to give it a little more information, so I double click the star to give the page a tag or two (that way when I type in the tag, the bar responds with the tagged pages first).

That is really what I like about Fx3, but it is way more than enough. I've been using it since it was about to enter alpha 3 (I switched to the minefield nightlies at that time) and I haven't used Fx2 or IE since (well maybe IE every once in a while when I was tired of specific sites crashing in Fx or I needed to test my development items).

There are a couple things about it that I don't like:

• The skin; I can't stand it (I always liked Qute best; and luckilly Qute is available for 3)
• The dropdown listing all my open tabs (I tend to have 1 window with several hundred tabs open; the whole tab idea just doesn't seem to scale that far, I often lose tabs and find myself with 3 or 4 instances of the same tab open; some that I haven't viewed in days)
• The bookmark toolbar: totally pointless now (I have upwards of 2k bookmarks), except for the places folder (which is really cool and useful). I wish I could place the Places folder in the actual toolbar, just left of the back button.

But luckilly, the skin is easy to fix; the tab stuff isn't too big of a problem and the bookmark toolbar can be shut off (though I do hope someone out there is working on an extension to create a places button).

possible code quality equations

So... I haven't posted in a while; here's why: I have been using the firefox 3 nightlies for a long time now and blogger was crashing the past couple of times I tried posting. As I was not about to give up Firefox 3 (it is definitely one of the best pieces of software ever, I am completely dependant on the awesomeBar; using the star for bookmarking and the speed aren't bad either; next post will talk more). It appears as though I can now post from Fx3. That means more posts again.

This was something I posted a while ago on the alt.net list and am reposting it here to keep it for remembering to try out sometime in the future:

In regards to:

http://www.sei.cmu.edu/str/descriptions/mitmpm.html#78991

...

I don't believe this equation (from that article) will give very meaningful results. For one thing it places a very odd value on the percent of comments.

For that portion, here is a table:

  perCM | 50 * sin (sqrt(2.4 * perCM))
      0 | 0
      1 | 50
      2 | 40
      3 | 22
      4 | 2
      5 | -16
...
     10 | -50
     15 | -15
     20 | 30
     25 | 50

So, 1% comments is worth the same amount as 25%? And 10% is downright awful (note that the perCM variable is not used in the data, implying that it may not be a good variable)

171 - 5.2 * ln(aveV) - 0.23 * aveV(g') - 16.2 * ln (aveLOC) + 50 * sin (sqrt(2.4 * perCM))

The coefficients are derived from actual usage (see Usage Considerations). The terms are defined as follows:

aveV = average Halstead Volume V per module (see Halstead Complexity Measures)

aveV(g') = average extended cyclomatic complexity per module (see Cyclomatic Complexity)

aveLOC = the average count of lines of code (LOC) per module; and, optionally
perCM = average percent of lines of comments per module

Also I don't know any tools that will compute the Halstead Volume for .NET. In general I think that those 3 metrics would be useful in determining maintainability and that aveV and aveLOC should probably be on a log scale, but the numbers appear to be arbitrarily picked to support the conclusions of the research.

There is a tool that can be used to get many useful metrics out of a codebase:
http://www.ndepend.com/Metrics.aspx

I think the following on that page are particularly useful for measuring code quality:
overall:
NbLinesOfCode
PercentageCoverage

averaged (per assembly)
Instability
Abstractness
Distance from main sequence (abs(I+A-1), ideally as close to 0 as possible)

averaged (per type)
LCOM HS (Lack of Cohesion Of Methods - Henderson-Sellers; basically can tell you if your type is physically disregarding Separation of Concerns by not being cohesive)
ILCC (IL level cyclomatic complexity; afiak the only reason to use this one is because it can be computed for any .NET code, not just C#)
Depth of Inheritance Tree

averaged (per method)
IL Nesting Depth

Additionally, some other functions could be very useful:
average(PercentageCoverageMethodLevel * MethodRank) (will cause more important methods to be weighted more when computing code coverage)
or
average(PercentageCoverageTypeLevel * TypeRank) (would do the same thing for types)

I'd say if you want to have some sort of scale to come up with good individual functions for how each factor contributes to overall quality, and then either do a sum of the functions or some kind of weighted average.

For example, a decent function for basing quality solely on code coverage by unit tests could be (each function has been normalized to give output on a 10 point scale):
Q(x) = (arcTan(10x-5)+pi/2-.1)*11/pi
where x is [0,1], the decimal version of %coverage
or
Q(x) = (arcTan(10x-7)+pi/2-.1)*11/pi
where x is [0,1] = AVERAGE(the decimal version of %coverage at the method/type level * method/type rank)

LCOM HS could be:
R(x) = -12.5x^3 + 31x^2 - 28x + 10
x is [0,1]

ILCC could be:
S(x) = 10.4e^(-0.06x)
x is [1,inf)

and LOC could be:
T(x) = -0.4*ln(x) + 10
x is [1,inf)

And the final score could be the average of all of those parts.

WatiN testing ASP.NET - app startup time issues

I started a test project to test a web app. One thing I noticed was that due to application startup, occasionally the first couple of tests fail with TimeoutExceptions because the application takes too long to compile some of the pages.

So, I came up with the following to work around this:

using SHDocVw;
using WatiN.Core;
using WatiN.Core.Exceptions;

namespace Tests {
    public class TestBase {
        private static bool _siteSetupRun = false;

        public TestBase() {
            if (!_siteSetupRun) {
                setupSite();
                _siteSetupRun = true;
            }
        }

        private static void setupSite() {
            bool ok = false;
            using (IE ie = new IE()) {
                object nil = null;
                ((InternetExplorer)ie.InternetExplorer).Navigate("http://testsite/",
                    ref nil, ref nil, ref nil, ref nil);
                while (!ok) {
                    try {
                        ie.WaitForComplete();
                        ok = true;
                    } catch (TimeoutException tex) {
                        if (!tex.Message.Contains("'Internet Explorer busy'")) {
                            throw;
                        }
                    }
                }
            }
        }
    }
}

This needs to run before any unit tests.

Resolving extension method conflicts using a Proxy pattern.

If you happen to get this error: "The call is ambiguous between the following methods or properties: ...", here is how you would fix it:

Problem Setup

Lets say you are using the following library:

namespace PRI.Interfaces {
    public interface IEntity {
        string Name { get; set; }
    }
}

namespace PRI {
    public class DataEntity:Interfaces.IEntity {
        public string Name { get; set; }
    }
}

And the library authors decide to release an extension method (along with a couple of others you wish to use):

 
namespace PRI.Extensions {
    using PRI.Interfaces;
 
    public static class Entity {
        public static string CapitalizeName(this IEntity entity) {
            entity.Name = entity.Name.ToUpper();
            return entity.Name;
        }
    }
}

Meanwhile you are using a third party extension method library which already contains this method:

 
namespace Contoso.Extensions {
    using PRI.Interfaces;
    using System.Text;
 
    public static class Entity {
        public static string CapitalizeName(this IEntity entity) {
            StringBuilder sb = new StringBuilder(entity.Name.Length);
            string[] words = entity.Name.Split(new char[] { ' ' });
            foreach(string word in words) {
                sb.Append(char.ToUpper(word[0]));
                sb.Append(word.Substring(1).ToLower());
                sb.Append(" ");
            }
            entity.Name = sb.ToString().Trim();
            return entity.Name;
        }
    }
}

The Problem

This is a problem because you can no longer call the CapitalizeName method as an extension method if you happen to have both namespaces in your using constructs. As long as you are using functionality from both classes where the names of the methods are different you will not have any conflicts and there will not be any problems using your code. Unfortunately, the moment you add a call to the CapitalizeName method you will get a compile time error.

namespace Program {
    using System;
    using PRI;
    using PRI.Extensions;
    using Contoso.Extensions;
 
    class Program {
        static void Main(string[] args) {
            DataEntity dataEntity = new DataEntity() { Name = "frank smith" };
            dataEntity.CapitalizeName();
            Console.WriteLine(dataEntity.Name);
        }
    }
}

This will not compile because CapitalizeName cannot be resolved.

Enter the Proxy Pattern

Because extension methods are static methods and can be called just as any other static method gets called, you can build a wrapper class around these third party extension methods in order to resolve the conflicts that the method names impose.

namespace Program.ExtensionResolvers {
    using PRI.Interfaces;
 
    internal static class Resolver {
        public static string CapitalizeName(this IEntity entity) {
            return PRI.Extensions.Entity.CapitalizeName(entity);
        }
        public static string ConvertNameToTitleCase(this IEntity entity) {
            return Contoso.Extensions.Entity.CapitalizeName(entity);
        }
    }
}

Using the Solution

The extension method proxy class can now be used in order to resolve the naming conflict.

namespace Program {
    using System;
    using PRI;
    using ExtensionResolvers;
 
    class Program {
        static void Main(string[] args) {
            DataEntity dataEntity = new DataEntity() { Name = "frank smith" };
            dataEntity.ConvertNameToTitleCase();
            Console.WriteLine(dataEntity.Name);
        }
    }
}

Recommendation

If you are going to use more than 1 extension method library ever in the course of working on a project, I believe it is awfully important to encapsulate the extension methods you will be using into a proxy class (or several such classes) as I have shown here. It is probably best to keep this class internal as you wouldn't want to continue to pollute the function name domain to other third party libraries which are using your code.

I will argue that all calls to extension methods from third party libraries be internalized in this way. Doing so adds value (you can add xml documentation to these methods for your coworkers and the R# tools will be able to find usages and such) and it better decouples you from minor API changes in the extension libraries.

--
Thanks to Peter Ritchie on the altnetconf mailing list for most of the above code in the first section of this post.

Visual Studio 2008 first impressions

ok, ...

I will not be using VS 2008 until Resharper 4.0 EAP begins. I began starting to use 2008 this evening for my next post and I almost immediately realized just how dependent on R# I have become. As I began the first things I noticed (within the first 5 seconds) were:

• Intellisense was different and I am not used to it.
• I had forgotten where StringBuilder was located (R# will let you know when you reference a class that is not in a namespace you are using).
• I really miss the error detection system.
• Alt+Enter
• F6
• F2
• Ctrl+B
• Ctrl+T (I have binded this shortcut to Resharper.UnitTest.ContextDebug; more on that at some later time)

Other than that, I really liked my initial impressions:

• Startup is much faster.
• F1 doesn't hang VS for 5 minutes (I really hate this shortcut and I remove it from my system when possible because I tend to accidentally press it when going for F2 sometimes)
• Hidden toolbox tabs show up faster when moused over.
• Compilation seems faster.
• VS seems to close faster.

So, in general, I really like it. Without R# I will not be using it.

Job Hunting - questions to ask

Recently I asked a couple of questions openly to a person who posted a job offer* on the alt.net list which I think are important for discovering the attitude and environment of the potential employer.

These are more or less the questions I asked:

• Does the company use OSS?


• How does the company view OSS solutions?


• Are you stuck with basic VS or do you get so use R# or the DevExpress plugins (or other productivity tools)?


• Do your developers get to blog (or is that shunned)?


• Are they allowed to work on OSS projects in their spare time?


• Are they allowed to do so on company time for any projects the company (or even just the group) is using?

I believe these questions provide valuable insight into the employer.

*Note: I am not currently looking for a job, but if an offer comes up and it is significantly better than my current position I will look into it. It had better have a good pay raise, great benefits, not move me from Bozeman Montana, provide a flexible schedule, allow me to work from home when I want to and give me the flexibility to work on the projects I want to be working on. Ok, maybe that is a little exaggerated, but it had better be a very very good deal.

Object to DTO and back in an efficient manner

Reading Oren's post about converting an object to a DTO I got to thinking. Why do all that work of reassigning a bunch of properties if you can avoid it? The DTO is probably going to be serialized before being sent over the wire and only public properties are serialized; it doesn't make much sense to me to run a transform which would need to run at least 1 delegate (1 for every property to property transform), instantiate a new DTO, instantiate a List, instantiate an enumerator and enumerate over a list and instantiate a transformation class just to call a single method on it. It seems to me that most of this extra work can be avoided.

Here is a naive approach I would consider before running to lists of lambda expressions:

internal class DbOrder {
    public string Name;
    public int Id;
}
 
public class Order {
    private DbOrder _dbOrder;
 
    private Order(DbOrder o) {
        _dbOrder = o;
    }
 
    internal DbOrder DbOrder {
        get {
            if (_dbOrder == null) {
                _dbOrder = new DbOrder();
            }
            return _dbOrder;
        }
    }
 
    public string Name {
        get { return DbOrder.Name; }
        set { DbOrder.Name = value; }
    }
 
    public int Id {
        get { return DbOrder.Id; }
        set { DbOrder.Id = value; }
    }
 
    public static explicit operator Order(OrderDTO obj) {
        return new Order(obj.DbOrder);
    }
}
 
public class OrderDTO {
    private DbOrder _dbOrder;
 
    private OrderDTO(DbOrder o) {
        _dbOrder = o;
    }
 
    internal DbOrder DbOrder {
        get {
            if (_dbOrder == null) {
                _dbOrder = new DbOrder();
            }
            return _dbOrder;
        }
    }
 
    public string CustomerName {
        get { return DbOrder.Name; }
        set { DbOrder.Name = value; }
    }
 
    public int ID {
        get { return DbOrder.Id; }
        set { DbOrder.Id = value; }
    }
 
    public static explicit operator OrderDTO(Order obj) {
        return new OrderDTO(obj.DbOrder);
    }
}

The reason I would consider doing this this way is because both the Business class and the DTO class are nothing more than proxies to the data. Since this is the case, a Proxy pattern seems to me to be the best way to treat them.

heh - 88 % geek

88% Geek

found on http://fredericiana.com/2007/11/24/how-geek-are-you/

[altnetconf] RE: What is your current "task system" of choice, and how tied are you to it?

I was reading a post on the alt.net mailing list that just showed up on my inbox and thought it would be best to reply here:


We use Bugzilla for tracking everything that goes on with our applications. We have tried getting rid of it and failed too many times now (to replace it with JIRA, Fogbugz, mantis, SugarCRM, SalesForce and VSTS to name a few), there is just no better application. Bugzilla is not exactly what we want, but neither is anything else. We have since gotten rid of the idea of replacing Bugzilla and have integrated it with the rest of our processes. It receives commit messages from subversion; it will soon receive error reports directly from the application; we are looking into getting ccnet build reports to integrate into it. Our customer service had been using sharepoint to track and deal with their tasks, but they will soon be switching fully into Bugzilla. Our scrum board is nothing more than a shared search that looks at bugs that block a sprint tracker (this works really well as I work from Montana and the rest of the company is in Ohio, Pennsylvania and New Jersey and an actual whiteboard would be rather impossible). We now use it to do everything from manage releases to tracking defects and enhancements to track modifications made to the firewalls and network infrastructure to record helpdesk phone calls with their solutions.

Needless to say, our company runs off Bugzilla (yes, that takes BDD to a whole new level).

Even though it is not perfect and the imperfections are glaringly obvious (yet nearly impossible to explain how to fix), wherever it is good it is almost perfect. The perfect tools for this would fade into the background and no one would realize they were using them. It is very natural to use a buglist for the scrum board. It is also quite natural to commit a revision to subversion and have a bug get resolved as a side effect (well about as natural as the act of committing in subversion can be). Or to publish a release (another commit that goes against a different bug) then get up and go get a drink as CruiseControl.NET updates the qa environment and bugzilla resolves all the bugs waiting to get to qa, sending emails to the relevant testers that the issues are ready for them to verify, all without any user interaction (other than the commit).

What isn’t good about it is that anything that isn’t integrated or doesn’t have a natural appropriate workflow from the business perspective (regardless of the tool) is very difficult to get anyone in a habit of using (time tracking for example has not caught on despite the fact that we need to do it and know we have for the past 2 years). If the item that we try to quantify with Bugzilla is not a direct result or direct byproduct that appears on its own (even though it is something that can be figured out and we know how to do so) then it inevitably doesn’t get tracked.

Time tracking is an example there, but so are:
“What UI areas does issue X affect that will be visible to end users?”
“Does this issue need to be in release notes?”
“What was the outcome of meeting N on mm/dd/yyyy which related to this bug and why was implementation A taken over B?”
“What meetings has this bug been brought up in?”
“How much impact does this issue have with end users?”

We have been trying to figure out how to quantify those questions and many like them for several years and that is why we have tried other systems.

Additionally we have run into another issue which dwarfs the questions of this topic, as ultimately I feel that any of those systems could have wound up working for us (except VSTS, that one just didn’t fit the bill at all) had they been introduced at the right time (Bugzilla was introduced early and was simply leaps and bounds better than mere email), and that question is: “How do you deal with taking over another company that is at a different location and uses an entirely different task system?” The single biggest problem with Bugzilla at our company is that it isn’t enough to receive the corporate Buy-In from the higher ups in other locations who are already entrenched in a different system. It is far more important to be using a single task system companywide which works good for most things (and excels at a couple) than it is to sit down and figure out which system is best for you right now.

Schwartzian Transform in C# 2.0

In case someone was reading Joe Cheng's post about performing a Schwartzian Transform in C# 3.0 and was wondering what it would look like in 2.0 code, here it is:

private static void SchwartzSort<E, S>(List<E> list, 
                                       Converter<E, S> converter, 
                                       Comparison<S> comparison) {
    List<KeyValuePair<S, E>> pairs = list.ConvertAll<KeyValuePair<S, E>>(delegate(E x) {
        return new KeyValuePair<S, E>(converter(x), x);
    });
    pairs.Sort(delegate(KeyValuePair<S, E> x, KeyValuePair<S, E> y) {
        return comparison(x.Key, y.Key);
    });
    for (int i = 0; i < list.Count; i++) {
        list[i] = pairs[i].Value;
    }
}
 
/// <summary>
/// Sorts a list using a Schwartzian transform (applies a conversion 
/// function to each element and sorts by the value of that function).
/// </summary>
/// <typeparam name="E">The type of element to be sorted</typeparam>
/// <typeparam name="S">The type of the element to sort by</typeparam>
/// <param name="list">The list to be sorted (sort occurs in place).</param>
/// <param name="converter">
/// The converter function (converts element of type <code>E</code> to type <code>S</code>).
/// </param>
/// <param name="comparison">
/// The comparison function, compares 2 values of type <code>S</code>.
/// </param>
/// <seealso cref="Sort{E,S}(List{E},Converter{E,S})"/>
public static void Sort<E, S>(List<E> list, Converter<E, S> converter, Comparison<S> comparison) {
    SchwartzSort(list, converter, comparison);
}
 
/// <summary>
/// Sorts a list using a Schwartzian transform using the default comparer 
/// on type <code>S</code> (applies a conversion function to each element 
/// and sorts by the value of that function).
/// </summary>
/// <typeparam name="E">The type of element to be sorted</typeparam>
/// <typeparam name="S">The type of the element to sort by</typeparam>
/// <param name="list">The list to be sorted (sort occurs in place).</param>
/// <param name="converter">
/// The converter function (converts element of type <code>E</code> to type <code>S</code>).
/// </param>
/// <seealso cref="Sort{E,S}(List{E},Converter{E,S},Comparison{S})"/>
public static void Sort<E, S>(List<E> list, Converter<E, S> converter) where S:IComparable {
    SchwartzSort(list, converter, delegate(S x, S y) { return x.CompareTo(y); });
}

Obviously this is not quite as aesthetically pleasing as the 3.0 version, but it is still useful for any developers doing 2.0 coding out there and need to sort a list by the results of a function. Here is an example of how it would be used:

public class foobar {
    private string _foo;
    private string _bar;
 
    public string Foo {
        get { return _foo; }
        set { _foo = value; }
    }
 
    public string Bar {
        get { return _bar; }
        set { _bar = value; }
    }
 
    public foobar(string foo, string bar) {
        _foo = foo;
        _bar = bar;
    }
}

Assuming class foobar:

List<foobar> items = new List<foobar>(4);
items.Add(new foobar("a","b"));
items.Add(new foobar("asdf","jkl"));
items.Add(new foobar("green","purple"));
items.Add(new foobar("c", "a"));
 
Sort<foobar,string>(items, delegate(foobar item) { return item.Foo; });

Colors

I don't know about these colors. I know I didn't like what was there before, but I don't have any idea if this is any good now. I do like this layout much better. But, I don't know much of anything about these colors because I am colorblind. I think some of the borders and such are a shade of green on the blog side and I don't know how well they go together. I suppose I will be trying to figure this out for a long time. Any help would be appreciated. Also, ignore the image colors, they were there before. I will get to them at some point.

Some sites I used to help get myself this far with the colors:

• colordb
• style:phreak
• GenoPal Online
• Color schemes generator 2
  

Read only source?

ScottGu on releasing read only source code for .NET 3.5

I don't know about this. I will not be looking at any code under the MS-RL. It seems like having that license makes the code supplied under it bait. I wonder how it will affect the number of contributors to mono? Once you look at the Microsoft .NET source, you can no longer contribute to mono.

It seems like embrace, extend, extinguish to me. First Microsoft embraces all developers by making it really easy to look at and use the source for the framework. They continue working on it to build up libraries for anything imaginable. Then a few years later they bombard open implementations and competitors with the full force of their legal department. Or worse, they eat up so much of the development pool that there is no one left to compete with them, they get in with colleges to use their implementation and have people write books about it, etc. And I was beginning to think the MS dev offices were a whole different better side of MS.

Kudos to the hard working guys at MS who got it this far, but I am unsure that this is far enough.