What’s new in Visual Studio 2010 part 1: quick overview of the key improvements

I won’t be the first listing the improvements of a new version Visual Studio .NET and I won’t be the last. This list contains improvements that are most apparent when you work with Visual Studio 2010 as a professional developer. I won’t list the stuff your manager likes, nor will I list the improvements that I consider not too helpful, i.e., that won’t make your life so much easier. This list is, of course, my personal list that I use to convince myself of upgrading (which I have already done by the time I finish this post). This list is what you need in your daily life and what you missed in previous versions of .NET.

Key improvements in .NET Framework and CLR

Here’s what improves your professional life:

• Concurrency finally made it! Parallel LINQ and Task Parallel Library make concurrency just a library call away;
• In process Side By Side execution: libraries can call different .NET versions from the same process space;
• SortedSet generic class, Tuples, BigInteger and even Complex Numbers are added to the BCL;
• Introducing background garbage collection (really!);
• Introduction of the Dynamic Language Runtime which boosts IronPython, IronRuby and F# to the front, as well as giving support for the dynamic keyword in C#;
• Keep an eye out for LoopExpression and TryExpression in expression trees;
• Covariance and ContraVariance are now almost fully supported by delegates and generic interfaces.

Key improvements in C#.NET 4.0, aka C#.NET 2010

While arguably the most-used language in professional development for the Windows platform these days, many eyes are focused on the changes made to the C# language itself. C# 1.0 introduced, among itself, delegates which set it apart from Java. C# 2.0 introduced generics, perhaps to catch up with Java. C# 3.0 (not 3.5 as some may call it) introduced LINQ and, best improvement in history to any imperative language ever, lambda expressions and expression trees. What’s up with C# 4.0? Another ground-breaking feature? Choose your pick of your favorite, time will tell which is the most distinguising:

• Optional parameters. Really, finally. No need for overloading anymore when it’s all too trivial anyway;
• Dynamics support using the new dynamic keyword, already a controversy before it came out;
• Covariance and Contravariance (FAQ);
• Way easier COM interop as a result of introducing dynamics, this is marketed as Office Programmability;

Not that impressive, really. But the second, about C# dynamics, may change your world further than you currently suspect. Is it going to be the end of type safety as some suggest? I hope not, but abuse of a new feature is often around the corner, especially with less-experienced programmers. And surely, you don’t want to go back to this nasty Visual Basic time where everything can be untyped?

Key improvements in VB.NET 2010, aka VB.NET 10

I’ve stopped being a core fan of VB.NET since about 1996, the year I learned Perl, Java and Eiffel. I hardly use Perl or Eiffel these days but VB.NET I encounter with just about every customer I’ve had ever since. Unfortunately, this has only hampered my enthusiasm further and to me, VB.NET is has become the language of choice for Office hackers but in professional development it can do little less than harm. Ok, I’m biased, but here’s a list regardless, with some surprises that should’ve been there in VB 3.0 already:

• Implicit line continuation support. Boy, have I been wanting this feature. Ever tried LINQ with VB? Now you less painlessly;
• Covariance and Contravariance;
• Collection initializers which make initializing arrays and collection a breeze;
• Auto-implemented properties. Yes. Finally! No jealousy towards the C# camp anymore.

If you ask me, the auto-properties and the line continuation (which is still tricky to get right, though!) are too little and too late a features to really boost VB.NET to the professional camp again. But perhaps Microsoft never intended that, which is perhaps why there’s so little effort from them to improve this language seriously.

Key improvements to ASP.NET 2010

Just the list without the fuzz (here’s a full list):

• Split web.config in multiple sections and less (redundant) info by default;
• Cleaner HTML markup and better CSS compatibility;
• JavaScript intellisense improvement, among support for jQuery, prototype and others;
• Web packaging (package as ZIP, unpack and ready)
• Inclusion of and support for ASP.NET MVC;
• Compressed Session State: finally those annoying session states become manageable.

Key improvements, other

While I could drag on, I promised to stick to the improvements that matter to you, the professional programmer. I’m sure you’ll disagree on the lists here, as you will disagree that I excluded WPF and EF so far. And where’s F#? Here’s a short-list of those improvements that I didn’t mention above:

• Improved IntelliSense support in the IDE: much faster, more accurate;
• Introducing F#, a functional language which is here to stay. Solid, concise, succinct and filling the gap;
• Lazy loading in the entity framework, will it really catch up with NHibernate?
• Call hierarchy at design time (!);
• Direct support for contracts like pre- and post-conditions;
• Introducting Silverlight 4.0, finally up to the task;
• UML 2.1.1. support in Team System;
• Consumer First IntelliSense, meaning: if the method is used, but not defined, IntelliSense can still find it;
• Support for multiple monitors and better docking.

Now, the odd thing is, this last item had been there in Visual Studio 6, but never returned. I missed it ever since, and for me, just after concurrency and F#, it’s the best improvement they introduce.

Conclusion

I already said it. F# is my conclusion. Concurrency is mine, too. And some features introduced in the IDE that were missing from earlier editions have made it back. But what will really improve your coding experience? Not everyone will move to F# or find it useful. It’s quite a leap from imperative to functional programming. After working a while with VS 2010, I find myself using the Call Hierarchy, Consumer First IntelliSense and the dynamic keyword (DLR) support the most. They improve my everyday-life with Visual Studio. The others, including concurrency which I so dearly missed, don’t improve my everyday-life, they just make complex tasks easier.