John Vlissides

John Vlissides (25 percent of the GoF) passed away on Thanksgiving.

TF30177 Error When Installing Team Foundation Beta 3 Refresh

After installing the Beta 3 Refresh of Team Foundation Server, I had a small problem -- I couldn't create new team projects. I received a TF30177 error when the team site was configured in WSS. Rob Caron pointed me to the WSS installation, where the default virtual server apparently hadn't been extended. I investigated a bit and found that although the WSS config database did have an entry for the default virtual server in the VirtualServers table, and the config database had been created, the virtual server had apparently not been properly extended.

I found that running the service account (TFSservice) as a local admin would enable the Team Foundation Server installation to properly configure WSS. I'm not sure if this is a problem with WSS SP2 (which is now required), or a problem with the TFS install.

Update:The error is TF30177, not TF31077. Also, I've run some tests, and it looks like the TFSService account also needs elevated privileges after installation -- if you drop back to just User group membership it's not possible to create a project.

Richard Hale Shaw Fails the Blog Screen

As a practice manager, I usually spend a portion of my week interviewing candidates. Occasionally I'll get an incorrect answer delivered with such confidence that I wonder if the candidate has any real experience whatsoever. RHS recently gave some very bad advice about the using statement and is so incorrect that I frankly might immediately flip the no-hire bit if we were in an interview. In fact, he is so off the mark, I hardly know where to begin, but I'll just note that:

• The Dispose pattern is about strong ownership, not shared ownership
• The using statement is about easing a specific usage of the Dispose pattern
• The fact that you're not required to allocate an object in the using statement is a red-herring
• Anyone that even hints at suggesting the use of a finalizer instead of using/Dispose is just not qualified to touch code on a large dynamic system, let alone have a position of higher authority
• using(){} is less complex than addref/release, malloc/free, and new/delete/delete[]
• Most mere mortals have difficulty coding a proper substitute for using(){}. In fact, if they have trouble with using, I assert that there's no way that they'll be able to properly implement the required try/finally code in all cases.

Go, read -- it's really just scary in an entertaining way.

I'll try to post more later with code

Ward Cunningham Leaves Microsoft

Ward Cunningham is leaving Microsoft to work at Eclipse. I was really hoping that he would get PAG into a more social frame of mind -- but I guess not.

BPEL Cookbook Online at OTN

Oracle is publishing a BPEL cookbook online at http://www.oracle.com/technology/pub/articles/bpel_cookbook/index.html.

It's very Oracle-centric, but some useful stuff is in the first three chapters published so far. If you squint just right, it almost looks like C#.

Other Upcoming Talks

In addition to my internal talks at Neudesic and the .NET Technical Summit in San Diego on Saturday, I also have two upcomming webcasts:

• Operator Overloading in Visual Basic 2005
• My Namespaces in Visual Basic 2005

Yes, I can program in more than one language. No, my favorite languages are still Eiffel and C#.

I also have a Managed C++ talk coming up, but I'm not sure if it's public. If it is, I'll post details here when I know more.

Saturday! Saturday ! Saturday!

This Saturday (October 8^th), I'll be speaking at the San Diego .NET Technical Summit. I'll be giving a presentation on WCF (pronounced "Indigo"), and there are also talks about ASP.NET 2.0 and TDD. I'll post my slides and bits after the talk, so watch this space.

Visual Haskell is Available!

Are you a funtional programming gearhead that wants (nea, needs) to have GHC running in Visual Studio? Visual Haskell is available from haskell.org (requires Visual Studio 2003.)

PutStr "Nice."

A few thoughts on var and anonymous types in C# 3.0

Now that generics are becoming more prevalent in C# programming, a common C++ issue starts to rear its head: the really long declaration. Consider:

Dictionary<IdentitySlot<Person>, List<Paystubs>> emp2Paystubs = new Dictionary<IdentitySlot<Person>, List<Paystubs>>();

Think about it -- in the general case, the compiler knows what the type of emp2Paystubs should be. Although you might want the variable to be typed as a base type, in the majority of cases the type on the left-hand side matches the right-hand value. In C# 3.0, shown at PDC05, the compiler can simplify your declaration in the most common case, allowing you to specify var as the type:

var emp2Paystubs = new Dictionary<IdentitySlot<Person>, List<Paystubs>>();

As a side note, var also helps eliminate the need for the dreaded typedef in C/C++. As a footnote to the side note, if you don't dread the typedef and are urgently demanding its return, perhaps now would be a good time to point out the recently improved syntax for mangaged C++ in Visual C++ 2005. It has typedef, and it's now much easier to use C++ for writing managed code. You're welcome. The rest of you should be using Eiffel for your second language.

Keep in mind that var is really just some compiler magic over existing types: A var declaration can only be used as a local variable - it can't appear as a member, parameter, or return type. This enables the compiler to always assign a known type in the IL emitted during compilation, without you actually whispering the type name to the compiler.

Further, in a number of scenarios such as when projecting an anonymous Linq type, you don't even know the name of the type. Consider this Linq fragment:

var q = from ord in db.Orders,
        prod in db.products
        where ord.OrderID == prod.OrderID
        select new{ord, prod};

What is the type of q? Although the compiler can certainly assign a type name (perhaps something memorable such as __ilAeizneKeneR), it certainly is not discoverable prior to compilation (although it is available through reflection). It turns out that var enables you to use instances of these anonymous types in a simplified manner. The alternative would be to force you to artificially concoct a name for the type, even though it really isn't important to any actors in the drama, except for several portions of the compiler. More in another post.