DevMavens Feed

The Law of Conservation of Tradeoffs

Oren Eini — Fri, 03 Sep 2010 13:00:00 GMT

Every so often I see a group of people or a company come up with a new Thing. That new Thing is supposed to solve a set of problems. The common set of problems that people keep trying to solve are:

Data access with relational databases
Building applications without needing developers

And every single time that I see this, I know that there is going to be a catch involved. For the most part, I can usually even tell you what the catches involved going to be.

It isn’t because I am smart, and it is certain that I am not omnificent. It is an issue of knowing the problem set that is being set out to solve.

If we will take data access as a good example, there aren’t that many ways tat you can approach it, when all is said and done. There is a set of competing tradeoffs that you have to make. Simplicity vs. usability would probably be the best way to describe it. For example, you can create a very simple data access layer, but you’ll give up on doing automatic change tracking. If you want change tracking, then you need to have Identity Map (even data sets had that, in the sense that every row represented a single row :-) )

When I need to evaluate a new data access tool, I don’t really need to go too deeply into how it does things, all I need to do is to look at the set of tradeoffs that this tool made. Because you have to make those tradeoffs, and because I know the play field, it is very easy for me to tell what is actually going on.

It is pretty much the same thing when we start talking about the options for building applications without developers (a dream that the industry had chased for the last 30 – 40 years or so, unsuccessfully). The problem isn’t in lack of trying, the amount of resources that were invested in the matter are staggering. But again you come into the realm of tradeoffs.

The best that a system for non developers can give you is CRUD. Which is important, certainly, but for developers, CRUD is mostly a solved problem. If we want plain CRUD screens, we can utilize a whole host of tools and approaches to do them, but beyond the simplest departmental apps, the parts of the application that really matter aren’t really CRUD. For one application, the major point was being able to assign people to their proper slot, a task with significant algorithmic complexity. In another, it was fine tuning the user experience so they would have a seamless journey into the annals of the organization decision making processes.

And here we get to the same tradeoffs that you have to makes. Developer friendly CRUD system exists in abundance, ASP.Net MVC support for Editor.For(model) is one such example. And they are developer friendly because they give you he bare bones of functionality you need, allow you to define broad swaths. of the application in general terms, but allow you to fine tune the system easily where you need it. They are also totally incomprehensible if you aren’t a developer.

A system that is aimed at paradevelopers focus a lot more of visual tooling to aid the paradeveloper achieve their goal. The problem is that in order to do that, we give up the ability to do things in broad strokes, and have to pretty much do anything from scratch for everything that we do. That is acceptable for a paradeveloper, without the concepts of reuse and DRY, but those same features that make it so good for a paradeveloper would be a thorn in a developer’s side. Because they would mean having to do the same thing over & over & over again.

Tradeoffs, remember?

And you can’t really create a system that satisfy both. Oh, you can try, but you are going to fail. And you are going to fail because the requirement set of a developer and the requirement set of a paradeveloper are so different as to be totally opposed to one another. For example, one of the things that developers absolutely require is good version control support. And by good version control support i mean that you can diff between two versions of the application and get a meaningful result from the diff.

A system for paradeveloper, however, is going to be so choke full of metadata describing what is going on that even if the metadata is in a format that is possible to diff (and all too often it is located in some database, in a format that make it utterly impossible to work with using source control tools).

Paradeveloper systems encourage you to write what amounts to Bottun1_Click handlers, if they give you even that. Because the paradevelopers that they are meant for have no notion about things like architecture. The problem with that approach when developers do that is that it is obviously one that is unmaintainable.

And so on, and so on.

Whenever I see a new system cropping up in a field that I am familiar with, I evaluate it based on the tradeoffs that it must have made. And that is why I tend to be suspicious of the claims made about the new tool around the block, whatever that tool is at any given week.

How far can you push commercialization?

Oren Eini — Thu, 02 Sep 2010 13:00:00 GMT

I was recently at a private company event (not my company, I was invited, along with others, because we have a close association to that company). The event itself wasn’t notable, but there was one thing that really bothered me, before the event actually started, there was the usual phase when everyone is munching on the snacks and mingling. The food was some sort of green cupcakes with inspirational messages on them: “think positive”, “fitting the world to you”, etc.

