Wednesday Oct 31, 2007

Google OpenSocial and the perils of abstraction

Google has announced the imminent release of something they call OpenSocial. My understanding from the press coverage, though not necessarily correct, is that Google is trying to abstract away (using a framework) the specifics of developing apps for certain social platforms. It sounds interesting, but we in Sun tools know what a dangerous path this is; abstraction is a religion among software developers for dealing with complexity. Sadly, this religion is founded on a lie.

My opinion for the last couple of years, as a tool provider, has increasingly been that we need to stop thinking like software architects ("abstract everything", "there can be only one") and instead deal with the real, messy, heterogeneous world. We need to dive into the chaos and find other strategies for dealing with it (or to reflexively use my argument above, there is not just one general strategy, abstraction, for dealing with complexity).

There is usually one overriding reason for abstraction in software: productivity. Abstraction gives people a conceptual handle to a larger number of specific things than is otherwise possible to manage in a fixed amount of time. This works well when the level of complexity is low and when specific instances fit well into a single conceptual framework. Unfortunately, most things don't--oh, they look like they do at first, but quickly the edge cases the abstraction cannot deal with become more of the problem than the original productivity problem. This is when a new paradigm shift is born, the old technologies and tools are swept away, and a new wave of technology and tools emerges (usually built around a different, but simpler, abstraction that is easier to grasp, until it too becomes top-heavy).

Abstraction is inherently limited in what it can do precisely because it ignores specifics; this is why abstraction is a useful, but not an ideal, strategy in the real world. I think we are well past the days on the Web when abstraction alone can help us be more productive. Now, it's up to more powerful methods of expression plus domain-tailored tools that will really help us deal with complexity without the religion of abstraction.

However, there is another way to meet the same productivity goal as abstraction, at least in the medium range where there are more than a few and less than a lot of specific instances: raise productivity through other means, like the use of disposable software. Thus, one could argue that you don't need a metaplatform like OpenSocial in order to plug into various platforms if instead plugging into those platforms is essentially as easy as a couple lines of code. Plus, when you have something this productive, you can still take advantage of platform specifics and better tailor the integration and user experience.

About

toddfast

Search

Archives
« July 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
  
       
Today