Bernhard Glück

Beta 2 of Visual Studio 2010 has arrived and is available for download for just about anyone to grab.

I’ve played around with this release for a week now ( Msdn release was a few days prior to public availability )
and so far my feelings are best described in romantic terms: Love at first sight.

There are so many great features/improvements that I just don’t know where to begin, but I’ll try anyway.

For the first time since Visual Studio 6 back in the 90s, online help is fast again. Microsoft rewrote the complete help
system and based it around a small local Web server that serves Javascript enriched help content.
Hovering on some identifier, pressing F1 and waiting for the new context sensitve help to pop up takes about 0.5 seconds
on my local machine.

TFS Basic is great. I stayed clear of TeamFoundation server for the last releases since my initial evaluation turned out that it did
not offer much over other tools, but required insane ammounts of hardware and installation/administration effort that just were
not easily recouped by it’s functionality.

TFS Basic installs easy, fast ( 20 minutes for me without any error whatsoever ) and runs even on client OS editions if you’re into that.

UML Modelling support has finally arrived, of course it’s the first release, and code generation support seems not to be on the agenda, but
for some fast and simple diagramming it’s certainly enough.

The C++ compiler supports a few things from the upcoming revised standard, like the auto keyword, lambda functions and nullptr.
TR1 support has also matured and so we can write even better standard compliant code right now.
Performance of C++ intellisense seems also much better, especially with larger codebases.
Also C++ finally uses Msbuild for it’s build system as well as project files. So codebases that mix C++ with C# are now much easier to handle
in build environments.

For C# we have of course the new dynamic dispatch features, as well as optional and named parameters, and better co/contravariance support for generics.
I still don’t like dynamic dispatch support, simply because I think it will be used for all the wrong reasons, and because it throws out a lot of the investment
in static source code analysis technology, and proofing program correctness.

On the runtime side of things, of course we have additions to WCF/WPF a completly rewritten Workflow Foundation, and many other small things like
a few conveniance methods ( string.IsNullOrWhiteSpace ).

The Task Parallel library is a godsend, but I am still in fear of it’s usage patterns. I see a lot of developers who are not experienced in multithreading
just use things like Parallel.ForEach or PLINQ because it’s so damn easy thereby ignoring the concurrency issues, producing code that will just fail
at unpredictable times.
At least we have some by default threadsafe collections now, but the performance implications of those must not be overlooked, collections are rarely the
right place for some last effort “catch all” synchronization.

Things like native support for Memory Mapped files, the inclusion of Code Contracts which were previously available as an addon, as well as conveniance
data structures like tuples or sets round off the framework itself.

The client GC can now do parallel garbage collections under certain circumstances ( during full collections a certain number
of allocations can be still be done while the collection is running ).

The server GC does not support this apparently because of lack of development time, which is really not nice, since especially there it would have resolved certain issues in long running applications
that have bitten me in the past.

Last but not least ADO.NET Entity Framework is in it’s second release, supports forward engineering finally, and generally seems much more mature now, time to take it for a spin in the next few days.

All in all a great release, and the nice WPF UI of Visual Studio just make working that little extra spicy, so in conclusion: I really like it !

As a friend asked me today, what kind of tools I use for my day to day .NET development work in addition
to Visual Studio, I thought I’ll whip up a list, and include some not so common tools as well.

So here it is:

Resharper: Not much to say, if you still write C# code without it, you can’t be helped.

Regionerate: Code layout/reformatting on steroids. A time saver if you have to reformat a lot of inherited code.

StyleCop: Code style analysis, based on the .NET framework design guidelines by Microsoft. There is also a plugin for Resharper available that executes the analysis in the background while you work. ( http://www.codeplex.com/StyleCopForReSharper )

Sandcastle for Visual Studio: Allows you to create documentation projects in a solution and automatically build
Msdn style documentation based on xml documentation comments, and manually edited content.

FxCop: Static code analysis. This is of course included in Visual Studio, but I am often surprised how little people make use of it, so I thought I’d mention it anyway.

RockScoller: Addin that provides you with an overview of the source file you’re working on. Great for large files.

Pex: Automated white box testing for your code. Allows you to generate unit test code by executing your code and trying to find the weak spots.

Chess: Automated testing of multithreaded code, to detect interleave patterns that cause deadlocks/livelocks or race conditions in your code. This is a godsend, I can’t reiterate enough how great this tool is.

InteliShade: HLSL syntax highlighting and intellisense support. For the graphics developers among us.

Code Contracts: Code contract support, which allows you to add precondition, postcondition and invariant checking code, enforce it at runtime, and find weak spots through static analysis.

Pinvoke.Net: Easy lookup of P/Invoke signatures for those pesky Win32 API imports ( and a lot of others ).

PostBuild.Net: Code obfuscation, compression and virtualization. Allows you to deploy your .NET client applications to systems without them even needing .NET installed.

PostSharp Great tool for post build code modification with included AOP support and msbuild integration. Use it for post processing your assemblies, injecting code, or modifying it.

Visual WebGui: Build AJAX or Silverlight based RIA applications with a development model similar to Windows Forms.

Script#: Write code in C# with a special class library, and have it automatically translated to client side JavaScript code at build time. Great if you don’t like the JavaScript syntax or object model.

VisualSVN: Work with Subversion from Visual Studio, based on the familiar TortoiseSVN base platform. Beats any other integration hands down.

Of course I left out some others, so if you have any ideas of tools to add, leave a comment.

Thanks to the new WPF based GUI of Visual Studio 2010 there are some noticeable cosmetic improvements.
Most of you might already know this, but the text editor supports arbitrary zooming now. Simply hold down
your CTRL key and use the mouse wheel to zoom in and out. Thanks to the much improved text rendering
support in WPF ( ClearType and sophisticated hardware anti aliasing using shaders ) the results are quite gorgeous in my opinion and make for great presentations on large displays or projector screens:

The theme i am using is Vibrant Ink by the way, a quite natural port of the same theme from TextMate.

No, I am not playing the game, ( that should be left to way smarter people than me ) but fiddling around with Microsoft CHESS a product by their research group, that is going to be included in Visual Studio 2010. Right now it’s available in Beta form and it simply rocks.

The basic premise is that a new Test Runner for the Microsoft Testing Framework will run your unit tests that make use of multiple threads a large number of times with different thread interleave patterns, and thus detecting many kinds of threading bugs in your code.

After it has found a thread interleave sequence that will make your unit test fail, you can save this information and add it to the unit test itself, making your unit test reproduce the problem each time reliably.

This is simply a godsend, and the magic does not stop there.

While debugging the running unit test you can also break on any thread preemption which are very likely the spots in your code that actually contain the code that is the root cause of your bug.

So give this awesome tool a try, and write even better multithreaded code.

Microsoft Chess