Category Archives: PDC05

Introducing LINQ!

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!

Tag:

Coming soon to a VB near you… LINQ!

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…

Tag:

Talking about VNext…

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!

Tag:

The real reason we have conferences…

I’ve made it to the PDC and managed to dodge, so far, the power outages. Hooked up with a bunch of other VB’ers for dinner and now I’m trying to figure out when I’m going to get everything I’ve got to get done done in the next four days… Dinner, though, was good – good food, good conversation. It occurs to me that one of the real reasons we have conferences is to get everyone out of the office so we can mix outside of the little groups that we tend to move within at work. Lots of good cross-talk from different people in different areas…

Tag:

Why being a developer presenter at the PDC sucks…

See, normally, someone who’s not a developer and is presenting at the PDC takes the technology they’re going to demo, works with it, figures out what works and what doesn’t work, and then writes their demo around that. But since I’ve been actually building a bunch of the technology that I’m going to show, as I work through my demo I keep getting ideas along the lines of “hey, it’s be really cool if this worked.” So here I am, Sunday morning, still adding tweak-level features in the vain hope that I can demo them during my talk. Instead of working on the talk as I really should be doing. No worries, it’s actually all pretty solid and I’ve still got plenty of time for the last bit of polish, but still. Geez…

Tag:

PDC Schedule

Update: I’ll also be at the Tools and Languages track lounge on Tuesday and Wednesday @ 6:30pm for the “Meet the VB team” events. Hope to see you there!

Well, folks, we’re getting close… Did my second session dry run yesterday and we’re headed in to the home stretch! Looking forward to seeing everyone at the PDC. For those of you who’d like to chat about VB, I’m definitely going to be in the Tools and Languages lounge Thursday afternoon after my talk, and I’ll also be at the Ask the Experts that night. I’m also listing the sessions I’m participating in below. Hope to see you all there! 

TLN308  Visual Basic: Future Directions in Language Innovation

Day/Time: Thursday, September 15 10:00 AM- 11:15 AM Room: 411
Session Level(s): 300
Session Type(s): Breakout
Track(s): Tools & Languages

Visual Basic 9.0 will offer radical improvements in its ability to work with data in all its forms: as objects, as XML, as relational data. Join the language architects for a detailed discussion of features such as query comprehensions, object initializers and anonymous types that enable querying data in a more flexible, natural way than ever before. Also, get a glimpse into the future of dynamic programming in VB with coverage of new features intended to radically simplify working with dynamically typed data on the .NET platform.

PNL03  Scripting and Dynamic Languages on the CLR

Day/Time: Friday, September 16 8:30 AM- 10:00 AM Room: 515 AB
Speaker(s): Jim Hugunin, Erik Meijer, Jim Miller, Bruce Payette, Dave Thomas, Paul Vick
Session Level(s): 300
Session Type(s): Panel
Track(s): Tools & Languages

With the recent rise in popularity of dynamic languages as a first class tool for software development, there are new questions around how to effectively use these tools, and how well they play in the .NET ecosystem. Join members of the CLR team, Microsoft languages teams, and external language implementers in a panel to answer questions around when and where dynamic languages should be used, the futures of these languages, and open discussion on the challenges and opportunities of implementing dynamic languages on the CLR.

PNL11  .NET Language Integrated Query End-to-End

Day/Time: Friday, September 16 1:00 PM- 2:30 PM Room: 152/153 (Hall F)
Speaker(s): Luca Bolognese, Don Box, Anders Hejlsberg, Erik Meijer, Dave Remy, Paul Vick
Session Type(s): Panel
Track(s): Tools & Languages

.NET Language Integrated Query promises to extend the .NET platform in new an exciting ways. Join Anders Hejlsberg and other key Architects and designers responsible for creating this new advance in data access on the .NET platform. The panelist will be able to comment on the history leading up to the advent of NET Language Integrated Query, its immediate usages in C#, VB and the .NET Platform generally as well as some thoughts on future directions.

Tag: