Home
  Latest posts
  My Writings
  My Code
  My Gallery
  About me
 
  rssfeed Syndication
 
Bloggtoppen.se
 
 
Links
  Cornerstone
  SweNug
 
Post categories
  misc (48)
  Architecture (21)
  C# (19)
  Asp.Net (2)
  Vb.Net (2)
  Training (7)
  Data (19)
  Events (40)
  Platform (2)
  Orcas (4)
  Updates (3)
  Methods (10)
  Tools (6)
  Announcements (14)
  Languages (1)
  Patterns (6)
  Opinions (11)
  Fun (3)
  Ineta (1)
  Opinion (0)
  Practices (2)
  WCF (5)
 
 
 

The search for the holy abstraction level

Thursday, June 07, 2007

Somehow the first post is bugged, I'll just repost it here.

Every now and then Microsoft and other vendors releases a new initiative that will be the abstraction level that will be the "one abstraction level to rule them all".

The latest addition is the Software Factories push where, among others, the PAG team is building slick factories like the WCF Factory and CAB block to automate certain tasks when building applications.

Just around the corner is a new such factory, the Acropolis product. When Ayende saw that, he wrote a blogg post that I think was right on the spot. He criticizes some of the pushes for the "no code approaches" as  being an attempt to run away from code.

I have to agree with him on this. Almost every push to automate stuff is with the promise of "no code" or at least "less code". Once in a while it also bundles with a promise of "including the domain experts in the implementation". Yeah, let's do that. Let's go back to when the accounting staff, that was skilled in Spreadsheets, designed and built advanced enterprise type of applications, that went really well then.

I'm seeing two kinds of problems with this approach they are both related but I will try to explain them separate.

The first problem is usually around people who don't code. Just a week or so ago I was called into a meeting where I was asked to do a quick estimate on the effort to move an application from excel to the web, from a stand alone spreadsheet to a collaboration tool. When I explained what kind of ballpark we where talking about, they where silent for a moment and then someone commented "but I can add most of this logic in excel in a day or two". In a sense she was right, it would be quick to come half-way in excel, but in another she was wrong. Excel is an application with million rows of code that already abstracts away most of the complexity of the task at hand and what they wanted was an application that mimicked some of excels features but without some of the constraints of excel.

Basically the abstraction level Excel offers have hid away the complexity and makes stuff easier, but it also gives a false sense of simplicity. Excel makes complex tasks seem simple, but Excel is still a complex application.

The other problem with having a false sense of simplicity based on a high abstraction level was very well argued for at this years Developer Summit (http://www.cornerstone.se/expertzone/dev07/) by Eric Dörnenburg from Thoughtworks (http://erik.doernenburg.com/). He was talking about "How simple is to simple" and one of the points he brought up has the same flavor as the excel one but targeted at developers.

When DCOM arrived it had the promise to do distributed applications simple as newing up an object. DCOM hid away the communication and the complexity of remote objects and the developer using the object had really no way of knowing if that object was local or not. Very much so in VB6 development a little less so in C++. The idea was to register a proxy that looked like a local object and acted like a local object. Now if both those are true, a lot of developers will assume it works like a local object as well (If it walks like a duck ...).

The problem, Eric pointed out, was that the complex task of distributing objects was hid away by the abstraction level and made people write bad software not taking in account that there was a wire in between them and the real object, which in the end resulted in chatty interfaces and problems with scalability and/or performance.

I am not saying that abstractions are a bad thing, just that they have to be very carefully created and implemented. In the DCOM case, Microsoft came to their senses and created WCF, which also is an abstraction layer. But the abstraction is the communication it self. It's easy to communicate but you are very much aware that you are communicating. Some of the complex stuff is invisible others, where problems could arise, are very visible.

Finding the right abstraction level is a tedious task, it is not simple, and in many cases it is the developer version of "the search for the holy graal", only for us it is "the search for the holy abstraction level".

kick it on DotNetKicks.com
 

Comments
6/11/2007 4:18:00 AM     -   HoyaSaxa93
 
These failed abstractions are the cause of platform changes (see http://www.lhotka.net/WeBlog/SomeSoftwareReallyIsTooDarnHard.aspx). When you build your software on leaky abstractions and your platform changes, like lemmings, you follow the platform vendor into oblivion... always hoping that the platform will solve the leak.
 
6/11/2007 9:17:00 AM   https://lowendahl.net   -   Patrik Löwendahl
 
While I have hughe amount of respect for Rocky, he has done much for the community, his strive to support the bussiness misses the point with both TDD and ORM in that post.

Although he has a valid point, stuff should be more simple. He also fails to understand where TDD and ORM will be the enabler for simplicity that he looks for.

But yes, lemmings is a very good description of the vast majority of developers / teams out there. If MS says jump they not only ask how high they also asks how many times.

I have a post around the "lemming symdrome", maybe it's time to put it into the world ;)


Comment
Title:
Your name:
Your url:
Text:
Please enter the text from the image: