Monday May 12, 2008

Applications for the Masses by the Masses: Why Engineers Are An Endangered Species

I did a session last week at JavaOne 2008 where I talked about how application development, and the role of application developers, is changing. Here's the abstract:


When we engineers normally think of applications, we think of elaborate technology that takes highly trained developers weeks, months, or years to develop and debug. But our days are possibly numbered. In this era of light-speed boom and bust, the demand for technology is higher than ever and engineers and their traditional development techniques simply can’t keep up. What’s needed is “disposable applications,” applications so quick and easy to write that they are cheaper to throw away than to maintain and which the increasing numbers of casual technologists can consume and even create themselves.

Fueling this demand in recent months has been the release of high-profile web platforms (such as Facebook, Ning, Meebo, and others) that increasingly enable nontechnical users to compose mashups and other social and situational applications out of widgets and RESTful-style web services, all built by use of lightweight technologies and composed right from the browser.

This session describes how these factors are coming together to produce a new paradigm of application development in which hordes of 16-year-olds are in charge and software engineers are overwhelmed by the flood of applications created by tech-savvy novices. It also examines the roles of high technology versus technology for the masses and shows that they are actually complementary and a boon to engineers and nonengineers alike.

...

I presented to about 500 people over two sessions on Wednesday and Friday, and despite the fact that I could not show a demo, it was a rapt audience. Since then, coverage has been popping up around the Web.

Here are slides and links to articles and other material:

Articles

Blogs

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