Showing posts with label EF v1 Manifesto. Show all posts
Showing posts with label EF v1 Manifesto. Show all posts

Friday, November 21, 2008

Entity Framework Team Abandons Unified N-Tier Architecture for v2

Updated 11/21/2008: See below

Jeff Derstadt, Jaroslaw Kowalski, and Diego Vega posted on 11/19/2008 a lengthy N-Tier Improvements for Entity Framework [v2] article, which proposes the following “goal” for change management in future n-tier implementations:

Entity Framework won’t define its own unique representation for the set of changes represented in an N-Tier application. Instead, it will provide basic building block APIs that will facilitate the use of a wide range of representations.

The decision to abandon a unified n-tier architecture for EF v2 appears to stem from the anticipation that users would expect such a design to offer the programming simplicity of DataSets (represented by Martin Fowler’s Table Module pattern) combined with the versatility and strong decoupling offered by Data Transfer Objects. The availability of ADO.NET Data Services to provide a REST-based tiered service layer probably contributed to the designers’ justification of an n-tier non-goal.

To achieve the proposed non-goal, the team intends to supply helper methods that developers can mix and match for customizing their tiered implementations to accommodate varying domain models, trust boundaries, batch operations, and optimistic concurrency management granularity. Following are the proposed methods, together with the authors’ summary of their purpose:

  • ApplyOriginalValues() applies property values to original state of the entity
  • ChangeObjectState() changes the state of the entity and incident relationships
  • ChangeRelationshipState() changes state (new, modified, or deleted) of a relationship
  • ChangeRelationshipState() (overload) changes state of a relationship represented by a navigation property
  • ChangeRelationshipState<TSource>() changes state of a relationship represented by a lambda expression

The team presents simplified sample code for two scenarios:

  1. General purpose Attach with state resolution delegate in which the client sends a modified entity graph to the mid-tier for processing and persisting.
  2. ChangeOrder Service Operation in which the parent of a dependent entity is changed or added

I’m disappointed by the authors’ compromised approach to n-tier EF implementation, but I’ll reserve judgment until I can test sample code for both simple and very complex, tightly controlled scenarios with POCO entities at least as convoluted as those from AdventureWorks. Hopefully, the sample code will include a complete test suite with mocked data.

It will be interesting to hear the reaction to this approach from the ALT.NET petitioners, AKA the “NHibernate Mafia”, as well as that of the ADO.NET Advisory Council.

Update 11/21/2008: Frans Bouma’s Baby-sitter Framework 2.0: Change tracking in the EF v2, it's still your problem post takes the EF team to task for forcing developers to write their own n-tier change-tracking code. Frans points out that clients or employers should not be required (or requested) to pay for writing data access code. Ayende Rahien agrees with Frans in his Stealing from your client post of the same date. Ayende says “This Is Broken, By Design.” I agree.

Astoundingly, Jeff Derstadt said in a reply to Frans’ comment to the post:

One of our goals was to avoid defining a part[i]cular wire-level format for changes sent from client to another tier.

I’m no longer reserving judgment. This is Nuts! Not only must developers write their own client-side change-tracking code but kludge their own “wire-level format for changes sent from client to another tier.”

Hopefully Matt Warren will revive his mini-connectionless DataContext for LINQ to SQL or Danny Simmons will productize Perseus.

P.S. for Tim Mallalieu: We still haven’t seen the promised minutes of the Advisory Council’s first meeting.

Saturday, November 08, 2008

Professional ADO.NET 3.5 with LINQ and the Entity Framework: Table of Contents

Following is the final table of contents for Professional ADO.NET 3.5 with LINQ and the Entity Framework from Wiley, which will be published in January or February 2009:

  Introduction
Part I   Getting a Grip on ADO.NET 3.5
Chapter 1   Taking a New Approach to Data Access in ADO.NET 3.5
Part II   Introducing Language Integrated Query
    Introduction to Part II
Chapter 2   Understanding LINQ Architecture and Implementation
Chapter 3   Executing LINQ Query Expressions with LINQ to Objects
Chapter 4   Working with Advanced Query Operators and Expressions
Part III   Applying Domain-Specific LINQ Implementations
    Introduction to Part III
Chapter 5   Using LINQ to SQL and the LinqDataSource
Chapter 6   Querying DataTables with LINQ to DataSets
Chapter 7   Manipulating Documents with LINQ to XML
Chapter 8   Exploring Third-Party and Emerging LINQ Implementations
Part IV   Introducing the ADO.NET Entity Framework
    Introduction to Part IV
Chapter   9   Raising the Level of Data Abstraction with the Entity Data Model
Chapter 10   Defining Conceptual, Mapping, and Storage Layers
Chapter 11   Introducing Entity SQL
Part V   Implementing the ADO.NET Entity Framework
    Introduction to Part V
Chapter 12   Taking Advantage of Object Services and LINQ to Entities
Chapter 13   Updating Entities and Complex Types
Chapter 14   Binding Data Controls to the ObjectContext
Chapter 15   Using the Entity Framework As a Data Source

I’ll be reviewing final page layout during the next week or two. I estimate the final page count will be close to 650 (not 550) pages.

Sunday, September 21, 2008

Forcing Gratuitious Pluralization of EF EntitySet Names Was a Very Bad Decision

Following is the full text of my How to Disable Unwanted EntitySet Pluralization in v1? thread of 9/20/2008 in the ADO.NET Entity Framework and LINQ to Entities (Pre-release) forum:

Jarek Kowalski says in EF Newbie Question on Pluralization: "Pluralization of entity set names and singularization of entity type names is not supported in EFv1 tools, but we're considering adding them in future releases."

As of EF v1's RTM I find the above to be incorrect. Manually singularizing EntityObject names pluralizes EntitySet names by renaming them to the singularized version and adding a "Set" suffix (e.g., renaming Customers to Customer generates a CustomerSet EntitySet name.) This requires manually changing the name of each EntitySet in the entity’s Properties sheet back to its original plural form.

Pluralization occurs with the Tools | Options | Database Tools | OR Designer | Pluralization property set to false. The Pluralization option description reads "Controls whether pluralization is applied to names when creating objects. Pluralization is only enabled for English." The description infers that only Pluralization is affected, which is what the EDM Designer is doing, not Singularization; LINQ to SQL's OR Designer does Singularization.

I'm curious why the EF tools devs foisted an ugly pluralization naming convention on unsuspecting users and then didn't choose the obvious approach to turning it off. Was it because the term "OR Designer" would denigrate the "EDM Designer?"

Further, beta testers weren't given the opportunity to complain about this unwanted and unhelpful operation or notified about the change in Jeff Derstadt’s Entity Framework RTM Breaking Changes post to the ADO.NET Team Blog of August 12, 2008.

How do I turn this so-called "feature" off?

Not only was the pluralization gratuitous, it was inserted by a stealth process into EF’s SP1 RTM. I discovered the operation when updating EF Beta 2 code for my forthcoming Professional ADO.NET 3.5: LINQ and Entity Framework book for WROX.

Although the Northwind database is the example data source in much of EF’s documentation, the only use of sample EntitySets having names suffixed with “Set” that I can find is Entity Containers (EDM).

If I had detected it in time, I probably would have signed the ADO.NET Entity Framework Vote of No Confidence manifesto.

I’d like to know how many EF beta testers requested this bogus “feature.” It’s arbitrary and capricious design decisions like this that led to the manifesto.

Note: Fortunately, Huageti Systems’ Huagati DBML and EDMX Tools has an EF (and LINQ to SQL) add-in that has a “renaming function that goes through all entity sets, entity types (classes), properties, and navigation properties in a EDMX file (EF designer) and renames them according to a user-selectable set of rules.”

Update 9/21/2008: The Singularizing EntityType and Pluralizing EntitySet Names with the Huagati DBML/EDMX Tools post of 9/21/2008 demonstrates the Huagati DBML and EDMX Tools’ capabilities.

More Fuel on the Fire: Mike Pizzo’s Reply to an Earlier Question

