15 years ago, the research journal Human-Computer Interaction published their special issue on Object-Oriented Programming. Having realized that a lot of the claims made about OOP at the time were not technical in nature, but rather were psychological and cognitive, the special issue attempted to present empirical and experimental research examining the claims about OOPs advantages on procedural programming. Or as the editor Bill Curtis notes:
Object-oriented (OO) design and programming trace their lineage to research on abstract data types in the late 1960s and early 1970s, but they did not become popular software development techniques until the late 1980s. In all this time there has been little serious empirical or experimental study of OO techniques. What usually passes for evaluation is either a testimonial from an industry pundit who may have developed a small application using an OO technique [..]
Even worse, this special issue of Human-Computer Interaction will be read by very few of the thousands of the people who read Computerworld, Information Week, Datamation, Software Development, and the other trade press periodicals in which OO methods are touted as often as explained. The results reported in this special issue are promising, but simultaneously they provide sobering expectations about the effort involved in obtaining the benefits of OO methods.
And little have changed since then – if anything the influence of Computerworld pundits and today’s bloggers are even larger than that of empirical and experimental research.
Just 15 years later, though, few of the journal issue’s articles have stood the test of time. Still, there are some anecdotes and pieces of information that are still interesting, if nothing else as a reminder of what people were thinking about OOP before it became mainstream, standard fare.
One quote from Curtis is still interesting for programmers changing from procedural to OO-style programming – as I guess most programmers actually still do while learning the ropes:
[..] professionals may require experience on as many as three 00 projects before they become proficient in these methods. The reputed advantages ultimately occur, but not during the early projects in which programmers are on the learning curve and have difficulty capitalizing on the capabilities offered by 00 methods.
Also, Herbsleb reports a few interesting facts from general cognitive psychology on how people generally understand objects, as part of a larger article on software engineering teams:
In careful experiments, Gentner (1981; Gentner & France, 1988) showed that, when people are asked to repair a simple sentence with an anomalous subject-verb combination, they almost always change the verb and leave the noun as it is, independent of their relative positions. This suggests that people take the noun (i.e. the object) as the basic reference point. Models based on objects may be superior to models based on other primitives, such as behaviours.
And object hierarchies..
Miller (1991) described how nouns and verbs differ in their cognitive organizational form. Nouns – and hence the concepts associated with them – tend to be organized into hierarchically structured taxonomies, with class inclusion and part-whole relations as the most common linkages. These are also, of course, the most common relations in OO representations. In human cognition, these hierarchies tend to be fairly deep for nouns – often six to seven layers. These hierarchies support a variety of important cognitive behaviours, including the inheritance of properties from superordinate classes. In contrast, verbs tend to be organized in very flat and bushy structures. This again suggest a central place for objects, in that building inheritance hierarchies will mirror the way humans represent natural categories only if the basic builiding blocks are objects rather than processes or behaviours.
And with the risk of going past what is acceptable amounts of quoting (but this is all closed research, so I have to quote it for you to read it):
[..] human understanding of hierarchies tends to be organized around basic-level classes (i.e., intermediate levels of abstraction that form an anchor point for human classification and reasoning). As described by Rosch (1978; Rosch, Mervis, Gray, Johnson, & Boyes-Braem, 1975), basic-level categories have large numbers of differentiating attributes, whereas, at leves both lower and higher, the differentiating attributes are very modest in number. [..] The tendency in generating class hierarchies for inheritance is to push attributes and behaviours as high as possible. But, to the extent that this is successful, it will lead to hierarchies radically different from those that both users and developers have naturally.
The psychology papers by Gentner and Rosch seems to be very well worth a read for anyone interested in how the brain does categorization “in the wild”. They are also freely accessible!
It might be forgotten, but originally a large argument in favour of OOP was improved knowledge sharing and better communication about program code between developers and with external forces. Now, you will more often hear arguments about code reuse, if OOP is ever even questioned. Better communication and knowledge sharing appears to be the main focus of the papers in special issue, but where they also mostly fail to find hard empirical evidence.
As I’ve mentioned before, code understanding and knowledge sharing should be a field of far more interest for developers. That it is hard to find solid empirical evidence to base advice on in that regard is a big, under-appreciated problem! All the examples from general cognitive psychology appears to provide direction for OO design, but without actual programming-specific experiments it is impossible to tell if that is the case.
And that was a blast from the past…