Lecture 1

Introduction to Software Engineering

Objectives
The objective of this lecture is to introduce a software engineering —a coherent
set of activities for software production. After this lecture, student will
■ understand what software engineering is and why it is important;
■ understand what is Software or Software System;
■ understand that the development of different types of software system may
require different software engineering techniques;
■ understand the Software Characteristics, Software Quality, Type of Software /
Application Domains;
■ know who develop Software System? and what are Good Software Engineer
factors;
■ know the Software Engineering Principles – common activities & Software
Process
■ understand ethical and professional issues that are important for software
engineers;- ―Software Engineering Code of Ethics‖

Reference Reading
• Roger. S. Pressman, ―Software Engineering, A Practitioner’s Approach‖, 8th
edition, 2015
• Chapter 1: The Nature of Software
• Chapter 2: Software Engineering
• Iron Sommerville, ―Software Engineering‖, Global Edition, 10th edition, 2016
• Chapter 1: Introduction
• Rajib Mall, ―Fundamentals of Software Engineering‖, 4th Edition, 2014
• Chapter 1: Introduction

1. Introduction
The objectives of this chapter are to introduce software engineering and to
provide a framework for understanding what software engineering is and why it is
important.
The role of computer software has undergone significant change over the last 60
years. Dramatic improvements in hardware performance, profound changes in computing
architectures, vast increases in memory and storage capacity, and a wide variety of exotic

-1-
input and output options have all precipitated more sophisticated and complex computer-
based systems. Sophistication and complexity can produce dazzling results when a
system succeeds, but they can also pose huge problems for those who must build and
protect complex systems.
There are many different types of software system, ranging from simple
embedded systems to complex, worldwide information systems. There are no
universal notations, methods, or techniques for software engineering because
different types of software require different approaches. Developing an
organizational information system is completely different from developing a
controller for a scientific instrument. Neither of these systems has much in common
with a graphics-intensive computer game. All of these applications need software
engineering; they do not all need the same software engineering methods and
techniques.

2. What is Software Engineering?

Software engineering is intended to support professional software development
techniques that support program specification, design, and evolution. To get a broad
view of software engineering, the following definition for Software Engineering will
help you to understand.

• Definition 1

Software engineering is the systematic development, operation, maintenance,

refinement and cost effective approach to develop software.

• Definition 2

Software engineering encompasses a process, a collection of methods (practice),

management and an array of tools that allow professionals to build high-quality
computer software.

• Definition 3

Software engineering is an engineering discipline that is concerned with all

aspects of software production from initial conception to operation, management
and maintenance.

• Definition 4 (IEEE)

Software engineering is a systematic, disciplined and quantifiable approach to

the development, operation, maintenance and refinement of software.

-2-
In the Software Engineering definition, there are two key phrases:

1. Engineering discipline or process

2. Software

2.1 Engineering discipline or process

Now let’s try to figure out what exactly is meant by an engineering process to
develop software. Suppose you have asked a small contractor to build a small house for
you. These contractors are not really expert in house building. They normally carry out
minor repair works and at most undertake very small building works such as the
construction of boundary walls. Now faced with the task of building a complete house,
your petty contractor would draw upon all his knowledge regarding house building. Yet,
he may often be clueless regarding what to do. For example, he might not know the
optimal proportion in which cement and sand should be mixed to realize sufficient
strength for supporting the roof. In such situations, he would normally succeed in his
work, if the house you asked him to construct is sufficiently small. Of course, the house
constructed by him may not look as good as one constructed by a professional, may
lack proper planning, and display several defects and imperfections. It may even cost
more and take longer to build.
Now, suppose you entrust your petty contractor to build a large 50-storeyed
commercial complex for you. He might exercise prudence, and politely refuse to
undertake your request. On the other hand, he might be ambitious and agree to undertake
the task. In the later case, he is sure to fail. The failure might come in several forms—the
building might collapse during the construction stage itself due to his ignorance of the
basic theories concerning the strengths of materials; the construction might get unduly
delayed, since he may not prepare proper estimates and detailed plans regarding the
types and quantities of raw materials required, the times at which these are required,
etc. In short, to be successful in constructing a building of large magnitude, one needs
a good understanding of various civil and architectural engineering techniques such
as analysis, estimation, prototyping, planning, designing, and testing.
Similar is the case with the software development projects. For sufficiently
small-sized problems, one might proceed according to one’s intuition and succeed;
though the solution may have several imperfections, cost more, take longer to
complete, etc. But, failure is almost certain, if one without a sound understanding of
the software engineering principles undertakes a large-scale software development
work.
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. This

-3-
development discipline has schematically been shown in Figure 1.1. 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.

Figure 1.1 Computer systems engineering

2.2 Software

(1) What is Software (or) Software System?

When we are talking about software engineering, software is not just the
computer programs but also all associated documentation, libraries, support websites,
and configuration data that are needed to make these programs useful. A professionally
developed software system is often more than a single program. A system may consist
of several separate programs and configuration files that are used to set up these
programs. It may include system documentation, which describes the structure of the
system, user documentation, which explains how to use the system, and websites for
users to download recent product information. To get a broad view of software, the
following definition for Software system will help you to understand.

-4-
 • Definition 1

Software is: (1) instructions (computer programs) that when executed provide
desired features, function, and performance; (2) data structures that enable the
programs to adequately manipulate information, and (3) descriptive information
in both hard copy and virtual forms that describes the operation and use of the
programs.

• Definition 2

Computer software is the product that software professionals build and then
support over the long term. It encompasses programs that execute within a
computer of any size and architecture, content that is presented as the computer
programs execute, and descriptive information in both hard copy and virtual
forms that encompass virtually any electronic media.

• Definition 3

Software is defined as a collection of programs procedures, rules, data and

associated documentation developed by that software professional for a particular
customer or for a general market.

• Definition 4

Software is the sequences of instructions in one or more programming languages

that comprise a computer application to automate some business function.

(2) Software Characteristics

It’s important to examine the characteristics of software that make it different

from other things that human beings build. Software is a logical rather than a physical
system element. Therefore, software has one fundamental characteristic that makes it
considerably different from hardware: Software doesn’t “wear out.” Figure 1.2 depicts
failure rate as a function of time for hardware, often called the ―bathtub curve,‖ indicates
that hardware exhibits relatively high failure rates early in its life (these failures are often
attributable to design or manufacturing defects); defects are corrected, and the failure rate
drops to a steady-state level (hopefully, quite low) for some period of time. As time
passes, however, the failure rate rises again as hardware components suffer from the
cumulative effects of dust, vibration, abuse, temperature extremes, and many other
environmental maladies. Stated simply, the hardware begins to wear out.

-5-
 Figure 1.2 Failure curve for hardware, ―bathtub curve‖

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
of the “idealized curve” shown in Figure 1.3. Undiscovered defects will cause high
failure rates early in the life of a program. However, these are corrected and the curve
flattens as shown. The idealized curve is a gross oversimplification of actual failure
models for software. However, the implication is clear—software doesn’t wear out. But
it does deteriorate!
This seeming contradiction can best be explained by considering the actual curve
in Figure 1.3. During its life, software will undergo change. As changes are made, it is
likely that errors will be introduced, causing the failure rate curve to spike as shown
in the ―actual curve‖ (Figure 1.3). Before the curve can return to the original 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.
Another aspect of wear illustrates the difference between hardware and
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, the software maintenance tasks that accommodate requests for change
involve considerably more complexity than hardware maintenance.
Some software characteristics can be summarized as follows:

• Software can be developed.

• Software is complex in nature.
• Software has specific set of attributes that depends on its application.

-6-
 Figure 1.3 Failure curves for software

• For example,
• an aircraft control system must be safe,
• an interactive game must be responsive,
• a telephone switching system must be reliable, and so on.
• Software is associated with documentation
• which describes the structure of the system, user documentation, which
explains how to use the system

Characteristics of a software can be easily distinguished as of from the hardware.

• Hardware failure rate is initially high but decreases as the faulty components are
identified and removed. The system then enters its useful life. After sometime,
hardware becomes wear out.
• Software failure rate is at its highest during integration and test. During testing,
errors are identified and removed resulting in reduced failure rate. When change
is requested, causing the curve to spike again.
• Software doesn’t wear out. But it does deteriorate(fail)!

(3) Type of Software (or) Software Application Domains

There are many different types of application being developed. Today, seven broad
categories of computer software present continuing challenges for software engineers:

-7-
1. System software
A collection of programs written to service other programs (e.g., compilers,
editors, and file management utilities, operating system components, drivers,
networking software, telecommunications processors)

2. Application software
Stand-alone programs that solve a specific business need. (e.g., business
operations or management/technical decision making software)

3. Engineering/scientific software
A broad array of ―number-crunching‖ programs that range from astronomy to
volcanology, from automotive stress analysis to orbital dynamics, and from
computer-aided design to molecular biology, from genetic analysis to
meteorology.

4. Embedded software
Resides within a product or system and is used to implement and control features
and functions for the end user and for the system itself. Embedded software can
perform limited and esoteric functions (e.g., key pad control for a microwave
oven) or provide significant function and control capability (e.g., digital
functions in an automobile such as fuel control, dashboard displays, and braking
systems).

5. Product-line software
Software designed to provide a specific capability for use by many different
customers. Product-line software can focus on a limited and esoteric marketplace
(e.g., inventory control products) or address mass consumer.

6. Web/Mobile applications
This network-centric software category spans a wide array of applications and
encompasses both browser-based apps and software that resides on mobile
devices.

7. Artificial intelligence software

Makes use of non-numerical algorithms to solve complex problems that are not
amenable to computation or straightforward analysis. Applications within this
area include robotics, expert systems, pattern recognition (image and voice),
artificial neural networks, theorem proving, and game playing.

-8-
 Each type of system requires specialized software engineering techniques
because the software has different characteristics. For example, an embedded control
system in an automobile is safety-critical and is burned into ROM (read-only memory)
when installed in the vehicle. It is therefore very expensive to change. Such a system
needs extensive verification and validation so that the chances of having to recall cars
after sale to fix software problems are minimized. User interaction is minimal (or perhaps
nonexistent), so there is no need to use a development process that relies on user interface
prototyping. For an interactive web-based system or app, iterative development and
delivery is the best approach, with the system being composed of reusable components.
However, such an approach may be impractical for a system of systems, where detailed
specifications of the system interactions have to be specified in advance so that each
system can be separately developed.

(4) The Essential Characteristics of a Professional Software system or

Software Quality

When we talk about the quality of professional software, we have to consider that
the software is used and changed by people apart from its developers. Quality is therefore
not just concerned with what the software does. The specific set of attributes that you
might expect from a software system obviously depends on its application. Therefore, an
aircraft control system must be safe, an interactive game must be responsive, a telephone
switching system must be reliable, and so on. These can be generalized into the set of
attributes which are the essential characteristics of a professional software system.
Nevertheless, there are software engineering fundamentals that apply to all types of
software systems:

• Portability: A software product is said to be portable, if it can be easily made to

work in different operating system environments, in different machines, with
other software products, etc.

• Usability: A software product has good usability, if different categories of users

(i.e. both expert and novice users) can easily invoke the functions of the product.

• Reusability: A software product has good reusability, if different modules of the

product can easily be reused to develop new products.

• Correctness: A software product is correct, if different requirements as specified

in the SRS document have been correctly implemented.

• Maintainability: A software product is maintainable, if errors can be easily

