Software

Engineerin
g
Chapter 1

Introduction to Software Engineering

2024/2025
 Table of content
01 02 03
Introductio History, Principles of
n definitions and Software
objectives Engineering

04 06
Software Software life
Quality cycle
Criteria
Introduction
What is a software?
Software consists of a series of
instructions (programs) and data
(such as files, images, and databases)
that a computer automatically
executes to complete a specific task.

Software everywhere!!
 Introduction
 Our life depends very heavily on the quality of the software that manages it.

 Most issues related to computers are fundamentally software-related problems.

What are the consequences of having poorly made software?

Poorly made software can lead to various issues, including system crashes, data
loss, security vulnerabilities, and user frustration, ultimately affecting productivity
and trust in the technology.
 Examples: 01

The Mariner-1 bug on July 22, 1962: A space rocket

(Cost: 18.5 million dollars to explore the planet Venus)
went off trajectory because of a mathematical formula
that was incorrectly transcribed into source code. The
range safety officer ordered its destruction 294
seconds after its launch.
 Examples: 02

1985/1987: Therac-25 issue, overdose in radiation

therapy "therapeutic irradiation device"
At least 5 deaths due to massive radiation doses
Cause: Design flaws in the hardware and software
 Examples: 03

1991, during the Gulf War: An American missile kills 22

American soldiers instead of intercepting an enemy
missile. Cause: a rounding function error.
 Examples: 04

In 1996, the Ariane 5 rocket exploded during its maiden

flight due to an overflow error when converting a 64-bit
floating-point number to a 16-bit integer. The cost of
this failure was $500 million, making it the most
expensive software bug in history.
 Software developement
Development involves turning an idea or need into functional software. This idea originates from a
customer (user) and is developed by a supplier.
Software
developement
Software development is marked by several challenges:

 Customers often struggle to articulate their needs clearly for suppliers.

 Requirements frequently evolve, along with the surrounding
environment.
 Software is intangible, making it harder to evaluate.
 There is often a communication gap between technical and non-technical
people.
 Identifying errors before the product is delivered can be difficult.
 Software piracy poses significant risks and losses for supplier
Software developement
According to a study on 8,380 projects by the Standish Group in 1995:
Software developement
To succeed a project :
 Software Engineering: history
The term "Software Engineering" was first introduced at a conference in Germany in 1968 to
address the software crisis.

Software construction was very costly

(average overruns of 70%). The software
crisis refers to
Delivery deadlines were often not met the period when
(average overruns of 50%). the costs,
software timelines, and
crisis quality of
Software did not meet user needs.
software projects
were often
Software was difficult to use, maintain, unsatisfactory.
or evolve (40% - 70% of software costs).
 Software Engineering: definitions

 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 engineering is the art of producing good software. It is based on methodologies,
techniques and tools that make it possible to produce large-scale software, that is to say,
requiring significant human resources and whose development is relatively long while
satisfying the customer and the supplier:
 Within reasonable deadlines and with acceptable costs
 Quality
 Software Engineering: definitions
The SE focuses on software manufacturing processes to ensure that the following four
criteria are met:

Cost (C): Costs remain within the initially planned limits.

Quality (Q): Quality corresponds to the initial service contract.
Functionality (F): The developed system meets user needs.
Deadline (D): Timelines stay within the initially set limits.
 Principles of Software Engineering
Six principles have been determined which form a reasonably independent and
complete set. These are:
 Generalization : grouping of a set of similar functionalities into a configurable
functionality (genericity, inheritance)
 Structuring : how to decompose software (use of a bottom-up or top-down method)
 Abstraction : mechanism which allows us to present a context by expressing the
relevant elements and omitting those which are not
 Modularity : decomposition of software into discrete components
 Documentation : management of documents including their identification,
acquisition, production, storage and distribution
 Verification : determination of compliance with specifications established on the
basis of needs identified in the previous phase of the life cycle
 Software Quality Criteria
