Evolution and It's Solution to the Software Crisis

Evolution--From an ART From To an Engineering Discipline

In this Article, we review how starting from an esoteric art form, the software engineering discipline has evolved over the years.

{tocify} $title= {Table of Contents}

1.  Evolution of an Art into an Engineering Discipline

Software Engineering Principles have evolved over the last sixty years with contributions from numerous researchers and software professionals. Over the years, it has emerged from a pure art to a craft, and finally to an engineering discipline.

The early programmers used an ad hoc programming style. The style of development is now variously being referred to an exploratory, build and fix, and code and fix styles.

Note: - In a build and Fix style, a program is quickly developed without making any specification, plan, or design. The different imperfections that are subsequently noticed are fixed.

The exploratory programming style is an informal style in the sense that there are no set rules or recommendations that a programmer has to adhere to – every programmer himself evolves his own institution, experience, whims, and fancies. The exploratory style comes naturally to all first time programmers. Later in this chapter, we point out that except for trivial software development problems, the exploratory style usually yields poor quality and unmaintainable code and also makes program development very expensive as well as time-confusing.

 As we have already pointed out, the build and fix style was widely adopted by the programmers in the early years of computing history. We can consider the exploratory program development style as an art- since this style as an art – since this style, as is the case with any art, is mostly guided by intuition. There are many stories about programmers in the past who were like proficient artists and could write good programs using an essentially build and fix model and some esoteric Knowledge. The bad programmers were left to wonder effortlessly write elegant and correct programs each time. In contrast, the programmers working in modern software industry rarely make use of any esoteric knowledge and develop software by applying some well- understood principles.

2.  Evolution Pattern for Engineering Disciplines

If we analyze the evolution of the software development styles over the last sixty years, we can easily notice that it has evolved from an esoteric art form to a craft form, and then has slowly emerged as an engineering discipline. As a matter of fact, this pattern of evolution is not very different from that seen in other engineering disciplines. Irrespective of whether it is iron making, paper making, software development, or building construction; evolution of technology has followed strikingly similar patterns. This pattern of technology development has schematically been shown in Figure 1. It can be seen from Figure 1. It can be seen from graduates to a craft and finally emerges as an engineering discipline. Let us illustrate this fact using an example. Consider the evolution of the iron making technology. In ancient times, only a few people knew how to make iron. Those who knew iron making, kept it closely-guarded secret. This esoteric knowledge got transferred from generation to generation as a family secret. Slowly, over time technology graduated from an art to a craft from where tradesmen shared their knowledge with their apprentices and the knowledge pool continued to grow. Much latter, through a systematic organization and documentation of knowledge pool continue to grow. Much later, through a systematic organisation and documentation of knowledge, and incorporation of scientific basis, modem steel making technology emerged. The story of the evolution of the software engineering discipline is not much different. As we have already pointed out, in the early days of programming, there were good programmers and bad programmers. The good programmers knew certain principles (or tracks) that helped them write good programs, which they seldom shared with the bad programmers. Programs writing in later years was akin to a craft. Over the next several years, all good principles (or tricks) that were discovered by programmers along with research innovations have systematically been organized into a body of knowledge that forms the discipline of software engineering.

Software engineering principles are now being widely used in industry, and new principles are still continuing to emerge at a very rapid rate—making this discipline highly dynamic. In spite of its wide acceptance, critics point out that many of the methodologies and guidelines provided by the software engineering discipline lack scientific basis, are subjective, and often inadequate. Yet, there is no denying the fact that adopting software engineering techniques facilitates development of high quality software in a cost-effective and timely manner. Software engineering practices have proven to be indispensable to the development of large software products—though exploratory styles are often used successfully to develop small programs such as those written by students as classroom assignments.

1.  A Solution to the Software Crisis

 At present, software engineering appears to be among the few options that are available to tackle the present Software crisis. But, what exactly is the present software crisis? What are its symptoms, causes, a d possible solutions? To understand the present software crisis, consider the following facts. The expenses that organizations all over the world are incurring on software purchases as compared to the expenses incurred on hardware purchases have been showing an worrying trend over the years see figure 2. As can be seen in the figure, organizations are spending increasingly larger portions of their budget on software as compared to that to that of hardware. Among all the symptoms of the present software crisis, the trend of increasingly software costs is probably the most vexing.

At present, many organizations are actually spending much more on software than on hardware. If this trend continues, we might soon have a rather amusing scenario. Not long ago, when you bought any hardware product, the essential software that ran on it came free with it. But, unless some sort of revolution happens, in not very distant future, hardware prices would become insignificant compared to software prices—when you buy any software product the hardware on which the software runs would come free with the software.

Note:

 Not only are the software products becoming progressively more expensive than hardware, but they also present a host of other problems to the customers—software products are difficult to alter, debug, and enhance; use resources non-optimally; often fail to meet the user requirements; are far from being reliable; frequently crash; and are often delivered late.

 

The symptoms of software crisis are not hard to observe. But, what are the factors that have contributed to the present software crisis? Apparently, there are many factors, the important ones being—rapidly increasing problem size, lack of adequate training in software engineering techniques, increasing skill shortage, and low productivity improvements.  What is the remedy? It is believed that a satisfactory solution to the present software crisis can possibly come from a spread of software engineering practices among the developers, coupled with further advancements to the software engineering discipline itself.

Summary

With this brief discussion on the evolution and impact of the discipline of software engineering, we now examine some basic concepts pertaining to the different types of software development projects that are undertaken by software companies.