This is the third and final part to my write up on MDC Chicago 2009.
VSTS 2010
The VSTS 2010 presentation was done by Angela Binkowski, the Midwest evangelist for platform tools. In terms of the quality of speakers, Angela was the best, and one of the better speakers I have seen overall. She is knowledgeable, enthusiastic, and seems to really like what she does, which helps break up the monotony of power point presentations.
The presentation of VSTS 2010 focused on two areas, Testing and Architecture. Based on what I saw, I am really glad I have VSTS Suite so I can get my hands on these new tools when they come out (the current CTP seemed a little buggy, so I’ll probably wait for a more stable release).
TFS – UI: Rich text box control for the history window in TFS. I know there are allot more new features in the 2010 version then just this, but this was pretty much the only one called out. I know Buck Hodges posts stuff regularly to his blog about TFS and new features.
TFS – Builds: Adding support so that you can use Windows Workflow in your builds.
Test Impact Tool: Uses code coverage to indicate which tests you should run in order to validate a change. Since it uses code coverage, it shouldn’t matter if you use MSTest or another testing framework.
While it sounds like a good feature, I don’t see the need for it if you properly write (and break up) your unit tests. One of the core principles behind unit tests, is that they should be written to execute fast so that developers will take the time to run them all. Even if you take a step back to widen the scope to include integration and regression testing, you are “supposed” to run all the tests before you do a check-in.
Gated Check-in: Allows you to run your continuous integration tests before the source code is committed to the source control repository. Since this is a resource intense task, it was suggested that you should only enable this when you are getting close to a release milestone to make sure a bug doesn’t get into your repository.
Functional UI testing: Full support for testing Web pages and Windows Forms applications. By full support, I mean that your test will invoke the controls in the web browser or windows forms app, and not just simulate it (i.e. creating a HTTP request like MS WebTest does today). On the web side, this can be compared to WatiN, Watir, etc. A GUI is provided that helps you record your tests. The example showed tests being created in MSTest (no surprise there), but hopefully there is extensibility built-in to allow for other testing frameworks to be used.
I’ve used the WebTest tool in MSTest, and it works pretty well for getting something setup quickly. I think it works better for load testing, then functional testing, although I haven’t played around with the generated code, which may provide better support for functional testing.
I just started using WatiN, and it will be the standard to which I compare the web test version of this new tool to. I don’t have a windows forms testing tool, and really haven’t seen any free ones out there, so the MSTest version will be a definite addition to my toolbox.
Test reproduction tool (Camano): This is a new tool targeted at testers who follow manual test plans. A set of controls, along with the test script is displayed on the left side of the screen, while the application being tested is displayed on the right. I couldn’t tell if this was all in one window, or if the application runs normally and the test tool attaches to it.
So what does the tool do? It records every action taken to a timeline, and records what the user sees to video. The tool also records the testers system settings, and in the event of an exception, a historical debug trace is captured and attached to the test run. All of this information is then seamlessly transferred to TFS and stored as a new bug work item. The tool is not part of Visual Studio, so testers don’t have to install VS, just the testing tool.
I have been told that the tool doesn’t required TFS, and that it should be possible to package up all of the information that would normally be attached to a work item in TFS, and send it manually to a developer (for those shops that don’t use TFS). I’m not sure on what the licensing for just the testing tool will be.
Architecture – Diagrams: Visualize dependencies by namespace, and reverse engineer sequence diagrams from code were the two diagrams shown. I’ve seem the visual dependencies in nDepened, but it’s nice to see it in VSTS. The reverse engineering of code to create a sequence diagram looked really slick, and I can’t wait to use it. Both additional should help address the problem of stale documentation, as well as helping to get developers new to a project up to speed.
Architecture – Validation: There was some type of validation in the architecture edition before, but it was at a very high level. I tried it out once, and it just didn’t click for me. The validation feature introduces in 2010, allows you to create a more traditional architecture diagram composed of your various layers (UI, Business Domain, DAL, Infrastructure etc), define allowed relationships, and then drag and drop your classes onto the different layers. VS will then make sure that classes do not make calls to other classes unless they are allowed to (for example, your UI can’t use the DAL directly).
As with the new visual dependency and sequence diagrams, this is something that I think will be useful, especially for when you bring new members onto a team. It too also addresses the issue of stale documentation, as it will need to be updated in order for your solution to build.
While you need Architecture edition or Team suite to edit the files, they are supposed to be available in a read-only mode to any other version of Visual Studio. The validation is also supposed to work across all versions.
Dotfuscator: At the end Angela turned the presentation over to someone from the company that creates Dotfuscator, which has been included with VS since it’s initial release in 2001 I believe. The guy walked, talked and acted like a salesman, but at least he knew his product.
The three features talked about was the ability to add instrumentation, anti-piracy, and centralized logging to your application. All of the work that dotfuscator does, happens after your application is compiled. The Dotfuscator tool inspects the IL and lets you select, down to the method level, where you want to add the instrumentation, logging etc.
The instrumentation feature includes items such as what features are your customers actually using (by injecting a call into a entry method that defines your feature), how many people are using trial versions of your software, etc.
The anti-piracy is a special type of instrumentation that is supposed to alert you if someone tampers with your software. My thought is, if someone hacks your software, wouldn’t they be able to hack the dotfucscator code as well?
So how do you get all this information? The third feature was the centralized logging feature, that allows you send all this data back to your company via the Internet. Of course this brings up huge privacy concerns. It was suggested that could add a opt-in screen for more general purpose metrics, but what about the anti-piracy functionality? Would you actually give someone the option to opt-in to the anti-piracy feature, and who would actually opt-in? Even as a software developer, I take issue with software that reports what I am doing without my consent, even if I was “pirating” the software. Software companies do no own my PC, nor do they pay for my Internet connection.
Asp.Net Futures
The final session of the day was on Asp.Net futures, and showed stuff for both Asp.Net web forms and Asp.Net MVC. Most of the material on Asp.Net MVC was stuff I was already familiar with given my recent deep dive into it.
Asp.Net 4.0 focuses on 4 themes:
- Better support for standards (HTML, CSS, etc)
- Easy to create LOB and extend data driven web sites
- Support pattern based development (MVC, TDD)
Re-invest in the core, address top customer pain points (new caching interface)
The new features in web forms talked about were:
- Generate client ids (should make scripting and testing easier)
- Transparent support for CSS (default to CSS instead of tables)
- URL Routing (Already available in Asp.Net 3.5 SP1)
- View State
- Ability to disable view state on the page, but enable it on a specific control
- Ability to disable view state on a control, but enable it on a sub control
- Better support for no view state on grid/list view
There was a pretty nice demo showing off Asp.Net MVC and Asp.Net Dynamic Data. Dynamic Data is a recent addition to asp.net that allows you to quickly generate CRUD functionality on your web site, and have it updated as your data (schema) is updated. The view is all controlled by templates so you can arrange the controls created however you want. I’m still missing the a-ha moment with the dynamic data stuff, and need to sit down and play around with it.
All in all, I really enjoyed the trip down to Chicago for MDC. I hope that Microsoft continues to offer these one day local events after each of the three major conferences. Ideally, I would like to see them happen a little sooner after the conferences, as they are really targeted towards those who didn’t go to major conferences. I would also like to suggest that the goody bag contain a DVD with all of the major conference presentations.
Dotfuscator’s anti-piracy isn’t really instrumentation as such. It does several things to obfuscate your code, such as renaming all of your methods to a, b, aa, bb, overloading as many different method signatures to use the same name, inserting goto commands and other branching to confuse the logic flow, etc. That way, when you look at the code, the names are meaningless, and it’s much more difficult to determine what the code does or how it does it.
There are several obfuscator products out there, primarily for protection of thick-client software. Dotfuscator wasn’t very good the last time I used it (about two years ago); it had problems with default scenarios in Compact Framework, especially around Windows Forms resource naming and such, and the UI was pretty horrid. But it could have improved a lot since then, those problems could have fixed, etc.
I don’t know if they are coming out with a new name for a suite of products, but the presentor only referred to the Dotfuscator name. I found this video on Channel 9 that talks about the new features: http://channel9.msdn.com/shows/Inside+Out/PreEmptive-Feature-Monitoring-Usage-Expiry-and-Tamper-Defense-in-Visual-Studio-2010/