DevMavens Feed

PAVE the Way to Effective Calls to Action

Steve Smith — Mon, 08 Feb 2010 21:53:00 GMT

In their book, Inbound Marketing (review), authors Shah and Halligan describe some key traits of effective calls to action. The four important qualities of killer calls-to-action are that they be Valuable, Easy-to-Use, Prominent, and Action-Oriented (chapter 8). The authors go on to suggest that this be referred to as “VEPA”, but I think we can do better than that. By simply shifting the letters by 2 positions, this becomes the much more memorable mnemonic, PAVE:

Prominent. Your offer must stand out. It should be difficult to miss. Don’t make potential customers have to think about how to interact with you.

Action-Oriented. You want the visitor to DO something. The call to action should compel the user to take action (hence the name) using a verb. A great analysis of the difference wording can make can be found here.

Valuable. Make sure it’s clear to the visitor what’s in it for them if they take action. Internet users have (justifiably) grown skeptical of wasting their time with offers online. Make sure your offer if valuable but also instills trust and helps you build a relationship with the user.

Easy-to-Use. Make it as simple as possible for the user to respond to your call to action. Think Amazon One-Click purchasing. Again, don’t make the user think about how to proceed, and don’t put any unnecessary barriers (like longer-than-necessary registration forms) in front of them.

So there you have it – four qualities of calls to action that will help PAVE the way to higher response rates for your web site. Perhaps when it comes time for a second edition of Inbound Marketing, they’ll use the PAVE acronym (and maybe even credit me).

http://www.flickr.com/photos/myconstructionphotos/ / CC BY-NC-ND 2.0

Upcoming Events

Scott Allen — Mon, 08 Feb 2010 19:12:00 GMT

Here are some events I’ll be speaking at over the next couple months:

DevTeach

Toronto / Mississauga March 8-12. DevTeach stands for Developers Teaching. It’s a conference done by developers for developers. This annual event offers the elements of an international conference and the elements of a community event. Sessions include both presentation material and, whenever possible, hands-on training. We like to describe this event as the Developers Festival. Find out who should attend at this link. Check out the top ten ways to convince your boss to let you go this event. DevTeach is about becoming one of the best developer by getting training from the best in the industry.

Scandinavian Developer Conference

Göteborg, Sweden March 16-17. Whether you are someone learning development in Java, .NET or IBM i or you are an experienced user of these technologies for 10 years or more, there are lot of great information to be shared with everyone.

In addition to technical sessions, we will also have tracks with presentations about the Development Process and Methodology: Agile Methodology, Test Driven Development, System Engineering, Architecture, Project Management, Best practices, "Agile in the Organization". We will also have tracks about hot topics like Cloud Computing, Testing, Web Development and Mobile Solutions. At the Conference there will also be a track of Emerging Technologies presented in cooperation with ThoughtWorks ( www.thoughtworks.com )

DevDays 2010

DevDays is being held at World Forum in Den Haag March 30-31. DevDays 2010: the biggest Microsoft event in the Netherlands for software development and software architecture. Every year, thousands of professionals visit DevDays to get completely up-to-date with all recent developments in their area of expertise in two days.

DevConnections

Las Vegas April 12-14 2010. Developers from around the world will gather at the world famous Bellagio, for the Microsoft Visual Studio Conference & Expo, ASP.NET & Silverlight Conference & Expo and SQL Server Conference & Expo. You can be a part of this exciting event while you enjoy one of the most stunning hotels on the Las Vegas Strip at a great conference rate!

Say hello to Uber Prof

Oren Eini — Mon, 08 Feb 2010 15:00:00 GMT

I got several requests for this, so I am making Uber Prof itself available for purchasing.

What is Uber Prof?

It is a short hand way of saying: All the OR/M profilers that we make.

An Uber Prof license gives you the ability to use:

And it will automatically give you the ability to use any additional profilers that we will create. And yes, there is an upgrade path if you already purchased a single profiler license and would like to upgrade to Uber Prof.

Read more: Say hello to Uber Prof | Subscribe

