The application lifecycle model, as Microsoft expresses it in Visual Studio 2005 Team System, forges a path familiar to participants in global-scale projects but which has never been scaled down for small to moderate efforts.
The plan leans heavily on inserting intelligence into workflow. In execution, VS 2005 Team System elements in a fixed sequence become intelligent work items. Those work items arrive and depart with memory of where they’ve been, the smarts to know what needs to happen next, and role-relevant data payloads that take humans directly to the site of the work assigned to them.
When a piece of work is completed, the team member doesn’t need to do anything to kick it back into some staid workflow. Work items beget new work items that, in an almost sentient fashion, make a bee line straight to the responsible individuals.
When all of the activities in a project are managed with Team System and Visual Studio 2005, the project has a single source of current and historical data. It constantly analyses its incredibly detailed database of knowledge to manage and report on the project’s state.
Project managers will go nuts over Team System from day one, but over time, everyone on the team will appreciate not having to concern themselves with anything but the work assigned to them. Team System handles the rest.
I gave Team System a thorough work-out — and I admit that I had zero expectations that software could play such a large role in project management. I had little faith that Microsoft could, in its first attempt, do a passable job of executing a right-sized subset of functionality of massive lifecycle management systems like that of IBM’s Rational.
But Microsoft decided to create a solution that fits only its own tools and serves projects of small to moderate scale. By accepting its limits and working within them, Microsoft pulled it off. And they did customers a favour with Team Suite, which is a starter bundle of all the Team products Microsoft sells. You grow Team Suite a seat at a time. Not all team members need to use all of the pieces of this immense package; you can add licences that fit the roles of individual members so there’s little waste.
Team Suite suits up
VS 2005’s IDE features haven’t changed dramatically since I wrote up Beta 1 more than two years ago. The VS 2005 IDE keeps developers constantly aware of the structure and condition of their code. The need for disruptive side-trips to do things such as track class and function definitions to header files or do desktop test builds to generate the imprecise guidance of compiler warnings is scant. VS 2005’s integrated tools for static and run-time analysis, along with detailed reports from Team Suite’s build server, provide more specific and relevant guidance than the old ways.
Microsoft has put an enormous amount of effort into Visual Studio 2005’s compiler, linker, profiler and other low-level facilities, bringing it up to par with Intel’s development tools. A developer with a need for speed will find VS 2005’s profiler and optimiser to be a playground. The buttons and knobs and gauges are not merely more plentiful; they produce more dramatic results for the code generated for 32-bit x86, AMD64 (and its derivations), Itanium, and mobile targets alike.
Deploying Team Suite is easy: server and client component installation is simple and automated. After Team Suite is deployed, developers use the Visual Studio 2005 IDE and keep working exactly the way they do now, with no knowledge that the process has changed.
The work of code testers and architects feeds physical deployment requirements that are reality-checked by Visual Studio 2005, and then VS 2005 generates skeletal code matching the architecture. Project managers track the metrics and make sure that personal and political conflicts don’t drag down productivity or quality.
At first, it looks like Team Suite just puts all the scattered server and client pieces you use now into one box. But Team Suite works its magic behind the scenes. When developers go to check in their code, Team Suite checks it against standards set by the project manager. If the changes cause the code to deviate from project standards, Team System won’t check the changes in — and it’ll explain why.
Testers have a marvellous array of new tools at their disposal (it’s about time), but Team System adds a twist: when a tester finds a flaw, Team Suite automatically creates a work item for the responsible developer, including which party it identifies on its own, and attaches to that item all of the information needed to back up the tester’s findings.
Team Suite is geared for fine-grained human multitasking. It eliminates dead-time by making it easy for team members to switch among work items. For example, a developer who is assigned a work item of higher priority than the project he’s in can shelve the current project, which snapshots its working state (including GUI layout) for later retrieval.
The work items themselves don’t change hands. Each is handled and resolved through creation of new work items, so there’s no need for out-of-band email or instant messaging to inform anyone that a work item is complete. Each work item appears practically sentient in that regard: it knows when it’s time to move along and what needs to happen next.
The fire-testing Team Suite received inside Microsoft’s walls shows in the final release. In my various roles during testing, I stumbled, hid under my desk, got sucked into projects outside my domain, and did other misdeeds that bring down total productivity. I took testing shortcuts by filing bugs that I found while informally eyeballing and driving the app around. I turned in perfectly valid code that ran like a one-legged dog. In spite of all this, I could not create cracks through which the teeming particles of the VS 2005 app lifecycle could slip.
Small groups only
Team System has no mechanism for blending the work of offshore, outsourced, or partnered developers into a project’s lifecycle. That’s too bad; it makes it difficult for companies to transition development back in-house in stages. It’s also one of the tip-offs that Team Suite is not intended for large teams.
Team System avoids redundancy and resolves conflicts when the same work accidentally gets done twice, but cross-disciplinary, ad hoc teams are not part of its plan. Group attack of associated tasks through collaboration can only be done out of band, outside of Team System.
The potential for disruption here is substantial. Out-of-band effort can cause Team System’s perception of the lifecycle to fall out of sync with reality, leaving workers to resort to sticky notes and email.
Most commercial and in-house development shops have accepted the need to part with the sequential/waterfall model that places everyone in everyone else’s critical path. Like any genuine paradigm shift (that term is appropriate here) making a non-disruptive transition is critical.
It’s true that the transparent, constantly circulating lifecycle model of application development, deployment, and maintenance challenges comprehension, much less implementation.
But Team System, as implemented by the assembled components of Visual Studio 2005 Team Suite, bypasses that problem for small and medium-sized development teams: it handles the paradigm complexities while your people focus on their jobs.
Verbal Score: Very Good
Numeric Score: 8.0
Criteria Score Weight
Flexibility 9.0 20.0
Manageability 8.0 20.0
Performance 9.0 20.0
Scalability 6.0 20.0
Setup 8.0 10.0
Value 8.0 10.0
Cost: US$10,939, includes all components of Visual Studio 2005 Team System plus one year premium subscription to MSDN
Platforms: Windows 2000 SP4, Windows Server 2003 SP1, Windows XP SP2, Windows Vista; x64 releases of Windows Server 2003 and Windows XP
Bottom line: Microsoft’s new Team Suite painlessly replaces the contentious, sequential development paradigm with a fully automated, asynchronous, full-life-cycle application model. Integration with Visual Studio 2005 IDE is impressive.
New tools for testers, and analytics for project managers, really stand out, and team members’ activities and interactions are transparent.