What is a killer application?

Anatomy of a Killer Application

It is interesting to compare the adoption cycle of various IT technologies. One challenging goal consists in predicting how these technologies may evolve. One interesting observation is the industrial take-off of a technology, i.e., the moment when it leaves the research labs and prototype to enter production and become main street.  This is quite hard since it is not only a technical problem, but a complex process where many human, societal or political factors usually interfere with the core technical issues. Comparing advantages or drawback of technical solutions is usually quite hard.

Computer science is still very young. However we have now more than half a century of technology evolution from which we can learn. Hopefully this could be useful to anticipate some forthcoming technology changes. Of course the common wisdom says that the only thing we learnt from history is that we did not learn anything from history. Or as Alan Kay puts it, the best way to predict the future is to invent it.

How can we explain that? The ideas had been maturing since 1965 with Simula and started to be made popular with Smalltalk in the early 80’s.  But the real event that started all this process was the publication of a paper documenting a real object-oriented killer application. The paper is now quite hard to find, so here is my archived copy:

TomLove‘s paper

The publication of this paper was one of the major events that triggered the move of OT from the labs to industry.  To me this is the perfect example of a technology use case becoming a killer app.

Many comments may be made on this work:

  • This is, to the best of my knowledge,  the first report on an external use of Smalltalk outside Xerox. There was also an important application called “The Analyst”, but it was made public by another division of Xerox.
  • The paper is typical of an industry track paper, without any bibliographical references.
  • The author just mention the bare facts, like the number of lines, the time used to develop it, etc.
  • The author compares the cost of developing the application with object technology compared with the time needed to develop it with procedural technology.
  • The bare facts are exposed letting the reader draw the conclusion from this clear and reproducible experiment..
  • The paper was rapidly published in a small conference, not polished and “beautified” and submitted to a prestigious academic ICSE-like conference.

In [1] the author reports the following facts:

In 1983 at Schlumberger, I used Smalltalk-80 to build a tiny prototype of an analyst workstation for viewing a diverse collection of data from oil wells. A working demonstration was built with only 220 lines of new code and lots of reused classes provided by Xerox. It provided an interactive interface to data residing on a VAX computer. This interface furnished iconic menus for accessing maps, measurement data, analysis reports, and photographs. It also did simple plotting of measurement data.I showed my work to any number of software professionals in the company and asked them to estimate how much effort it would have required to develop comparable facilities in FORTRAN, the most commonly used language at Schlumberger at that time. The smallest  estimate I ever received was 10,000 lines of code. While certainly not a commercial product, it was a commercial problem, and the leverage provided by objects seemed most impressive.This project was also interesting because of some important observations about the use of objects. One day, a company Vice President was in my office looking at the small amount of work I had done. He said, “do you mean I paid you a year’s salary to produce 220 lines of code?” At first, I felt terrible. Then I began to realize how inappropriate it is for us to feel obligated to produce bulk in return for our compensation.How I had actually spent that year was learning Smalltalk-80 as the first commercial user of that system. Much of the year was spent reading source code I though I could reuse in the prototype application I was building. Documentation for Smalltalk did not become available until next year!
[1] Love, Tom.   Lessons Learned in Object-Oriented Development Projects, in Object Lessons, Projects Series: SIGS: Advances in Object Technology (No. 1), ISBN: 9780134724324, (February 1998), 292 pages
This entry was posted in Models, Object. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s