SOFTWARE ENGINEERING

LECTURE 3

Ghulam Farooque
Lecturer
Department: CS & IT
The University of Lahore
Email: ghulam.farooque@cs.uol.edu.pk
 Software Engineering
Software Engineering is the set of processes and tools to develop
software. Software Engineering is the combination of all the tools,
techniques, and processes that used in software production. Therefore
Software Engineering encompasses all those things that are used in
software development like:
• Programming Language
• Programming Language Design
• Software Design Techniques
• Tools
• Testing
• Maintenance
• Development etc.
 Well-Engineering Software

Well-engineered software is one that has the following characteristics

• Provides the required functionality

• Maintainable
• Reliable
• Efficient
• User-friendly
• Cost-effective
 Reasons For Software Failure
Increasing demands
• Systems have to be built and delivered more quickly; larger, even more complex
systems are required
• systems have to have new capabilities that were previously thought to be
impossible.
• Existing software engineering methods cannot cope and new software engineering
techniques have to be developed
Lack of SE techniques
• It is relatively easy to write computer programs without using software engineering
methods and techniques
• 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.
 Professional and ethical responsibility

• Software engineering involves wider responsibilities than simply the

application of technical skills

• Software engineers must behave in an honest and ethically

responsible way if they are to be respected as professionals

• Ethical behaviour is more than simply upholding the law.

 Issues of professional responsibility
• Confidentiality
Engineers should normally respect the confidentiality of their
employers or clients irrespective of whether or not a formal
confidentiality agreement has been signed.

• Competence
Engineers should not misrepresent their level of competence.
They should not knowingly accept work which is out with their
competence.
 Issues of professional responsibility
Intellectual property rights
Engineers should be aware of local laws governing the use of
intellectual property such as patents, copyright, etc. They should be
careful to ensure that the intellectual property of employers and
clients is protected.

Computer misuse
Software engineers should not use their 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 (spread of viruses).
 ACM/IEEE Code of Ethics
• The professional societies in the US have cooperated to produce a
code of ethical practice.

• Members of these organisations sign up to the code of practice

when they join.

• The Code contains eight Principles related to the behaviour and

decisions made by professional software engineers, including
practitioners, educators, managers, supervisors and policy makers,
as well as trainees and students of the profession.
 Code of ethics - principles
1. PUBLIC
Software engineers shall act consistently with the public interest.

2. 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.

3. PRODUCT
Software engineers shall ensure that their products and related
modifications meet the highest professional standards possible.
 Code of ethics - principles
4. JUDGMENT
Software engineers shall maintain integrity and independence in
their professional judgment.

5. MANAGEMENT
Software engineering managers and leaders shall subscribe to
and promote an ethical approach to the management of software
development and maintenance.

6. PROFESSION
Software engineers shall advance the integrity and reputation of
the profession consistent with the public interest.
 Code of ethics - principles
7. COLLEAGUES
Software engineers shall be fair to and supportive of their colleagues.

8. 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.
 Software Development
Construction
Some of the major construction activities are listed below.
• Requirement Gathering
• Design Development
• Coding
• Testing
Management
Some of the major management activities are listed below.
• Project Planning and Management
• Configuration Management
• Software Quality Assurance
• Installation and Training
 Software Development Loop

• Software development activities could be performed in a cycle called software development

loop which is shown in Figure below:

• The software developed through this process has the property that this could be evolved
and integrated easily with the existing systems.
 Software Development Loop
Problem Definition: In this stage, Determine what is the problem against which we
are going to develop software. Here we try to completely comprehend the issues
and requirements of the software system to build.
Technical Development: This is the stage where a new system is actually developed
that solves the problem defined in the first stage.
Solution Integration: All existing system(s) integrate with our new system at this
stage.

Status Quo: After going through the previous three stages successfully, when we
actually deployed the new system at the user site then that situation is called status
quo. But once we get new requirements then we need to change the status quo.

After getting new requirements we perform all the steps in the software
development loop again.
 Ad hoc Software Development

• Developing software without planning for each phase, and

without specifying tasks, deliverables, or time constraints.
• Relies entirely on the skills and experience of the individuals
performing the work.
• The software process may change as work progresses.
 Case Study : SaudiTech
What could go wrong in a software development project?
SaudiTech is a software company. It has a team of 25 programmers. Ali has recently
established a dental clinic in Riyadh and asked SaudiTech to develop a management
system for his dental clinic.

