Chapter : Introduction to

Software Engineering
Contents..
• Evolving Role of Software
• Hardware vs. Software
• Software characteristics
 Evolving Role of Software
Today software takes on a dual role:
1.Software is a product
• Transforms information - produces, manages, acquires, modifies, displays, or transmits
information
• Delivers computing potential of hardware and networks
2.Software is a vehicle for delivering a product
• Controls other programs (operating system)
• Effects communications (networking software)
• Helps build other software (software tools & environments)
What is Software ?
Software can define as:
 Instruction – executed provide desire features, function & performance.

 Data structure – to adequately manipulate operation.

 Documents – operation and use of the program.

Software products may be developed for a particular customer or may be developed for a general market.

Software products may be
 Generic - developed to be sold to a range of different customers e.g. PC software such as Excel or Word.

 Bespoke (custom) - developed for a single customer according to their specification .

Examples – embedded control systems, air traffic control software, traffic monitoring systems.
 Without using software engineering principles it would be difficult to
develop large programs
In industry it is usually needed to develop large programs to accommodate
multiple functions. A problem with developing such large commercial
programs is that the complexity and difficulty levels of the programs increase
exponentially with their sizes.

 Software engineering helps to reduce this programming complexity.

Software engineering principles use two important techniques to reduce
problem complexity: abstraction and decomposition.
 The principle of abstraction implies that a problem can be simplified by
omitting irrelevant details. In other words, the main purpose of abstraction is
to consider only those aspects of the problem that are relevant for certain
purpose and suppress other aspects that are not relevant for the given purpose.

• The other approach to tackle problem complexity is decomposition. In this

technique, a complex problem is divided into several smaller problems and
then the smaller problems are solved one by one

• The problem has to be decomposed such that each component of the

decomposed problem can be solved independently and then the solution of
the different components can be combined to get the full solution.
 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 the 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.
2 Characteristics of Good Software
A software product can be judged by what it offers and how well it can be used. This software
must satisfy on the following grounds:
•Operational
•Transitional
•Maintenance

Operational
This tells us how well software works in operations. It can be measured on:
•Budget
•Usability
•Efficiency
•Correctness
•Functionality
•Dependability
•Security
•Safety
Transitional
This aspect is important when the software is moved from one platform to
another:
•Portability
•Interoperability
•Reusability
•Adaptability
Maintenance
This aspect briefs about how well a software has the capabilities to maintain
itself in the ever-changing environment:
•Modularity
•Maintainability
•Flexibility
•Scalability
• Three parties are involved in software engineering:

• Client: The client is the individual who wants a product to be built (developed).

• Developers: The developers are the members of a team responsible for

building that product.

• User: The user is the person or persons on whose behalf the client has
commissioned the product and who will utilize the software.
• Types of software:

• Based on parties relationship:

• Internal Software: Both the client and developers may be part of the same
organization.
• Contract Software: The client and developers are members of totally independent
organizations.

• Based on the functionality: 

• Custom software: It is written for one client.

• Commercial off-the-shelf (COTS) software: It has multiple copies and the copies are sold at
much lower prices to a large number of buyers. It is developed for “the market”.
• Open-source software: It is developed and maintained by a team of volunteers and may be
downloaded and used free of charge by anyone.
SCOPE OF SOFTWARE ENGINEERING:
The scope of software engineering is extremely broad. In general, five aspects are involved:
• Historical Aspects
• Economic Aspects
• Maintenance Aspects
• Requirements, Analysis, and Design Aspects
• Team Development Aspects
Historical aspects:
● A NATO study group in 1967 coined the term software engineering
• Building software is similar to other engineering tasks
● Software engineering should use the philosophies and paradigms of established
engineering disciplines to solve the software crisis
•Despite many success stories, a large proportion of softwareproducts still are being
• Delivered late
• Over budget
• With residual faults.

Solution: A software engineer has to acquire a broad range of skills, both technical and
managerial. These skills have to be applied to: Programming; and Every step of software
production, from requirements to post_delivery maintenance.
 Economic Aspects:

Applying economic principles to software engineering requires the client to

choose techniques that reduce long-term costs in terms of the economic
sense.

•Software engineer is interested in techniques that make

sound economic sense
• The cost of introducing new technology into an organization
• The cost of shifting to new technology (training)
• The cost of maintenance, effect of new technology on maintenance
• Considering client responses
Maintenance Aspects
● Maintenance is described within the context of the software life cycle
● Life-cycle model — Description of the steps performed when
building a software product
Many different models. Eg: waterfall model, spiral model etc.
● Phases — Life-cycle model broken into a series of smaller steps
• Easier to perform a sequence of smaller tasks
• Number of phases varies from model to model
● Life cycle of a product — Actual series of steps performed on the software product
• From concept exploration through final retirement
• In Contrast to the life-cycle model (a theoretical description)
• Classical and Modern Views of Maintenance
● In 1970s, software production viewed as two distinct activities of
development followed by maintenance
• Described as the development-then-maintenance model
• A temporal definition (an activity is classified depending on when it is
performed)
Classical View of Maintenance:
• Development-then-maintenance model.

But this model is unrealistic due to:

oDuring the development, the client’s requirements may change. This leads to the changes in the specification and design.
oDevelopers try to reuse parts of existing software products in the software product to be constructed.

Modern view of Maintenance:

It is the process that occurs when “software undergoes modifications to code and associated documentation due to a problem or the need for improvement or adaptation”.
That is, maintenance occurs whenever a fault is fixed or the requirements change, irrespective of whether this takes place before or after installation of the product,
Classical Post-delivery Maintenance: All changes to the product once the product has been delivered and installed on the client’s computer and passes its acceptance
test.
Modern Maintenance (or just maintenance): Corrective, perfective, or adaptive activities performed at any time.
Classical post-delivery maintenance is a subset of modern maintenance.
Team Development Aspects:

Most software is produced by a team of software engineers

•Team development leads to interface problems among code, components
and communication problems among team members
•Unless the team is properly organized, an inordinate amount of time can
be wasted in conferences between team members
•The scope of software engineering must include techniques for ensuring
that teams are properly organized and managed
Requirements, Analysis, and Design Aspects

•Cost of correcting a fault increases steeply throughout the phases

•The earlier one corrects a fault, the better
•A fault in requirements may also appear in the specifications, the design,
and the code
•Studies have shown that between 60% and 70% of all faults detected in
large projects are requirements, analysis, or design faults
•It is important to improve requirements, analysis, and design techniques
Manufacturing vs. Development
• Once a hardware product has been manufactured, it is difficult or
impossible to modify. In contrast, software products are routinely
modified and upgraded.
• In hardware, hiring more people allows you to accomplish more
work, but the same does not necessarily hold true in software
engineering.
• Unlike hardware, software costs are concentrated in design rather
than production.
2.Software does not “wear out” but it does deteriorate.
• Software is not susceptible to the environmental maladies that cause hardware to wear out
• In theory, therefore, the failure rate curve for software should take the form shown here.
• Undiscovered defects will cause high failure rates early in the life of a program. However these
are corrected and curve get flattened.
• During its life software will undergo change (maintenance) As changes are made it is likely that
some new defects will be introduced, causing the failure rate curve to spike as shown.

• Before the curve can return to the originally steady state failure rate,
another change is requested causing the curve to spike again Slowly
the minimum failure rate level begins to rise the software is
deteriorating due to change.
Failure curve for Hardware
 Failure curve for Software

When a hardware component wears out, it is replaced by a spare part.

There are no software spare parts. Every software failure indicates an
error in design or in the process through which design was translated
into machine executable code. Therefore, software maintenance involves
considerably more complexity