You’ve probably seen this elsewhere, but… The PDC05 videos are now online and available to anyone who wants to watch them for (I believe) the next six months. You can catch my sessions there in case you missed the fun the first time around!
Now that I’m back, safe and sound, in Seattle, I can start to catch up on some of my blog backlog! So let’s start with the highlight of the trip, my talk. I was a little nervous about it, but the worried turned out to be for naught — the session went really well! Lots of people showed up and we had a good time talking about all the ideas we’ve been working on for VB 9.0.
I’m not sure what the plans are in terms of making slides available outside of the PDC. You can find a bunch of the VB 9.0 PDC information here, and I’ll be talking more in upcoming months about the stuff we discussed in the talk. As I said in the talk, too, there’s a lot more going on than we had time to talk about in the session, so we’ll be talking more about that stuff, too!
The audience reaction was very positive. People were extremely excited about LINQ, the VB query syntax and, especially, the integration of XML into the language. Got a lot of comments on that.
This is just the beginning, more to come…
Still not at a point to post more about how the session went (long story, short: very good), but I had a funny moment just a second ago. I was looking at the internal website that has speaker evaluation information to see how people liked the session. Pulled up the data and sorted it in Excel. Then I was thinking, “You know, I really want to filter out sessions that didn’t get a lot of feedback reports because they might skew the data.” Since I’m not an Excel expert, the thought occured to me:
You know, I could just fire up my LINQ-enabled VB that I demo’ed today, save the Excel file to XML, read the XML into XLinq and then write a query on that data and then I’d be able to use VB instead of having to figure out all that Excel stuff.
What happens when you drink your own Kool-Aid? I guess I’ve found out…
The session was just wonderful, a total blast, but more info on that later… But please do fill out the online evaluations! It’s something you can do to help me be a better speaker and let us know how much you liked the content!
During my talk, I raffled off 6 signed copies of my book:
Without further ado, the following were chosen at random as winners:
- Chris Bradley
- Brion Burghard
- Anthony Parkinson
- Rupesh Sanghavi
- Roger Andrews
- Derek Sipe
(Apologies for any typos.) If you’re one of the lucky winners, please stop by the VB team table at Ask the Experts tonight and claim your signed copy!
…as Hannibal (A-Team Hannibal, not Lecter) would say.
See, I’m kind of a last-minute kind of guy. Not the absolutely last minute, but I tend to work stuff out in my head for a while before I actually start doing anything concrete, and that can be a little disconcerting. Amanda has been bugging me for the past month about my presentation, asking me if I needed help with the demos or wanted her to review the slides. I’m sure that her help would have been great, given the number of presentations she’s done, but I wasn’t able to take advantage of it too much because most of the stuff was in my mind for most of the time. It’s only been in the past week or two that things have really solidified. A little nerve wracking for her, but we’ll see whether it pays off today…
The turning point with the presentation, as always, was in the final dress rehearsal. Yesterday I had a bit of onsite speaker training with Richard Klees, who does a lot of this stuff for Microsoft conferences. The focus was on presentaiton style, not substance, and we covered a few things that were really killing my flow. The biggest thing I needed to work on was something I remember well from my acting days in high school: no matter what happens, no matter how badly you’re messing up, no matter how many lines you just missed, don’t break character. The truth is that if you just keep going like everything is normal, most people will never notice. And even if it’s so bad that people do notice, if you carry on and get back into the groove, most people will forgive and forget. The audience, by and large, wants you to succeed. As long as you’re not boring them, they’re on your side.
We’ll put that to the test this morning.
This does remind me of a funny story. My senior year of high school, I was in a production of “the Scottish play” being done by a local theater troupe (the Young People’s Performing Company, or YPPC). I was playing MacDuff, and early on in the play, I was in a scene where I was supposed to chat for a little while with MacBeth and then a servant comes on stage and announces the king is coming. After the servant’s speech, MacBeth turns, looks off stage, and says something to the effect of “Why, yes, here is your master now,” as the king comes on stage.
Well, during the second or third performance, everything is going great until the point at which MacBeth turns, looks off stage and says “Why, yes, here is your master now.” Instead of the king standing there, ready to enter, there was just some random cast member who gets a sudden deer-in-the-headlights look and then scurries off as he realizes that the king is supposed to be standing there and isn’t. MacBeth, myself and the servant stand there for an awkward moment until, finally, MacBeth says to the servant, “Hmmmm. Perhaps not. Perhaps you should go get thy master,” to which the servant replies, “Good idea.” Exeunt servant to go find the king. After a moment, the errant king shows up on stage, starts his speech, and on with the play.
Hopefully, nothing like that is going to happen today, but if I could make it through that, I’m sure I can make it through any flubs I might make in my presentation today…
Throughout this week and beyond, we’re going to be doing a lot of talking about Project LINQ, so I wanted to start with a relatively brief overview of what the project is, what its goals are, and how they apply to VB.
To start with, LINQ stands for “Language Integrated QUery.” LINQ fundamentally is about integrating query operations into the .NET platform in a comprehensive and open manner. It’s also about providing a unified way for you to query across any kind of data that you have in your program, whether it’s relational, objects or XML. This, we believe, will represent a tectonic shift in the way that VB programmers will work with data. The possibilities that having query capabilities always available right at your fingertips, regardless of the type of data you’re working with, are immense and will fundamentally alter the way people program.
The core of LINQ is a set of API patterns. I say “patterns” instead of “interfaces” or “classes” because we want to maintain maximum flexibility in our ability to provide querying for any kind of data, regardless of whether it has a particular object model or interface implemented. These API patterns specify how an object model can become “queryable,” and they cover all the basic query operations that we know and love: projection (select), filter (where), grouping (group by), ordering (order by), joining (join), etc. By implementing this API pattern, any data provider on .NET can become queryable. There is also a lot of flexibility as to how a data provider can become flexible — i.e., whether it wants to delegate most of the work on querying or whether it wants to do all the work itself.
(It’s also important to note that these patterns are fully compatible with .NET 2.0 and require no additional platform features. They’re totally implementable in VS 2005, so you won’t need a new CLR to use them.)
We will also be providing three implementations of the LINQ API patterns that cover 95% of the types of data that people need to query: relational, object and XML. First, we will provide a set of “standard query operators” that will make the interface IEnumerable(Of T), the fundamental collection interface on the .NET platforms, queryable. Second, we will provide a component called “DLinq” that implements a query-enabled object/relational mapping service which allows querying over remote relational data. And third, we will provide a component called “XLinq” that implements a very lightweight, query-enabled XML DOM. By hitting each element of the ROX equation, we believe we will provide a query solution for most situations right out of the box.
Now we get to the languages, which is where the fun really starts. Any .NET-enabled language is free to build extra language support on top of the LINQ API patterns, and VB and C# have already begun to do so. Although you are welcome to call the lower-level APIs directly if you like, VB will provide a set of “query comprehensions” that provide a very natural, SQL-like syntax on top of the LINQ APIs. For example, if you have an array of Customer objects, you can write a query that looks like this:
Dim custs() As Customer = ...
Dim waCusts = Select c.Name, c.City From c In custs Where c.State = “WA”
This high-level syntax then compiles down to calls to the standard LINQ APIs. This means that you can learn a very simple, natural query language that then applies across any component that is query-enabled, including the standard query operators, DLinq, and XLinq. (C# will also be providing a high level syntax that is similar, but not the same. We’ll be talking about some of the differences as we dig more into the syntax.)
So far we’ve been discussing things that are general to the platform or apply to both VB and C# (modulo the differences in approaches). However, there are a several things that are specific to VB that play a role in the LINQ project.
The first is that we’ve been working on several features that we believe will make working with dynamic data easier. By “dynamic data,” I mean data whose schema is flexible, malleable or likely to change. The best example of this is XML data — although there is plenty of highly schematized XML out there, there is a vast sea of XML data for which no schema information exists or for which there is no 100% solid schema (RSS is a perfect example). For languages that understand only static type information, this means that when you deal with dynamic data, you frequently have to do a lot of extra work to access information, for example you end up writing:
XElement ord = ...;
int amount = (int)ord.Element(“amount”);
instead of something much more natural like:
Dim ord As Order
Dim amount As Integer = ord.amount
So, what we’ve been doing is taking VB’s historical embrace of dynamic binding (aka “late binding”) and extending it further to make working with dynamic data such as XML and relational much easier.
The other major thing we’ve been working on is making it much more natural to read and produce XML data. XML has become the lingua franca of the Internet and XML should be as easy as possible to work with. We’ve been exploring ways to take the XLinq API and add syntax that looks and feels very natural, but still compiles down to regular API calls:
Dim orderAmount As Integer = 10
Dim order As XElement = _
<% orderAmount %>
Dim orderDate As Date = CDate(order.@date)
As you can see, the LINQ project is extremely ambitious and this blog entry has just scratched the surface. In conjunction with the PDC, we are releasing a bunch of preliminary information about LINQ and about VB LINQ support specifically. There are documents describing in more detail a lot of what I discussed here today, as well as pointers to preliminary bits. (I would emphasize that word “preliminary” as in “lots of things don’t work yet.” We expect to roll out new bits regularly as functionality comes online.) I encourage everyone who’s interested to check them out and then check back here regularly. I’ll be talking in more detail about a lot of this stuff as time goes on and we’re looking forward to your feedback!
Today at the PDC, we’re launching “Project LINQ,” and it’s big. Really big. I mean, really, I wish I had the money to hire those guys who do the movie trailer voiceovers (and you know who I’m talking about):
In a world torn apart by incompatible conflicting and incompatible data domains, one company dared to stand up to the status quo. (Shots of scowling programmers looking at computer screens. One desperate programmer exclaims “We just can’t make it work!”) Doing what they said couldn’t be done, that company cut through the artificial barriers separating the world’s data, making querying relational data, object data and XML data as easy as a stroll in the park. (Voice over of programmer gasps, “Oh my god!”, fade out to black.) Now, a project that was millions of years in the making (well, two actually, but this is a trailer, after all) arrives to change all the rules: Project LINQ!
(This project not yet rated. No one under 17 admitted with out parent or guardian. See website for more details.)
But enough foolishness. Let’s talk real turkey…
Today marks the beginning of one of the bigger experiments that I’ve been a part of during my 13 years at Microsoft. No, I don’t mean any of the new technologies that we’re going to start talking about today and through the week. The grand experiment that we’re beginning at this PDC is radically opening up the development process within the Visual Basic group (and the rest of our division) in ways that we’ve never attempted before. I’ve been through a bunch of product cycles up until this point, and it’s never been the case that we’ve been so prepared to talk about so much so early. To be honest, I’m pretty nervous about the whole thing, but very excited as well. We’ve got a lot of great ideas and it’s wonderful to be able to really engage with people about them.
Before we start getting into this stuff over the course of this week and beyond, though, there were some basic questions that I wanted to address up front.
What version of VB are we going to be talking about? When is it going to ship?
We’re talking about the next major version of Visual Basic. It’s way too early to put any kind of timeframe on the release, especially given the fact that VB2005 still isn’t out the door.
Why are you talking about it, then, if the current version still hasn’t shipped?
As you’ll see throughout the week, we’re contemplating some major features for VB and the platform. These features are big enough that customer feedback is going to be essential to help guide us through the design phase to ensure that we produce a version that is both complete and addresses people’s needs. Waiting until the design is finished and we’re in beta would preclude the possibility of certain types of design changes that may be highly desirable. Early exposure is key.
I should add that none of this should detract from the awesomness of the current release. VB2005 is a kick-ass product that is the best version of VB yet. All of the work that we’re doing now is purely additive — making an awesome product even more awesome — so you can start using VB2005 as soon as its released and know that it’s going to get even better in the future.
Are you going to ship everything you talk about at the PDC exactly as you presented it?
The main purpose of talking about this stuff so early is so that we can get a lot of feedback on our plans. If everyone loves everything we’ve done exactly as it is now, great! We’ll go home happy. However, living here in the real world, as I do, I expect that plans will change one people start engaging with the features. Not too much, I hope, but I’m not a psychic…
Is what you’re presenting at the PDC the feature list for the next major version of VB?
Hardly. The next version contains some “big bets” that we’re getting out there early for extra feedback, but the stuff we’re talking about this week is not going to be the end-all, be-all of the next major version. There are still plenty of other things that we’re considering, just not on the scale of some of the stuff we’re discussing now.
I’m not going to be at the PDC. Am I screwed?
Not at all… We’ll be talking about everything here (in the VNext category) and elsewhere. Stay tuned for more information!