All in all, I found that somewhat strange, but I didn’t really care, but I was talking with a few friends when a woman walked up to us and started handing out coupons for some free demo courses using a whole new technique, etc. I was quite taken aback. I am used to stuff like that on conferences floors, where you have booth babes doing stuff like that, but that was a private meeting of less than fifty people, and I couldn’t understand what was going on.

It helped that the woman kept dropping the same phrases that appeared on the cupcakes. That was later confirmed at the beginning of the meeting, where the presenter stood up and started by thanking the sponsors for bringing the food, etc.

Looking back at this, I am both appalled, amazed and utterly unsurprised (you can be both at the same time, it seems). That company actually sold sponsorship for an internal, private, meeting. I don’t really know what was the point, if they were trying to save money on the food or they were actually making money out of this, but that behavior really bother me.

I am absolutely for commercialization, if only because the bank would otherwise object, but I was utterly stunned by how crass it was.

What is next? Hiring employees for the express purpose of watching commercials while the company is getting paid for that?

More to the point, there is some expectation about how such functions are going to be, and stunts like that are leaving very bad impression.

NHibernate Quick-start Workshop - November 1th

Oren Eini — Wed, 01 Sep 2010 13:16:00 GMT

Tikal is delighted to invite you to join our .NET open source workshop on November 1^th , lead by Oren Eini (Ayende Rahien) and other Tikal .NET experts.

Tikal offers a set of software development tools and methodologies that enable .NET developers to integrate open source software modules into their native .Net environment.

We invite you to join our .NET open source workshop, which will equip you all the knowledge required for using open source tools to develop excellent .NET applications quickly and effectively.

The workshop will include diverse topics such as:

NHibernate hands on training, covering assimilation of the ORM framework to your product.
S#harp Architecture introduction.
Assessment of your application development needs and where open source tools can fit in.

Don’t TOUCH that debugger, you moron, READ the exception stack

Oren Eini — Wed, 01 Sep 2010 13:00:00 GMT

There is a tendency to reach the debugger for every error that you run, but in most cases, it is the exception (and the exception stack) that provides enough to solve the problem in 99% of the cases.

Case in point, I made some changes to Uber Prof and run the tests. For various reasons, I had to reinstall SQLExpress, and all the Java related tests failed, throwing up copious amount of error text in my lap. I cringe when they do that, because it means having to setup the Java environment and having to check how to do things like real debugging in Java (something I have very little knowledge of).

I did just that, spending over an hour getting things to a position where I could run everything properly. Then I run a scenario and got an error, then I looked at the exception stack:

Moron, did I mention already?

Applying Interface Segregation to Configuration Files

Steve Smith — Wed, 01 Sep 2010 04:22:00 GMT

In .NET, it’s very easy to set up custom configuration section handlers to handle your application or component’s configuration needs. As my previous post shows, it’s also very easy to configure these with attributes that enforce required fields and other validation. However, over time it’s very easy to create fairly large configuration sections that violate the Interface Segregation Principle, which states that classes shouldn’t be forced to depend on things they don’t need.

Consider this relatively simple configuration section:

<configSections>
  <section name="ConfigurationSettings" 
type="InterfaceSegregation.Configuration1.ConfigurationSettings, InterfaceSegregation"/>
</configSections>
<ConfigurationSettings 
  ApplicationName="Interface Segregation"
  AuthorName="Steve Smith"
  CacheDuration="60"
  DatabaseServerName="localhost"
  DatabaseName="Northwind"
  DatabaseUserName="ssmith"
  DatabasePassword="secret"
  WebServiceBaseUri="http://localhost/"
  />

I’ve intentionally made it a bit more verbose than needed (obviously the database settings could be combined into a connection string, etc), but the intent is to show that my relatively generic Settings section has completely lost its cohesion. Let’s look at an interface that we’ve created to support these settings (because we don’t want to have an Insidious Dependency On Our Configuration File in our code):

public interface IConfigurationSettings : IApplicationIdentitySettings
{
    // application identity settings
    string ApplicationName { get; }
    string AuthorName { get; }
    
    // performance tuning settings
    int CacheDuration { get; }
    
    // data access settings
    string DatabaseServerName { get; }
    string DatabaseName { get; }
    string DatabaseUserName { get; }
    string DatabasePassword { get; }
        
    // web service api settings
    string WebServiceBaseUri { get; }
}

From the comments I’ve included in this interface, it’s clear that there are four different kinds of settings grouped together by this interface. With only 8 properties, it has already become an example of a “fat” interface. Now let’s look at one of the clients of this interface, a simple AboutPage file (that isn’t an ASP.NET page, but could be):

public class AboutPage
{
    private readonly IConfigurationSettings _configurationSettings;

    public AboutPage(IConfigurationSettings configurationSettings)
    {
        _configurationSettings = configurationSettings;
    }
        
    public AboutPage() : this(ConfigurationSettings.Settings)
    {}

    public void Render(TextWriter writer)
    {
        writer.Write("{0} By {1}", 
            _configurationSettings.ApplicationName, 
            _configurationSettings.AuthorName);
    }
}

This class takes advantage of Dependency Injection to eliminate a direct dependency on the ConfigurationSettings class/file, through the use of the IConfigurationSettings interface. However, it’s still depending on a much larger interface than it needs, and thus is violating ISP. Fortunately, there’s a very easy fix for this that will let us ensure this class only depends on what it needs, without breaking anything else in our application. The refactoring involves creating a new interface for AboutPage to depend upon, that is more cohesive and only includes things AboutPage (and perhaps other classes that require the same things) requires. First, we need to identify these settings and come up with a name for the new interface:

public interface IApplicationIdentitySettings
{
    string ApplicationName { get; }
    string AuthorName { get; }
}

Next, we need to modify the IConfigurationSettings interface so that it no longer has these settings, but inherits them from the newly created IApplicationIdentitySettings interface:

public interface IConfigurationSettings : IApplicationIdentitySettings
{
    // performance tuning settings
    int CacheDuration { get; }
    
    // data access settings
    string DatabaseServerName { get; }
    string DatabaseName { get; }
    string DatabaseUserName { get; }
    string DatabasePassword { get; }
        
    // web service api settings
    string WebServiceBaseUri { get; }
}

Finally, the AboutPage class can be modified to use the new, more focused interface. In its default constructor, though, it can still use the ConfigurationSettings.Settings class, as this implements IConfigurationSettings, which now automatically implements IApplicationIdentitySettings:

public class AboutPage
{
    private readonly IApplicationIdentitySettings _applicationIdentitySettings;

    public AboutPage(IApplicationIdentitySettings applicationIdentitySettings)
    {
        _applicationIdentitySettings = applicationIdentitySettings;
    }
        
    public AboutPage()
        : this(ConfigurationSettings.Settings)
    { }

    public void Render(TextWriter writer)
    {
        writer.Write("{0} By {1}",
            _applicationIdentitySettings.ApplicationName,
            _applicationIdentitySettings.AuthorName);
    }
}

Summary

The Interface Segregation Principle states that classes should not be forced to depend on things they do not use. By refactoring “fat” interfaces into smaller, more focused and cohesive interfaces defined by the clients that use them, we can reduce the coupling in our code. This results in code that is easier to change, maintain, and test, not to mention being much more fun to work with. Be breaking up the fat interface but using interface inheritance to ensure the original interface remains unchanged, this refactoring can be done to existing codebases without requiring extensive changes that spider through every class that touches the original interface.

It is an issue of traffic

Oren Eini — Wed, 01 Sep 2010 03:41:00 GMT

I just had to respond to this post, Davy Brion talks about the Ruby community, and he had the following to say:

When i asked them about interesting resources to follow as a newbie Rubyist, they all gladly shared their suggestions. When i thanked them for it, they all replied stating that i should feel free to contact them if i had any more questions about whatever Ruby related. Seriously, can you imagine the few .NET heroes that we have responding to questions through email from people they don’t even know like that? I can’t. Hell, i know most of them don’t respond like that. The few that do are still trying to earn their MVP award or are too worried about renewing their MVP status.

Ignoring the MVP dig, allow me to explain exactly what is going on.

In the last 48 hours:

Those are all cold requests, from people I have never met, and all to my private email. Note that in most cases, there is a dedicated mailing list for the topic in question.

For that matter, the last two days has been decidedly quiet in the NHibernate front, this represent a more realistic sample of what is going on:

And those are in addition to the business, private, mailing list and other stuff that I do in email.

Putting it simply, there is too much traffic for me to welcome most cold questions with anything more than a direction to the appropriate mailing list. This isn’t about being rude, or uncaring, this is about actually being able to do any work at all.

Read more: It is an issue of traffic | Subscribe

It really happened, legacy programmers tales

Oren Eini — Tue, 31 Aug 2010 13:00:00 GMT

Fairy tales always start with “Once upon a time”, and programmers tales starts with “when I was at a client”…

Two days ago I was a client, and the discussion turned to bad code bases, as it often does. One story that I had hard time understanding was the Super If.

Basically, it looked like this:

I had a hard time accepting that someone could write an if condition that long. I kept assuming that they meant that the if statements were 50 lines long, but that wasn’t the case.

And then yesterday I had an even more horrifying story. A WCF service making a call to the database always timed out on the first request, but worked afterward. What would be your first suspicion? Mine was that it took time to establish the database connection, and that after the first call the connection resided in the connection pool.

They laughed at my naivety, for it wasn’t connecting to the database that caused the timeout, it was JITting the method that the WCF service ended up calling.

Yep, you got that right, JITting a single method (because the runtime only JIT a single method at a time). I had even harder time believing that, until they explained to me how that method was built:

Some interesting stats:

It had a Cyclomatic Complexity of either 4,000 or 8,000, the client couldn’t remember.
The entire Rhino Mocks codebase fits in 13,000 LOC, so this single method could contain it several times over.

But you know what the really scary part is?

I upgraded from Super If to Black Hole Methods, and I am afraid to see what happen today, because if I get something that top the Black Hole Method, I may have to hand back my keyboard and go raise olives.

Entity != Table

Oren Eini — Mon, 30 Aug 2010 13:00:00 GMT

I recently had a chance to work on an interesting project, doing a POC of moving from a relational model to RavenDB. And one of the most interesting hurdles along the way wasn’t technical at all, it was trying to decide what an entity is. We are so used to make the assumption that Entity == Table that we started to associate the two together. With a document database, an entity is a document, and that map much more closely to a root aggregate than to a RDMBS entity.

That gets very interesting when we start looking at tables and having to decide if they represent data that is stand alone (and therefore deserve to live is separate documents) or whatever they should be embedded in the parent document. That led to a very interesting discussion on each table. What I found remarkable is that it was partly a discussion that seem to come directly from the DDD book, about root aggregates, responsibilities and the abstract definition of an entity and partly a discussion that focused on meeting the different modeling requirement for a document database.

I think that we did a good job, but I most valued the discussion and the insight. What was most interesting to me was how right was RavenDB for the problem set, because a whole range of issues just went away when we started to move the model over.

August 29th Links: .NET, ASP.NET, IIS Express, Silverlight, Windows Phone 7

Scott Guthrie — Mon, 30 Aug 2010 10:23:36 GMT

Here is the latest in my link-listing series. Also check out my VS 2010 and .NET 4 series and ASP.NET MVC 2 series for other on-going blog series I’m working on.

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

.NET/WPF/EF

5 Little C#/.NET Wonders that Make Code Better: Nice blog post from James that highlights 5 nice language/framework tips you can take advantage of within your apps. I’m betting a lot of people didn’t know about the StopWatch class.

WPF Ribbon Control Released: The WPF team recently released the final V1 release of the WPF Ribbon control. This makes it easy to build ribbon-based applications. Also read this WPF team blog post for lots of great details on what it enables.

EF4 .Include() Method w/ Lambda Support: Ever wanted to use a Lambda expression instead of a string parameter when eagerly loading associations in EF4 using the Include() method? This blog post shows you how you can.

ASP.NET

Performance Tuning tricks for ASP.NET and IIS7 Part 1 and Part 2: Mads has a nice set of posts that detail some great performance optimization tips you can use with ASP.NET and IIS7.

