CHAPTER 1: SOFTWARE ENGINEERING FUNDAMENTALS
Introduction to Software Engineering
Software engineering is an engineering branch associated with development of software product
using well-defined scientific principles, methods and procedures. The outcome of software
engineering is an efficient and reliable software product.
Software project management has wider scope than software engineering process as it involves
communication, pre and post-delivery support etc.
Let us first understand what software engineering stands for. The term is made of two words,
software and engineering.
Software is more than just a program code. A program is an executable code, which serves some
computational purpose. Software is considered to be collection of executable programming code,
associated libraries and documentations. Software, when made for a specific requirement is
called software product.
Engineering on the other hand, is all about developing products, using well-defined, scientific
principles and methods.
1
Software engineering is an engineering branch associated with development of software product
using well-defined scientific principles, methods and procedures. The outcome of software
engineering is an efficient and reliable software product.
Definitions
IEEE defines software engineering as:
(1) The application of a systematic, disciplined, quantifiable approach to the development,
operation and maintenance of software; that is, the application of engineering to software.
(2) The study of approaches as in the above statement.
Fritz Bauer, a German computer scientist, defines software engineering as:
Software engineering is the establishment and use of sound engineering principles in order to
obtain economically software that is reliable and work efficiently on real machines.
Software crisis
Is a term used in the early days of computing science for the difficulty of writing useful and
efficient computer programs in the required time. The software crisis was due to the rapid
increases in computer power and the complexity of the problems that could not be tackled. With
the increase in the complexity of the software, many software problems arose because existing
methods were insufficient.
The causes of the software crisis were linked to the overall complexity of hardware and the
software development process. The crisis manifested itself in several ways:

Projects running over-budget

Projects running over-time

Software was very inefficient

Software was of low quality

Software often did not meet requirements

Projects were unmanageable and code difficult to maintain
2

Software was never delivered
The main cause is that improvements in computing power had outpaced the ability of
programmers to effectively utilize those capabilities. Various processes and methodologies have
been developed over the last few decades to improve software quality management such
as procedural programming and object-oriented programming. However software projects that
are large, complicated, poorly specified, and involve unfamiliar aspects, are still vulnerable to
large, unanticipated problems.
Need of Software Engineering
The need of software engineering arises because of higher rate of change in user requirements
and environment on which the software is working.

Large software - It is easier to build a wall than to a house or building, likewise, as the
size of software become large engineering has to step to give it a scientific process.

Scalability- If the software process were not based on scientific and engineering
concepts, it would be easier to re-create new software than to scale an existing one.

Cost- As hardware industry has shown its skills and huge manufacturing has lower down
the price of computer and electronic hardware. But the cost of software remains high if
proper process is not adapted.

Dynamic Nature- The always growing and adapting nature of software hugely depends
upon the environment in which user works. If the nature of software is always changing,
new enhancements need to be done in the existing one. This is where software
engineering plays a good role.

Quality Management- Better process of software development provides better and
quality software product.
Software services
A software service usually involves either development of a customized software or development
of some specific part of a software in an outsourced mode.
i. Customized software
3
A customized software is developed according to the specification drawn up by one or at most a
few customers. These need to be developed in a short time frame (typically a couple of months),
and at the same time the development cost must be low.
Usually, a developing company develops customized software by tailoring some of its existing
software. For example, when an academic institution wishes to have a software that would
automate its important activities such as student registration, grading, and fee collection;
companies would normally develop such a software as a customized product. This means that for
developing a customized software, the developing company would normally tailor one of its
existing software products that it might have developed in the past for some other academic
institution.
ii. Outsourced software
A company might consider the outsourcing option, if it feels that it does not have sufficient
expertise to develop some specific parts of the software; or if it determines that some parts can
be developed cost-effectively by another company. Since an outsourced project i s a small part of
some larger project, outsourced projects are usually small in size and need to be completed
within a few months or a few weeks of time.
Six of the most important quality characteristics of software include:
1. Maintainability is "the ease with which changes can be made to satisfy new requirements or to
correct deficiencies.
Well-designed software should be flexible enough to accommodate future changes that will be
needed as new requirements come to light. Since maintenance accounts for nearly 70% of the
cost of the software life cycle, the importance of this quality characteristic cannot be
overemphasized.
Quite often the programmer responsible for writing a section of code is not the one who must
maintain it. For this reason, the quality of the software documentation significantly affects the
maintainability of the software product.
4
2. Correctness is "the degree with which software adheres to its specified requirements. At the
start of the software life cycle, the requirements for the software are determined and formalized
in the requirements specification document.
Well -designed software should meet all the stated requirements. While it might seem obvious
that software should be correct, the reality is that this characteristic is one of the hardest to
assess. Because of the tremendous complexity of software products, it is impossible to perform
exhaustive execution-based testing to insure that no errors will occur when the software is run.
Also, it is important to remember that some products of the software life cycle such as the design
specification cannot be "executed" for testing. Instead, these products must be tested with various
other techniques such as formal proofs, inspections, and walkthroughs.
3. Reusability is "the ease with which software can be reused in developing other software. By
reusing existing software, developers can create more complex software in a shorter amount of
time. Reuse is already a common technique employed in other engineering disciplines. For
example, when a house is constructed, the trusses which support the roof are typically purchased
preassembled. Unless a special design is needed, the architect will not bother to design a new
truss for the house. Instead, he or she will simply reuse an existing design that has proven itself
to be reliable.
In much the same way, software can be designed to accommodate reuse in many situations. A
simple example of software reuse could be the development of an efficient sorting routine that
can be incorporated in many future applications.
4. Reliability is "the frequency and criticality of software failure, where failure is an
unacceptable effect or behavior occurring under permissible operating conditions. The frequency
of software failure is measured by the average time between failures. The criticality of software
failure is measured by the average time required for repair. Ideally, software engineers want their
products to fail as little as possible (i.e., demonstrate high correctness) and be as easy as possible
to fix (i.e., demonstrate good maintainability).
For some real-time systems such as air traffic control or heart monitors, reliability becomes the
most important software quality characteristic. However, it would be difficult to imagine a
highly reliable system that did not also demonstrate high correctness and good maintainability.
5
5. Portability is "the ease with which software can be used on computer configurations other
than its current one. Porting software to other computer configurations is important for several
reasons. First, "good software products can have a life of 15 years or more, whereas hardware is
frequently changed at least every 4 or 5 years.
Thus good software can be implemented, over its lifetime, on three or more different hardware
configurations.
Second, porting software to a new computer configuration may be less expensive than
developing analogous software from scratch.
Third, the sales of "shrink-wrapped software" can be increased because a greater market for the
software is available.
6. Efficiency is "the degree with which software fulfills its purpose without waste of resources.
Efficiency is really a multifaceted quality characteristic and must be assessed with respect to a
particular resource such as execution time or storage space.
One measure of efficiency is the speed of a program's execution. Another measure is the amount
of storage space the program requires for execution. Often these two measures are inversely
related, that is, increasing the execution efficiency causes a decrease in the space efficiency. This
relationship is known as the space-time tradeoff. When it is not possible to design a software
product with efficiency in every aspect, the most important resources of the software are given
priority.
6