Monthly Archives: June 2006

Roger Jennings gives an excellent recount of the rise and fall of WinFS on his blog. It is highly recommended reading. He links to lots of blog posts about WinFS from past to present by people like:

Their blogs are worth subscribing to as well in your RSS reader. The links above link to their RSS feed.ckey="7DA8D937"

Through Jason Zander's blog I found a good white paper on MSDN article titled "Deploying Microsoft .NET Framework Version 3.0".

It details how the .NET Framework 3.0 (fka WinFX) relates to the .NET Framework 2.0 and where the various components are installed. I noted a couple of inconsistencies with how the .NET Framework 2.0 is deployed:

  1. Components shared with .NET Framework 2.0 are installed in the following location: %windir%Microsoft.NETFrameworkV2.0.50727

    Components that are new to .NET Framework 3.0 are installed in the following location: %windir%Microsoft.NETFrameworkV3.0

    So the build number is gone from the directory name.

  2. You can look for a specified registry key value to detect whether
    the .NET Framework is installed on a computer. The following table
    lists the registry keys and values that you can test to determine
    whether specific versions of the .NET Framework are installed.

    Version

    Registry Key Name

    Value

    3.0

    HKEY_LOCAL_MACHINESOFTWAREMicrosoftNET Framework
    SetupNDPv3.0Setup

    InstallSuccess (DWORD value = 1)

    2.0

    HKEY_LOCAL_MACHINESOFTWAREMicrosoftNET Framework
    SetupNDPv2.0.50727

    Install (DWORD value = 1)

    As you can see, the key name has changed from Install to InstallSuccess , it is nested one level deeper (inside Setup) and you can no longer determine the build number.

  3. The user-agent string for Internet Explorer does include the full version version when .NET Fx 3.0 is installed. It contains even more information (the revision number) than the identifier for other .NET Fx versions:

    Mozilla/4.0 (compatible; MSIE 6.0;
    Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04131.06)

    However, there is no CLR 3.0! Since this release the CLR version number is no longer coupled to the .NET Framework version number. .NET Fx 3.0 uses CLR 2.0.

    Why could other naming schemes be changed to further progress and why is this identifier not corrected?

I wish Microsoft had released this white paper simultaneuously with the WinFX rename announcement. That would have prevented a lot of confusion.

I haven't installed the .NET Framework 3.0 June CTP yet, because no compatible build of Expression Interactive Designer has been released yet. So I cannot determine if the information in the white paper is completely accurate.

WinFS is no more. At least not as a separate product to be released as an add-on to Windows Vista and XP some time after Windows Vista itself is released. Parts of the WinFS technologies will be released as part of the .NET wave codenamed "Orcas" and SQL Server "Katmai" (SQL Server vNext if you will). This was announced today on the WinFS blog by Quentin Clark.

Let me start with some historical background.

WinFS was introduced at PDC03 as the metadata-rich user-data store for Windows Vista (or "Longhorn" as it was known) based on SQL Server 2005 (or "Yukon" as it was known then). It was to combine the power of a relational database with a file system. With rich and fast query capabilities for content and metadata. Hence it has also been called: Windows Future Storage and Windows File System. The "Future" part proved prophetic: WinFS was slashed from Windows Vista, because it wouldn't be done in time, even though Windows Vista itself was already delayed.

WinFS Beta 1 was released in August 2005, and I posted an analysis.

The world has changed since then. Tools like MSNWindows Live Desktop Search and Google Desktop Search have filled some of the search void that WinFS was meant to fill. Windows Vista and Office 2007 will ship with integrated search solutions. Actually ones that work well, instead of the troubled desktop search (Indexing Service) that shipped with Windows XP. The WinFS project continued to struggle with realizing the vision. LINQ has emerged. The ADO.NET Entity Framework has been announced.

Quentin writes:

"The Entities features we are now building in ADO.NET started as things we were building for the WinFS API."

"We are choosing now to take the unstructured data support and auto-admin work and deliver it in the next release of MS SQL Server, codenamed Katmai."

