Scott Bellware has written some recent posts on how agile teams sustain capacity as they mature their process.

The posts can be found on his blog (permalinks and content abstracts below):

Sustaining Capacity in Maturing Agile Software Teams – Part 1: Nothing Fails Like Success

We all know that following an Agile process as it is prescribed will only take us so far, eventually we’ll have to make changes. When we do begin to make changes we need to understand why. The principal reason for changing elements of the process should be to remove constraints that limit the team’s performance. As the teams’s performance increases new constraints will appear that are proportionate to that performance. Without reaction to these appearing constraints, obstructions will occur causing the team to lose its ability to perform at the new levels of expectations. Scott refers to this as entropy.

Sustaining Capacity in Maturing Agile Software Teams – Part 2: Entropy

Talks about some of the natural constraints that come out of software development. For example, design rigidity, which is where a design hasn’t been optimized to easily support change.

Sustaining Capacity in Maturing Agile Software Teams – Part 3: Recognizing Entropy

How to identify entropy and when to act upon it. Acting too early might mean that the team hasn’t enough context to understand the source of the constraints. Quite often constraints appear in code, which is a core means of communication for an agile team.

Sustaining Capacity in Maturing Agile Software Teams – Part 4: Counter Measures

Identifies some of Scott’s counter measures in dealing with constraints. In short, the environment in which Developers work should foster a learning culture that directly supports continuous improvement. With this in place the team will learn to identify constraints, and then how to counter act them. There are also a few suggested technical practices such as writing Soluble Code, Test-Driven Development and Design Improvement.

Well it's been six months since I last posted an entry, so let me begin by reassuring my readership (all two of them), that I have not been hit by a bus or anything like that. Things have been really busy since I started in my current role, and I just haven't found the time to post any new entries. It's a shame too since my unique visitor count was growing steadily as I posted, but obviously those figures have now since dropped off. The lesson to learn from this is that if you plan to setup a blog - post to it!

So what has taken up all my time? Well, those who are connected via LinkedIn can see that I started a new role at Confused.com back in January. This has been a fantastic (but busy), opportunity from a development and technology perspective since I'm being exposed to the very latest Microsoft technologies, including the .NET 3.0/3.5 stack (including WCF and WF), and ASP.NET MVC (we're onto Preview 3 already). The most interesting aspect of my current role however, is my involvement with the adoption of Team System and Team Foundation Server.

Confused.com is adopting Scrum as an agile methodology, and we've all been involved in slowly introducing agile to the business. To support Scrum in Team System, I have developed an appropriate Process Template from the ground up. This was easily achieved using the Process Template Editor that is part of the Team System Power Toys. The principal reason for developing a custom Process Template, rather than using one of many free versions (such as Conchango's Scrum for Team System), is that we see integration opportunities with other processes and tools already being used within the organization. A custom Process Template will support these integration opportunities much more easily than trying to shoe-horn a third-party template.
Read More...

Within my current role, I am helping the client interview candidates for both Senior .NET Developer and Architect positions. As part of the interview process I ask the candidate a few quick-fire questions regarding .NET (dependent on the position that they have applied for), and then I ask them to model a Russian Doll using a UML class-diagram.

For those who don’t know, a Russian Doll (or a Matryoshka Doll), is made up of many pieces that nest inside one another. The idea behind this simple modelling exercise is to allow the candidate to demonstrate both abstract thinking (by applying some form of object-oriented analysis), and their agile modelling capabilities. This is obviously a very important aspect if the candidate is to fit in an Agile team.

Once the description of a Russian Doll is agreed upon, the candidate simply needs to begin modelling on the whiteboard. It is surprising how many candidates fail to apply an analysis process to the problem, or simply ask questions. I wouldn’t consider it a weakness if a candidate asks me to get the model started for them. Many have simply given up immediately.

By far the simplest approach would be to analyse the nouns in the agreed description (i.e., a “doll” made up of many “pieces”). That gives us two candidate classes. Then we need to think about how the pieces nest inside one another, and also how we can represent the fact that a piece is the last piece in the set making up the doll.

I am sure that there are several ways in which this exercise can be modelled, but my model answer is shown below:



All design is subjective, but my model answer has two qualities (which hopefully would also be represented in the candidate’s design). First, it distinguishes between two distinct piece types (one hollow and one solid), and secondly, how these pieces can be arranged using the Composite design-pattern to form a doll that is made up of several hollow pieces, with a solid piece being the terminating condition for the overall structure. The use of the Composite design-pattern also prevents us from having a structure that has a solid piece that is the container for other pieces, since clearly it is collaborating in the leaf role.

So far, one or two candidates have actually questioned the validity of the association between HollowPiece and Piece (its base). I am hoping however, that this is down to inexperience with UML, since I feel that Composite is one of the most commonly used design-patterns (regardless of whether a candidate knows they are using it in their code or not).

I would be interested to hear any thoughts on this modelling exercise, especially as part of an interview process. I would also welcome any comments on my model answer too.

So you've installed Team Foundation Server and now you need to setup your permissions. There's quite a lot to follow in the TFS Installation Guide, so if you're using Active Directory, here's a digest of how I've recently defined permissions on a single-server deployment (this should work with both 2005 and 2008):

First, we have to remember that there are three areas where permissions have to be managed. TFS itself, SharePoint Services, and SQL Server Reporting Services. As far as I can tell, SQL Server Reporting Services appear to be the least secure of the three. When a user is assigned a Role Assignment it is not in relation to any particular Team Project.

There are also four distinct role types that we have to consider when thinking about permissions (summarized below):

• TFS administrators are those users who create Team Projects
• TFS project administrators are those users who manage Team Projects
• Everyone else is either a Contributor or a Reader

The approach that I have taken (obviously working in conjunction with an Active Directory Administrator), is to define two Active Directory domain groups called TFSAdministrators and TFSProjectAdministrators. TFSAdministrators is added to the SharePoint Administration Group (or the Farm Administration Group in SharePoint 2007). It is also added as a System Administrator for the site-wide security settings in SQL Server Reporting Services. Basically any user added to this group will then have the appropriate permissions to create Team Project Portals and Reports in both SharePoint and SQL Server Reporting Services.

The second group (TFSProjectAdministrators), gives Team Project Administrators the Content Manager Role Assignment within SQL Server Reporting Services. Finally, to support the Contributor and the Reader roles, we define a new Browser Role Assignment within SQL Sever Reporting Services for the Domain Users group (i.e., the group to which everyone on the Domain in a member).

The combination of these two Active Directory groups and their permissions within SharePoint and SQL Server Reporting Services, effectively means that there is no longer a need to manually add users to the appropriate Role Assignment in SQL Server Reporting Services. Instead, a user can be added to their appropriate Active Directory group. Since permissions in SQL Server Reporting Services are not relative to a Team Project, this makes things much more intuitive going forward. In fact, it is now possible to forget about SQL Server Reporting Services altogether, and instead focus on adding users to the Team Foundation Server groups (i.e., Team Foundation Administrators or [project_name]\Project Administrators), and then adding the user to an appropriate group in the Team Project Portal.

I think that this provides a sensible and intuitive approach in managing user permissions within TFS. One change that I might consider is not adding the Domain Users group to the Browser Role Assignment in SQL Server Reporting Services, since this effectively gives every user in the Domain the ability to view all reports.

A common "agile" misconception reflected in a way that only Scott Adams can:



(isn't this all too familiar?)

If you want to place a Guidance Automation recipe virtually anywhere within Visual Studio's menu structure, then here's a great tip for finding those menu Guids and Id's.

Having looked over my current and past engagements recently, I have noticed that I have been working flat out for over three-and-a-half years. No breaks in-between assignments, and certainly no holidays - apart from the bank-holidays, but they don't count. I'm completing a short assignment with a financial client in the next few weeks, so I have decided to take a well earned break from work. It won't all be about relaxing though, as people who know me will tell you - I can't just sit around and do nothing. In the run up to the winter holidays I have decided to begin upgrading my current MCAD certification to the new MCPD Windows, Web and Enterprise Application Developer versions.
Read More...

I've touched upon Wikis before, but if you want an extremely comprehensive Wiki solution for FREE, then check out MindTouch. They have an open-source .NET Wiki product called Deki Wiki, which has a feature list that most of the commercial Wiki products would be proud of.