corrected, new functions can be easily added to the product, and the
functionalities of the product can be easily modified, etc.

-9-
3. Why need Software Engineering?

In general, software engineers adopt a systematic and organized approach to their

work, as this is often the most effective way to produce high-quality software. However,
engineering is all about selecting the most appropriate method for a set of circumstances,
so a more creative, less formal approach to development may be the right one for some
kinds of software. A more flexible software process that accommodates rapid change is
particularly appropriate for the development of interactive web-based systems and mobile
apps, which require a blend of software and graphical design skills.
There are many different types of software system, ranging from simple
embedded systems to complex, worldwide information systems. Developing an
organizational information system is completely different from developing a controller
for a scientific instrument. There are no universal notations, methods, or techniques for
software engineering because different types of software require different
approaches. There are still many reports of software projects going wrong and of
―software failures.‖ Software engineering intends to supports professional software
development techniques to develop program specification, design, and evolution and to
produce reliable and trustworthy systems economically and quickly.

Software engineering is important for two reasons:

1. More and more, individuals and society rely on advanced software systems. We
need to be able to produce reliable and trustworthy systems economically
and quickly.
2. It is usually cheaper, in the long run, to use software engineering methods and
techniques for professional software systems rather than just write programs as
a personal programming project. Failure to use software engineering method
leads to higher costs for testing, quality assurance, and long-term maintenance.

3.1 Why software failure?

When developing an organizational information system with different methods

and techniques, there are still many reports of software projects going wrong and of
―software failures.‖ Software engineering is criticized as inadequate for modern software
development. However, many of these so-called software failures are a consequence of
two factors:

1. Increasing system complexity

As new software engineering techniques help us to build larger, more complex
systems, the demands change. Systems have to be built and delivered more
quickly; larger, even more complex systems are required; and systems have to

- 10 -
 have new capabilities that were previously thought to be impossible. New
software engineering techniques have to be developed to meet new the
challenges of delivering more complex software.

2. Failure to use software engineering methods

It is fairly easy to write computer programs without using software engineering
methods and techniques. Many companies have drifted into software
development as their products and services have evolved. They do not use
software engineering methods in their everyday work. Consequently, their
software is often more expensive and less reliable than it should be. We need
better software engineering education and training to address this problem.

4. Who develop Software System?

Software system are developed by software engineers adopting a systematic

and organized approach (software engineering process) to their work, as this is often
the most effective way to produce high-quality software.

• Teams of software specialists, each focusing on one part of the technology

required to deliver a complex application,
• A software engineer is a person who applies a broad range of
application development knowledge to the systematic development of
application systems (well-structured computer programs) for
organizations.
• System analysts, the people who perform systems analysis

Software engineers are those who contribute by direct participation or by

teaching, to the analysis, specification, design, development, certification, maintenance
and testing of software systems. A good software engineer must know what principles,
practices, and tools to use, when to use them, and why they are needed.

4.1 Good Software Engineer

Qualities skills possessed by a good software engineer:

1) General Skill
• Analytical skill, Problem solving skill, Group work skill
2) Programming Skill
• Programming language, Data structure, Algorithm, Tools (Compiler,
Debugger)
3) Communication skill

- 11 -
 • Verbal, Written, Presentation
4) Design Skill
• Software engineer must be familiar with several application domain

5. Software Engineering Discipline

Software Engineering (The IEEE definition): The application of a systematic,
disciplined, quantifiable approach to the development, operation, and maintenance of
software; that is, the application of engineering to software.
Software engineering is a layered technology. Referring to Figure 1.3, any
engineering approach (including software engineering) must rest on an organizational
commitment to quality. The bedrock that supports software engineering is a quality
focus.

Figure 1.4 Software Engineering Layers

