No Name: Just Notes on Software Reuse

No Name: Just Notes on Software Reuse. Robert Biddle, Angela Martin, James Noble.

In the beginning, so our myths and stories tell us, the programmer created the program from the eternal nothingness of the void. In this essay, we recognise that programs these days are like any other assemblage, and suggest that in fact programming has always been about reuse. We also explore the nature of reuse, and claim that Components themselves are not the most important consideration for reuse; it is the end product, the composition. The issues still involve value, investment, and return. But pervasive reuse promotes a change in the method of construction of the program, and in the program itself.

This report isn't new, but seeing as it's awfully quiet around here and it does contain amusing pictures and quotations, I thought I'd share the link.

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

One thing they forgot: infighting

Business division inside a company fightings can prevent code reuse, I've witness it happened two times..
That's logical: projects boss want to have the maximum number of dev under them, so they actively fight against using the reusable components provided by another division inside the company.

Language aspects

...should be the focus here ;-)


at some point, are responsible for writing the language. Respectfully, anything tagged as SE should be allowed to take that into account, and all it entails. We'll stay quiet on the heavy pi-calculus/dependent-types/ADT/System-F stuff, I promise.

(Mind you, I think the conclusion of the paper is a load of dingo's kidneys, but that doesn't mean I think discussion of it is out of bounds.)

mmm... dingo's kidneys...

That's a good point, although I'd think that the human factor only really becomes interesting if the language choice affects it somehow. What language features would discourage infighting, for example? :)

Have the language

Have the language specification specify that only code encrypted with Jose's private key is valid. Infighting problem solved.

Infighting problem

Infighting problem solved.

Wouldn't annexing the code simply escalate the fighting into all out war? :-)


What language features would discourage infighting, for example? :)

Language design themes, such as the approach taken to modular development, have a huge impact in that area.

As a trivial but easy-to-see example, consider a shop-of-many-programmers who are all contributing C code to some program. There is a natural role there for a local czar of naming conventions for exported identifiers. As trivial as naming conventions are, it isn't hard to imagine a set of rules that favors some developers in a group more than others, or some set of interests in a group more than others. So, the language creates a point of political contention: who gets to be humpty dumpty?

A less trivial example: some programmers specialize in emitting stuff marked up in HTML, others (with overlap, of course) specialize in programming graphical designs to render that (e.g., writing CSS). The languages in question here define an abstraction barrier between the two based narrowly on how standard html elements are used and how attributes (particularly "class" and "id" attributes) are used. That abstraction barrier discipline is a peace-maker because its model puns to the HTML programmer as semantic markup and to the graphic artist as presentation markup.

There's probably some rule of sociology that predicts that the total amount of infighting (measured in calories?) is constant, but language design definitely shapes the power relationships for better or worse, and consequently, shapes the nature of what technology actually gets developed.


Technologies as eco-systems

language design definitely shapes the power relationships for better or worse, and consequently, shapes the nature of what technology actually gets developed.

I think the authors hypothesis is a bit more radical: it doesn't really matter which single piece of technology/methodology is actually used. We get a working IT infrastructure with HTML, CSS, JavaScript, Java, XML, C, Perl and PHP. This however is an arbitrary collection that could be substituted by another set of concrete technologies as long as they together respond to certain forces being inherent to the problem domain. So the nature of software development tends towards eco-systems that are open systems but open only towards new settlers and species being complient and "play well with the others". Later these newcomers might become the dominant factors of compliency themselves. Technologies, not only human beings, create social aggregations ( HTML+CSS is a good example for one). The natural history of programming is not driven by an overarching paradigm, neither it is responsive to the psychodrama of modernist ideology ( i.e. the eternal software crisis, the rise and fall of the american programmer or other monumental imaginations ).

Language design may throw new participants into the technology mix or affects on how current participants adapt towards new solutions of old problems but it neither changes the basic rules of the game, nor does it change much on the concrete output i.e. the usability characteristics of the products. The analysis of power structures in social analysis is overrated and leads easily to the identification of the evil other that is the fundamental drive for all kinds of religious wars that seek for the extinction of evil.

An end to tragic melodrama

In "The End" (section 29) we murder the king (software engineering) and resurrect the prince murdered fifty years ago, Cybernetics.

Synthetic and Analytic

The authors seem to be arguing a "systems" or "cybernetic" agenda, which is something I have thought a lot about. However, I see this agenda evolving in a different way. The most important aspect of this agenda is not reuse, but knowledge. The ultimate system of reuse is a knowledge representation system. We simply tell or represent to the system what we want and it constructs what we need. It is a focus on knowledge and not code.

To make this work we have to think of knowledge as both analytic and synthetic for reasons alluded to elsewhere. The knowledge base must not only supply answers but it must produce behavior. If you are able to comprehend an analytic system with state you are on the right track.

What do you think? Is it nonsense? Who can say? No one wants to try it. I cringe at mentioning my web pages again, but nothing is for sale and they only expand on what I have said above. If you are interested send me an email.

Natural science of software

O.K. brothers, you dismiss pain and suffering, you bust the mythology of the software crisis and your mind has lifted up to post millenial thinking. After the civilization wasn't doomed by the Y2K bug, hystery has no credibility anymore. So far I follow you wholeheartedly, just like your against method attitude.

But than you come up with the idea of a natural science of software and I'm in trouble because it sounds like you want to trade the big mythology of software engineering that will cure all our problems at jugdement day, by many little tales, the botany of design pattern, catalogues of things that work and don't. Now the duty is on you, brothers, to present a new-kind-of-science that is more than just enumeration and classification. We want everything but cells and tissues and structural maps that show everything and explain nothing. It's o.k. for fun, after hour and blog conversations but not the real thing. You know what I mean?


A possible answer in the form of a cliche: The more things change the more they stay the same. It is like surfing. As long as you stay on the edge of the wave everything stays the same.
Edit: Actually only kidding about the wave thing, but the cliche is worth thinking about.