Microsoft is offering a first look at the next version of its Visual Studio integrated development environment (IDE) and platform, which will be named Visual Studio 2010 and the .Net Framework 4.0. There's a lot promised in the new release (expected to ship, duh, in 2010), from improved software testing tools to software engineering modeling capabilities to integrated development and database functions for the application lifecycle management (ALM).

I could bulk that up with a lot more feature buzzwords, but the bottom line is that Microsoft is putting its attention on improving Visual Studio for the benefit of every one of its users—from the CIO to the software architect to the enterprise developer to the software testing team. I was given an overview of some of these new-and-improved features, particularly in Visual Studio Team System 2010 (VSTS, code-named Rosario) by Dave Mendlen, Microsoft's director of developer tools, and Cameron Skinner, VSTS product unit manager.

Assemblies (Image supplied by Microsoft)

But it would be too easy to simply report on vendor promises and rely on my own jaded programmer-meets-journalism background. With Microsoft's permission, I shared some of the product details with experienced programmers and software quality assurance professionals, so you can learn how the software developers in your shop may respond to the new software (or at least, to its promises based on demo-ware).

A key goal in VSTS 2010, says Microsoft, is to help democratize ALM by bringing all members of a development organization into the application development lifecycle, and remove many of the existing barriers to integration.

One way that Visual Studio 2010 will do this is to break down the ALM roles, from the business decision maker (who needs a project overview but doesn't want to be bogged down in details) to the lead developer or system architect (who enables the software infrastructure and draws the blueprint), to the developer who writes the code and the database administrator (DBA) who integrates it with the company database to the testers (who make sure the software is of high quality).

For the IT manager or CIO, says Mendlen, VSTS will give clarity and visibility into the state of the project throughout the lifecycle, using Team Foundation Server-enabled dashboards customized for her role. The dashboard can answer high level questions such as ongoing project cost or project status.

Agile Tools, Built-In

Visual Studio 2010 also will sport features to integrate Agile methodologies into the tech stack using Team Foundation Server. Skinner explains, "We'll include in the [VSTS] box an Excel workbook for teams that are leveraging, say, the Scrum process so they can get burndown from their project." These features, he says, will let Agile teams track daily progress, see projects broken down into iterations and use sprints.

The result of right-clicking on a method in the VS text editor, selecting "Generate Sequence Diagram⬦". A UML 2.1.1 sequence diagram depicting the call chain originating from the selected method. (Image supplied by Microsoft)

Skinner and Mendlen are obviously very proud of Microsoft's investments around modeling, pointing to the company's recent membership in the Object Management Group and their work to advance design tools with UML. They aim to take these software engineering efforts further. "Tools for architects have traditionally been designed for that population," says Mendlen, "But they could be useful across the lifecycle. One place we think that's very valuable is for developers."

So in this upcoming Visual Studio Team System, an "architecture explorer" tool will let the user interrogate the code base and graphically display its architecture, including the relationships in the code and their dependencies. Microsoft hopes this feature will help developers see what their code really looks like (not just what they imagined). While this feature will obviously be valuable for iterative development and debugging purposes, it also will help a developer who inherits a project and needs to figure out its design. If it works as promised, it might help save a developer a pizza-and-Jolt fueled weekend spent wondering, "What the heck is this F variable supposed to be doing?"

"I love the idea of the architecture map for inherited projects that are not well-documented," comments Julia Lerman, .Net Mentor and author of O'Reilly's Programming Entity Framework ."Or better yet, when I return to an old project that I wrote for my own personal use and didn't bother to document very well."

Cory Foy, a development manager from Tampa, is a little less thrilled by the promised architectural validation features. "This has been somewhat available in the Team Edition for Architects," he says, but "I've known very few teams who have bothered," Foy says. "The concept is wonderful sounding, especially to a CIO or development manager: Draw a diagram of your data center, of your deployment, of your application and of your architecture—and you can magically 'validate' that everything will work when deployed," he explains.

In practice, however, even when teams go through all of that effort, someone has to maintain all of those diagrams, Foy says. "They typically fall out of sync rather quickly, and just as quickly get abandoned. Until there are ways of automatically keeping those things in sync (datacenter machines report out what they have, applications report what they need based on dependencies, deployment diagrams are generated from build scripts, and architectures are created based on code), and all of this is automated as part of the build/continuous integration process) I predict this either not being well adopted, or being a hindrance."

The last release of Visual Studio had support for a continuous build process. Inspired in part by Agile methodologies, says Mendlen, "We're taking it to the next level." The build process will have a customizable workflow engine, ensuring that, say, when a developer checks in her code, it goes to the architect. The build process can be tuned for the specific problem domain, Mendlen says.

Part of that build process includes architectural validation. If the software specs say that the user interface code must not directly call the data layer, VSTS will be able to flag as an error any code that breaks that rule. New tools will help the development staff visually draw diagrams that describe the software's architecture, and map the physical assets to existing code. As part of the check-in policy, says Skinner, "We'll tell if the code is abiding by those constraints" and let the developers act on it appropriately. Just what a developer does about noncompliance is up to the development team leaders; besides, these architecture validation features are just as likely to identify design bugs as they are check-in noncompliance issues.

"The more that Microsoft is [enables] developers to engage in Agile techniques, right out of the box, the more adoption you'll see," opines Lerman. "I've witnessed this in the .Net user group I lead. Once unit testing was embedded into VS2008 Professional, many members were suddenly interested in learning how to test—even though tools like nUnit have been around and highly regarded for years."

Next: Putting Quality Earlier in the Development Lifecycle