CS-6209 Software Engineering 1

1
Week 1: The Scope of Software Engineering

Module 001: The Scope of Software Engineering

Course Learning Outcomes:

1. Understand what software engineering is and why it is important;
2. Understand that the development of different types of software Systems
may require different software engineering techniques;
3. Understand some ethical and professional issues that are important for
software engineers;
4. Understand the scope of Software Engineering

Introduction
The term software engineering is composed 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 a 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. So, we can
define software engineering as an engineering branch associated with the development of
software product using well-defined scientific principles, methods and procedures.

The outcome of software engineering is an efficient and reliable software product. IEEE
defines software engineering as: The application of a systematic, disciplined, quantifiable
approach to the development, operation and maintenance of software. We can alternatively
view it as a systematic collection of past experience. The experience is arranged in the form
of methodologies and guidelines. A small program can be written without using software
engineering principles. But if one wants to develop a large software product, then software
engineering principles are absolutely necessary to achieve a good quality software cost
effectively. 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. Once the simpler problem is solved, then the omitted details
can be taken into consideration to solve the next lower level abstraction, and so on.
Course Module
 CS-6209 Software Engineering 1
2
Week 1: The Scope of Software Engineering

Abstraction is a powerful way of reducing the complexity of the problem. The other
approach to tackle problem complexity is DEPT OF CSE & IT VSSUT, Burla decomposition.
In this technique, a complex problem is divided into several smaller problems and then the
smaller problems are solved one by one. However, in this technique any random
decomposition of a problem into smaller parts will not help. 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.

A good decomposition of a problem should minimize interactions among various

components. If the different sub components are interrelated, then the different
components cannot be solved separately and the desired reduction in complexity will not
be realized.

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.

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

This tells us how well software works in operations. It can be measured on:
 CS-6209 Software Engineering 1
3
Week 1: The Scope of Software Engineering

 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 software has the capabilities to maintain itself in
the ever-changing environment:

 Modularity
 Maintainability
 Flexibility
 Scalability

In short, Software engineering is a branch of computer science, which uses well-

defined engineering concepts required to produce efficient, durable, scalable, in-
budget and on-time software products

Software engineering diversity

Software engineering is a systematic approach to the production of software
that takes into account practical cost, schedule, and dependability issues, as
well as the needs of software customers and producers. How this systematic
approach is actually implemented varies dramatically depending on the
organization developing the software, the type of software, and the people
involved in the development process. There are no universal software
engineering methods and techniques that are suit-able for all systems and all
companies. Rather, a diverse set of software engineering methods and tools
has evolved over the past 50 years.

Perhaps the most significant factor in determining which software engineering

methods and techniques are most important is the type of application that is
being developed. There are many different types of application including:

Course Module
CS-6209 Software Engineering 1
4
Week 1: The Scope of Software Engineering

1. Stand-alone applications. These are application systems that run on a

local computer, such as a PC. They include all necessary functionality
and do not need to be connected to a network. Examples of such
applications are office applications on a PC, CAD programs, photo
manipulation software, etc.

2. Interactive transaction-based applications. These are applications that

execute on a remote computer and that are accessed by users from their
own PCs or terminals. Obviously, these include web applications such as
e-commerce applications where you can interact with a remote system
to buy goods and services. This class of application also includes
business systems, where a business provides access to its systems
through a web browser or special-purpose client program and cloud-
based services, such as mail and photo sharing. Interactive applications
often incorporate a large data store that is accessed and updated in each
transaction.

3. Embedded control systems. These are software control systems that

control and manage hardware devices. Numerically, there are probably
more embedded systems than any other type of system. Examples of
embedded systems include the software in a mobile (cell) phone,
software that controls anti-lock braking in a car, and software in a
microwave oven to control the cooking process.

4. Batch processing systems. These are business systems that are designed
to process data in large batches. They process large numbers of
individual inputs to create corresponding outputs. Examples of batch
systems include periodic billing systems, such as phone billing systems,
and salary payment systems.

5. Entertainment system. These are systems that are primarily for personal
use and which are intended to entertain the user. Most of these systems
are games of one kind or another. The quality of the user interaction
offered is the most important distinguishing characteristic of
entertainment systems.

6. Systems for modeling and simulation. These are systems that are
developed by scientists and engineers to model physical processes or
situations, which include many, separate, interacting objects. These are
often computationally intensive and require high-performance parallel
systems for execution.

7. Data collection systems. These are systems that collect data from their
environment using a set of sensors and send that data to other systems
for processing. The software has to interact with sensors and often is
installed in a hostile environment such as inside an engine or in a
remote location.
 CS-6209 Software Engineering 1