Built-in Charting Controls (VS 2010 and .NET 4 Series)

Scott Guthrie — Mon, 08 Feb 2010 10:54:52 GMT

[In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu]

This is the fifteenth in a series of blog posts I’m doing on the upcoming VS 2010 and .NET 4 release. Today’s post covers a nice addition to ASP.NET and Windows Forms with .NET 4 - built-in charting control support.

ASP.NET and Windows Forms Charting Controls

A little over 14 months ago I blogged about how Microsoft was making available a free download of charting controls for both ASP.NET 3.5 and Windows Forms 3.5.

You can download and use these runtime controls for free within your web and client applications today. You can also download VS 2008 tooling support for them. They provide a rich set of charting capabilities that is easy to use. To get a sense of what all you can do with them, I recommend downloading the ASP.NET and Windows Forms sample projects which provide more than 200 samples within them. Below is a screen-shot of some pie and doughnut chart samples from the ASP.NET sample application:

Charting Controls Now Built-into .NET 4

With .NET 3.5 you had to separately download the chart controls and add them into your application. With .NET 4 these controls are now built-into ASP.NET 4 and Windows Forms 4 – which means you can immediately take advantage of them out of the box (no separate download or registration required).

Within ASP.NET 4 applications you’ll find that there is now a new <asp:chart> control within the “Data” tab of the Toolbox:

You can use this control without having to register or wire-up any configuration file entries. All of the charting control configuration is now pre-registered with ASP.NET 4 (meaning nothing has to be added to an application’s web.config file for them to work). This enables you to maintain very clean and minimal Web.config files.

Learning more about the <asp:chart> control

Scott Mitchell has written a great series of articles on the www.4guysfromrolla.com site on how to take advantage of the <asp:chart> control:

Getting Started - walks through getting started using the Chart Controls, from version requirements to downloading and installing the Chart Controls, to displaying a simple chart in an ASP.NET page.
Plotting Chart Data - examines the multitude of ways by which data can be plotted on a chart, from databinding to manually adding the points one at a time.
Rendering the Chart - the Chart Controls offer a variety of ways to render the chart data into an image. This article explores these options.
Sorting and Filtering Chart Data - this article shows how to programmatically sort and filter the chart's data prior to display.
Programmatically Generating Chart Images - learn how to programmatically create and alter the chart image file.
Creating Drill Down Reports - see how to build drill down reports using the Chart control.
Adding Statistical Formulas - learn how to add statistical formulas, such as mean, median, variance, and forecasts, to your charts.
Enhancing Charts With Ajax - improve the user experience for dynamic and interactive charts using Ajax.

His articles are written using .NET 3.5 and the separate ASP.NET charting controls download – but all of the concepts and syntax work out of the box exactly the same with ASP.NET 4.

Michael Ceranski has also written a blog post demonstrating how to use the ASP.NET Chart control within an ASP.NET MVC application. I’m hoping someone will create some nice ASP.NET MVC Html.Chart() helper methods soon that will make this even easier to do in the future.

Hope this helps,

Scott

Windows 7 brings new life to devices that don’t have Vista drivers

Jeffrey Palermo — Mon, 08 Feb 2010 07:28:14 GMT

Back in 2005, I purchased an mVox 100 (mv100). This device worked great on Windows XP, and I used it in various VOIP application. Really great USB speakerphone. It’s tiny, also, and I kept it tucked in my back for the last 5 years.

When I upgraded my computer to Windows Vista, I was rather disappointed that this useful little device no longer worked.

I could not find any Vista drivers. From what I gleaned from forums, it relied on usbaudio.sys, which was overhauled in Windows Vista. Even though I couldn’t use the device, it stayed in my computer bag for 2 years! I switched computer bags today and uncovered this little speakerphone. I decided to give it a shot on my Windows 7 computer. Lo and behold, it worked! No driver install. I plugged it in, it detected it, and registered both the built-in microphone and sound card/speaker. I happened to have Skype open, and Skype immediately registered the device as the microphone and speaker. Bottom line: I am impressed by Windows 7 once again!

My mobile telephony kit now contains this mVox 100 USB speakerphone as well as my trusty Logitech notebook headset.

A marketing mistake: WCF Data Services & WCF RIA Services

Oren Eini — Sun, 07 Feb 2010 15:00:00 GMT

There are some things that I just don’t understand, and the decision to name two apparently different technologies working in the same area using those two names is one of them.

The image on the right is from In Search Of Stupidity, an excellent and funny book, which talks about a lot of marketing mistakes that software, dedicate a whole chapter for this error.

Coming back to WCF Data Services & WCF RIA Services, I read this page, and I am still confused. It appears that the major difference in that RIA services will generate the Silverlight client classes as part of the build process, where as using Data Services this is a separate process.

And I am not sure even of that.

NoSQL – A Practical Approach, Part 1

Rob Conery — Sun, 07 Feb 2010 04:05:14 GMT

In my last post I took a look at possible approaches to using NoSQL and Reporting, and many people wanted to see what this might look like in practice. In part one, below, I’ll show you ways to work with a NoSQL solution (in this case DB4O) in ways that you will find pretty familiar. I’ll also show you the freedom you can have as a developer when you stop thinking relationally.

The Problem

We’re building an application with [Favorite ORM] and so far it’s worked out pretty well, but we’ve had to make some compromises that we don’t particularly like and we’re finding that as our application matures we’re having to think way too much about how the data is being handled. Our “maintenance scaling” is not optimal. If you’re not one of these people, then you’re very lucky. I’ve written my own ORM and it still gets in my way, making me very cranky sometimes.

Step 1: Shift Your Thinking

We work in a pseudo-OO world, straddling a weird purgatory between relational and object-oriented programming. We’ve been lying to ourselves people – we can’t “go full OO” because our ORMs won’t like it.

ORMs are high-maintenance girl/boyfriends from hell that creep their little co-dependent weirdness deep into your application. Don’t believe me? What namespaces have you had to include in your object model lately? That ISession thing – yah that lives right in your FRICKIN GLOBAL ASAX.

Buddy, you moved your application into that apartment, got your own drawer, and now you’re having to deal with a high-maintenance partner from hell, who looked all sweet and honey-pottish when you first met but now is demanding foot rubs and chocolate. You get cranky – maybe say some things you didn’t mean and then…

There your ORM sits, pouting quietly.

I know what it is. You think I’m fat. That’s the problem – you don’t love me anymore.

You want to tell the truth:

Yes, well, sweetie 11 dlls – 800,000 lines of code (and counting) which all weighs in at 4Mb – all to query a database… yah YOU’RE A PIG

… but you don’t. You’re nicer than that and so you sit quietly and console your ORM. “I don’t mind working up another IUserType sweetie – it’s no big thing. This time I’ll be sure to override *all* the methods so you don’t fail completely when a weird value comes out of the database. It’s my fault… as always…”

There is an alternative and it requires something of you – open your mind and shift into OO. Many of the questions people have about OO/DocumentDBs can be answered by leaning on what you learned from school or books.

OODBs just serialize and persist your object to disk – keep this in mind, always. The dehydrate/rehydrate them and if you change a type on your object – well the hydrator will do what it can to help out. If you add a property, then all your prop settings for it will be null for all your objects. If you change a property name you’ll have to tell your persistence somehow.

Lots of questions – so let’s do this. I want to offer as much real code to get your juices flowing so here we go…

Step 2: You’ll Need A Helper

One thing that many people love about Rails is having so much support from the command line. You can kick up the console and work directly with your model interactively. We don’t have that with .NET and instead rely on our tooling – Visual Studio – which tells us most of what we want to know.

I like working with a console and I include one in every project. It helps me to work directly with the domain – adding in data from another system, spiking things, whatever. You’ll need one if you’re going to work with an OODB and I know that right there I’ve probably lost many of you. I know I can’t talk you into it – so go ahead and take off if you like :). I think it’s your loss…

…Because things become a whole lot easier when you get the hell out of the database (where you shouldn’t be anyway). Working in two different systems at once is not only disorienting – it’s also silly. If you need to rename a property and reset it’s data you can do so quickly with a method. I know it’s not as fast as rename column/regen codebase – but honestly it’s incredibly fast.

But wait. Wait just a damn minute. How often have you *needed* to do this? Yes yes I know that changing property names during development is something that happens – but how often have you had data that you needed to take with it? If you say “all the time” and you’re talking development – you’re doing it wrong.

If you’re talking about a hot-swap on a live system, well OK. In the 24 years that I’ve been doing this, I’ve changed a column name on a DB precisely twice – and I paid the damn price for it. But I know that people need to do this and I’m happy to say it’s actually *easier* with an object system because you don’t have to worry about blowing up Views or other stored queries.

To do this change you:

Create your new property, leaving the old one
Create a console task (or use Albacore) to copy, intelligently, the old property to the new one (perhaps there’s rules? Lookups?)
Delete your old property and refactor your code

I don’t think that it’s that difficult – but I will acknowledge that it’s a downside. I’ll take that downside for the other improvements, however.

Step 3: You’ll Need The DLLs

For the code you’re about to see I’m going to use DB4O because it’s the most current, mature, and cheapest solution. It’s not free for a commercial project, but it is for developers. If you’re using it in Open Source they have a BSD-friendly license that you can use for distribution if you like.

You can download it from here.

Step 4: Switching Your Model Over

This is probably the simplest thing you can do – believe it or not. You don’t have to add any attributes, no weird base classes. You don’t have to mark your properties as virtual or implement some kind of interface – DB4O will just take your object, serialize it to disk, and let you go on to your business.

You can (GASP) even remove parameterless constructors. How many ORMs let you do that?

Bask in that for a second. You can use factories and patterns that help you write less code and you can do it completely without thinking about what your co-dependent database thinks. It’s so freeing that it’s actually a bit scary – just let it roll for a bit – we’ll come back to this.

Here’s my model – it’s the one I’m using with Oren for Kona, our app we’re building for the NHibernate series on Tekpub. I’ve copied the project on my hard drive and haven’t touched a thing, except to:

Remove the NHibernate namespacing that lives on a number of the model classes
Remove the mapping files (there were 8 of them)
Remove the IUserType stuff we added for episode 3

I left everything else the same.

Step 5: Setup Unit of Work

I really like the way NHibernate (and Linq to SQL) allow you to use Unit of Work. It’s a very natural way of persisting the data – so let’s set that up. First I’ll setup the interface:

Next I want to setup the connection to DB4O. Normally this is done by opening up a file but that won’t work on the web (it’ll work just fine for desktop apps) so I want to make sure to use the client/server model here which DB4O implements nicely:

Notice that I’m putting the data file into App_Data – this is because it’s a protected directory by ASP.NET and also allows me to terse up the connection string so I don’t need to put in a file reference.

The thing to note here is you want to be sure the server stays a singleton – which you can work with your favorite IoC if you like (it implements IObjectServer). There’s probably a better pattern here – happy to take recommendations.

Finally – let’s create our Unit of Work, which will implement our interface above:

Step 6: Taking it For a Spin

There’s more we’re going to do here – but for those of you feeling antsy, crank up a test project and add an App.config with a hard file reference for your “ObjectStore” connection string (you can’t use HttpContext in a test project unless you mock it- just hard code a file ref, it’s easier. Call it whatever you want but the extension should be “.yap”).

Here’s some code that will work, assuming you have a Category and Product object:

        
        [Fact]
        public void DB_Should_Save_Multiple_Nested_Objects() {

            using (var s = SessionFactory.Current) {
                
                s.DeleteAll<Category>();
                s.DeleteAll<Product>();

                var c = new Category("test1");
                var c2 = new Category("test2");

                var p = new Product();
                p.SKU = "1234";
                p.Name = "Jurge";

                p.Categories.Add(c);
                p.Categories.Add(c2);

                s.Save(p);
                s.CommitChanges();

                var cat = s.Single<Category>(x => x.Name == "test2");
                Assert.NotNull(cat);

                Assert.Equal(2, s.All<Category>().Count());
                Assert.Equal(1, s.All<Product>().Count());
            }
        }