"These changes do mean that we are not pursuing a separate delivery of WinFS, including the previously planned Beta 2 release.  With most of our effort now working towards productizing mature aspects of the WinFS project into SQL and ADO.NET, we do not need to deliver a separate WinFS offering."

Productizing only mature aspects means that inmature features will not be productized yet. Quentin doesn't go into what features will not make the cut. Note that Quentin has repositioned WinFS as an incubation project, productizing features as they are ready.

Paul Mooney posted photographs of a couple of interesting slides from the TechEd 2006 presentation "Building on WinFS: Developing a Great WinFS App from Scratch". The summary slide says "WinFS is the new data platform for the desktop" (my emphasis). I thought there was supposed to be a server story for WinFS as well...

[Update 2006-06-24: Changed the title to more accurately reflect this post.]

Microsoft has just released the June 2006 CTP of the .NET Framework 3.0 (fka WinFX Runtime Components). I found out through an announcement on Tim Sneath's blog.

Remember, .NET Framework 3.0 = .NET Framework 2.0 + WPF + WCF + WF + WCS. So the installer first installs version 2.0 of the .NET Framework if you don't already have it installed. After that it adds the WinFX technologies on top of it.

If you download the full version (x86), you'll see that it weighs in at a hefty 45.8 MB. If you crack open the file in WinZip, you see that it is composed of multiple installers for the different components mentioned above:

Does it look like four installers, without even a real naming convention, slapped together to you too? ๐Ÿ™‚

When you uninstall version 3.0 it leaves version 2.0 of the .NET Framework installed, because the uninstaller cannot determine if it is no longer in use. You can manually remove version 2.0 if you like, but why would you ๐Ÿ˜‰

There is also an accompanying build of the Windows SDK for the .NET Framework 3.0, the Microsoft Visual Studio Extensions - Development Tools for .NET Framework 3.0ยฎ and the Visual Studio 2005 Extensions for Windows WorkFlow Foundation.

[Update 2006-06-24: The Windows SDK doesn't seem to be available for download yet (at least not in Europe), so the link might not work. The large downloads tend to replicate slowly through Microsoft's download servers.]
[Update 2006-06-26: The download for the Windows SDK is now working (1.1 GB). As an alternative you might want to check out the setup program that downloads only selected parts of the SDK when it becomes available.]

1 Comment

[Update 2006-06-22: Microsoft's Pablo Castro from the ADO.NET team posted a comment on my blog in which he indicates that a first ADO.NET vNext CTP is to be expected around August 2006. That is quite a bit sooner than what I expected based on "before the end of this year". I've updated the title of this post to reflect this. Pablo also writes that the LINQ integration work is further along than I thought: IQueryable<T> is already implemented for the ADO.NET Entity Framework and LINQ for Entities does not use Entity SQL as an intermediate step. The problem of LINQ to SQL versus LINQ to Entities remains, so I have left my blog post below unchanged.]


Today Microsoft's S. "Soma" Somasegar blogged about LINQ and ADO.NET innovations. In his blog post he announces the names for various LINQ variants. For DLinq and XLinq this means a name change. The new names started to appear a little over a week ago. Soma separates the LINQ variants into two categories:

LINQ to ADO.NET, which includes:
            LINQ to DataSet
            LINQ to Entities
            LINQ to SQL (formerly DLinq)

LINQ support for other data types include:
            LINQ to XML (formerly XLinq)
            LINQ to Objects

LINQ is already very real in CTP form since September 2005. The latest is the May 2006 CTP. But the ADO.NET Entity Framework currently only has a public appearance in two whitepapers. Soma ends his post with "keep an eye out for a preview of the Entities work before the end of this year". I guess, this is Microsoft-speak for "don't expect any bits before the end of December 2006" since Microsoft has a tendency to overrun announced dates. Remember, how the beta 2 of "Whidbey" was to be released in the first quarter of 2005, but didn't arrive until something like March 48, 2005 (i.e., April 17, 2005 ;).

