A Suggestion for Technorati's Blog Authority Ranking Algorithm

Technorati's Director of Product Development, Dorion Carroll, announced on May 5, 2007, that henceforth the firm will rank blogs by Authority rather than "N blogs link here" and "X links from Y blogs." Technorati determines Authority by the number of links from unique sites during the preceding 180 days. 

I've added a Technorati Authority widget below the LINQ and Entity Framework popularity graphs.

The change made no appreciable difference in the OakLeaf System blog's ranking, which was Authority = 94, Rank = 45,767, and 218 links when this post was written. The main blog page has had a constant Google PageRank of 0.5 for many months.

I believe Technorati needs to use a different algorithm if they're going to claim to rank Authority. If the Authority of a blog is based on the number of inbound links from unique sites, the measure should take into account the Authority of each linking site. That is, a link from a blog such as Michael Arrington's TechCrunch (Authority = 18,372, Rank = 8, Links = 128,985) or Mary Jo Foley's All About Microsoft blog (Authority = 1,431, Rank = 1,110, Links = 3,974) should carry more weight than links from Splogs or LinkBlogs with no authority. For starters, I'd recommend not counting links from blogs with Authority < 1.

Summing the authority—rather than the number—of each unique linked blog won't work because doing so would add excessive weight to Authority. However, a root that weighs inbound links from the top blog say 10 times those of a blog with Authority = 1 might be appropriate. The top-ranked blog is Engadget with Authority = 27,553 and Links = 595,691.

Using the 0.228th power (~4.4th root) of Authority (Authority^0.228) = 10.08 for Authority = 27,553 provides the following Authority multipliers with the four blog examples in this post and more common lower Authorities:

Blog	Authority	Multiplier
Engadget	27,553	10.1
TechCruch	18,372	9.2
All About Microsoft	1,431	5.2
OakLeaf Systems	94	2.8
Many Blogs	10	1.7
More Blogs	5	1.4
Most Blogs	2	1.2
Lowest-ranking Blog Counted	1	1.0

Obviously, rankings would change substantially because the Authority of blogs' inbound links would increase, so the exponent might need to be recalculated frequently when transitioning to the new method. Limiting the Authority refresh frequency would aid in reducing the resources devoted to the calculations.

What's your opinion?

Technorati tags: Technorati, Authority, Rank, Links

New Series on Closures in Visual Basic 9.0

If the term "lifting the variable x" leaves you scratching your head, read Jared Parsons' multi-part Closures in VB blog series. Jared is a developer on the VB team working with the VB compiler and debugger.

Jared describes lexical closures (usually just closures) as:

[T]he underpinnings for several new features in Visual Basic 9.0.  The[y] are part of the guts of Lambda and Query expressions. ... A closure is a feature which allows users to se[a]mlessly access an environment (locals, parameters and methods) from more than one function. ... Closures are responsible for making the single variable "x" available to [multiple] functions in a process that is referred to as "lifting the variable".

Update: 6/15/2007: Following are links to the first two four members of the series:

1. Closures in VB Part 1: The Basics (May 2, 2007)
2. Closures in VB Part 2: Method Calls (May 3, 2007)
3. Closures in VB Part 3: Scope (May25, 2007)
4. Closures in VB Part 4: Variable Lifetime (June 15, 2007)

Jared says:

This will be a several part series on Closures in VB 9.0; how they work, their limitations, pitfalls surrounding their use. 

So I'll add links to later series members as Jared posts them.

Update: 5/11/2007: If you'd really like to deep-dive into closures, check out these VB 9.0-based posts from Brian Beckmann:

• Lambdas, Closures, Currying, and All That. Behind the scenes, I’m working on the lambda-execution mode for the IQ97. [IQ97 is a simulator of the HP97 programmable printing calculator that Brian wrote in a 2006 CTP of VB9.] I’m hoping for a few tweaks to VB and LINQ before I can do this satisfactorily, but I can take the opportunity now—with the current CTP —to illustrate the general technique of defining with lambda and what I hope it might look like in VB some time down the road.
• Closures without Closures; Currying without Currying. Last installment, we found we could write a factorial function with a function call in the recursive branch, but not a recursive call. This ‘nearly recursive’ style allows us to write factorial without using its name.
• Rebirth of the Y [Combinator]. Let’s review the bookends of our so-far successful foray into recursion elimination. The general theme has been replacement of recursive calls by self-application of functions adhering to recursive types .
• A Hint and a Challenge about the search for a non-recursive implementation of the Y Combinator in VB 9.0.

Mike Champion's Brian Beckmann on LINQ underpinnings - Bringing functional programming to "Mort" post links to a Channel9 interview with Brian, a former cosmologist: Brian Beckman: Monads, Monoids, and Mort.

Update 5/13/2007: Mads Torgersen, a Microsoft program manager who's responsible for the design of the C# language, plows the ground in Brian's neighborhood to prove that you can write write a recursive lambda expression, using factorial as an example, and can substitute a named generic recursive method for the Y combinator. Here's the result:

i => new Func<Func<int,int>,Func<int,int>>(fac => x => x == 0 ? 1 : x * fac(x - 1))(new SelfApplicable<Func<Func<Func<int,int>,Func<int,int>>,Func<int,int>>>(y => f => x => f(y(y)(f))(x))(y => f => x => f(y(y)(f))(x))(fac => x => x == 0 ? 1 : x * fac(x - 1)))(i)