Something to notice here – when I save the Product object (with a child IEnumerable<Category>) the objects are pealed apart and joined by pointers. Take that in for a moment: DB4O knows that these are complex objects and will separate them for you so you can query them individually (as opposed to a document db, which just embeds the objects).

Something else to notice is that to store these things you need to call “CommitChanges()”, which commits the files to disk. If you don’t do this the objects will still be “stored” – but only in RAM. This makes DB4O an ideal testing mechanism – you don’t have to mock out your repository (if you don’t want to) and you’re also working directly with the storage medium so you’ll know if there are any weirdnesses.

One question that comes up is:

How does DB4O know to add a new object, or update an old one?

This is a great question because the answer is so simple that, many times it’s a cold splash of water to shake you out of your Relational Malaise. The answer is “Equals() and GetHashCode()” – DB4O just checks an internal index to see if there is an existing hash for the object you pass in – reset GetHashCode to return the hash of your identifier and you’re all set.

In my case I overrode all of that (like you should anyway in an OO world) and set my Product.Equals()/GetHashCode() to evaluate the SKU.

Finally – for those wondering about transactions – that’s exactly what CommitChanges() does (which calls the DB4O Commit() method). You can Rollback() after Save() if you like – it’s all very intuitive and there’s a lot more info on their website including a 200 page PDF will all kinds of great examples.

Step 7: Making it Pretty

This all seems pretty good – but it would be fun to get past the method noise with all the generic typing – like Linq to SQL and SubSonic do with built-in properties for objects.

Great! Let’s do it:

    public class KonaSession:Db4oSession {
        internal KonaSession(IObjectServer server) : base(server) { }
        public IQueryable<Product> Products {
            get {
                return All<Product>();
            }
        }
        public IQueryable<Order> Orders {
            get {
                return All<Order>();
            }
        }
        public IQueryable<Customer> Customers {
            get {
                return All<Customer>();
            }
        }
    }

To make this work I had to reset the SessionFactory to return KonaSession instead of Db4oSession (2 lines of code – once again focusing on OO means here, not relational weirdness):

    public class SessionFactory {
        static ISession _current;
        //this needs to stay static - can't have more than 
        //one server on the file
        static IObjectServer _server;

        public static ISession CreateSession() {

            if (_server == null) {
                string _dbPath = System.Configuration.ConfigurationManager
                    .ConnectionStrings["ObjectStore"].ConnectionString;

                //check to see if this is pointing to data directory
                //change as you need btw
                if (_dbPath.Contains("|DataDirectory|")) {

                    //we know, then, that this is a web project
                    //and HttpContext is hopefully not null...

                    _dbPath = _dbPath.Replace("|DataDirectory|", "");
                    string appDir = HttpContext.Current.Server.MapPath("~/App_Data/");
                    _dbPath = Path.Combine(appDir, _dbPath);
                }
                _server = Db4oFactory.OpenServer(_dbPath, 0);
            }

            return new KonaSession(_server);
        }

        public static KonaSession Current {
            get {
                if (_current == null)
                    _current = CreateSession();
                return (KonaSession)_current;
            }
        }
    }

Now you can query happily in the way you’ve been used to:

        [Fact]
        public void I_Dont_Want_To_Have_My_Cheese_Moved_Too_Far_Away() {
            using (var db = SessionFactory.Current) {
                var prods = db.Products;
                Assert.Equal(1, prods.Count());
              
            }
        }

Summary

All of a sudden you begin to feel a ton of freedom that’s afforded by staying close to OO principles. In this case I can go further and seal up the DB4O-specific stuff – which will force people to only query through the KonaSession class above. This is nice because, ho ho ho, these are your AggregateRoots and you really only want people to access/work with the child object (such as Category) through the parent objects – just like DDD says you should.

In Part 2 I’ll do a deeper dive on ways to approach reporting.

Traditional architecture makes me flinch

