Now that we have made the 2010 CTP available for your use ( please see Brian Keller's post for all the details on how to get it, what's in it, activation help, etc. ), I want to start a series of posts designed to bring you up to speed on those bits and give you a better understanding of where we are going for RTM.
In this post, I want to start by discussing the composition of the product, giving some higher level descriptions of the parts of the product that make up the whole, while at the same time discussing the set of problems we are out to solve with this product.
Below is a quick picture of the major areas of the product, grouped by "problem area" or "purpose". The top three areas that I want to hilite are the following:
One of the key value propositions of the product is to provide you the ability to reason over your existing code base. The idea is fairly simple and straight forward. You first need to Understand your code before you can Manipulate it, in order to Leverage that code in some new or existing way. There are an amazing number of real world scenarios that begin with the requirement that you must understand what the existing code base does before successful next steps can be taken.
There are a number of features in the product designed specifically to help you understand you existing or legacy code base. Here are the top three specifically focused on the "Understanding Existing Assets" value proposition:
- Architecture Explorer
- This was first seen at TechEd 08 in a Bill Gates keynote. This overall feature gives you the ability to explorer and visualize your solution / projects inside Visual Studio, allowing you to reason over various questions you may have: "How is this class dependent on this other?" "What assemblies does this assembly reference?" "How many lines of code in this method?"
- "Standard" Graphs
- Common views of your system. In the 2010 CTP, you'll see three menus in the "Analyze" menu item, as well as from the Architecture Explorer tool window, seen here:
- Sequence Diagram Reverse Engineering
- The ability to right click inside a method, select "Generate Sequence Diagram...", resulting in, you guessed it! A sequence diagram! :) To see this in action, check out the video of my PDC talk here, around the 40 minute marker. ( You'll also see that the Generate Sequence Diagram code in the CTP bits are a little, uh, flaky. 😉 ).
I will be digging into each of these areas in future posts, so stay tuned.
The need to describe and design the "should be" architecture, establish common glossary specific to the problem domain, and then communicate those concepts to the rest of the team is another key value proposition we're out to tackle with VSTS 2010 Architecture. This is where our new investments in the UML space come in, as well as increased investments in the DSL Tools ( more on this shortly ).
In VSTS 2010, we are shipping an initial set of five UML diagrams:
- Class diagram ( we refer to this as the "Logical" class diagram )
- Use Case diagram
- Sequence Diagram
- Activity Diagram
- Component Diagram
I should also mention that we will be shipping the rest of the diagrams post RTM, either as PowerTools, or something else we cook up. 😉
Now I mentioned the DSL Tools above. In many ways, the DSL Tools functionality should be included in every box in my initial graphic, as it is one of the key technologies that is supporting a lot of the features already mentioned. For example, all the UML diagrams are built on top of the DSL Tools and runtime. The DSL Tools infrastructure and technologies are so important, we just reorganized last week so that the folks who build that technology are now part of my team! I'm very excited about this, as there are a number of exciting opportunities this will afford this team and our customers, much of which will be felt in the VSTS 2010 release. Stuart Kent, one of the leaders driving the DSL tooling effort, has recently posted on the new features in the DSL Tools in 2010.
Last but most certainly not least, is the need to make all these modeling artifacts a first class citizen throughout the entire life cycle of your software development lifecyle. There are a number of capabilities that we are enabling here in concert with Team Foundation Server and Visual Studio itself.
2010 Architecture edition is deeply integrated into Visual Studio. That integration is felt not only in the fact that all the diagrams and functionality is clearly inside the Visual Studio shell, but we have added a brand new project system inside Visual Studio, designed to house your UML diagrams, and other modeling artifacts, such as the dgml files created via the Architecture Explorer.
These modeling projects can be version controlled right along with the rest of your projects in your solution.
You'll also find a new tool window which is currently called the "Model Explorer" ( I'm certain that will likely change by RTM ), which shows you the logical view of all the modeling elements found throughout your various modeling projects ( you can have more than one modeling project in your solution ).
Our integration with Team Foundation Server goes much farther than simply enabling the versioning of modeling artifacts in TFS. We also support the concept of "Architectural Validation" as a first class citizen in your build and checkin processes. In that PDC video I mentioned earlier, I walk through a bit of what this looks like, starting around the 30 minute mark.
You can also expect further integration with the Work Item tracking capabilities also resident in Team Foundation Server. This feature set didn't make the 2010 CTP unfortunately, but I will be drilling into this functionality in a future post as well. Essentially, we're going to give you the ability to associate any model element with any work item, allowing you to quickly understand how a particular set of modeling or design artifacts are related to a particular requirement, test case, bug, etc.
Consider this a roadmap and first post of a number of future posts where I will drill into each of the areas I mentioned above, and some. Stay Tuned! 🙂