The foundation for software engineering is the process layer. The software engineering
process is the glue that holds the technology layers together and enables rational and timely
development of computer software. Process defines a framework that must be established for
effective delivery of software engineering technology. The software process forms the basis for
management control of software projects and establishes the context in which technical methods
are applied, work products (models, documents, data, reports, forms, etc.) are produced,
milestones are established, quality is ensured, and change is properly managed.
Software engineering methods provide the technical how-to’s for building software.
Methods encompass a broad array of tasks that include communication, requirements analysis,
design modeling, program construction, testing, and support. Software engineering methods
rely on a set of basic principles that govern each area of the technology and include modeling
activities and other descriptive techniques.
Software engineering tools provide automated or semi-automated support for the
process and the methods. When tools are integrated so that information created by one tool can
be used by another, a system for the support of software development, called computer-aided
software engineering, is established.

- 12 -
6. Software Process
What are the elements of a software process?

In the context of software engineering, a process is not a rigid prescription for how-to build
computer software. Rather, it is an adaptable approach that enables the people doing the work
(the software team) to pick and choose the appropriate set of work actions and tasks. The intent is
always to deliver software in a timely manner and with sufficient quality to satisfy those who
have sponsored its creation and those who will use it.
The systematic approach used in software engineering called a software process. A software
process is a sequence of activities that leads to the production of a software product. There are no
universal software engineering methods or techniques that may be used. Although different
software processes need for different type of software system, they all must include the four
fundamental software engineering activities.

Four fundamental activities are common to all software processes.

1) Software specification, where customers and engineers define the software that is to be
produced and the constraints on its operation.
2) Software development, where the software is designed and programmed.
3) Software validation, where the software is checked to ensure that it is what the customer
requires.
4) Software evolution, where the software is modified to reflect changing customer and
market requirements.

These activities are complex activities in themselves, and they include sub-activities such as
requirements validation, architectural design, and unit testing. Processes also include other
activities, such as software configuration management and project planning that support
production activities.
Software processes are complex and, like all intellectual and creative processes, rely on
people making decisions and judgments. As there is no universal process that is right for all kinds
of software, most software companies have developed their own development processes.
Processes have evolved to take advantage of the capabilities of the software developers in an
organization and the characteristics of the systems that are being developed. For safety-critical
systems, a very structured development process is required where detailed records are maintained.
For business systems, with rapidly changing requirements, a more flexible, agile process is likely
to be better.
There are many different types of software. There are no universal software engineering
methods or techniques that may be used. However, there are four related issues that affect many
different types of software:

1. Heterogeneity
Increasingly, systems are required to operate as distributed systems across networks that
include different types of computer and mobile devices. As well as running on general-
purpose computers, software may also have to execute on mobile phones and tablets. You

- 13 -
 often have to integrate new software with older legacy systems written in different
programming languages. The challenge here is to develop techniques for building
dependable software that is flexible enough to cope with this heterogeneity.

2. Business and social change

Businesses and society are changing incredibly quickly as emerging economies develop
and new technologies become available. They need to be able to change their existing
software and to rapidly develop new software. Many traditional software engineering
techniques are time consuming, and delivery of new systems often takes longer than
planned. They need to evolve so that the time required for software to deliver value to its
customers is reduced.

3. Security and trust

As software is intertwined with all aspects of our lives, it is essential that we can trust that
software. This is especially true for remote software systems accessed through a web
page or web service interface. We have to make sure that malicious users cannot
successfully attack our software and that information security is maintained.

4. Scale
Software has to be developed across a very wide range of scales, from very small
embedded systems in portable or wearable devices through to Internet-scale, cloud-based
systems that serve a global community.

To address these challenges, we will need new tools and techniques as well as innovative
ways of combining and using existing software engineering methods.

6.1 Software Process vs Software Project vs Software Product

Figure 1.5 Concepts between Software Process, Software Project and Software Product

• Software Process is the entire s/w development task as a process that defines
who is doing what, when & how to reach a certain goal.