5
Week 1: The Scope of Software Engineering

8. Systems of systems. These are systems that are composed of a number of

other software systems. Some of these may be generic software
products, such as a spreadsheet program. Other systems in the assembly
may be specially written for that environment.

Of course, the boundaries between these system types are blurred. If you
develop a game for a mobile (cell) phone, you have to take into account the
same constraints (power, hardware interaction) as the developers of the phone
software. Batch processing systems are often used in conjunction with web-
based systems. For example, in a company, travel expense claims may be
submitted through a web application but processed in a batch application for
monthly payment.
You use different software engineering techniques for each type of system
because the software has quite different characteristics. For example, an
embedded control system in an automobile is safety-critical and is burned into
ROM when installed in the vehicle. It is therefore very expensive to change.
Such a system needs very 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 a web-based system, an approach based on iterative development and

delivery may be appropriate, 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.

Nevertheless, there are software engineering fundamentals that apply to all

types of software system:

1. They should be developed using a managed and understood

development process. The organization developing the software should
plan the development process and have clear ideas of what will be
produced and when it will be completed. Of course, different processes
are used for different types of software.

2. Dependability and performance are important for all types of systems.

Software should behave as expected, without failures and should be
available for use when it is required. It should be safe in its operation
and, as far as possible, should be secure against external attack. The
system should perform efficiently and should not waste resources.

Course Module
 CS-6209 Software Engineering 1
6
Week 1: The Scope of Software Engineering

3. Understanding and managing the software specification and

requirements (what the software should do) are important. You have to
know what different customers and users of the system expect from it
and you have to manage their expectations so that a useful system can
be delivered within budget and to schedule.

4. You should make as effective use as possible of existing resources. This

means that, where appropriate, you should reuse software that has
already been developed rather than write new software.

These fundamental notions of process, dependability, requirements,

management, and reuse are important themes of this book. Different
methods reflect them in different ways but they underlie all professional
software development.

You should notice that these fundamentals do not cover implementation

and programming. I don’t cover specific programming techniques in this
book because these vary dramatically from one type of system to another.
For example, a scripting language such as Ruby is used for web-based
system programming but would be completely inappropriate for embedded
systems engineering.

Software engineering ethics

Like other engineering disciplines, 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 accept that your job involves wider
responsibilities than simply the application of technical skills. You must also
behave in an ethical and morally responsible way if you are to be respected as
a professional engineer.

It goes without saying that you 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. However, there are areas where standards of acceptable behavior
are not bound by laws but by the more tenuous notion of professional
responsibility. Some of these are:

1. Confidentiality. You should normally respect the confidentiality of your

employers or clients irrespective of whether or not a formal
confidentiality agreement has been signed.
 CS-6209 Software Engineering 1
7
Week 1: The Scope of Software Engineering

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, say) to extremely
serious (dissemination of viruses or other malware).

Software Engineering Code of Ethics and Professional Practice

ACM/IEEE-CS Joint Task Force on Software Engineering Ethics and Professional
Practices

PREAMBLE

The short version of the code summarizes aspirations at a high level of the
abstraction; the clauses that are included in the full version give examples
and details of how these aspirations change the way we act as software
engineering professionals. Without the aspirations, the details can become
legalistic and tedious; without the details, the aspirations can become high
sounding but empty; together, the aspirations and the details form a
cohesive code.

Software engineers shall commit themselves to making the analysis,

specification, design, development, testing and maintenance of software a
beneficial and respected profession. In accordance with their commitment
to the health, safety and welfare of the public, software engineers shall
adhere to the following Eight Principles:

PUBLIC — Software engineers shall act consistently with the public interest.

CLIENT AND EMPLOYER — Software engineers shall act in a manner that is in

the best interests of their client and employer consistent with the public
interest.

PRODUCT — Software engineers shall ensure that their products and

related modifications meet the highest professional standards possible.
Course Module
CS-6209 Software Engineering 1
8
Week 1: The Scope of Software Engineering

JUDGMENT — Software engineers shall maintain integrity and independence

in their professional judgment.

MANAGEMENT — Software engineering managers and leaders shall

subscribe to and promote an ethical approach to the management of
software development and maintenance.

PROFESSION — Software engineers shall advance the integrity and

reputation of the profession consistent with the public interest.

COLLEAGUES — Software engineers shall be fair to and supportive of

their colleagues.

SELF — Software engineers shall participate in lifelong learning regarding

the practice of their profession and shall promote an ethical approach to the
practice of the profession.

Professional societies and institutions have an important role to play in setting

ethical standards. Organizations such as the ACM, the IEEE (Institute of Electrical
and Electronic Engineers), and the British Computer Society publish a code of
professional conduct or code of ethics. Members of these organizations
undertake to follow that code when they sign up for membership. These codes of
conduct are generally concerned with fundamental ethical behavior.

