Slashdot Mirror
First Look At Visual Studio 2010 Beta 1
snydeq writes "InfoWorld's Martin Heller takes VS2010 Beta 1 for a test drive and finds the upgrade promising, particularly with regard to improved thread debugging and a revamped UI. But the biggest enhancements have to do with parallel programming, Heller writes. 'I'm not sure that I've completely grasped the power of the new .Net Framework and native C++ support for task and data parallelism in VS2010, but what I've seen so far is impressive.' Heller points to intriguing parallel programming samples posted to CodePlex and offers numerous screenshots of VS2010 Beta 1 functionality. He also notes that the beta still lacks support for ASP.Net MVC, smart devices, and the .Net Micro Framework."
ParallelFX is definitely interesting, but I'd say that another very major addition is Visual F# - to the best of my knowledge, this is the first time a primarily functional language goes mainstream, and gets documentation, tooling (IDE/debugging/profiling), and general support on par with the likes of C# and VB. It's not Haskell (read: no typeclasses), and it's not quite OCaml either (no functors), even though the core language is recognizably ML. But it's got most of the nice FP bits OCaml has to offer, some syntactic sugar on top of that (e.g. ability to declare locals as mutable when needed, and arithmetic operators overloaded for all numeric types), and it's got direct and full access to one of the largest class libraries on the market today.
(I'm sure someone will remind me of Scala, which is in many ways similar to F#. It's definitely comparable, but its tooling support is lagging behind, and, most importantly, it's not backed by any of the "big players" in Java land - not Sun, not Google, not IBM - or indeed, any other company.)
The second, smaller, but still interesting bit is improved language interop. It seems that, as new core (i.e. MS-supported) .NET languages are added to the batch, the framework itself is extended as needed to provide primitives for them where more than one language uses them. For example, both F# and IronPython work with tuples, but they have previously each defined their own type for that - and so .NET 4 introduces the standard System.Tuple type, and all languages are changed to use that. So now you can actually make a tuple in IronPython, and pattern-match it in F# - nice.
Another bit along the same lines is C# 4 dynamic type - which is nothing but opt-in duck typing - and the associated DLR framework for exposing runtime dynamic type information in a common way. This means that static/dynamic language interop on .NET is now two-way - previously, you could easily call C# class methods from IronPython/IronRuby, but there was no easy way to call methods on IronPython/IronRuby objects in C# - but now you can do the latter just as easily.