The preceding looks to me like a write-only function because it's impossible (for most folks) to read. Brian's VB examples are certainly more readable. (After reviewing this post, Sahil Malik said C# has become too complicated.) Mads has a few other interesting posts relating to C# 3.0 and LINQ in his "Language Designers Workshop" blog. (He isn't a prolific blogger.)

Update 5/11/2007: Amanda also says that VB 9.0 will get the Let keyword in Beta 2 and Beta 2 will deliver full suport of lambdas by VB 9.0.

Update 5/15/2007: Paul Vick also covers closures for VB programmers in his two-part series on lambda expressions and an earlier post:

• Lambda expressions, Part I: Syntax
• Lambda expressions, Part II: Closures
• Local variables: scope vs. lifetime (plus closures)

Technorati tags: Closures, Lexical Closures, Visual Basic, VB, Visual Basic 9.0, VB 9.0, Orcas, LINQ, Lambda Expressions, Query Expressions

PS: Amanda Silver has posted the slide deck from her VSLive! Orlando The .NET Language Integrated Query (LINQ) Framework presentation. She promises to update this post with links to sample code in a few days and answer questions related to her session.

LINQ to SQL:Entity Framework::REST:SOAP?

There's a current controversy regarding the need for—and desirability of—two object/relational mapping (O/RM) tools in ADO.NET vNext: LINQ to SQL and the ADO.NET Entity Framework and its components. Based primarily on blog posts and comments, the debate appears to center on the following contentions:

1. Entity Framework's three XML mapping files and Object Services layer are overly complex for the needs of the vast majority of .NET developers.
2. Entity Framework is over-reaching by attempting to extend the Entity Data Model to "Replication, Reporting Services, BI, Integration Services, etc.", and remoting as well as lighter-weight incubator applications such as "Project Astoria" and, especially, "Project Jasper."
3. LINQ to SQL satisfies the needs of the vast majority of .NET developers.
4. Entity Framework doesn't provide "Persistence Ignorance"; that is, the persistence layer is limited to relational databases and isn't transparent to the object layer. The current version is targeted on database-to-model implementation rather than the model-to-database approach preferred by domain-driven modeling proponents.
5. Table per concrete object and table per type inheritance models and many-to-many relationships can be added to LINQ to SQL post-Orcas.
6. Entity Framework and LINQ to Entities reduce Microsoft resources devoted to LINQ to SQL, including opening the LINQ to SQL provider model to other database vendors and delivering a once-promised provider SDK.
7. LINQ to SQL wasn't invented by the ADO.NET Team, who developed the Entity Framework in parallel with LINQ to SQL (then DLinq). When the ADO.NET folks got control of LINQ to SQL, they hobbled it with an artificial SQL Server-only limitation.

The preceding contentions closely parallel those in the REST vs. SOAP Web services controversy that's continued since SOAP was Dave Winer's XMLRPC, but began in earnest in mid-2002. Here are some of the common points raised:

1. The SOAP and WSDL specifications are overly complex for almost everyone's needs.
2. SOAP has spawned Web Services (WS*) specifications to support security (WS-Security, WS-SecurityPolicy, WS-SecureConversation, WS-Trust, WS-Federation), messaging (WS-Addressing, WS-Enumeration, WS-Eventing, WS-Transfer, WS-ReliableMessaging), and transactions (WS-Coordination, WS-BusinessActivity, and WS-AtomicTransaction). The WS* specifications are almost impossible to read, understand, and/or implement.
3. REST doesn't support security, messaging, or transactions and most network admins don't permit invoking HTTP's PUT and DELETE verbs.
4. REST satisfies the needs of the vast majority of programmers, content providers, and users.
5. REST can be upgraded with extensions to conventional URI syntax, such as those proposed for Microsoft's "Project Astoria" incubator project.
6. SOAP requires frameworks and/or toolkits, such as Web servers, application servers, Windows Communication Framework, Visual Studio, and/or Eclipse, which developers might need to purchase. Even if open-source, developers must devote substantial time and effort to master them.
7. SOAP and the WS* specifications were subsumed by Microsoft, IBM and, to a lesser extent, BEA and other vendors, who sell servers, SOAP toolkits, frameworks, development environments, security certificates, and/or consulting service. Intraoperability (and some interoperability) issues lead to vendor lock-in.

Discussions re LINQ to SQL vs. Entity Framework

Paul Wilson, the developer of the commercial (US$50) Wilson ORMapper, said on April 29, 2007 Great News: Only One O/RM Shipping in Orcas:

I almost can't believe the great news that came from MS today. That's right, the ADO.NET Entity Framework has been delayed ! I bet most of you think I'm being sarcastic, but I am serious. I've got at least three reasons why this is good news to me.

First, this gives Linq to Sql a better opportunity to thrive. Linq to Sql is the "simpler" OR/M that's looking good enough for the vast majority of cases, while ADO.NET EF is far more complex -- and yet most gurus only wanted to talk about the EF.

Next, since ADO.NET EF is so complicated, it absolutely must have a great designer ship concurrently, which was not the plan. MS has apparently accepted this feedback since this is at least the publicly given rationale for the delay in shipping the EF.

Finally, and this one may not pan out, but it is my own hope that ADO.NET EF is being re-aligned somewhat with Linq to Sql. These two O/RMs are similar enough to share at least some code, and I believe that some of the MS guys have hinted at this too.

So I'm happy that at first there will be one O/RM -- Linq to Sql. The gurus may be disappointed, but the vast majority of MS devs will be new to O/RMs anyhow, and Linq to Sql will be good enough. Very much like my simple WilsonORMapper has been so widely used.

Ian Cooper's convincing April 29, 2007 LINQ to Entities and Occam's Razor post says, in part:

[T]he decision not to support querying to relational stores other than Microsoft SQL Server from LINQ to SQL seems to be deliberately crippling that product for no good reason. The provider model should be exposed and other implementations encouraged. Isn't that the value of LINQ? This feels like an internal turf war over who provides the standard data access layer to .NET developers. As a customer I am not interested in your internal disputes but in solving my customer's problems with your tools. LINQ To SQL should be capable for simple mapping scenarios across backend types and the provider model should be opened up for that. Do not force us to swallow the whole LINQ To Entities pill, just to get support for multiple backends. This is not a reasonable decision.

Similarly I would hope that later releases of LINQ to SQL could be enhanced to support many-to-many associations and table per concrete classes inheritance strategies. Why force an upgrade to LINQ To Entities to obtain these feature sets which are common to many ORMs which do not have an additional abstraction layer? I do not see any technical reason for the Entity Framework being a requirement for these to work. NHibernate and Wilson for example, already provide these capabilities on the existing ADO.NET framework.

Experience with many MS developers suggest that if you give an 'upgrade path' to LINQ to Entities you will implicitly degrade LINQ to SQL as being a toy. It is not; unless you make it so.

Kevin Hoffman compares LINQ to Entities with LINQ to SQL in this August 17, 2007 LINQ to Entities vs. LINQ to SQL - What should I use and when? post, which waxes enthusiastic about the Entity Framework, its conceptual data model, and LINQ to Entities:

LINQ to Entities allows me to write C# LINQ queries that run against a conceptual data model. This is huge. I cannot stress enough to you how unbelievably forward-thinking and useful it is to be able to run queries against a conceptual object model as opposed to a database schema. The issue that a lot of folks have is in trying to decide if they need to use the Entity Framework or if they are fine with plain-vanilla LINQ to SQL (formerly called DLINQ).

Kevin complains about the inability to use foreign key fields as discriminator columns in ADO.NET Entity Framework - Entity Inheritance Woes of October 10, 2006, and the initial delay to the release of the EDM Designer in Microsoft finally shows off their EDM designer... but it won't ship with Orcas?!? (March 28, 2007) and Who ships a modeling tool without a visual designer? Microsoft (April 24, 2007).

Julie Lerman also compares the two technologies in LINQ to SQL vs. Entity Framework (April 4, 2007).

Entity Framework and LINQ to SQL Background

"Project Jasper" demonstrates the resource hit for implementing the Entity Data Model (EDM) dynamically. In Sam Drucker and Shyam Pather's DEV18 - Rapidly Building Data Driven Web Pages with Dynamic ADO.NET MIX07 video it took about 30 seconds (19:17 to 19:47) to initialize and cache the DynamicContext object, which represents the EDM, for a short list of blog entries. (Jasper's DynamicContext object corresponds to LINQ to SQL's DataContext object.)

Danny Simmons' May 3, 2007 Where’s the model? Is it the code or something else? post takes on Jeffrey Palermo's concern with substituting the Entity Data Model (defined by its XML files) for the domain model (defined by its code). Danny says:

We do talk about the EDM for an application as "the model", but that's just a verbal short-hand for "data model", which I believe is a critical distinction. We are explicitly NOT trying to define behavior in the EDM. The code is the right way to define that. We are, however, trying to define enough about the structure and constraints on the data that we can provide a rich set of services in a general fashion that still honor those constraints. ...

Once we start generating code from the EDM, things definitely become blurred a bit, but the explicit goal of the generated code is not to replace your object model—it's to save you some typing of repetitive things when you are building that object model. Further, the intent is that we would not require this generated code—you can always build your model completely on your own and just align the EDM with the shape of that model so that you can take advantage of the EDM-enabled services we provide (right now that means persistence/query, but eventually that means other things like reporting, replication, remoting, etc.).

For more about the EDM Designer delivery delay see Déjà Vu All Over Again: Entity Framework Cut from Orcas.

Discussions re REST vs. SOAP

Mike Champion's May 1, 2007 Reporting for duty on WS-Deathstar post, which announced that he's moving from the "core XML team in SQL Data Programmability ... to a position in the Connected Systems Division's Interoperability unit." His responsibilities there "include representing Microsoft on the W3C, helping with web services standards partnerships, and generally helping the world understand the method behind the apparent WS-Madness, or at least the subset of it that Microsoft endorses."

In his LINQ to XML swansong, Mike says:

I've always been annoyed by the zealotry manifested in the "SOAP vs REST" debate. The overhyped WS marketing and the RESTifarian pushback in 2001-2002 or so had the effect of people "flipping the bozo bit" on each other wholesale. We're just now seeing some exploration of the sensible middle position -- the native Web technologies are powerful and deserve first class support in the services-oriented tools and specs, and at least some of the WS technologies are useful on the Web as well as the enterprise, especially in the realm of identity and security. People on the WS side are finally understanding the the potential of the SOAP GET binding, and maybe the REST folks are starting to understand the oft-maligned WS-Transfer ("HTTP over SOAP over HTTP") is not quite so pointless in a multi-hop, multi-protocol world.

Update 5/24/2007: Jon Udell reviews the recently published RESTful Web Services by Leonard Richardson and Sam Ruby, who also are subjects of Jon's interview for a forthcoming IT Conversations show. Jon quotes the authors:

“We’re writing a book,” the authors say in their web introduction, “to codify the folklore, define what’s been left undefined, and try to move past the theological arguments.”

According to Jon, the book proposes use of Resource-Oriented Architecture (ROA) for Web services, wherein:

• Data are organized as sets of resources
• Resources are addressable
• An application presents a broad surface area of addressable resources
• Representations of resources are densely interconnected,

when the "security protocols and complex coordinated workflows" provided by Service-Oriented Architecture (SOA), such as SOAP and implementation of the WS* specifications aren't required.

Tim Ewald's April 26, 2007 I finally get REST. Wow. post details his decision to substitute REST for SOAP says, inter alia:

It's depressing to think that SOAP started just about 10 years ago and that now that everything is said and done, we built RPC again. I know SOAP is really an XML messaging protocol, you can do oneway async stuff, etc, etc, but let's face it. The tools make the technology and the tools (and the examples and the advice you get) point at RPC. And we know what the problems with RPC are. If you want to build something that is genuinely loosely-coupled, RPC is a pretty hard path to take.

That realization would have gotten me down if not for the fact that something else jazzed me up an hour or so later. I was in the process of considering the alternatives when I finally understood REST. And wow, it was eye-opening. REST is often positioned as CRUD operations against entities identified by URIs. Then it is dismissed as to simplistic to be useful. You can't build with just CRUD, the reasoning goes, just think about why we write sprocs. I've been down that path any number of times and always ended up in the same place. But I had it all wrong.

Tim was a staunch SOAP Web services proponent/evangelist and wrote MSDN's "House of Web Services" column while a Microsoft employee.

Don Box, one of the initial contributors to SOAP 1.0 and a power behind WCF, makes these recommendations for choosing SOAP, REST with POX (plain old XML), or both in his February 17, 2006 Pragmatics post:

1. If you want a great experience for .NET/Java devs, you’ll typically publish schemas (through WSDL) and support SOAP.
2. If you want a great experience for LAMP folks, you’ll support POX messages and will provide a non-XSD description of your formats.
3. If you want to reach both audiences, you’ll do both #1 and #2.
4. If you want to reach both audiences before your competition does, you'll avoid indulging in religious debates and ship something.

Don and Steve Maine presented DEV03 - Navigating the Programmable Web at MIX07. Here's the description from the MIX07 sessions page:

Abstract: RSS. ATOM. JSON. POX. REST. WS-*. What are all these terms, and how do they impact the daily life of a developer trying to navigate today's programmable Web? Join us as we explore how to consume and create Web services using a variety of different formats and protocols. Using popular services (Flickr, GData, and Amazon S3) as case studies, we look at what it takes to program against these services using the Microsoft platform today and how that will change in the future.

It's clear that the SOAP folks understand the need for RESTful Web services. Following are some highlights from the session's slides:

• It's the URI, Stupid! Query, Structured Expression, or Opaque Identifier. Orcas provides System.UriTemplate to support URI template syntax.
• GET is more Important than you think. Most of the world is GET; the rest is relative chaos. Orcas adds GET support to WCF, as well POST, PUT, and DELETE.
• WebHttpClient is a speculative feature, "which we hope will show up in an interesting vehicle very soon."
• Formats Matter: POX (Plain Old XML), JSON (JavaScript Object Notation), RSS/ATOM, and SOAP.
• RSS/ATOM constrain POX by adding list structure.
• SOAP constrains POX by adding a header processing model.
• WCF's WebGet/WebInvoke in Orcas support XML, JSON, or opaque binary formats (e.g., JPEG, PNG); WCF 1.0 supported POX and SOAP.
• WCF's SyndicationFeed/SyndicationItem provide a programming model for RSS/ATOM that integrates with the .NET serialization stack.
• Astoria is built on top of the technology presented in the session.
• "We could have put a SOAP wrapper on any of these services, but we didn't. We wanted reach."

The initial Astoria CTP doesn't support RSS/ATOM formats. Obviously, a later CTP should.

James Governor's February 15, 2005 SOAP is boring, wake up Big Vendors or get niched post, says:

Yesterday my partner Stephen issued a wake up call for middleware and tools vendors - give developers what they want, not what you think they should have.

• I have yet to hear any vendor - not one - talk to me about how they help developers design, implement and consume RESTian web services.

I take my hat off to Robert McMillan at Network World for writing this story two years ago…

One big question is why haven’t IBM and Microsoft responded? The obvious answer is vested interest. When you have “bet the company” on a technology stack its kind of a drag to have to respond to something else. Its interesting that in a week when the bug guys, including Gartner, have trumpeted the arrival of UDDI 3.0, the world is quietly getting on with more interesting projects. ...

Whats a web service? Still a great question. But anyone that defines a Web Service using SOAP in the definition is missing out on where the action is. Distinctions between enterprise and “consumer” are breaking down. REST is evidently where that convergence is being played out, not WS-I.

Governor's challenge to IBM and Microsoft raised a flurry of responses. For example, Dare Obasanjo wrote his Understanding the Place of POX, SOAP and WS-* in Building XML Web Services the same day. Be sure to read the comments and responses by Stephen O'Grady, James Governor, XML Team, Brain.Save, and, especialy, Mike Taulty.

Amit Asaravala delivers a reasoned argument for RESTful Web services in his October 21, 2002 Giving SOAP a REST post on DevX:

Many developers will be surprised to learn that SOAP isn't the only game in town for Web services interfacing. REST offers a perfectly good solution for the majority of implementations, with greater flexibility and lower overhead. Developers need to stop reaching immediately for SOAP and start choosing the right technology for the application.

Joel Spolsky says in his April 25, 2002 Joel on Software post about "Soap Backlash":

The real problem with SOAP is that it's a completely inadequate remoting system. It doesn't have events (which makes it useless for large classes of applications). It doesn't support references (ditto). It has about 10 years to go before it gets to where CORBA and DCOM were 10 years ago. And we're supposed to be all excited about this because we can sneak through the firewall. Gee, I wonder what the firewall vendors are working on these days? As soon as they're done, we're even further back than we started.

REST and SOAP Background

Roy T. Fielding, whom Jon Udell calls "the primary architect of HTTP" and who's a co-founder of the Apache Software Foundation, is credited with the definition of the Representational State Transfer (REST) architectural style in his University of California Irvine doctoral dissertation, Architectural Styles and the Design of Network-based Software Architectures (2000). Listen to Jon's August 25, 2006 podcast, A conversation with Roy Fielding about HTTP, REST, WebDAV, JSR 170, and Waka.

"Project Astoria," introduced at MIX07 as an incubator project by Pablo Castro in his XD006 - Accessing Data Services in the Cloud session, appears to me to be Microsoft's first semi-official foray into RESTful Web services.

My January 31, 2003 "Soap Extension Soup" article for XML & Web Services Online discussed the flurry of WS* specifications foisted on the Web services development community in 2002H2. It took the moribund Web Services Interoperability Organization (ws-i.org) three years to come up with their Basic Security Profile 1.0 recommendation. (OASIS published the Web Services Security v1.0 spec in March 2004.) I was overly optimistic in saying:

If OASIS produces a final WS-Security spec by the end of 2003, WS-I could easily take another year to produce a WS-Security 1.0 profile, test tools, and PKI-based sample applications. [Emphasis added]

Conclusion: Entity Framework clearly has the potential to become another SOAP. Hopefully, Microsoft's ADO.NET team will avoid that trap.

Technorati tags: LINQ, LINQ to SQL, Entity Framework, REST, SOAP, Entity Data Model, LINQ to Entities, Entity SQL, eSQL

MIX07 Session Videos with LINQ, EF, or VB[x] Hooks - Part 2

The MIX07 team released this morning an update to yesterday's RSS feed for MIX07 Session Feeds that's the subject of MIX07 Session Videos with LINQ, Entity Framework, or VB[x] Hooks [Part 1].

The video for the Sam Druker and Shyam Pather "Jasper" session is available for viewing or dowload at the following link:

DEV18 - Rapidly Building Data Driven Web Pages with Dynamic ADO.NET

Speakers: Samuel Druker - Microsoft, Shyam Pather - Microsoft Audience: Developer

Come learn about how new technologies from Microsoft bring together the concepts of dynamic languages and ADO.NET and allow you to quickly develop data driven Web pages using ASP.NET dynamic data controls, scalable to even the most complex databases.

Following is the link for Pablo Castro's "Astoria" session video:

XD006 - Accessing Data Services in the Cloud Speaker: Pablo Castro - Microsoft Audiences: Designer, Developer

Come learn about new Microsoft technologies that enable you to make your data available over the Web through a simple REST interface and using open formats such as plain XML, JSON or even RDF. We also discuss the underlying entity framework that makes it easy to model, publish, and program against your data over the Web.

Alex Barnett's Microsoft Codename "Astoria": Data Services for the Web provides a basic description of Astoria and its URI syntax, including its more popular operators. He's also posted an interview with Pablo on YouTube and some pithy quotes from industry luminaries about Astoria. (Alex was working on Astoria when he left Microsoft in 2006.)

And here's the Aaron Dunnington and Tim Scudder session video:

DEV16 - Deep Dive on Data Driven Experiences Speakers: Aaron Dunnington - Microsoft, Tim Scudder - Microsoft Audience: Developer

Come learn how technologies like Silverlight, Language INtegrated Query (LINQ), and SQL Server 2005 can help developers build impactful, dynamic applications that reach the broadest possible audience.

Aaron and Tim have created Socializer, a Silverlight UI that demonstrates:

• The Silverlight 1.1 Alpha client
• LINQ to Objects in Silverlight 1.1
• LINQ to XML in future Silverlight CTPs
• Semantic Web
• XML, RDF (FOAF)
• Data binding, querying, and aggregation
• A socially-aware rich Internet application (RIA) that includes personal content aggregated from MySpace, de.licio.us, and Flickr.

You can run the Socializer client from this link on the Silverlight Community site (requires installing the Silverlight 1.1 Alpha, which might require a reboot) and download the Socializer source. You also can run the Silverlight Airlines flight booking client that Scott Guthrie demoed during the keynote and download its source code.

I'll add more text and a few screen captures later today.

Technorati tags: LINQ, LINQ to SQL, LINQ to XML, Entity Framework, Project Jasper, Microsoft Jasper, Project Astoria, Microsoft Astoria, Silverlight, Silverlight 1.1

MIX07 Session Videos with LINQ, Entity Framework, or VB[x] Hooks

MIX07 session videos have been unlocked, so you can select them from the MIX07 RSS feed. Click the feed's video item header to open the MIX07 Sessions page with the video selected in the list at the bottom. Press return with the sessions code in the Search box or double-click the list item to stream to Silverlight or download Zune or WMV versions.

Here's the link to "Jim and John Talk", which originally was named Just Glue It! Dynamic Languages in "WPF/E", disappeared from the session list, and then was announced as a stealth session:

DEV02 - Just Glue It! Ruby and the DLR in Silverlight

Speakers: Jim Hugunin, John Lam Abstract: The web was built using dynamic languages. Their plain-text format made it easy to mash up scripts to create the next great app. Similarly, dynamic languages will find a home in Silverlight applications where plain-text formats are common. Silverlight can be easily deployed, which means that a wider range of dynamic languages will be used in building browser-hosted applications. In this demo-centric talk, you will see this happen before your eyes as we rapidly create an application by combining code and markup from existing samples in Ruby, Python, JavaScript, and Visual Basic. This unprecedented level of integration is possible since all of these languages are implemented on top of the new Dynamic Language Runtime (DLR).

Jim and John spent most of their session on a Mac demonstrating Silverlight apps that combine the four DLR languages: Ruby, Python, JavaScript, and VB.

Following are three screen captures from the session:

VBx code for a LINQ query against Technorati search results for "silverlight"

Ruby code that calls JavaScript and the preceding VBx code.

Performance comparison of Python and IronPython

Following are the other three videos with LINQ content that were available as of May 2, 2007 at 12:00 PM PST.

DEV22 - Building Silverlight Applications Using .NET (Part 1 of 2)

Speaker: Jamie Cool Abstract: This session demonstrates building a rich interactive application (RIA) using Silverlight. We cover how to use Microsoft Visual Studio to create applications, how to create UI using XAML markup and code, how to build a custom control, how to retrieve data from a Web service, and how to manipulate data with XML and LINQ. (This is the first in a two-part series.)

DEV07 - Building Silverlight Applications Using .NET (Part 2 of 2)

Speakers: Jamie Cool, Nick Kramer Abstract: This session demonstrates building a rich interactive application (RIA) using Silverlight. We cover how to use Microsoft Visual Studio to create applications, how to create UI using XAML markup and code, how to build a custom control, how to retrieve data from a Web service, and how to manipulate data with XML and LINQ. (This is the second in a two-part series.)

Anders gave a preview of the LinqDataSource control for ASP.NET (based on LINQ to SQL) that's expected to arrive with Orcas Beta 2 in this session:

DEV04 - Using LINQ to Dramatically Improve Data Driven Development in Web Applications

Speaker: Anders Hejlsberg Abstract: Modern applications operate on data in several different forms: Relational tables, XML documents, and in-memory objects. Each of these domains have profound differences in semantics, data types, and capabilities, and much of the complexity in today's applications is the result of these mismatches. Anders Hejlsberg, Microsoft Technical Fellow and Chief Architect for Microsoft Visual C# and LINQ, will explain how LINQ (Language Integrated Query) unifies these programming models and dramatically improves the experience of creating data intensive Web applications. Anders promises to have few slides and lots of live code demos!

Update 5/5/2007: Jon Udell delivers a glowing review of Anders' session and LINQ technology in his May 1, 2007 Watching Anders Hejlsberg reinvent the relationship between programs and data post.

Following are a few screen shots of Anders' demo of the LinqDataSource control for ASP.NET 2.0:

Selecting a LinqDataSource Control from the Toolbox

Selecting the DataContext Object for the Database in the Choose Context Object Dialog

Selecting the Entity in the Configure Data Select Dialog

Connecting the ASP.NET DataGrid to the LinqDataSource Control

Enabling DataGrid Paging, Sorting, Editing, Deleting, and Selection

The LINQ-based GridView Open in IE7

Mike Champion, who's on his way from being the LINQ to XML honcho to Microsoft's WS-Deathstar team, has a review of Anders' and other MIX07 sessions at Accelerating Evolution: LINQ News from Mix 2007, which concludes:

It's interesting watching various pundits and analysts read the tea leaves of the numerous LINQ subprojects, Silverlight versions, and incubation projects such as Volta to figure out the "Microsoft" master plan for pulling it all together. Just as customer pain with today's technology drives diverse innovation across the industry, so it does within Microsoft, and the process resembles evolution in action more than intelligent design by a supreme architect. I don't think we're seeing a silly season so much as a Cambrian explosion of new ideas from all sorts of places, and Father Darwin alone knows how it will end up.

I'll update this page as the MIX07 team makes new LINQ, Entity Framework and VB-related videos available.

Technorati tags: MIX07, MIX 07, MIX '07, LINQ, Entity Framework, VB 9.0, VBx, LinqDataSource, IronPython, IronRuby, JavaScript

MIX07 Session Videos are Locked Down

The MIX07 team posted this message Tuesday evening:

Many of the session recordings from yesterday are now posted! Visit sessions.visitmix.com to browse the the list. Sessions will continue to be posted as the become available from our production team. We've provided an RSS feed to alert you when they are added and we'll also highlight here some of our favorites as well.

The session videos are no longer locked down. The easiest way to view them is to subscribe to the RSS feed. Double-clicking an item in the feed opens the sessions.visitmix.com with the code for the event you clicked in the search box.

However, the team forgot to mention that the videos have an ACL that requires a username and password. The Registration page says nothing about how to obtain a username and password.

Technorati tags: MIX07, MIX 07, MIX '07

The Visual Basic Language on Silverlight

The terms "Visual Basic," "VB," and "Dynamic VB" have popped up repeatedly in interviews and MIX07 sessions about the Dynamic Language Runtime (DLR). I suggested in my Stealth Dynamic Languages Presentation at MIX07 post that VB for the DLR would be VBScript or a related dialect.

The VB Team posted a VB On Silverlight item this afternoon, which describes (in considerable detail) the features of the VB language supported in Silverlight 1.1 Alpha. Here's an overview that confirms that "VB Lite" or whatever supports LINQ:

When deciding what aspects of the Visual Basic language and runtime should be included with Silverlight v1.1, we tried to follow a similar pattern: we wanted to preserve the core VB programming experience—late binding, conversions, Linq [sic], and so on; and we didn’t want to bloat the download size with anything that wasn’t absolutely necessary or didn’t make sense in Silverlight—things like some of the COM helpers (COM is not supported in Silverlight), financial functions, etc. It was a delicate balance to strike between functionality and overall size.

The current size of the Silverlight 1.1 runtime's .NET Framework is 4.2 MB.

Note: LINQ to XML for Silverlight is scheduled for inclusion post Alpha 1.

The Silverlight 1.1 Runtime download lets you write VB code-behind. The VB team says "It includes a version of the factored .NET Framework, including the VB runtime (Microsoft.VisualBasic.dll)." You'll also need Orcas Beta 1 and the VS Add-On for Silverlight, which includes project templates and IDE changes for building Silverlight applications in VB (and C#).

The Silverlight SDK delivers reference documentation for the VB runtime. According to the post, "[i]t basically details [the] functions and types in Microsoft.VisualBasic.dll."

The Silverlight 1.1 VB implementation Isn't VBx

The Microsoft Silverlight Developer Reference poster has a reference to Visual Basic and VBx under the Languages heading, with VBx carrying a Soon flag which the legend translates to "Post Silverlight 1.1 Alpha."

Paul Vick's What the heck is "VBx"? post describes a cross-platform, hostable version of VB that delivers scripting capabilities similar to VBScript and VBA:

Well, as I've been hinting at for a while now, there's been something I've been working on quite a lot in recent months that I couldn't talk about. With our announcements at MIX07, though, I can now take a bit of the wraps off. "VBx" is our current (subject to change) codename for the next major version of Visual Basic. (The "x" is supposed to signify the Roman numeral X, or 10, since the next major version of Visual Basic is going to be 10.0. The "x" really should be capitalized, but some people were worried there'd be confusion with the old VBX controls. Not that the search engines are really going to draw a distinction. Like VB itself, they're mostly case insensitive.)

Paul continues:

As excited as we are about VBx, it is, unfortunately, not part of the Silverlight 1.1alpha1 released yesterday. Although we have a significant amount of functionality already implemented there is still more work to be done to bring the VBx language support up to the level that we feel is necessary for a productive community preview. Our plans are to have a community preview out later this year, and to talk much more detail about VBx at PDC07.

VBx is the Next Version of Visual Basic

Paul Vick asks the question: After MIX, how many Visual Basic languages are there?

He answers it with "One. Just one. VBx is the next version of Visual Basic, not a new version of Visual Basic." And then he goes on to explain:

What John and Jim demoed [in their Tuesday session], and what the DLR enables, however, is a second scenario. Because the DLR is managed code, it can be run directly on Silverlight. This means that you can actually get a running instance of a DLR language within Silverlight itself. So instead of having to compile an application or library before you can use it in Silverlight, you can simply include the code as a part of the Silverlight application, and the code can be compiled by the DLR language on the fly. This enables the traditional style of client-side applications that you see in AJAX or other libraries. Instead of compiling the library ahead of time, you simply download the client code to the browser when it hits the page, and the code will be compiled and run within the browser in real time.

Will VBx be the Next Version of VBA?

Paul Vick's vision of VBx as "a hostable managed component (written in Visual Basic, no less!) built on top of the DLR" indicates to me that VBx could be Microsoft Office's Holy Grail--a drop-in replacement for VBA in Office 14 and beyond that could run on the PC and Mac. Comments anyone?

Stay tuned to the VB Team, Paul's Panopticon Central and this blog for more details on Visual Basic 10.0.

Technorati tags: VBx, Silverlight, Silverlight 1.1, DLR, MIX07, VBA

"Astoria" Enables RESTful Data Services

Pablo Castro's new blog's first post is Codename "Astoria": Data Services for the Web describes the ADO.NET team's new incubation project codenamed "Astoria."

Astoria is the topic of Pablo's MIX07 presentation:

Accessing Data Services in the Cloud
Speaker: Pablo Castro - Microsoft
Audiences: Designer, Developer

Come learn about new Microsoft technologies that enable you to make your data available over the Web through a simple REST interface and using open formats such as plain XML, JSON or even RDF. We also discuss the underlying entity framework that makes it easy to model, publish, and program against your data over the Web.

Update 5/3/2007: The video of Pablo's presentation is XD006 - Accessing Data Services in the Cloud.

Note: That's one of the members of LINQ-Related Sessions at MIX 07. I mentioned that Pablo Castro promised "to put a Web spin on the Entity Framework, which might include a side trip for LINQ to Entities." It turns out that I was right.

The project currently offers an Astoria toolkit for Orcas Beta 1 and a read-only demonstration of Astoria online services for various data sources, such as the Northwind and AdventureWorks sample databases, Encarta articles, and anonymous TagSpace items.

In the future, you'll be able to create your own experimental online data services and temporarily host them on the astoria.mslivelabs.com Web site.

According to the documentation, which you can download from the Astoria Web site:

Project Astoria consists of a combination of patterns, libraries and an online service that explores the concept of data services for the web. Currently, Astoria data services use relational databases as the underlying store, but in general the nature of the store does not surface in the Astoria interfaces.

The goal of Astoria is to facilitate the creation of flexible data services that are naturally integrated with the web. As such, Astoria uses URIs to point to pieces of data and simple, well-known formats to represent that data, such as JSON and plain XML. This results in the data service being surfaced to the web as a REST-style resource collection that is addressable with URIs and that agents can interact with using the usual HTTP verbs such as GET, POST or DELETE.

In order for the system to understand and leverage semantics over the data that is surfacing, Astoria models the data exposed through the data service using a model called the Entity Data Model (EDM), an Entity-Relationship derivative. This organizes the data in the form of instances of "entity types", or "entities", and the associations between them. ...

Currently Astoria can represent data in plain XML, JSON (JavaScript Object Notation) and in a subset of RDF+XML.

The default representation format is XML. This is not a specific format; it is a fixed mapping of the entity structure to XML elements, with some added semantics to make use of the information provided by the EDM schema.

The team is considering adding RSS and ATOM to the data formats.

Astoria data services rely on the Windows Communication Framework (WCF), Entity Data Model, and Entity Framework. Here's a brief excerpt from the FAQ page:

Q: What is the relationship between Astoria and Windows Communication Foundation (WCF)?
A: All Astoria data services are essentially WCF services. You can see Astoria data services as a special form of WCF service that is aware of the nature of the data that is exposing.

Q: What is the relationship between Astoria and the Entity Data Model (EDM)?
A: Astoria data services uses the EDM as the model for the data exposed through its services. Having a high-level data model allows Astoria to provided added semantics to the service, such as having a clear definition of what an “entity” is for a given service or how to navigate from one entity to another associated entity.

Q: What is the relationship between Astoria and the ADO.NET Entity Framework?
A: Astoria exposes data modeled as EDM models. The ADO.NET Entity framework is the natural choice for an infrastructure that already supports the EDM and through mapping technology can present relational stores in EDM terms. The Astoria runtime that sits in the web servers and serves the requests to data services is built on top of the ADO.NET Entity Framework.

I plan to test the toolkit later this week and will add links to posts with my results here.

This is the second of the promised MIX07 announcements of projects that take advantage of the Entity Framework, which was recently cut from the Orcas release of Visual Studio. The first is here.

Update 5/31/2007: Granville Barnett has posted a new article on DotNetSlackers.com, "Interacting with Astoria Data Services," which describes Astoria Web services, explains their impact on rich Internet applications (RIA, "rich interactive applications" in Microsoftese), and provides examples of using Astoria with ASP.NET AJAX.

Update 5/7/2007: Channel9 offers a Pablo Castro: Astoria Data Services video segment with Pablo at the whiteboard diagramming a RESTafarian view of data services.

Update 5/2/2007: Techmeme added two links to this post on 5/1/2007.

Alex Barnett's Microsoft Codename "Astoria": Data Services for the Web provides a basic description of Astoria and its URI syntax, including its more popular operators. He's also posted an interview with Pablo on YouTube and some pithy quotes from industry luminaries about Astoria. (Alex was working on Astoria when he left Microsoft in 2006.)

Update 5/1/2007: Read what Andrew Conrad has to say about Project Astoria and how it might integrate with Project Jasper.

Technorati tags: Project Astoria, Microsoft Astoria, REST, Data Services, Entity Data Model, Entity Framework, LINQ, AJAX

"Jasper" to Deliver Dynamic ADO.NET 3.0

During Monday morning's MIX07 keynote, Andrew Conrad spilled the beans about the project he's been working on for the past few months: "Project Jasper." Also known as Dynamic ADO.NET, here's the official description of this new data-access technology from Andrew's blog post:

Microsoft Codename “Jasper” is a set of components aimed at fulfilling the need for a rapid and iterative development experience for data. With Jasper, you are able to just point at a database and immediately begin coding against its data using intuitive, domain-specific data classes. No configuration and no source code generation are required. Jasper works with existing application frameworks (including ASP.NET, WinForms, and WPF) and existing, real-world databases.

Jasper provides a programming interface to your data that is well-suited to rapid development. Jasper provides two main services:

• Data Access: query and update facilities for reading and writing data, exposed via an Object-Relational (O/R) API.
• Data Binding: presentation of data in controls that form the visual user interface of the application.

And here's a second description from the download page for the MIX07 Community Technical Preview (CTP):

Jasper leverages the power of dynamic languages and the concept of convention over configuration to provide a programming surface for data that enables rapid development of data-bound applications. While most other rapid data access frameworks are only capable of working against simple databases, Jasper can scale to almost any database, regardless of size or complexity. This is possible because Jasper takes advantage of the ADO.NET Entity Framework’s significant investments in mapping and conceptual data modeling. [Emphasis added.]

Jasper's dependence on the ADO.NET Entity Framework (EF) is significant, considering Saturday's announcement that Orcas has dropped the EF from the RTM, after an earlier postponement of the Entity Data Model (EDM) Designer.

According to Andrew:

For CTP release, we are specifically targeting Visual Basic 9 (Orcas version of VB.NET) and Iron Python 1.1. In other words, these are the languages we did a bulk of our testing for the CTP release. The reality is any CLR language that supports late binding can be used with the Jasper framework

I plan to give the MIX07 CTP a workout this week and will add links to reports of my results here.

Update 4/30/2007 14:17 PM: The ADO.NET Team posted Project Codename "Jasper" - Announced at Mix 07 which describes Jasper as an "ADO.NET incubation project for building quick, clean and iterative applications." The post says:

Using “Jasper”, developers start with a connection string and can immediately begin programming the core of an application. “Jasper” uses a set of new technologies to make this happen:

• Dynamic generation of data classes so there is no configuration or design time code-gen to carry around.
• Rich query and O/R capabilities because “Jasper” is built on top of the Entity Framework.
• Auto-binding capabilities for ASP.NET, WinForms, and WPF to make binding data to a UI simple and automatic.

Carl Perry offers additional details about Jasper in his Announcing Project Jasper - A RAD vision for the Entity Framework post.

Shyam Pather adds his interpretation of Jasper and excerpts from the Jasper Technical Overview in Microsoft Codename "Jasper" CTP Released!

Note: Andrew also mentioned that the Dynamic Language Runtime (DLR) will be announced at MIX07.

Update 5/2/2007: The video for the Sam Druker and Shyam Pather "Jasper" presentation is available for viewing or download at the following link:

DEV18 - Rapidly Building Data Driven Web Pages with Dynamic ADO.NET

Speakers: Samuel Druker - Microsoft, Shyam Pather - Microsoft
Audience: Developer

Come learn about how new technologies from Microsoft bring together the concepts of dynamic languages and ADO.NET and allow you to quickly develop data driven Web pages using ASP.NET dynamic data controls, scalable to even the most complex databases.

For more information on the DLR, listen to Jon Udell's podcast: A conversation with John Lam about the dynamic language runtime, Silverlight, and Ruby.

Update 5/5/2007: Andrew Conrad's Jasper and C# post asks "Is Jasper usable from C#?"

The short answer is – We designed Jasper specifically for CLR languages with late-bound facilities such as VB and IronPython.  C# doesn’t currently support late-bound calls and hence the answer would be no though some aspects of Jasper may still be applicable.

He then goes into an explanation of how C# might be used. The real question is "Why would anyone want to use C# in a dynamic, late-bound environment?" Andrew then moots the issue with:

[W]e are actively working on moving Jasper over to the dynamic language runtime - the freshly announced .Net addition to the runtime designed to extent the CLR for dynamic typed CLR languages (VBX, IronPython, IronRuby).  Based on early analysis it is a strong possibility that we move away from the base class mechanism and support a more dynamic model where data class types (or even specific instances!) can be modified at runtime to allow the user to add their own business logic.

Update 5/8/2007: Andrew Conrad reports that Channel 9 has posted a pre-MIX07 interview with the Jasper team:

Project Jasper is geared toward iterative and agile development. You can start interacting with the data in your database without having to create mapping files or define classes. You can build user interfaces by naming controls according to your model without worrying about binding code. In this interview Shyam Pather, Carl Perry, Andrew Conrad and Jeff Derstadt, go deep whiteboarding and demoing Jasper.

Technorati tags: Project Jasper, Microsoft Jasper, Dynamic ADO.NET, MIX07, Entity Framework, Dynamic Language Runtime, DLR

Déjà Vu All Over Again: Entity Framework Cut from Orcas

Microsoft software architect Mike Pizzo announced in the ADO.NET Entity Framework Update post of 10:09 PM, Saturday, April 28, 2007:

[W]e have decided to ship the ADO.NET Entity Framework and Tools during the first half of 2008 as an update to the Orcas release of the .NET Framework and Visual Studio.

Mike does his best to spin the bad news by starting the announcement with:

Microsoft is deepening its investment in the ADO.NET Entity Framework as a critical piece of Microsoft’s Data Platform vision.

Many Microsoft observers will read that sentence as:

Microsoft is deep-sixing its investment in the ADO.NET Entity Framework as a critical piece of Microsoft’s Data Platform vision.

It's too soon to make that judgment, but there's no question that Mike's announcement delivers yet another blow to those developers (like me) who followed Microsoft's primrose path into its previous object/relational mapping (O/RM) tool void.

Microsoft MVP Scott Bellware avoided the most recent O/RM trap by abandoning a planned short-term implementation of the Entity Framework (EF), as described in his April 24, 2007 Falling Back to NHibernate - A Phone Call with the Entity Framework Folks:

We made a decision today to put an early end to our exploration of the Entity Framework for our current product work, and to fall back on NHibernate. ...

When the EDM designer started to drop out of the CTP's (post-August 2006), we had hoped that it would reappear around beta 1, and would be fairly solid around beta 2. We're scheduled to ship our current work product in coincidence with Orcas. We expect to start customer previews when a go-live license is offered. Without an editor for the metadata, we really can't justify the use of the EF to our customers.

The phone call [to the ADO.NET EF team] took place in two parts. The second part of the call got into some NDA-covered material that Kevin wasn't able to stick around for. Tim and Dan shared some info that gave me with a definitive and conclusive basis for making a sound call for our product. I'm very grateful to the EF team to have been enabled to make such a clear cut decision.

I have the feeling that Scott might have received advance notice (under NDA) that EF and its components were going back to the drawing board. Regardless, he said in an April 22, 2007 comment to my Persistence Ignorance Is Bliss, but Is It Missing from the Entity Framework? post:

I won't remain committed to the Entity Framework if the EDM Designer doesn't arrive by Orcas RTM.

I see the EDM designer as one of the most compelling features of EF in its current incarnation. It's the piece that translates well to how we expect our customers will expect to work with the entities in our product.

If the EDM designer is not in place by RTM, then I don't expect that we can ship a product to our customers if part of the product's customization story is based on the presence of the EDM.

We would need to fall back on NHibernate, and we have had this contingency plan in mind since we began the foray into EF.

Scott implemented his contingency plan two days later. (He insists he's not a member of the "NHibernate Mafia".)

Note: There still might be hope for EF with the Domain Driven Development (DDD) crowd. Interknowlegy's Tim McCarthy is writing .NET Domain-Driven Design with C#: Problem-Design-Solution to be published by Wiley. You can download the slides and code for Tim's April 19, 2007 "Domain-Driven Design using the ADO.NET Entity Framework" presentation to the International Association of Software Architects' Southern California chapter (IASA SoCal). The code is based on Paul Gielens original code for "Organizing Domain Logic" which compares Microsoft's Three-Layered Services Architecture (MS-TLSA) approach against DDD. (The three layers are the traditional data, business and presentation, not the EDM's storage, mapping, and coneptual layers.)

Does Microsoft Have a Data Access Strategy?

Mike posted Microsoft’s Data Access Strategy to the Data blog three minutes after the preceding bombshell. He answers the question with:

Yes, it turns out we do. Microsoft envisions an Entity Data Platform that enables customers to define a common Entity Data Model across data services and applications. The Entity Data Platform is a multi-release vision, with future versions of reporting tools, replication, data definition, security, etc. all being built around a common Entity Data Model.

Mike disclosed another part of the data access strategy in the first post:

Microsoft will be leveraging the Entity Data Model in future versions of Microsoft products such as SQL Server. This Data Platform vision enables customers to leverage their investment in a common conceptual entity model across product lines. [Emphasis added.]

Frans Bouma, the developer of LLBGen Pro, a commercial O/RM tool, has a different (and sinister) take on Microsoft's data access strategy:

The announcement speaks about Microsoft building applications on top of Entity Framework and also that the Entity Framework is moving towards SqlServer. Now, if you can add 1 and 1 together, you of course realize that if you have an application, say Sharepoint vNext, build on top of Entity Framework and you have one of your major cash cows SqlServer enabled with Entity Framework, you have a combination to earn more money: people who want the next version of your application also want your new database system.

The Entity Framework in ADO.NET vNext was designed to be database independent, and it might still be database independent when it eventually ships (I personally don't believe their H1 2008 mark). If you have one of your other major cash cows, say Sharepoint vNext, build on top of ADO.NET vNext, you then open up the road to host Sharepoint on say Oracle, DB2 or an open source database. This then would alienate one of your other cash cow products, SqlServer which will have the Entity Framework build-in.

Personally, I don't buy Frans' theory at present. Microsoft's "major cash cows" are Windows operating systems, the Office suite, and well-entrenched server-based applications, such as Exchange Server and SQL Server. By default, Windows SharePoint Services (WSS), which is a component of Windows Server 2003, uses freely distributable SQL Server 2005 Express (SSX) as its data store not as its host operating system.

Paul Wilson, the developer of the commercial WilsonORMapper (a simpler competitor to LLBGen Pro) says "Great News: Only One O/RM Shipping in Orcas." Wilson is a fan of LINQ to SQL because it's simpler but "good enough for the vast majority of cases."

Mike contrasts LINQ to SQL and LINQ to Entities:

LINQ to SQL supports rapid development of applications that query Microsoft SQL Server databases using objects that map directly to SQL Server schemas. LINQ to Entities supports more flexible mapping of objects to Microsoft SQL Server and other relational databases through extended ADO.NET Data Providers.

Despite the comments regarding support by LINQ to SQL for databases other than SQL Server by Dinesh Kulkarni, Scott, Guthrie, Matt Warren and Keith Farmer quoted in my Future LINQ to SQL Support for Multiple Databases? post of April 19, 2007, Mike has put that issue to bed. It's clear as part of Microsoft data access strategy that LINQ to SQL is LINQ to SQL Server (only).

Shades of WinFS, ObjectSpaces, Project Green, and the Microsoft Business Framework

The previous indication of trouble in the Entity Framework camp was the announcement at VSLive! San Francisco that the Entity Data Model (EDM) Designer had been cut from the Orcas release.

Earlier, a major controversy about EF's lack of "Persistence Ignorance" and its need to support Plain Old CLR Objects (POCOs), test-driven development (TDD), and agile programming techniques erupted at Microsoft's MVP Summit conference in Redmond on March 12 - 15, 2007.

But the real problem is that .NET developers might equate the result of EF's integration into the next version of SQL Server (code-named "Katmai") with the demise of ObjectSpaces, EF's ill-fated predecessor OR/M tool, when it was integrated into WinFS. My June 26, 2006 Microsoft Bites the Bullet: WinFS Bites the Dust post delivers the grisly details of the deaths of WinFS, ObjectSpaces, Project Green, and the MBF.

Here's Andrew Conrad's statement of the official status of ObjectSpaces in Visual Studio 2005 (then codenamed "Whidbey") as of April 6, 2004:

ObjectSpaces is not participating in Whidbey beta 1, however, it remains part of the Whidbey/Yukon wave and will be made available as a downloadable add-on pack for the .NET Framework Whidbey shortly after Whidbey ships. This additional development and stabilization period will be focused on improving the overall ObjectSpaces programming experience and providing tighter integration with WinFS, the next generation file system in Longhorn. The schedule for the ObjectSpaces mapping tool is also being adjusted accordingly.

His post concludes with:

Bottom line - this will mean some change in the release schedule, but should not adversely effect anyone's plans to deploy the ObjectSpaces framework. In fact, I believe the tighter integration with WinFS will significantly justify the delay.

Does that language sound familiar? Compare the comments with those to Mike's initial post.

Even more ominous is Barbara Darrow's April 26, 2007 speculation in CRN that "Katmai, Orcas Link Could Delay Longhorn Release." If true, which I doubt, Katmai's EF dependency could delay it and Longhorn Server until probably late 2008.

Mike replies with a Sunday-afternoon comment regarding spin, ObjectSpaces, and WinFS:

I apologize for the “PR-spin” feel people have associated with this post. Even a short delay of the Entity Framework is a difficult message, especially to convey through the imprecise nature of written communication. How do we convey that we believe this to be the right decision, without people losing confidence in the technology, particularly in light of Microsoft’s less-than-perfect record in shipping ORM solutions, and in the wake of WinFS? I struggled with the wording. With the approach. With the message. Yes, marketing was involved in reviewing the content (of course). I regret now accepting some of their input, but the message is the same. The Entity Framework will not ship in Orcas. It will ship shortly there-after. The slip isn’t about Microsoft’s lack of commitment to the technology. It does give us more time to address some key feedback we’ve received to date from internal and external customers, including providing at least CTP-quality tools for defining flexible mapping between the store and the objects. There’s no way I can convince you that this isn’t another ObjectSpaces, or another WinFS. You’ll have to look at how we continue to deliver over the next few months. You’ll have to look at the quality of the bits. You’ll have to look at the other investments Microsoft is making around the Entity Data Platform, including announcements and demos this week at Mix.

This year I celebrate my 20th year at Microsoft. In that time I’ve seen Microsoft invests heavily in a number of technologies that, for one reason or another, never come to market. This isn’t one of them.

I'm inclined to believe Mike's comment. NetDocs also comes to mind as an example of a well-funded Microsoft technology that never came to market.

"Those who cannot remember the past are condemned to repeat it."

George Santayana (1863 - 1952, The Life of Reason)

Mike says in his initial post, "Stay tuned for announcements starting next week at Mix around new products building on the ADO.NET Entity Framework." I plan to do this, but with trepidation.

Update 5/3/2007: Redmond Developer News senior editor Kate Richards quotes me in her April 30, 2007 ".NET Entity Framework Slips Beyond Orcas" article:

Roger Jennings, a developer and technology writer for OakLeaf Systems, doesn't think the later ship date is going to be a big deal. "They decided that they couldn't release the Entity Framework without the Entity Data Model Designer, which was my contention to start with," he said. "And they've also just announced a couple of incubation projects that depend on it that also might have an influence on the delivery date." ...

"Almost everybody is considering [Entity Framework] to be ObjectSpaces revisited, but I don't think that's the case," says Jennings.

The "incubation projects" are the ADO.NET Team's "Project Jasper" (a.k.a., Dynamic ADO.NET) and "Project Astoria" (a.k.a., "RESTful Data in the Cloud.)

Technorati tags: Entity Framework, Entity Data Model, EDM Designer, LINQ to Entities, LINQ, Orcas, Orcas Beta 1, SQL Server, Katmai, MIX07

Note: This item was linked from the Discussions section of the Techmeme entry for the original ADO.NET post. There's also a Discussions link to a Channel9 thread.

Stealth Dynamic Languages Presentation at MIX07

According to Beth Massi's April 27, 2007 So, you're going to Mix? post on the Visual Basic Team blog:

Jim Hugunin and John Lam [will be] talking about dynamic languages on .NET. (11:45am, Tuesday) This one has so much revolutionary stuff in it that they actually pulled it from the session descriptions on the Mix site. Long story short, search the web on musings about why John and Jim are at Microsoft, add to that the fact that the VB team has been working with them heavily, and you might be able to figure it out.

The original name of their currently anonymous presentation was Just Glue It! Dynamic Languages in "WPF/E": Jim Hugunin - Microsoft, John Lam - Microsoft.

Update: 5/2/2007: The final session blurb that appeared yesterday is:

DEV02 - Just Glue It! Ruby and the DLR in Silverlight

Speakers: Jim Hugunin, John Lam
Abstract: The web was built using dynamic languages. Their plain-text format made it easy to mash up scripts to create the next great app. Similarly, dynamic languages will find a home in Silverlight applications where plain-text formats are common. Silverlight can be easily deployed, which means that a wider range of dynamic languages will be used in building browser-hosted applications. In this demo-centric talk, you will see this happen before your eyes as we rapidly create an application by combining code and markup from existing samples in Ruby, Python, JavaScript, and Visual Basic. This unprecedented level of integration is possible since all of these languages are implemented on top of the new Dynamic Language Runtime (DLR).

Catch a preview with a few screen captures from the video in this post.

---

I'm guessing that the "Jim and John Show" will extend their March 26, 2007 MTS07: Jim Hugunin and John Lam on Dynamic Languages and the CLR presentation at the Microsoft Technical Summit and describe what Mary Jo Foley called the "Dynamic Language Runtime" (DLR) in her Microsoft to roll out dynamic-layer for .Net post of April 24, 2007.

In an August 6, 2006 eWeek interview, Darryl K. Taft quotes Jim:

"I joined Microsoft because I was so inspired by the possibilities of .Net," Hugunin said. "The chance to work with the Visual Basic team is wonderful. The chance to make changes into .Net to make it more amenable to dynamic languages is phenomenally exciting."

[W]ith Visual Basic, Hugunin said Microsoft is looking at leveraging some of the simplicity that Basic has. "That feels a lot like what people say they love today about dynamic languages," he said. "People say they love a language like Ruby because it has this simplicity and this dynamism."

And Visual Basic, in its formative years, "was state of the art in providing this simple, dynamic experience. So we see that there's this great potential for Basic to be another great dynamic language, where we keep all the great benefits that we put into Visual Basic .Net, but we have some of this dynamic feel that people love."

Hugunin demonstrated how, with simple changes in the code, Visual Basic could be made to behave like a dynamic language. "But that's just, at the moment, an experiment," he said with a smile.

So there's sure to be a VB hook in Jim and John session.

It appears that Andrew Conrad (one of the original ObjectSpaces devs and an early LINQ proponent) has been working on dynamic languages code for a MIX07 session or two. Andrew says:

More information to come in the new few weeks, but all I can say at this point is that the experience has been very dynamic. And if you can’t make it to Mix07, we should have some screen casts and white papers available some time in the next several weeks. [Emphasis Andrew's]

Plain Old Visual Basic (POVB) as a Dynamic Language?

The following MIX07 session underwent a dramatic metamorphosis recently:

Rapidly Building Data Driven Web Pages with Dynamic ADO.NET
Speakers: Samuel Druker Polita Paulus - Microsoft, Shyam Pather - Microsoft
Audience: Developer

ASP.NET dynamic data controls are part of a powerful, rich new framework that lets you create data driven ASP.NET applications extremely easily. ASP.NET dynamic data controls do this by automatically discovering the schema at runtime, deriving behavior from the database and finally creating an ASP.NET page. Anything that can be inferred from the schema works with almost no user effort. If needed, the page can be further customized either by using static languages such as Microsoft Visual C# or Visual Basic .NET, or dynamic languages such as IronPython, Visual Basic, Jscript, etc. In this talk, we show you how to build rich, database driven Web applications from scratch, such as TaskList along with other demos. [Emphasis added.]

Come learn about how new technologies from Microsoft bring together the concepts of dynamic languages and ADO.NET and allow you to quickly develop data driven web pages using ASP.NET dynamic data controls, scalable to even the most complex databases.

Notice that "dynamic ... Visual Basic" in the preceding description is plain VB, not VB .NET, which I'm betting is a reincarnation of VBScript for the CLR. Polita is the developer of Blinq, so there might be a LINQ hook in the session.

One of the topics of MTS07 was "When is the veil of silence going to be lifted?" It's been almost eight months since Jim added a post to his Thinking Dynamic blog. The last post announced the release of IronPython 1.0 on CodePlex and included a brief history of the three-year project. Microsoft released IronPython 1.1 with little fanfare on April 17, 2007.

Andrew Conrad's April 27, 2007 post starts with: 

Over the last several months, because of my current project I have had to program in a bunch of different languages.   (The reason for this will become crystal clear early next week).  Basically, I have had to code in C#, VB, and IronPython while at the same time I have been trying learning Haskell and occasionally Ruby - and some Javascript just for fun on the weekends. 

What's the chance of an announcement that IronPython (and perhaps even RubyCLR) will support LINQ?

Microsoft's Shri Borde wrote in a May 12, 2005 IronPython list message:

IronPython 1.0 will not support LINQ. We have started to look at it, but will seriously look at it after the summer. It is a meaty issue given that many of the concepts in LINQ are based on static typing.

Keith J. Farmer, now with Microsoft, started a [IronPython] Extension methods... thread on the users-ironpython.com list that compares Python's list comprehensions with LINQ expression trees, along with LINQ and Python extension method syntax. In his September 20, 2005 message, Keith says:

I think the interesting bit for us, now, is that all this runs on the [.NET Framework] 2.0 runtime. From what I can tell, all it'd take would be some compiler modifications to recognize extension methods (marked by attribute) and to create an easy way to create expression trees, and IronPython would be set for it.

Yes, I'm excited about LINQ.. I've seen many gems come out of .NET (and a few blunders). This, I think, is just plain beautiful.

LINQ is the big thing for C# and VB, as are dynamic languages for .NET. They deserve one another. Unfortunately, LINQ integration with .NET dynamic languages isn't one of Miguel de Icaza's guesses for MIX07 announcements.

Note: Go to LINQ-Related Sessions at MIX 07 for updates to current LINQ sessions. 

Technorati tags: MIX '07, MIX 07, MIX07, IronPython, RubyCLR, LINQ, Dynamic Language Runtime, DLR