Home > Articles > Programming

  • Print
  • + Share This
  • 💬 Discuss


Fact 21

For every 25 percent increase in problem complexity, there is a 100 percent increase in complexity of the software solution. That's not a condition to try to change (even though reducing complexity is always a desirable thing to do); that's just the way it is.


This is one of my favorite facts. It is a favorite because it is so little known, so compellingly important, and so clear in its explanation. We've already learned that software is very difficult to produce and maintain. This fact explains why that is so.

It explains a lot of the other facts in this book, as well.

  • Why are people so important? (Because it takes considerable intelligence and skill to overcome complexity.)

  • Why is estimation so difficult? (Because our solutions are so much more complicated than our problems appear to be.)

  • Why is reuse-in-the-large unsuccessful? (Because complexity magnifies diversity.)

  • Why is there a requirements explosion (as we move from requirements to design, explicit requirements explode into the hugely more numerous implicit requirements necessary to produce a workable design)? (Because we are moving from the 25 percent part of the world to the 100 percent part.)

  • Why are there so many different correct approaches to designing the solution to a problem? (Because the solution space is so complex.)

  • Why do the best designers use iterative, heuristic approaches? (Because there are seldom any simple and obvious design solutions.)

  • Why is design seldom optimized? (Because optimization is nearly impossible in the face of significant complexity.)

  • Why is 100 percent test coverage rarely possible and, in any case, insufficient? (Because of the enormous number of paths in most programs and because software complexity leads to errors that coverage cannot trap.)

  • Why are inspections the most effective and efficient error removal approach? (Because it takes a human to filter through all that complexity to spot errors.)

  • Why is software maintenance such a time consumer? (Because it is seldom possible to determine at the outset all the ramifications of a problem solution.)

  • Why is "understanding the existing product" the most dominant and difficult task of software maintenance? (Because there are so many possible correct solution approaches to solving any one problem.)

  • Why does software have so many errors? (Because it is so difficult to get it right the first time.)

  • Why do software researchers resort to advocacy? (Perhaps because, in the world of complex software, it is too difficult to perform the desperately needed evaluative research that ought to precede advocacy.)

Wow! It wasn't until I began constructing this list that I really realized how important this one fact is. If you remember nothing else from reading this book, remember this: For every 25 percent increase in problem complexity, there is a 100 percent increase in the complexity of the software solution And remember, also, that there are no silver bullets for overcoming this problem. Software solutions are complex because that's the nature of this particular beast.


This particular fact is little known. If there were greater awareness, I suppose there would be controversy as to its truth, with some (especially those who believe that software solutions are easy) claiming that whatever solution complexity exists is caused by inept programmers, not inherent complexity.


Woodfield, Scott N. 1979. "An Experiment on Unit Increase in Problem Complexity." IEEE Transactions on Software Engineering, (Mar.) Finding this source caused me more work than any other in this book. I looked through my old lecture notes and books (I was sure I had quoted this somewhere else), used search engines, and e-mailed so many colleagues I think I must have begun to annoy some of them (none had heard of this quote, but all of them said they wished they had). In the final analysis, it was Dennis Taylor of IEEE who found the correct citation and Vic Basili of the University of Maryland who got a copy of the paper for me. Thanks!

Fact 22

Eighty percent of software work is intellectual. A fair amount of it is creative. Little of it is clerical.


Through the years, a controversy has raged about whether software work is trivial and can be automated, or whether it is in fact the most complex task ever undertaken by humanity.

In the trivial/automated camp are noted authors of books like Programming without Programmers and CASE—The Automation of Software and researchers who have attempted or claimed to have achieved the automation of the generation of code from specifications. In the "most complex" camp are noted software engineers like Fred Brooks and David Parnas. In spite of the extremely wide diversity of these opinions, there have been few attempts to shed objective light on this vitally important matter. It was almost as if everyone had long ago chosen up sides and felt no need to study the validity of his or her beliefs. This fact, however, is about a study that did just that. (It is also, by the way, a wonderful illustration of another raging controversy in the field: Which is more important in computing research, rigor or relevance? I will return to that secondary controversy when I finish dealing with the first.)

How would you go about determining whether computing work was trivial/ automatable or exceedingly complex? The answer to that question, for this piece of research at least, is to study programmers at work. Systems analysts were videotaped performing systems analysis (requirements definition) tasks. They were seated at a desk, analyzing the description of a problem that they were to solve later. I was the researcher who led this project, and examining those videotapes was a fascinating (and yet boring) experience. For vast quantities of time, the subject systems analysts did absolutely nothing (that was the boring part). Then, periodically, they would jot something down (this was also boring, but a light that made this whole thing fascinating was beginning to dawn).