Better ViewState Management in ASP.NET 4 with the ViewStateMode Property: Scott Mitchell has a good article that discusses the new ViewStateMode property supported on ASP.NET 4 controls. This provides much more control over how viewstate is used within a page.

Filtering Data using ASP.NET 4’s QueryExtender Control: Scott Mitchell has a nice article that talks about the new <asp:QueryExtender> control in ASP.NET 4 that makes enabling dynamic querying against a LinqDataSource or EntityDataSource really easy.

Techniques to Avoid Duplicate URLs: Scott Mitchell has another great article that discusses techniques you can use within ASP.NET to avoid exposing duplicate URLs to the same content within your web-sites. These can help improve your search engine traffic.

Automatically pre-populate fields for Insert in ASP.NET 4: Scott Hunter has a nice blog post that discusses how to specify default values for insert with data controls in ASP.NET 4.

ASP.NET MVC

MvcContrib Template Gallery: Download 58 pre-built ASP.NET MVC Template Gallery styles that you can use to customize the look and feel of your applications. All available under a Community Commons license.

Step into the ASP.NET MVC Source Code with the VS Debugger: Nice blog post by Gunnar that describes how to use VS 2010’s built-in symbol server support to enable you to step into the ASP.NET MVC Framework source code when debugging.

Installation Options for ASP.NET MVC: Jon has a good post that describes how to install ASP.NET MVC 2 on a server. There are a couple of options you can use for servers that don’t already have ASP.NET MVC installed – the easiest is to just enable the “Copy Local” flag on System.Web.Mvc.dll and install it in the \bin directory.

IIS Developer Express

Visual Studio Support for IIS Express, SQL 4 Compact Edition, and Razor syntax: Channel 9 video with Damian Edwards and Scott Hanselman that discusses the support coming to enable IIS Express, SQL 4 CE, and Razor syntax support within Visual Studio 2010.

How to Use IIS Express with VS today: Kamran has a nice blog post that describes how you can use IIS Express with Visual Studio today – without having to wait for the official Visual Studio patch to enable it.

Silverlight and Windows Phone 7

Developers Roadmap for Windows Phone 7: The Windows Phone 7 team blogs about the release timeframe for Windows Phone 7 and the Visual Studio and Expression Blend tools for targeting it. The official developer release will be on September 16th.

Windows Phone 7 in 7 Minutes: Really nice set of 7 minute videos that enable you to quickly understand and learn Windows Phone 7 and the development fundamentals behind it.

Windows Phone 7 Jumpstart Training: Nice list of free training sessions you can watch online to learn how to build Windows Phone 7 applications using Silverlight and XNA.

Silverlight Panorama and Pivot Controls for Windows Phone 7: Jeff has a great post that discusses the awesome new Panorama and Pivot controls for Silverlight that will be part of the final Windows Phone 7 developer release.

Using XNA from Silverlight on Windows Phone 7: Good blog post from Mike that demonstrates how to use XNA APIs from Silverlight applications on Windows Phone 7. This post demonstrates how to use the XNA audio framework from Silverlight.

Creating High Performance Silverlight Applications for Windows Phone 7: This is a great whitepaper written by my team that discusses best practices for building Silverlight applications that run well on Windows Phone 7.

Performance of Silverlight on Windows Phone 7: A nice podcast with Scott Hanselman that discusses tips and techniques to enable smooth applications and great experiences on Windows Phone 7.

Book Recommendation

People often ask me for .NET book recommendations. Below is one book I always keep close by and find super-useful. If you are looking for a good one-volume C# and .NET Base Class Library reference, C# 4.0 in a Nutshell a great one:

Hope this helps,

Scott

Patch for VS 2010 Find and Replace Dialog Growing

Scott Guthrie — Mon, 30 Aug 2010 08:57:22 GMT

One of the top reported Microsoft Connect issues with VS 2010 has been an issue with the Find and Replace dialog – which grows 16px each time you use it (which is pretty annoying).

The Visual Studio team recently released a patch that fixes this issue. You can download and apply it here.

Hope this helps,

Scott

P.S. A few people reported issues installing the patch if they had an older version of the Silverlight 4 tools installed. If you see an error message that says you need an update to Visual Studio to support Silverlight 4, you can fix it by installing the latest Silverlight 4 tools release.