Software quality criteria are essential for assessing the effectiveness and reliability of a
software product. Here are some key criteria:
 Software Quality Criteria
 Functionality: The software must perform its intended functions correctly and meet
user requirements.
 Reliability: The system should consistently perform without failure under specified
conditions for a given period.
 Usability: The software should be user-friendly, intuitive, and easy to learn, ensuring
a positive user experience.
 Efficiency: The software should make optimal use of system resources, including
memory and processing power, while providing quick response times.
 Maintainability: The code should be well-structured and documented, making it easy
to update and fix bugs.
 Portability: The software should be able to operate on different platforms or
environments with minimal changes
 Software Life Cycle
 The software life cycle refers to all stages of software development, from the
definition of needs to its disappearance.

 The life cycle enables early error detection, allowing for better control over software
quality, production timelines, and associated costs.
 Software Life Cycle
All development projects have common activities: Analysis

Design

Implementation

Testing

Deployment

Maintenance
 Software Life Cycle
 Analysis: Gather and analyze user requirements to understand what the software needs to
accomplish.
 Design: Enrich the software description with implementation details to achieve a description very
close to that of a program (describing the "how").
- Architectural design aims to decompose the software into simpler components defined by
their interfaces and functions (the services they provide).
- Detailed design provides a description for each component regarding how functions or
services are implemented: algorithms and data representation.
 Implementation:
- Choice of the development environment, programming language(s), and development
standards...,
- Write and compile the code based on the design specifications.
 Software Life Cycle
 Testing: Conduct various tests to identify and fix bugs or issues. This includes unit testing,
integration testing, and user acceptance testing.

- Unit tests : These allow you to individually verify that each subset of the software is
implemented according to specifications.
- Integration tests : The objective is to ensure the interfacing of the different elements
(modules) of the software.
- User acceptance tests: verification of the conformity of the software to initial specifications
(Validation by the buyer).

 Deployment: Release the software to users, which may involve installation, configuration, and
training.

 Maintenance: Address any issues that arise after deployment, implement updates, and add new
features as needed. This phase can continue for the software's entire lifecycle.
To limit maintenance time and costs, efforts must be focused on the earlier stages.
Software Life Cycle
Document Activity
Final user manual Implementation
Architectural design document Design
Source code Implementation
Specification document Requirements analysis
Preliminary user manual Requirements analysis
Detailed design document Design
Test report Testing
Implementation documentation Functional specification
Specification
 Software Life Cycle Models
The cascade model (waterfall)

One of the first models offered (1970) inspired by the construction industry (no turning back).
each phase ends on a specific date with the production of certain documents or software.
A phase can only start if the previous one has finished. The results are subject to an in-depth
review and we only move on to the next phase if they are deemed satisfactory
There's no going back (or little).
Suitable for small projects, where the domain is well mastered (stable needs, new versions
of a project, etc.).
Note : The testing phase comes late (discovering errors, or changing specifications
requires redoing all the work)
 Software Life Cycle Models
The V model:

the best known and certainly the most used.

Testing and software development are carried out synchronously (Product testing is done
in parallel with other activities).
Each deliverable (of each step) must be testable (any description of a component is
accompanied by tests which will ensure that it corresponds to its description).
To use:
When the product to be developed has very high quality requirements.
When needs are known in advance.
 Software Life Cycle Models
The incremental model:

Design and deliver to the customer a minimal and functional sub-assembly of the system
We start by developing the most stable, most important parts…
Proceed by adding minimal increments until the end of the development process
Benefits:
better integration of the client in the development process.
Product meets expectations.
 Software Life Cycle Models
The spiral model (iterative):
Development takes up the different stages of the V (evolutionary) cycle. By implementing
successive versions, the cycle begins again by offering an increasingly complete and robust
product.
The spiral cycle, however, places more emphasis on risk management.
The start of each iteration includes a risk analysis phase . This is made necessary by the
fact that, during cyclical development, there is a greater risk of undoing
Requires a lot of experience.