When Jonathan Aneja took over, the first thing he did was have a little fun with the new WPF interface in VB 2010. I've written here about how WPF will become the dominant output technology for Microsoft. (A First Introduction to WPF and XAML for Visual Basic Programmers). This is tangible proof.
The second change you may notice in VB 2010 is No More Underscores! They're not necessary. After Jonathan demo'ed the feature, you wonder why they were ever needed.
You won't be able to simply add a new line in the middle of any statement. For example, the compiler won't recognize End Function on two lines. But it will allow multiple lines for just about anything where you would normally use an underscore to continue the statement. Since underscores will continue to be fully recognized for backward compatibility, they will become like line numbers. There was a time when line numbers were also required, but you never see them now even though they're still supported in VB.NET 2008.
This is going to cause me a lot of work! I use line continuation underscores in most of my examples to get them to fit the About.com web page format. When VB 2010 comes out, all my code is going to look like it was written in the dark ages!
One of favorite upgrade features is that Get and Set for Properties will disappear. Right now you have to code (for example):
Dim _myProperty As Integer
Public Property myProperty() As Integer
Get
Return _myProperty
End Get
Set(ByVal value As Integer)
_myProperty = value
End Set
End Property
There's a lot of obvious, unnecessary code in there. In VB 2010, the same thing can be expressed as:
Public Property myProperty() As Integer
In the unnecessary code department, this code ...
Dim myList as new List(Of String)
myList.add("1st")
myList.add("2nd")
myList.add("3rd")
... can be replaced by this code in VB 2010 ...
Dim myList as new List(Of String)
From {"1st", "2nd", "3rd"}
(And, notice! No underscore continuation character!)
From an architectural point of view, the CLR (Common Language Runtime - the code that actually does the work when your VB.NET 2008 program runs) will be joined by the DLR - Dynamic Language Runtime. Languages like Ruby and Python have been achieving a lot of popularity because they implement "dynamic typing". VB.NET will join the dynamic languages with VB 2010. You'll be able to use IronPython or IronRuby libraries! (Imports IronPython.Hosting)
Dynamic Runtime is essentially "late binding". The methods from those libraries will be found and used by the VB code when the program runs rather than being compiled into the static IL code built by the VB compiler. The way you will write it is just like late binding for existing VB libraries, so if you understand late binding now, this just expands your possibilities.
If you do any VB work using a COM based technology like Excel and Word, you're familiar with PIA's - Primary Interop Assemblies. These DLL's provide the mapping for your code necessary to use the methods and properties. The problem is that they're huge and they have to be. There's a lot of code in Excel and the PIA has to be able to provide an interface for all of it. Right now, the whole thing is not only required when when you're coding, but it also has to be on the client's computer at runtime. This makes your system bloated and slows things down.
VB 2010 to the rescue! When you build your system, the new compiler will include only the types that you actually use in your assembly - no PIA DLL will be required on the client at runtime. This makes your client system much smaller and much faster. But it will be a selectable property for your project so you can still do it the old way if you wish. And there's lots more. Jonathan went through an example of "generic variance" with "covariance" and "contravariance" that even he admitted was at the PhD level. His summary was that generic assignments that used to generate an error will "just work" in VB 2010.
Beyond VB 2010, Microsoft wants to open up the VB compiler and let you call the internal methods that the compiler itself uses. Old-time VB6'ers will recall that the Windows API was the escape hatch when you found that VB6 just wouldn't do something you needed. Dan Appleman made himself famous by writing "the" reference to the Windows API for VB6 coders. "The Compiler as a Service" (that's what Microsoft is calling it for now) will do something like this for the internal functions of the compiler itself.
But to make this happen, the compiler will have to be rewritten in VB.NET. Right now, the compiler is still written in C++. Using VB.NET for the compiler code will also make the compiler more efficient in working with your VB.NET code. Remember ... this is a "future" - not a VB 2010 feature.
Visual Studio 2010 Professional is in "pre-release" beta right now (July 2009). Be brave! Download it and try it yourself.