This is one of the first papers I have seen that addresses the deep interactions of coupling and cohesion, and their effects on software design. The paper rightly identifies that dealing with structural software complexity can contribute greatly to the design and development of better software systems. The authors use Wood’s task complexity model as a framework for studying coupling and cohesion, and their interrelationships as related to software maintenance. The paper is cogent and well written, the experiment is well controlled, and the results are appropriate in bringing forth the interrelatedness of coupling and cohesion in influencing the structural complexity of software.

The authors rightly point out several limitations to their experiment design, particularly the problems used and the sample sizes. I am not, however, entirely convinced that the programmers studied were very experienced, as claimed. A small sample size coupled with a large standard deviation is the first indication that calls attention to the limited nature of this study. Looking at the number of months in a programming career (in Table 2), most of the participants seem to have been programmers for only a few years, with at least one having only six months of experience, and the most experienced having only eight years of experience. The first data point, language experience, actually indicates that many had less than a year’s experience in the languages used, with one having less than a week’s experience. Also notable is the number of languages the participants seemed to know; many apparently have experience in only three languages or less, with the most number of languages being five. This indicates a certain rawness in the participants’ capabilities. Together, these data items do not agree with the authors’ claim that the programmers studied were all highly experienced software engineers. Their claim may be true for academic projects, but definitely not for industrial projects, where many of these participants might be entry-level or junior programmers, with little or no influence on either the design or the engineering of the system.

Many graduating students hold part-time programming jobs, and would answer that they know four or five languages, and could claim several months of programming experience. However, this doesn’t necessarily indicate that they are either experienced or accomplished software engineers. It would have been a more interesting experiment if the programmers’ experience in the specific languages used (C and C++) were factored into the experiment and subsequent analysis. Another issue arises from the nature of the languages that were used in the study. Together with the number of languages (three or less) that many of the participants seem to know, this further dilutes the validity of the experiments for any generalization of the results, because the similarities in these languages means that even those programmers who knew only C++ might have a good understanding of C, and hence the “number of languages” known may not be a very clear indicator of their expertise in multiple languages. It would have been better if two unrelated languages (for example, a high-level and a scripting language) were used in the experiment design.

Despite all of my observations above on the nature of the experiments, the paper is nevertheless very interesting, sufficiently and intuitively credible, and can be an excellent starting point for several other research works.