EF Data Architect Mike Pizzo wrote the following on 10/26/2007 in reply to JPAK’s Linq to entities and LIKE question in the same forum

Pluralization (and "Singularization") is one of the features we looked hard at for the designer (and underlying API) but had to cut for version 1.  The problem is not with the code (we actually have a couple of routines that are pretty advanced that we could borrow from) but with testing all of the different variations.

There is also the issue that the pluralization rules would be [E]nglish-language based (so we'd need a way to disable them for other languages), but we still believe even an [E]nglish-only version would be useful.

The only saving grace is that the designer does make it relatively easy to rename entities, but this is still one of my top 5 features that I wish we could have gotten in for version 1 (but leaves us something to do for V2... :-)

The above leads to questions regarding how and why the “feature” turned up in the final product.

Update 9/20/2008 11:45 AM PDT: According to Microsoft’s Noam Ben-Ami in a reply to my question:

We have heard other complaints about this behavior and it will be turned off in the next release, to which we are working on adding [E]nglish language pluralization/singularization. There is no setting at this time that controls this behavior.

Monday, July 28, 2008

LINQ and Entity Framework Posts for 7/24/2008+

Note: This post is updated daily or more frequently, depending on the availability of new articles.

Updated SQL Server Data Services (SSDS) Test Harness: Northwind REST and SOAP Uploads

The SSDSNwindEntitiesCS.sln sample project for my “Test-Drive SQL Server Data Services” cover article for the July 2008 issue of Visual Studio Magazine has been updated to SSDS Sprint 3, adds a couple of features, and has a few start-up bugs excised.

New Features:

  • The program attempts to create an authority if you haven’t added one.
  • A splash screen opens during the initial query for ACE container and entity object because the process is very slow with a moderate number of objects.

Updates:

  • The new 'application/x-ssds+xml' MIME type replaces ‘application/xml’.
  • The containerUri = response.Headers[HttpResponseHeader.Location]; instruction which now returns null has been replaced with concatenated constants as the containerUri value. This eliminates a problem when creating new containers with REST operations.

Download: You can download the SSDSNwindEntitiesCS project here (114-KB SSDSNwindEntities.zip file at Skydrive).

My Updated SQL Server Data Services (SSDS) Test Harness: Northwind REST and SOAP Uploads of July 27, 2008 has more details and screen captures.

Added: July 28, 2008

Stephen Forte’s Impedance Mismatch Post Elicits Responses from Domain-Driven Designers

The “Stephen Forte Embraces the Impedance Mismatch” topic of my LINQ and Entity Framework Posts for 7/14/2008+ post quotes Steve’s Impedance Mismatch post of June 27, 2008, which eschewed “object-fist” in favor of “data-first” design.

I assumed that Steve’s post would brew a storm of controversy, especially since he’s a member of the Entity Framework’s new Advisory Council. However, it turned out to be a tempest in a teapot as described in my Stephen Forte’s Impedance Mismatch Post Elicits Responses from Domain-Driven Designers of July 27, 2008.

Bidirectional Serialization of LINQ to SQL Object Graphs with Damien Guard’s T4 Template in VS 2008 SP1

LINQ to SQL developer Damien Guard, who joined the DPG in May 2008, announced the availability of a customizable T4 template to generate LINQ to SQL classes from the *.dbml file in his LINQ to SQL T4 template reloaded post of July 23, 2008.

A couple of minor modifications to the L2ST4.tt template file and addition of a reference to and using directive for the System.Runtime.Serialization namespace enables full-object-graph serialization of LINQ to SQL entities. This brings parity to both VS 2008 OR/M tools in the serialization department.

Read more at Bidirectional Serialization of LINQ to SQL Object Graphs with Damien Guard’s T4 Template in VS 2008 SP1 of July 24, 2008 (updated 7/27/2008) and download the sample C# project.

Mike Taulty Posts Five ADO.NET Data Services Screencasts

Following are titles with links to the five Astoria screencasts that Mike posted on July 25, 2008:

Ryan Dunn Makes IE Display SQL Server Data Services New application/x-ssds+xml MIME Type

Internet Explorer now prompts you to download SQL Server Data Services (SSDS) content that uses the new (post-Sprint 3) application/x-ssds+xml MIME type instead of application/xml.

Ryan’s Rendering POX for SSDS in Internet Explorer post of July 25, 2008 gives you the magic Registry hack to make IE display SSDS’s POX wire format.

Matthieu Mezil Shows You How to Instantiate a New EntityKey

Entity Framework uses EntityKeys to represent unique entities in its cache. EntityKeys are immutable, so Matthieu shows you how to instantiate new ones in his EntityReference change key post of July 25, 2008.

Phani Raju Demonstrates Using the AJAX 4.0 Preview’s DataView Control with ADO.NET Data Services

Phani’s ASP.NET AJAX 4.0 Master-Details View with the DataView and ASP.NET AJAX 4.0 Master-Details View with the DataView , Part 2 posts of July 24 and 25, 2008 use the ASP.NET AJAX 4.0 CodePlex Preview 1’s templating engine and DataView control to build master-details pages.

Phani uses Astoria and its AJAX Client Library for ADO.NET Data Services from CodePlex as the data source.

Jim Wooley: Quickly create an IEnumerable<T> from a DataReader

Jim’s Filling an object from a DataReader with LINQ using DataContext.Translate post of July 25, 2008 shows you how to use the DataContext.Translate<T>() method to create an entity set from a database table without mapping for the DataContext.GetTable() method.

Eric White Analyzes Responses to his “Are Developers Using LINQ?” Post

Eric received many detailed responses to his Are Developers Using LINQ? post of July 23, 2008. In his Are Developers Using LINQ? (Part 2) post of July 25, 2008, he describes these four common LINQ usage scenarios:

  • Using LINQ to Objects and LINQ to XML … .
  • Using query expressions … to access objects and XML.
  • Using LINQ to SQL or LINQ to Entities to access a database.
  • Using LINQ implemented using an IQueryable provider to something other than a SQL database.

and noted that there were only a few negative responses.

Keith J. Farmer points out in a comment to the first post that folks still call LINQ “link,” consider LINQ to SQL to be the only implementation, and believe SQL Server is the only LINQ-enabled data provider.

Ruurd Boeke Joins Microsoft’s Silverlight (not Entity Framework) Team

Ruurd notes in his I’m joining Microsoft!! post of July 25, 2008 that:

I was torn between working on EF (which, I’ve been very involved with lately) and on Silverlight. In the end, Silverlight won, because I strongly believe it to be the strongest contender in the client space.

I’m disappointed that Ruurd didn’t choose to join the Entity Framework team. His six-part Introducing Entity Framework Contrib: Easy IPoco implementation V 0.1 series used Postsharp to “[a]utomatically implement the IPoco interfaces. The project is aimed at helping you build your domain layer in a more persistence ignorant way than is possible at this moment.”

Note: Ruurd’s eight-part Workflow as controller: Introducing <M,V,C> where M: ViewModel, V : WPF, C : WF describes an inventive framework that uses WF in an unconventional role, although he won’t call his tutorial a framework.

Jeff Currier Defends SQL Server Data Services’ Missing PUT/POST Response Bodies

Mike Amundsen’s REST PUT/POST Responses contain ETag, but not body - Oops! thread of July 24, 2008 in the SQL Server Data Services (SSDS) - Getting Started says:

I note that the PUT results in a return that includes an ETag (yay!), but that there is no body returned for this PUT. I think this is a problem. ETags act as a version hash for the document body. Yet this Response has no body!

Jeff’s What happened to SSDS PUT/POST responses? post of July 25 replies:

Prior to this rollout the only mechanism that we had to communicate version information to you was via the entity body of the response (specifically the version element in the body).  However, now that we have true ETag support we now can simply return this value back to caller via the ETag header per the Http spec.

Jeff attributes the reason for the change to future ingress and egress charges; returning the body would increase downloaded bytes.

Beth Massi Posts Four WPF Forms Over Data Video Segments to the Code Gallery

Her WPF Forms over Data: 2 More Videos! post of July 24, 2008 announces #3 and #4 in the following series about data binding in WPF:

  1. How Do I: Create a Simple Data Entry Form in WPF?
  2. How Do I: Display Data in a List in WPF?
  3. How Do I: Create Lookup Combobox in WPF?
  4. How Do I: Hook Up and Display Validation in WPF?

Click the Watch Video link to substitute MediaPlayer for the miniature Silverlight window. VB and C# sample code is downloadable.

Charlie Calvert Continues with Aggregate Operators in his Revived LINQ Farm Series

Charlie’s LINQ Farm: More on the LINQ Aggregate Operators discusses the following LINQ aggregate operators and their overloads:

  • Count and LongCount
  • Min and Max
  • Average
  • Sum
  • Aggregate

Jeremy D. Miller and Ward Bell Discuss Object/Relational Modeling and the Entity Framework in a Two-Part Podcast

The first ALT.NET Object-Relational Mapping podcast with Jeremy D. Miller and Ward Bell covers Object/Relational Mapping (O/RM) tools and when to use them. Topics include:

  • Object-Relational Mapping
  • Object-first vs. Data-first Approaches
  • Evolutionary Database Design
  • Evolutionary Design
  • Code Generation
  • Persistence Ignorance
  • POCO
  • Domain-Driven Design
  • The Vietnam of Computer Science

    The second part “discusses the Vote of No Confidence on Microsoft's Entity Framework and what it means for the Alt.NET and .NET communities.”

    Scott Hanselman Does a Video Deep Dive on LINQ and the Entity Framework

    The actual title of Scott’s Jumpstart Data Driven Web Applications with ASP.NET 3.5 (Part 1 of 2) presentation for Tech*Ed 2008 Developer is “WUX101: Jumpstart Data-Driven Web Applications with ASP.NET 3.5 Dynamic Data Controls (Part 1 of 2).”

    Note: ASP.NET 3.5 Dynamic Data Controls became ASP.NET Dynamic Data after Tech*Ed.

    The deck for the presentation reads:

    Explore the new features in ASP.NET 3.5 that make buliding data driven Web applications a breeze. In this first of a two-part series, learn how to use LINQ to take the pain out of interacting with your relational data and how support for LINQ and its constructs are built into the paradigms you are familiar with in ASP.NET and Microsoft Visual Studio 2008.

    Hopefully the TechEd Online News folks will post Part 2 shortly.

  • Saturday, June 28, 2008

    Current Commentary About the “ADO.NET Entity Framework Vote of No Confidence” Manifesto

    Moved from LINQ and Entity Framework Posts for 6/25/2008+ on 6/24/2008 at 1600 PDT due to length. Updated: 7/3/2008 0830 PDT with copies of recent Tweets and 7/6/2008 with an added entry.

    Here’s a list of some of the more interesting posts about Scott Bellware’s ADO .NET Entity Framework Vote of No Confidence petition, which had collected 417 votes as of July 6, 2008 0720 PDT:

    For more background on the “No Confidence” petition, see Tim Mallalieu Addresses “ADO .NET Entity Framework Vote of No Confidence” Manifesto, New Entity Framework Design Blog Announces Transparent v2 Design Process, Ian Cooper Rings in with a Level-Headed Critique of Entity Framework v1.

    Thursday, June 26, 2008

    Ian Cooper Rings in with a Level-Headed Critique of Entity Framework v1

    Ian’s The criticism of the Entity Framework is not just around Domain Driven Design post of June 26, 2008 likens Entity Framework v1 to early versions of Enterprise Java Beans (EJB):

    EJBs were an ambitious attempt to support persistence, transactions, events, [remote procedure calls (RPC)], etc., in a single component. While there was an initial rush to adoption, they quickly proved a millstone around the Java communities neck, because of their complexity. Technologies like Spring and Hibernate emerged as less-complex ways of delivering enterprise class solutions, many of them were later to be incorporated into drastically revised EJB visions.

    The .NET community had a huge amount to gain from this experience. Ports of Hibernate and Spring offered the community the chance to avoid the mistakes of the past. However, seemingly unaware of the lessons of history the EF team embarked on a project to produce a complex framework, of which persistence is just one aspect, reminiscent of the EJB initiative. So the reaction against the EF comes from its failure to learn lessons that another community has struggled with around complexity and ambition.

    So the warnings issued around the EF are trying to prevent .NET developers straying into the same path of pain that their Java brethren experienced with complex non-PI frameworks.

    He concludes with an analysis of why domain-driven design is preferable to data-driven architectures.

    Backstory: Ian Cooper was one of LINQ to SQL early proponents and Entity Framework detractors. Ian wrote the first analysis of the architectural patterns supported by LINQ to SQL in his Being Ignorant with LINQ to SQL post of June 10, 2007 which concluded:

    LINQ to SQL is usable with a TDD/DDD approach to development. Indeed the ability to swap between LINQ to Objects and LINQ to SQL promises to make much more of the code easily testable via unit tests than before.

    His post garnered 122 comments.

    My Ian Cooper Takes on DDD, TDD and PI with LINQ to SQL post of June 11, 2007 is a lengthy review of his analysis and includes a link to Ian’s earlier critique of EF, LINQ to Entities and Occam's Razor.

    My post includes a link to Defining the Direction of LINQ to Entities/EDM post of May 29, 2007, which includes a lengthy comment on my recommendations by ADO.NET Architect Michael Pizzo.

    Note: If you’re working with LINQ to SQL, Ian has written an eight-part tutorial entitled Architecting LINQ to SQL Applications. This, alone, should prove Ian’s not an architectural bigot.

    Update 6/26/2008 1610 PDT: Added “Ian Cooper was one of LINQ to SQL early proponents and Entity Framework detractors” sentence from linking entry for clarification.

    Tuesday, June 24, 2008

    Tim Mallalieu Addresses “ADO .NET Entity Framework Vote of No Confidence” Manifesto

    In the tradition of Émile Zola’s “J'accuse” and Martin Luther’s The 95 Theses letters, the ADO .NET Entity Framework Vote of No Confidence petition in the form of a WuFoo page with attached Entity Framework Vote of No Confidence Signatories table had gathered more than 150 signatures by mid-afternoon of June 24, 2008.

    The petition focuses on these five theses:

    1. Inordinate focus [on] the data aspect of entities leads to degraded entity architectures
    2. Excess code [is] needed to deal with lack of lazy loading
    3. [A] shared, canonical model contradicts software best practices
    4. Lack of persistence ignorance causes business logic to be harder to read, write and modify, causing development and maintenance costs to increase at an exaggerated rate
    5. Excessive merge conflicts [occur] with source control in team environments

    Three of the signatories, Jeremy D. Miller, Scott Bellware, James Kovacs, and Dave Laribee are among the seven Microsoft MVPs who “took apartDanny Simmons and others on the ADO.NET team at the MVP Global Summit in Seattle on March 14, 2007 and taught them NHibernate. Ayende Rahien, a.k.a. Oren Eini, a primary contributor to NHibernate, the best-known EF competitor, is another MVP involved in last year’s controversy who signed the petition.

    The primary complaint at that time was lack of persistence ignorance, which I covered in detail by my Persistence Ignorance Is Bliss, but Is It Missing from the Entity Framework? post of March 17, 2008. Data-centric design was also a topic of contention.

    I’m surprised to find lack of an “out-of-the-box n-tier story” missing from the list. Most developers consider lack of SOA-friendly features is more significant than data-first design, which is necessary when connecting to legacy databases.

    On the whole I consider the “No Confidence Manifesto” to be doctrinaire and an example of attempts to enforce “political correctness” in software architecture. I’d wager that EF would perform more than adequately in 80% or more of the applications that require O/RM tools. It appears to be adequate for the Astoria team (It’s required to create updatable entities.) It works fine for me with the EntityDataSource and ASP.NET Dynamic Data.

    A Serious Case of Hubris

    Update 6/24/2008 1730 PDT re "doctrinaire” and “political correctness”

    In a comment to Tim Lee’s detailed Thoughts on the Entity Framework Vote of No Confidence of 6/23/2008 an anonymous commenter says:

    The perspectives in the letter are fed by many years of experience in building entity-based applications using the various techniques and frameworks that our evolving awareness of issues led us to along the way.

    It's great that you're questioning the validity of the claims of the letter and expressing your perspective.  I don't think that we can possibly have the same perspective because of the different experiences between us.

    Frankly, we can't really argue this issue on a peer level.  You'll have to practice entity-based designs within the context of practices that support reversability and the levels of productivity we get from choices of tooling and approach that have been honed by quite a bit of time invested in trial and error over the years.

    And yes, I know that you can take this comment as pomp and arrogance.  That always seems to be the risk in the .NET developer community when we tell someone that there's much more experience to be gained and much more learning to do. [Emphasis added.]

    Sounds like serious hubris to me. I wonder who was the author. (The comment form doesn’t have provision for entering a name or URL, but the author could easily have done so in the comment’s body.)

    Update 6/25/2008: The author of the comment to Tim Lee’s post was Scott Bellware. See his comment to this post.

    Fear and Loathing

    That’s the coincidentally appropriate name of Bil Simser’s blog that contains his ADO.NET Enity Framework Vote of No Confidence post of June 23, 2008. (He’s one of the Manifesto’s MVP signatories.) If you really want to stick the knife in, accuse users of being “VB6 drag-n-drop programmers,” as in this excerpt:

    Over the past year or two, I've been a casual observer into the Entity Framework coming out of Microsoft. Being an ALT.NET guy, the world tends to revolve around NHibernate for me so I've already got an excellent OR/M tool in my toolset. One of the big issues with EF that we've recognized is the general direction Microsoft has taken with it, following a data centric model rather than an object one. …

    What we see on the horizon is a new breed of VB6 drag-n-drop programmers embracing EF as the next Messiah. We see a new generation of developers focused on mapping their data models and missing the target of architecting and constructing well designed systems.

    It appears to me that the “NHibernate Mafia” are becoming the “ALT.NET Third Reich.” I’m surprised Bil didn’t sign his post “Elvis” or “Einstein.”

    My conclusion is that the NHibernate Mafia is attempting to protect a vested interest in NHibernate as a result of the investment in time and effort to needed to become an apprentice NHibernate plumber, let alone a journeyman. You need to bill a large number of client-hours to recoup the learning curve. An O/RM tool that can handle, say 80%, of the bread-and-butter applications that keep most developers mortgage paid with RAD design tools must truly be a chimera.

    Tim Mallalieu Responds to the Petitioners

    Unlike Zola, the petition signatories weren’t prosecuted for libel, nor were they requested to recant their theses, as Pope Leo X insisted of Luther. Instead, Tim Mallalieu quickly addressed the issues raised in the manifesto by his Vote of No Confidence post of June 24, 2008. Entity Framework v2 will deal with theses 1, 2 and 4. I’m not convinced that thesis 3 is well taken. Issue 5 appears to be up in the air at the moment.

    Mary Jo Foley’s Testers give Microsoft’s Entity Framework a no-confidence vote post of the same date puts the manifesto in perspective. Scott Bellware, who said in this comment that he was “the principal author” of the petition, requested that Mary Jo recant her classification of the signatories as “testers.” Scott’s comment to my persistence ignorance post, my reply, and Danny Simmons’ response start here. Scott’s primary concern at the time was availability of the EDM Designer in v1, not data-centricity.

    Update 6/25/2008: Mary Jo’s column hit Techmeme on 6/24/2008 at 4:45 PM. My favorite comment to her column: “I'm not a tester: I've never installed nor tested an Entity Framework beta, but I signed the vote of no confidence” by odenni.

    The manifesto had 226 signatories by 6/25/2008 at 8:30 AM.

    Rebuttals to the Manifesto

    Julie Lerman’s Oh that no-confidence vote on E.F. post of June 24, 2008 is a reasoned objection to the purpose, and therefore much of the substance, of the petition.

    Update 6/24/2008 1815 PDT Added below:

    But the most detailed, measured and even-handed response to the manifesto comes from Ward Bell, VP of Product Management of IdeaBlade, Inc. who posted Rejoinder #1 to "Vote of No Confidence in Entity Framework" late Wednesday. IdeaBlade produces the DevForce .NET enterprise application development framework. Its DevForce EF integrates EF with the DevForce framework to add advanced mapping and LINQ features.Dev Force contributes n-tier capabilities with its Business Object Server (BOS) and a full object graph caching on the client. DevForce EF is in the release candidate stage, which qualifies IdeaBlade in my view as an enterprise class user. A beta of a Silverlight 2 DevForce EF client is due in four to six weeks.

    His post covers too much territory to summarize here. Just read it.

    Update 6/25/2008: Dinesh Kulkarni’s Design of LINQ to SQL - What was I thinking or was I? post of 6/24/2008 is a parody of the manifesto’s author(s) position.

    New Zealand (Kiwi) Australian developer Keith Patton’s A vote of confidence for the Entity Framework post of 6/24/2008 begins:

    I've been working solidly with EF since the SP1 beta came out and can honestly say it's holding up very well across a large, enterprise data model structure, and alongside usage of a repository pattern and dependency injection to factor out most of the direct dependencies on the EF ObjectContext, we have a system that can move towards POCO over time with relatively little refactoring.

    And continues with a detailed refutation of the manifesto’s theses.

    Update 6/25/2008: Corrected Keith’s locale (see comments).

    New Entity Framework Design Blog Announces Transparent v2 Design Process

    Tim Mallalieu’s first post since taking over as Entity Framework (EF) program manager in the Autumn of 2007, Transparency in the design process of June 23, 2008, describes what’s in store for EF v2:

    • Persistence Ignorance (PI) with full Plain Old CLR Object (POCO) support for state management and ObjectContext interaction
    • N-Tier Support for remoting object graphs with change tracking using WCF
    • Code-First domain modeling with convention-based mapping instead of v1’s data-centric, forms-over-data approach
    • Test-Driven Development (TDD) Scenarios with POCO and virtual ObjectQuery<T> and entity classes
    • Foreign Key modeling support in addition to associations
    • Lazy Loading options, possibly implicit lazy loading
    • Query Tree Re-Writing to enable filtering query results horizontally and vertically without attempting to modify the expression tree

    These are the features required take EF out of the curiosity category and move it to an enterprise-class framework that’s capable of competing on a level playing field with NHibernate. They are precisely the features that the so-called “NHibernate Mafia” claimed were missing from EF v1’s original design.

    For more background about persistence ignorance and POCO, see my Persistence Ignorance Is Bliss, but Is It Missing from the Entity Framework? post of March 14, 2007.

    Tim is adopting Pablo Castro’s transparent design process for ADO.NET Data Services (Astoria), which I recommended to the SQL Server Data Services (SSDS) team last week. Tim promises to expose the design process:

    What exactly would we make visible? In short, our design process. To be more concrete, I’m not talking about some fancy set of specifications. What I mean is that as we go through the detailed design of the various aspects of Entity Framework V2, we would post to this blog a) the meeting notes from our design meetings (the team has a design meeting twice a week, plus a lot of impromptu hallway chats), and b) deeper write-ups of specific design challenges where we’d like folks to understand how we’re approaching a problem and provide a channel for deep, detailed feedback.

    Notice that there’s no mention of LINQ to SQL in this post, which undoubtedly represents the death knell for future improvements to LINQ to SQL. See my Is the ADO.NET Team Abandoning LINQ to SQL? post of May 23, 2008 for an earlier travelogue about LINQ to SQL’s journey to legacy product purgatory.

    Update 6/24/2008 1500 PDT: Moved to a full post and following added:

    It might or might not be a coincidence that an ADO .NET Entity Framework Vote of No Confidence petition in the form of a WuFoo form with attached Entity Framework Vote of No Confidence Signatories table appeared almost simultaneously with Tim’s original post.

    Get the full story in the Tim Mallalieu Addresses “ADO .NET Entity Framework Vote of No Confidence” Manifesto post of 6/24/2008.