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