It is not too far off if we run the analogy between the life of a human maturity process and that of software. Arguably, a human being starts from conception. A life goes in stages: the pregnancy, the birth, the nursing of a baby, the schooling with kindergarten, the twelve grades, college or technical school, then, the entry to the workforce, the prime of being an expert in a particular field, and the change of this field naturally as desirable or as needed; each individual is actively anticipating a development maturity while every one of us being useful and enjoying our lives.
To a logical mind, it is remarkably similar between a successful individual life and a software product. Let us continue this analogy to illuminate what software is and how to ensure software quality.
A. The conception
There is a broad range of reasons to conceive a life or create software! Without a doubt, the forefront reason is the result of our passion and our love. It could also be an accident or a deliberated act strategically or tactically. One strategic software project that immediately jumped to my mind was the one D. L. Parnas wrote in his paper [1]. He stated that he had his concerns about the health of that project vociferously. In hindsight, we knew that the primary purpose of the project was strategically aligned with our national interests during the cold war. Fortunately, we can say that this project ended with success because of the ending of the USSR. Meanwhile, there were plenty of software products that continued useful with longevity. An obvious example would be the office automation suites.
B. The pregnancy
Software requirement development is similar to the pregnancy stage of human life. The process should be carried out by a responsible individual who can bring such a life into the world. Although the stakeholders of software may be more than one individual, the final decision for bringing about a particular software product ought to stop at one responsible individual. Many examples supported such analysis; among them, there is in the AIR JAM report [2]. Without doing so, the requirement specification often induces failure with its skyrocketing cost as the symptom.
On the other hand, not all software projects can be associated with an individual’s responsibility. The requirements of those projects were part of the circumstances discussed by Neil Maiden in “Trust Me, I am an Analyst [3].” In his analysis, trust has been of the highest importance. Although it makes some sense, arguably, the responsibility must be emphasized at the forefront; specifically, the desirability and the feasibility must be differentiated clearly in an engineering sense under its software architect(s).
Software development professionals, who are specialized in software requirement engineering, must not only be able to “listen” to descriptions of stakeholders, but also to participate, like those movie actors or investigating reporters, who are taking active roles in the subjects they play or investigate. Learning what are the needs by participating, such as a banker developing a finical system or a controller developing an air traffic control system.
Good actors can quickly make sense of the roles they play. Requirement engineers can do the same as well. It is a must for experienced software engineers to do so because we understand both evolved technologies used to create software. We can effectively bridge the gap between the desirable requirements and the feasible implementation with available technologies.
C. The education
As human beings, whether one is useful/influential or not, it is judged by their knowledge and their capability in actions. A software product is the same if built with efficient knowledge structures for addressing its requirements. The key to efficient knowledge structures is the subject of studies in software architecture. An excellent software product with longevity must have enduring software architecture. Just as people in their workplaces, knowledgeable workers have resulted from their excellent educations, good software products come from good design and development. Architectural analysis is most important in software design. Good architecture is sustainable to software systems with continuously learning and continuously improving.
D. Entering the workforce
If the commencement at the end of schooling is a youngster’s entry into the workforce, the same is true for software to be first released to the real world. Software is tested during its development, but the key to being useful is in use in the real world by its end-users. Arguably, the most critical growth of a software product starts at this stage, unlike the following descriptions of the software project management life cycle of the past:
We built what we were told to build, managing it the best we could; and after it was over, we breathed a sigh of relief (or despair) and moved on to the next project [4].
Here, Favaro’s word “over” is not the end of software life cycle management but the project delivery to the operational people and maintenance engineers. It indicates the ending of the software-development and the beginning of the software-maintenance stage in the traditional software life cycle management. This point of view might be applicable 30 years ago. With modern software, the difference is that software matures through its use:
The more customers use it, the more feedback the software gets for improvement. It is essential for college graduates to learn-by-doing and to accumulate their real-world-knowledge at work. The same is true whether a software product is popular or not at its entry point. We should judge how it grows and how its customers react to it. It is often the case that if its design is sound, it grows better and serves better.
Defects in software products are inevitable, just as teenagers’ imperfection; continuous improvement is also inevitable while maturing within their life cycle, both young persons and newly developed software. As a person learns and corrects his unwanted habits to fit in society, software defects may be fixed whenever and wherever surfaced while being used.
Even though we don’t call a college graduate “version 2,” he or she becomes a better “version” compared with the “version” at his high school commencement ceremony. He has learned more comprehensive knowledge and special skills, provided that critical thinking develops throughout their education at a college. He/she is more capable of doing complex tasks and capable of serving society.
Judging software is like judging people; we want to see how one is educated/capable. In software, defects can be removed not only when it occurs while being tested before entering the market, but also when it occurs while being used. A Hewlett Parker study has shown that many defects of a software product may never have the chance to be exposed during its service. It depends on how its customers’ usage of it [5].
Both code reviews and extra efforts spent for defect removal advocated by experts of software development in the past [6] [7] may or may not be efficient uses of developers time if the software is a commercial product or a freeware, typically developed in an Agile development environment, rather than mission-critical software with potentially catastrophic effect [8] if anything goes wrong.
I have proposed a model of software defects to address software product quality issues [9], which is also part of a solution to software development under the software maturity modeling approach.
E. Maturing with lifelong learning
At the prime of our professional career, mature human beings are most productive and motivational in learning driven by unknowns provided that the more one learns, the more one may realize that what one do not know and want to know. The same happens in software products. If a software product is useful, it promotes the need to make the product even more useful. Improving a software product can be challenging, but it is feasible.
Demands for software changes can be given in two forms:
- A problem addressed by software may change when the environment that defines it has changed;
- The solution to the problem addressed by the software is improving.
In order to implement these changes, architectural changes may be necessary, and the cost of changes may be evaluated. In describing software aging caused by those preventable changes, Parnas wrote:
Changes made by people who do not understand the original design concept almost always cause the structure of the program to degrade. Under those circumstances, changes will be inconsistent with the original concept; in fact, they will invalidate the original concept. Sometimes the damage is small, but often it is quite severe. After those changes, one must know both the original design rules and the newly introduced exceptions to the rules, to understand the product. After many such changes, the original designers no longer understand the product. Those who made the changes never did [10].
This description reflects reality in many legacy systems, but it does not have to be this way if the responsibility of design ties with individuals. A close analogy between software designers and architects of landmark buildings may be appropriate. Individual responsibility should tie with the fame or the shame of the software systems, especially those important ones. Many failures in Robert Charette’s survey article [2] can be avoided if applying this software maturity model. Tying the responsibility with the architects of the software system could be a two-way street. Connecting the software architecture with an individual can be used as licensing approach for evaluating software architects if desirable, not for life but any particular software system. It goes nicely with the suggestion made by Maiden: requirements analyst should show their previously successful work.
Another close analogy runs with how FAA issues licenses to pilots, where flying hours and the types of airplanes they operate are the primary indications of pilot’s skills. In fact, that is how pilots get rated.
In her Quality Time column piece in IEEE Software, S.L. Pfleeger introduced Manny Lehman’s notion of program (referring his Life Cycles and the Laws of Software Evolution, Proc. IEEE, IEEE, Piscataway, NJ Vol. 68, No. 9, Sept. 1980, pp1060-1076,) a program describes a system in terms of the way it relates to the environment in which it operates. She pointed out: “Unlike programs handled in the abstract, the real world contains uncertainties and concepts we do not understand completely.” In my analysis, the dada uncertainty is the cause of our inability to test general systems behaviors with a particular input. It could be meaningful input to the environment but not to the program particularly. The system behavior in response to untested situations may seem odd to users, but it should not be seen as strange to developers when such is happening. She continued: “The more dependent a system is on the real world for its requirements, the more likely it is to change [11].” The same reason has motivated me to write this article. We must model software maturity as a life cycle management approach.
F. Retiring
Like the story of Compact Disc, when the CDs came along, recording music on cassette was inferior in terms of the sound quality, ease of retrieving, and storage capacity. Software products are retired due to their quality as well.
However, the differences between software and hardware change the dynamics in reality. The flexibility in software allows improvements constantly. The same is true in software engineers, as long as one keeps learning. The fact that software engineers are good at learning with being curious about possible self-improvement is natural. If computer hardware is to human bodies, then computer software is to human brains. Many religions in the world honor human souls as eternal; it couldn’t be a more appropriate analogy with computer software. While hardware is degrading/upgrading, the essential in software lives forever. Arguably, one should never retire a high-quality software product. The apparent high cost to “maintain” usually can be exchanged with technology transfers.
[1] D.L. Parnas. Software Aspects of Strategic Defense Systems, and SDI: A Violation of Professional Responsibility, In Chapters 26 and 27 of Software Fundamentals, Collected Papers by David L. Pamas, Edited by Hoffman and Weiss, Addison-Wesley, 2001 .
[2] R.N. Charette,” Why software fails”, IEEE Spectrum,Vol.42 No.9, p42-49, Doi:10.1109/MSPEC.2005.1502528.
[3] N. Maiden, “Trust Me, I’m an Analyst”, Software, IEEE, vol. 27, no. 3, June, 2010, p46-47, doi: 10.1109/MS.2010.22.
[4] J. Favaro, “Guest Editor’s Introduction: Renewing the Software Project Management Life Cycle”, Software, IEEE, vol. 27, no. 3, June, 2010, p17-19, doi: 10.1109/MS.2010.9.
[5] A.P. Wood, “Software reliability from the customer view”, Computer, vol. 36, no. 8, Aug. 2003, p37-42, doi:10.1109/MC.2003.1220580.
[6] R.L. Glass, Facts and Fallacies of Software Engineering, Addison-Wesley, c2003.
[7] A.M. Davis, 201 Principles of Software Development, McGrow Hill, Inc, 1995.
[8] G. Le Lann, “An analysis of the Ariane 5 flight 501 failure — a system engineering perspective”, in Proceedings., International Conference on Engineering of Computer-Based Systems, Mar 24-28, 1997, p339-346, doi: 10.1109/ECBS.1997.581900
[9] B.H. Wu, “Modeling Defects in Software Systems”, IEEE International Conference on Granular Computing (GrC2011), Kaohsiung, Taiwan, November 8-10, 2011, p739-744, doi: 10.1109/GRC.2011.6122690.
[10] D.L. Parnas, Software Aging, In Chapter 29 of Software Fundamentals, Collected Papers by David L. Pamas, Edited by Hoffman and Weiss, Addison-Wesley, 2001.
[11] S.L. Pfleeger, “The nature of system change”, Software, IEEE, vol. 15, No.3, 1998, p87-90, doi:10.1109/52.676964 .
Lightening up within; making influences mutually; making differences eternally...