Ali’s request was to develop a system to electronically manage patient records and
perform administrative functions similar to ‘what is being used in other clinics’ but within
a budget of 500 Saudi riyals and delivered within 3 months.

SaudiTech adopts an ad hoc approach (Developing software without planning for each
phase, and without specifying tasks, deliverables, or time constraints) to software
development and has not worked on large scale projects before.
What problems do you anticipate in this project?
 How can we overcome problems with ad hoc software
development?
Problems:
Difficult to distinguish between tasks  important tasks may be ignored.
Inconsistent schedules, budgets, functionality and product quality.
Delayed problem discovery  more costly to fix.

Solution? Software Process Model

SoftwareProcess Models provide guidelines to organize how software process activities

should be performed and in what order.
 Software Process
A process is a collection of activities, actions and tasks that are
performed when some work product is to be created.

It is not a rigid prescription for how to build computer software. Rather,

it is an adaptable approach that enables the people doing the work to
pick and choose the appropriate set of work actions and tasks.

Purpose of process is 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.
 Software Process…
Generic activities in all software processes are:

Specification - what the system should do and its development

constraints.

Development (Design and Implementation) - production of the software

system

Validation - checking that the software is what the customer wants.

Evolution - changing the software in response to changing demands.

 Plan-driven and Agile Processes
Plan-driven processes are processes where all of the process activities are planned
in advance and progress is measured against this plan.

Agile processes, planning is incremental and it is easier to change the process to

reflect changing customer requirements.

In practice, most practical processes include elements of both plan-driven and agile.

 There are no right or wrong software processes.

 Plan-driven and Agile Processes
Plan-driven Methods Agile Methods

Identifies separate stages in the

Focus on Central Activity and incorporate other
software process with outputs associated with each
activities
stage

High criticality Low criticality

Junior developers Senior developers

Requirements do not change often Requirements change often

Large number of developers Small number of developers

Culture that demands order Culture that responds to change

 Class Activity (Individual)

Suggest and justify that which software development (plan-driven or agile)

will best suit for the following software projects.

1) A business application for a multinational company

2) A high critical security system for a military organization
 Software Process / SDLC Models
Abstract representation of a software process

Each Process model represents a process from different perspective

There are a number of Software Development Lifecycle (SDLC)

Models, each having its strengths and weaknesses and suitable in
different situations and project types.
 Following are the most important and popular SDLC models followed in the industry:
 Waterfall model.
 V Model
 Evolutionary development.
 Component-Based development model (CBSE).
 Process iteration(incremental and spiral Models)
 Rapid Application Development (RAD)
 Waterfall Model
• First published model

• Because of the cascade from one phase to another, this model is known as
‘Waterfall Model’.

• It is also referred to as linear-sequential life cycle model.

• Each phase must be completed before the next phase can begin and there is
no overlapping in the phases.
 Waterfall Model
The sequential phases in Waterfall model are:

Requirement Gathering and analysis: All possible requirements of the system to be

developed are captured in this phase and documented in a requirement specification
document.
• System’s services
• Constraints
• Goals

System Design: The requirement specifications from first phase are studied in this phase
and system design is prepared. System Design helps in specifying hardware and system
requirements and also helps in defining overall system architecture.
 Waterfall Model

Implementation and unit testing: With inputs from system design, the
system is first developed in small programs called units, which are
integrated in the next phase. Each unit is developed and tested for its
functionality which is referred to as Unit Testing.

Integration and Testing: All the units developed in the implementation

phase are integrated into a system after testing of each unit. Post
integration the entire system is tested for any faults and failures.
 Waterfall Model

Deployment of system: Once the functional and non functional testing is

done, the product is deployed in the customer environment or released
into the market.

Maintenance: There are some issues which come up in the client

environment. To fix those issues patches are released. Also to enhance
the product some better versions are released. Maintenance is done to
deliver these changes in the customer environment.
Waterfall Model
 Waterfall Model
Applicability:

• Requirements are very well understood, clear and fixed

• Product definition is stable

• Technology is understood
 Waterfall Model
Advantages:
• Documentation - at each phase
• Phases are processed and completed one at a time.
• Easy to arrange tasks.

Problems:
• Inflexible
partitioning of the project into distinct stages makes it difficult to respond to
changing customer requirements.
• Provides no Guidance how to handle changes (Frozen Requirements)
• Views software development as manufacturing process rather than creative process
• Long wait before the final product