After I had observed this pattern for some period of time, it became obvious that when the subjects were sitting and doing nothing, they were thinking; and when they were jotting something down, it was to record the result of that thinking. A bit more research consideration, and it became clear that the thinking time constituted the intellectual component of the task, and the jotting time constituted the clerical part.

Now things really began to get interesting. As the videotaped results for a number of subjects were analyzed, a pattern soon emerged. Subjects spent roughly 80 percent of their time thinking and 20 percent of their time jotting. Or, putting things another way, 80 percent of the systems analysis task, at least as these subjects were performing it, was intellectual, and the remaining 20 percent was what I came to call clerical. And these findings were relatively constant across a number of subjects.

Let's return for a moment to that rigor/relevance issue. This was not, as you can imagine, a terribly sophisticated research process. From a researcher point of view, it definitely lacked rigor. But talk abut relevance! I could not imagine a more relevant research study than one that cast light on this issue. Nevertheless, my research colleagues on this study convinced me that a little more rigor was in order. We decided to add another facet to the research study. One weakness of the existing work was that it examined only systems analysis, not the whole of the software development task. Another was that it was empirical, relying on a small number of subjects who just happened to have been available when the study was run.

The second facet overcame those problems. We decided to look at the whole of software development by looking at taxonomies of its tasks. We decided to take those tasks and categorize them as to whether they were primarily intellectual or primarily clerical.

Now things get almost eerie. The categorization showed that 80 percent of those software development tasks were classified as intellectual and 20 percent were classified as clerical—the same 80/20 ratio that had emerged from the empirical study of systems analysis.

It would be wrong to make too much of the likeness of those 80/20s. The two facets of the study looked at very different things using very different research approaches. Likely, those 80/20s are more coincidental than significant. And yet, at least in the spirit of relevance if not rigor, it seems fair to say that it is quite possible that software development in general is 80 percent intellectual and 20 percent clerical. And that says something important, I would assert, about that trivial/automatable versus complex controversy. That which is clerical may be trivial and automatable, but that which is intellectual is unlikely to be.

There is a small addendum to this story. This research eventually evolved into an examination of the creative (not just intellectual) aspects of software development. As with the second facet of the first part of the research, we categorized the intellectual portion of those same tasks as to whether they were creative. After the amazing 80/20 finding of the first part of the research, we expected some similar lightning bolt result about how much of the software development job is creative.

We were to be disappointed. Our first problem was finding a useful and workable definition of creativity. But there is a creativity literature, and we were finally able to do that. The good news is that we did discover, according to our research, that roughly 16 percent of those tasks were classified as creative. But the bad news is that there were considerable differences among the classifiers; one thought only 6 percent of those tasks were creative, whereas another thought that 29 percent were. Regardless, it is certainly possible to say that a major portion of the work of software development is intellectual as opposed to clerical, and at least a significant but minor portion is even creative. And, to me at least, that clearly says that software work is quite complex, not at all trivial or automatable.


There is little left to say about the controversy involved here, since the entire Discussion section is about a pair of controversies. I would like to say that, in my mind at least, this study settled the first controversy—software construction is definitely more complex than it is trivial. It also gives what I consider to be an excellent example of why rigor in research is not enough. If I had to choose between a rigorous study that was not relevant or a relevant one that was not rigorous, I would frequently choose relevance as my major goal. That, of course, is a practitioner's view. True researchers see things very differently.

In spite of my strong beliefs resulting from these studies, I have to confess that both controversies continue to rage. And, quite likely, neither will (or perhaps even should) be resolved.

In fact, the latest instantiation of the first controversy, the one about trivial/ automatable, takes a somewhat different tack. Jacobson (2002), one of object orientation's "three amigos" (the three people who formed Rational Software, the company that created the United Modeling Language object-oriented methodology), takes the point of view that most of software's work is "routine." (He does this in an article analyzing the relationship between agile software processes and his UML methodology.) He cites the numbers 80 percent routine and 20 percent creative as emerging from "discussions with colleagues . . . and . . . my own experience." Obviously his 20 percent creative tracks with this fact, but his 80 percent routine certainly does not. Note that Jacobson fails to take into account the intermediate category, "intellectual," something important between creative and routine.


The intellectual/clerical and creative/intellectual/clerical studies were published in several places, but they are both found in the following book:

Glass, Robert L. 1995. Software Creativity. Section 2.6, "Intellectual vs. Clerical Tasks." Englewood Cliffs, NJ: Prentice-Hall.


Jacobson, Ivar. 2002. "A Resounding 'Yes' to Agile Processes, but Also to More." Cutter IT Journal, Jan.

  • + Share This
  • 🔖 Save To Your Account


comments powered by Disqus