Professional associations, notably the ACM and the IEEE, have cooperated to
produce a joint code of ethics and professional practice. This code exists in both a
short form, shown in Figure 1.3, and a longer form (Gotterbarn et al., 1999) that
adds detail and substance to the shorter version. The rationale behind this code
is summarized in the first two paragraphs of the longer form:

Computers have a central and growing role in commerce, industry, government,

medicine, education, entertainment and society at large. 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. 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.
 CS-6209 Software Engineering 1
9
Week 1: The Scope of Software Engineering

The Code contains eight Principles related to the behaviour of and decisions made
by professional software engineers, including practitioners, educators, managers,
supervisors and policy makers, as well as trainees and students of the profession.
The Principles identify the ethically responsible relationships in which individuals,
groups, and organizations participate and the primary obligations within these
relationships. The Clauses of each Principle are illustrations of some of the
obligations included in these relationships. These obligations are founded in the
software engineer’s humanity, in special care owed to people affected by the work
of software engineers, and the unique elements of the practice of software
engineering. The Code prescribes these as obligations of anyone claiming to be or
aspiring to be a software engineer.

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 particular individuals and the
nature of the dis-agreement. Is it best to argue a case for your position from
within the organization or to resign in principle? If you feel that there are
problems with a software project, when do you reveal these to management? If
you discuss these while they are just a suspicion, you may be overreacting to a
situation; if you leave it too late, it may be impossible to resolve the difficulties.

Such ethical dilemmas face all of us in our professional lives and, fortunately, in
most cases they are either relatively minor or can be resolved without too much
difficulty. Where they cannot be resolved, the engineer is faced with, perhaps,
another problem. The principled action may be to resign from their job but this
may well affect others such as their partner or their children.

A particularly 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 problem here is that there are no absolutes when it comes to safety.
Although the system may not have been validated according to predefined
criteria, these criteria may be too strict. The system may actually operate safely
throughout its lifetime. It is also the case that, even when properly validated, the
system may fail and cause an accident. Early disclosure of problems may result in
damage to the employer and other employees; failure to disclose problems may
result in damage to others.

Course Module
CS-6209 Software Engineering 1
10
Week 1: The Scope of Software Engineering

You must make up your own mind in these matters. The appropriate ethical
position here depends entirely on the views of the individuals who are involved.
In this case, the potential for damage, the extent of the damage, and the people
affected by the damage should influence the decision. If the situation is very
dangerous, it may be justified to publicize it using the national press (say).
However, you should always try to resolve the situation while respecting the
rights of your employer.

Another ethical issue is participation in the development of military and nuclear

systems. Some people feel strongly about these issues and do not wish to
participate in any systems development associated with military systems. Others
will work on military systems but not on weapons systems. Yet others feel that
national security is an overriding principle and have no ethical objections to
working on weapons systems.

In this situation, it is important that both employers and employees should make
their views known to each other in advance. Where an organization is involved in
military or nuclear work, they should be able to specify that employees must be
willing to accept any work assignment. Equally, if an employee is taken on and
makes clear that they do not wish to work on such systems, employers should
not put pressure on them to do so at some later date.

The general area of ethics and professional responsibility is becoming more

important as software-intensive systems pervade every aspect of work and
everyday life. It can be considered from a philosophical standpoint where the
basic principles of ethics are considered and software engineering ethics are
discussed with reference to these basic principles. This is the approach taken by
Laudon (1995) and to a lesser extent by Huff and Martin (1995). Johnson’s text
on computer ethics (2001) also approaches the topic from a philosophical
perspective.

However, I find that this philosophical approach is too abstract and difficult to
relate to everyday experience. I prefer the more concrete approach embodied in
codes of conduct and practice. I think that ethics are best discussed in a software
engineering context and not as a subject in their own right. In this book,
therefore, I do not include abstract ethical discussions but, where appropriate,
include examples in the exercises that can be the starting point for a group
discussion on ethical issues.
 CS-6209 Software Engineering 1
11
Week 1: The Scope of Software Engineering

References and Supplementary Materials

Books and Journals
1. SOFTWARE ENGINEERING, 9th Edition; Ian Sommerville

Online Supplementary Reading Materials

1. Fundamentals of Software Engineering;
https://www.academia.edu/2586877/Lecture_01_Fundamentals_of_Software_Engine
ering; October 14, 2019

2. Introduction to Software Engineering;

https://en.wikibooks.org/wiki/Introduction_to_Software_Engineering; October 14,
2019

Online Instructional Videos

Course Module