Hopefully the upcoming six months gives Microsoft enough time to get their future data access story straight and realign the disparate data access technologies LINQ to Entities and LINQ to SQL.

Currently LINQ to Entities appears to be bolted on the ADO.NET Entity Framework as an afterthought. And as OR/Mappers, LINQ to SQL and the Entity Framework to some extent do the same thing, yet in very different ways.

Without even seeing ADO.NET vNext bits, these "conflicts" are visible in the docs as silly differences like a "SubmitChanges()" method versus a "SaveChanges()" method.  And we don't need two different XML syntaxes for describing mappings between tables and entities. And Microsoft please don't release two different GUI tools for creating those mappings.

1 Comment

The documents on ADO.NET vNext that were previously pulled from MSDN have been republished by Microsoft.

I found the links on Steve Eichert's blog (who found them on Fabrice's blog):

I've scanned the documents. Although I don't fully recall the original versions that disappeared, it seems to me that LINQ is featured more prominently in the new versions. In addition to the new SQL variant for querying entities, called Entity SQL, ADO.NET vNext introduces LINQ to Entities.

Some detail as to how LINQ to Entities relates to LINQ to SQL (formerly known as DLinq) was added. The re-alignment of these two new data access technologies at Microsoft doesn't seem complete though. Steve Eichert calls upon Microsoft to not release two competing O/R mapping frameworks and work on integrating them.

LINQ to SQL has its roots in ObjectSpaces, which was first announced at the PDC in 2001. After PDC03 it was merged with WinFS. It later reappeared as DLinq. The DLinq overview document published in September 2005 was subtitled ".NET Language Integrated Query for Relational Data" and talks at length about creating and querying entity classes. It states "DLinq is part of the ADO.NET family of technologies". In hindsight this is an amazing statement, because it is obvious that at the time the DLinq efforts were totally oblivious to the ADO.NET Entity Framework efforts. And conversely, the ADO.NET vNext efforts seemed oblivous to LINQ by introducing yet another query language called Entity SQL.

To fully enable the power of LINQ, ADO.NET vNext should implements the IQueryable<T> interface. The LINQ-fication of the following piece of code from the overview document looks very promising:

using(AdventureWorksDB aw = new AdventureWorksDB(Settings.Default.AdventureWorks))
{
    Query<SalesPerson> newSalesPeople = aw.GetQuery<SalesPerson>(
        "SELECT
VALUE sp "
+
        "FROM AdventureWorks.AdventureWorksDB.SalesPeople
AS sp "
+
        "WHERE
sp.HireDate > @date"
,
        new QueryParameter("@date",
hireDate));

    foreach(SalesPerson p in
newSalesPeople) {
        Console.WriteLine("{0}t{1}", p.FirstName, p.LastName);
    }
}

Using LINQ it can be written as:

using(AdventureWorksDB aw = new AdventureWorksDB(Settings.Default.AdventureWorks))
{
    var
newSalesPeople = from p in aw.SalesPeople
                         where p.HireDate > hireDate
                         select p;

    foreach(SalesPerson p in
newSalesPeople) {
        Console.WriteLine("{0}t{1}", p.FirstName, p.LastName);
    }
}

(Which version do you prefer? ๐Ÿ™‚

It is easy to write down the code. To really make this happen, a lot has to happen behind the screens. The type of aw.SalesPeople should implement IQueryable<T>. The C# compiler will then translate the query into an expression tree. The query isn't executed until the newSalesPeople object is enumerated over by the foreach statement. At this point the expression tree has to be translated to T-SQL to be sent to the SQL Server database. As no ADO.NET vNext bits have been released yet, it is not clear if the IQueryable<T> implementation already exists for ADO.NET vNext and/or if ADO.NET vNext will use Entity SQL as an intermediate step.

BTW: The Channel9 video on ADO.NET "3.0" that also disappeared will probably not re-appear. It might be a bit hard to reshoot now that Robert Scoble is leaving Microsoft ๐Ÿ˜‰ I guess it has been superseeded by the Channel9 video with Anders Hejlsberg and Sam Druker.

1 Comment

Ever wondered why the acronym for Windows Workflow Foundation is WF and not WWF?

Of course, WWF would be more logical, considering the WinFX.NET Framework 3.0 (minus .NET Framework 2.0!) technologies have the following acronyms:

  • WPF = Windows Presentation Foundation
  • WCF = Windows Communication Foundation
  • WF = Windows Workflow Foundation
  • WCS = Windows CardSpace

On this slide from a TechEd 06 presentation (through JevDemonโ€™s blog) you can find a cute explanation:

PS: For those of you who need more explanation: WWF stands for World Wrestling Federation or for World Wide Fund for Nature (Wereld Natuur Fonds in Dutch).

Dennis has just upgraded
BloggingAbout.NET to use the Community Server 2.0 platform.

This post is to test to see if publishing a blog entry from Word 2007 has become easier. With CS 1.1 I had some problems with publishing a new entry.

Update: Publishing a new entry from Word 2007 now works just fine as does republishing. Another problem with CS 1.1 was that it resent all trackbacks after republishing an entry. Hopefully that problem is now gone as well.

1 Comment

Kirk Allen Evans has the best explanation so far of what comprises the .NET Framework 3.0. It can be summarized as:

.NET Framework 3.0 = .NET Framework 2.0 + WCF + WPF + WF + WCS

He also has a diagram showing the different parts.

Brad Abrams also tries to clear up the confusion by giving some more information .NET 3.0 and the "Orcas" release, which will be the vNextNext of the .NET Framework. The "Orcas" release will include the LINQ related technologies, like the new C# 3.0 and VB 9.0 compilers. Brad anticipates that the "Orcas" release will be called the .NET Framework 3.5. If you look at the comments to his blog entry you can see that a lot of confusion about the details still remains.

Most people are happy to see the WinFX components being put under the .NET Framework umbrella. Nevertheless a lot of people (including me) aren't happy with the version number 3.0. It suggests too much. You would think the step from 2.0 to 3.0 would mean an updated version of the CLR, the compilers and framework classes like those in ASP.NET and ADO.NET.

Yes, the WinFX components are a major addition to the .NET Framework. But I think the major version number of the .NET Framework is the wrong place to put the marketing spin about this. I even have doubts about changing the minor version number of the .NET Framework. I think it should just remain:

.NET Framework 2.0 + WinFX = .NET Framework 2.0 + WCF + WPF + WF + WCS

No matter how big in functionality, WinFX is still only an addition to .NET 2.0. As such it should not change the version number. I think Microsoft should use the "Orcas" release, which does change .NET 2.0 by updating the compilers and framework classes, to fully embrace WinFX and change the version number of the .NET Framework.

Last Friday a Channel9 video appeared with Anders Hejlsberg and Sam Druker talking about LINQ and Entities. They talk about raising the level of abstraction for programmers when programming against data. Anders makes a very good point at 6m42s that LINQ adds a level of abstraction without taking away capabilities at the bottom level (like writing your own SQL query). The loss of capabilities at the bottom often happens when the level of abstraction is being raised. Anders says: โ€œWe are very conscious of not sliding the spectrum up but growing the capabilities.โ€

At the end of the video (at 21m58s) we get a glimpse into the reason behind the retraction of the MSDN Article called Next-Generation Data Access: Making the Conceptual Level Real which was also about this subject. Microsoft was working on two parallel tracks (ADO.NET vNext and LINQ) on different teams and is now struggling with realigning those efforts.

The Entity concept will be part of the next version of ADO.NET. Note that I no longer call this future version ADO.NET 3.0, since this might cause confusion with the version number of the next version of the .NET Framework itself. LINQ and ADO.NET vNext will NOT be included in the .NET Framework 3.0. Instead .NET 3.0 will contain ADO.NET 2.0. Confusing isnโ€™t it? ๐Ÿ™‚