Oren Eini — Sat, 06 Feb 2010 15:00:00 GMT

I just finished drawing the following:

It makes me feel dirty inside, to do so. Mostly because I really don’t like or believe in building applications in this manner anymore. I would really like to be able to do this:

Unfortunately, I am talking about another subject in the context where I am showing the first architectural diagram, and I need to present only a single new concept at a time.

Hanselminutes Podcast 199 - How Craigslist Works - with Jeremy Zawodny

Scott Hanselman — Sat, 06 Feb 2010 06:47:01 GMT

My one-hundred-and-ninety-ninth podcast is up. I chat with Jeremy Zawodny, a developer at Craigslist on how the system is put together. How many servers do they have? How does it all fit together and what are the major technology problems they have

If you are way off in the deep end, there is only so much that tooling can do for you

Oren Eini — Fri, 05 Feb 2010 15:00:00 GMT

I get a lot of requests for what I term, the regex problem. Why the regex problem?

Some people, when confronted with a problem, think "I know, I’ll use regular expressions." Now they have two problems. — Jamie Zawinski in comp.lang.emacs.

A case in point, which comes up repeatedly, is this question:

Can you show us an example for loading collections of collections.
How would you write a query and avoid a Cartesian product multiple levels deep ?

In this case, we have someone who wants to load a blog, all its posts, and all its comments, and do it in the most efficient manner possible. At the same time, they want to have the tool handle that for them.

Let us take a look at how two different OR/Ms handle this task, then discuss what an optimal solution is.

First, Entity Framework, using this code:

db.Blogs
    .Include("Posts")
    .Include("Posts.Comments")
    .Where(x => x.Id == 1)
    .ToList();

This code will generate:

SELECT   [Project2].[Id]             AS [Id],
         [Project2].[Title]          AS [Title],
         [Project2].[Subtitle]       AS [Subtitle],
         [Project2].[AllowsComments] AS [AllowsComments],
         [Project2].[CreatedAt]      AS [CreatedAt],
         [Project2].[C1]             AS [C1],
         [Project2].[C4]             AS [C2],
         [Project2].[Id1]            AS [Id1],
         [Project2].[Title1]         AS [Title1],
         [Project2].[Text]           AS [Text],
         [Project2].[PostedAt]       AS [PostedAt],
         [Project2].[BlogId]         AS [BlogId],
         [Project2].[UserId]         AS [UserId],
         [Project2].[C3]             AS [C3],
         [Project2].[C2]             AS [C4],
         [Project2].[Id2]            AS [Id2],
         [Project2].[Name]           AS [Name],
         [Project2].[Email]          AS [Email],
         [Project2].[HomePage]       AS [HomePage],
         [Project2].[Ip]             AS [Ip],
         [Project2].[Text1]          AS [Text1],
         [Project2].[PostId]         AS [PostId]