• Software Project:
1. A project is a temporary work undertaken to create a unique product.
2. Temporary means every project has a definite beginning and a definite
end.

- 14 -
 3. Unique means the product must be different in some ways from all
similar product.

• Software Product:
Outcome of software project is known as software product

7. Software Engineering Code of Ethics

Software engineering is carried out within a social and legal framework that
limits the freedom of people working in that area. As a software engineer, you must
behave in an ethical and morally responsible way to be respected as a professional
engineer. A software engineer should uphold normal standards of honesty and
integrity. You should not use your skills and abilities to behave in a dishonest way or in
a way that will bring disrepute to the software engineering profession.

A software engineer’s professional responsibility are:

1) Confidentiality: You should respect the confidentiality of your employers or
clients regardless of whether or not a formal confidentiality agreement has been
signed.

2) Competence: You should not misrepresent your level of competence. You

should not knowingly accept work that is outside your competence.

3) Intellectual property rights: You should be aware of local laws governing the
use of intellectual property such as patents and copyright. You should be careful
to ensure that the intellectual property of employers and clients is protected.

4) Computer misuse: You should not use your technical skills to misuse other
people’s computers. Computer misuse ranges from relatively trivial (game
playing on an employer’s machine) to extremely serious (dissemination of
viruses or other malware).

Because of their roles in developing software systems, software engineers have

significant opportunities to do good or cause harm, to enable others to do good or cause
harm, or to influence others to do good or cause harm. To ensure, as much as possible,
that their efforts will be used for good, software engineers must commit themselves to
making software engineering a beneficial and respected profession. In accordance with
that commitment, software engineers shall adhere to the following Code of Ethics and
Professional Practice†.

- 15 -
7.1 Situation of Ethics

In any situation where different people have different views and objectives, you
are likely to be faced with ethical dilemmas. For example, if you disagree, in principle,
with the policies of more senior management in the company, how should you react?
Clearly, this depends on the people involved and the nature of the disagreement. Is it best
to argue a case for your position from within the organization or to resign in principle?

The ACM/ IEEE Code of Ethics

Figure 1.6 The ACM/ IEEE Code of Ethics (ACM/IEEE-CS Joint Task Force on Software
Engineering Ethics and Professional Practices, short version. http:// www.acm.org/about/se-code)
(© 1999 by the ACM, Inc. and the IEEE, Inc.)

For example,
• If you feel that there are problems with a software project, when do you reveal
these problems to management?
• If you discuss these while they are just a suspicion, you may be overreacting to a
situation; if you leave it too long, it may be impossible to resolve the difficulties.

- 16 -
A difficult situation for professional engineers arises when their employer acts in an
unethical way. Say a company is responsible for developing a safety-critical system and,
because of time pressure, falsifies the safety validation records. Is the engineer’s
responsibility to maintain confidentiality or to alert the customer or publicize, in some
way, that the delivered system may be unsafe?

• The appropriate ethical position here depends on the views of the people
involved. The potential for damage, the extent of the damage, and the people
affected by the damage should influence the decision.

************************************************************************

Exercises

(1) What is the principal aim of the software engineering discipline? What does
the discipline of software engineering discuss?
(2) Distinguish between a program and a professionally developed software.
(3) Software has one fundamental characteristic that makes it considerably
different from hardware: Software doesn’t “wear out.” Explain why?
(4) What Characteristics of a software can be easily distinguished as of from the
hardware?
(5) What are the Essential Characteristics of a Professional Software Quality?
(6) Who develop the software system?
(7) What are the good software engineer skills?
(8) What are the fundamental activities that are common to all software
processes?
(9) Distinguish among a software process, a software project and a software
product.
(10) In Software Engineering Code of Ethics, what are the software engineer’s
professional responsibilities?

********************* End of lecture 1 **************************

The more that you read, the more things you will know.
The more that you learn, the more places you will go.
Dr. Sesus

- 17 -