Great talk by a Microsoft Fellow, Brian Harry, about what’s coming in Visual Studio 2008 SP1 and the next release of Visual Studio code named “Rosario”.
Coming up in SP1 for 2008 is some very nice changes for Team Foundation Server/Team Explorer, which is the source control piece. The biggest one that is going to save me headaches is that the “Add files/Folders” dialog has been made smart enough to only show files that are not already under source control.
Also added is some really nice performance comparison tools when running code to check to see how much a change to some code changed the overall performance. This analysis also shows so called “hot paths” that tell you some part of the code that takes the most amount of time, or makes the most calls. It also allows you to see the most called functions and methods.
Coming up in Rosario are a couple of really cool sounding changes: Historical Debugging and Architecture Modeling.
Historical Debugging takes the way we currently debug and basically stands it on its head and allows a “step back” to go backwards. This helps when you’re trying to find out where an exception is being thrown. Normally, when you’re stepping through code, you step over methods until you find the one the exception is occurring in, set a breakpoint there, restart the program and step into that method. This is repeated until you get to actual line with the problem. This can be a very time consuming process. Historical debugging removes the rerun piece by allowing a developer to step back, everything is restored to how it looked before executing the method with the problem, allowing the developer to then step into the method immediately instead of having to stop the application and step back to it.
Architecture Modeling allows someone to define how they feel their architecture should look like, defining all their layers. Then, Visual Studio can look at your classes and their references to each other to catch when you break out of the architecture you wanted to follow. The example given was a web page using a direct access of a data access class instead of going through the data access service layer. Visual Studio will flag this and let you know your architecture has been violated.
Also coming in Rosario are “Gated Checkins”, which won’t allow a checkin if it breaks the build. This means that the build server should never get a build that’s broken on checkin. In addition, the current build available to QA isn’t broken.
One last really cool feature around testing is the addition of being able to test interfaces automatically via scripts. These can be recorded and replayed by testers, or played to a particular point ( i.e. Login, click this, click that ), and the tester takes up manually manipulating from that point. If during this testing, the tester finds a new bug ( or why they are doing manual testing ), the testing can be recorded and this recording can be added to a bug report along with the historical debugging info. This allows the developer to replay the video for showing reproducibility, as well as the state of the application during the bug and the ability to step back and forward around the bug.
This was a great talk, but it’s too bad so many of these features aren’t available for us to use today. As with most things Microsoft, everything I wanted was in the “next release”.