FROM     (SELECT [Extent1].[Id]             AS [Id],
                 [Extent1].[Title]          AS [Title],
                 [Extent1].[Subtitle]       AS [Subtitle],
                 [Extent1].[AllowsComments] AS [AllowsComments],
                 [Extent1].[CreatedAt]      AS [CreatedAt],
                 1                          AS [C1],
                 [Project1].[Id]            AS [Id1],
                 [Project1].[Title]         AS [Title1],
                 [Project1].[Text]          AS [Text],
                 [Project1].[PostedAt]      AS [PostedAt],
                 [Project1].[BlogId]        AS [BlogId],
                 [Project1].[UserId]        AS [UserId],
                 [Project1].[Id1]           AS [Id2],
                 [Project1].[Name]          AS [Name],
                 [Project1].[Email]         AS [Email],
                 [Project1].[HomePage]      AS [HomePage],
                 [Project1].[Ip]            AS [Ip],
                 [Project1].[Text1]         AS [Text1],
                 [Project1].[PostId]        AS [PostId],
                 CASE 
                   WHEN ([Project1].[C1] IS NULL) THEN CAST(NULL AS int)
                   ELSE CASE 
                          WHEN ([Project1].[Id1] IS NULL) THEN CAST(NULL AS int)
                          ELSE 1
                        END
                 END AS [C2],
                 CASE 
                   WHEN ([Project1].[C1] IS NULL) THEN CAST(NULL AS int)
                   ELSE CASE 
                          WHEN ([Project1].[Id1] IS NULL) THEN CAST(NULL AS int)
                          ELSE 1
                        END
                 END AS [C3],
                 [Project1].[C1]            AS [C4]
          FROM   [dbo].[Blogs] AS [Extent1]
                 LEFT OUTER JOIN (SELECT [Extent2].[Id]       AS [Id],
                                         [Extent2].[Title]    AS [Title],
                                         [Extent2].[Text]     AS [Text],
                                         [Extent2].[PostedAt] AS [PostedAt],
                                         [Extent2].[BlogId]   AS [BlogId],
                                         [Extent2].[UserId]   AS [UserId],
                                         [Extent3].[Id]       AS [Id1],
                                         [Extent3].[Name]     AS [Name],
                                         [Extent3].[Email]    AS [Email],
                                         [Extent3].[HomePage] AS [HomePage],
                                         [Extent3].[Ip]       AS [Ip],
                                         [Extent3].[Text]     AS [Text1],
                                         [Extent3].[PostId]   AS [PostId],
                                         1                    AS [C1]
                                  FROM   [dbo].[Posts] AS [Extent2]
                                         LEFT OUTER JOIN [dbo].[Comments] AS [Extent3]
                                           ON [Extent2].[Id] = [Extent3].[PostId]) AS [Project1]
                   ON [Extent1].[Id] = [Project1].[BlogId]
          WHERE  1 = [Extent1].[Id]) AS [Project2]
ORDER BY [Project2].[Id] ASC,
         [Project2].[C4] ASC,
         [Project2].[Id1] ASC,
         [Project2].[C3] ASC

If you’ll look closely, you’ll see that it generate a join between Blogs, Posts and Comments, essentially creating a Cartesian product between all three.

What about NHibernate? The following code:

var blogs = s.CreateQuery(
    @"from Blog b 
        left join fetch b.Posts p 
        left join fetch p.Comments 
    where b.Id = :id")
    .SetParameter("id", 1)
    .List<Blog>();

Will generate a much saner statement:

select blog0_.Id             as Id7_0_,
       posts1_.Id            as Id0_1_,
       comments2_.Id         as Id2_2_,
       blog0_.Title          as Title7_0_,
       blog0_.Subtitle       as Subtitle7_0_,
       blog0_.AllowsComments as AllowsCo4_7_0_,
       blog0_.CreatedAt      as CreatedAt7_0_,
       posts1_.Title         as Title0_1_,
       posts1_.Text          as Text0_1_,
       posts1_.PostedAt      as PostedAt0_1_,
       posts1_.BlogId        as BlogId0_1_,
       posts1_.UserId        as UserId0_1_,
       posts1_.BlogId        as BlogId0__,
       posts1_.Id            as Id0__,
       comments2_.Name       as Name2_2_,
       comments2_.Email      as Email2_2_,
       comments2_.HomePage   as HomePage2_2_,
       comments2_.Ip         as Ip2_2_,
       comments2_.Text       as Text2_2_,
       comments2_.PostId     as PostId2_2_,
       comments2_.PostId     as PostId1__,
       comments2_.Id         as Id1__
from   Blogs blog0_
       left outer join Posts posts1_
         on blog0_.Id = posts1_.BlogId
       left outer join Comments comments2_
         on posts1_.Id = comments2_.PostId
where  blog0_.Id = 1 /* @p0 */

While this is a saner statement, it will also generate a Cartesian product. There are no two ways about it, this is bad bad bad bad.

And the way to do that is quite simple, don’t try to do it in a single query, instead, we can break it up into multiple queries, each loading just a part of the graph and rely on the Identity Map implementation to stitch the graph together. You can read the post about it here. Doing this may require more work on your part, but it will end up being much faster, and it is also something that would be much easier to write, maintain and work with.