Introduction to Software Engineering

CHAPTER 1
WEEK 1
 Every organization nowadays needs software to work
properly
Examples:

Banks need software to handle your money

Hospitals use software to keep patient records
Schools use software to manage grades

Software Engineering Government offices use software to provide services to

citizens

•Software powers virtually everything.

• Organizations of all types and sizes, including businesses and governmental entities, depend on
software systems to deliver their services effectively.
•Software is also embedded in physical products, including cars, airplanes, satellites, and robots.
Furthermore, software is transforming traditional industries such as telecommunications,
transportation in large urban centers, and advertising.
•Software Engineering focuses on systematic, disciplined, and quantifiable approaches
to developing, operating, maintaining, and evolving software systems.
 Key Idea 1: "Engineering discipline"
"Engineers make things work."
Engineers don t always have perfect solutions, so they use what is available wisely. If existing methods don t work, they try
to find new ways to solve problems.
Engineers works under the required constraints contraints maybe budgets (money) and organizational rules.

Introduction
Software engineering is an engineering discipline that is concerned with all aspects of software
production from the early stages of system specification through to maintaining the system after
it has gone into use. In this definition, there are two key phrases:
1. Engineering discipline Engineers make things work. They apply theories, methods, and tools
where these are appropriate. However, they use them selectively and always try to discover
solutions to problems even when there are no applicable theories and methods. Engineers also
recognize that they must work to organizational and financial constraints so they look for
solutions within these constraints.
2. All aspects of software production Software engineering is not just concerned with the
technical processes of software development. It also includes activities such as software project
management and the development of tools, methods, and theories to support software
production.
 A software process is the Step-by-Step Approach
that leads to the production of a software product.

Cont’d
The systematic approach that is used in software engineering is sometimes called a software
process. A software process is a sequence of activities that leads to the production of a software
product. There are four fundamental activities that are common to all software processes. These
activities are:
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.
Characteristics of Software Engineering
Software is defined as a collection of
computer programs, procedures, rules, and
data. Software Characteristics are classified
into six major components. Software
engineering is the process of designing,
developing, testing, and maintaining software.
Characteristics of Software Engineering : Functionality
It refers to the degree of performance of the The more functionality a software has, the more
software against its intended purpose. powerful and versatile it is, but also the more
complex it can be. It is important to balance the
Functionality refers to the set of features and need for functionality with the need for ease of
capabilities that a software program or system use, maintainability, and scalability.
provides to its users. It is one of the most
important characteristics of software, as it
determines the usefulness of the software for
the intended purpose. Examples of functionality
in software include:
Data storage and retrieval
Data processing and manipulation
User interface and navigation
Communication and networking
Security and access control
Characteristics of Software Engineering : Reliability
Reliability is a characteristic of software that To improve the reliability of software, various
refers to its ability to perform its intended techniques, and methodologies can be used,
functions correctly and consistently over time. such as testing and validation, formal
Reliability is an important aspect of software verification, and fault tolerance.
quality, as it helps ensure that the software will
work correctly and not fail unexpectedly.
Examples of factors that can affect the reliability
of software include:
•Bugs and errors in the code
•Lack of testing and validation
•Poorly designed algorithms and data structures
•Inadequate error handling and recovery
•Incompatibilities with other software or
hardware
 Characteristics of Software Engineering : Efficiency
It refers to the ability of the software to use To improve the efficiency of software, various
system resources in the most effective and techniques, and methodologies can be used,
efficient manner. The software should make such as performance analysis, optimization, and
effective use of storage space and executive profiling
command as per desired timing requirements.
Examples of factors that can affect the efficiency
of the software include:
1. Poorly designed algorithms and data
structures
2. Inefficient use of memory and processing
power
3. High network latency or bandwidth usage
4. Unnecessary processing or computation
5. Unoptimized code
Characteristics of Software Engineering : Usability
It refers to the extent to which the software can be used with ease. the amount of effort or time
required to learn how to use the software.
How easy software
is to use
Characteristics of Software Engineering : Portability
A set of attributes that bears on the ability of software to be transferred from one environment
to another, without minimum changes.
Portability in software means how easy it is to
move a software program from one place to
another. For example, if you create a
program on one computer, portability is the
ability of that program to also work on
another computer or system without needing
many changes.
Characteristics of the Software

It is intangible, meaning it cannot be seen or touched.

It is non-perishable, meaning it does not degrade over time.
It is easy to replicate, meaning it can be copied and distributed easily.
It can be complex, meaning it can have many interrelated parts and features.
It can be difficult to understand and modify, especially for large and complex systems.
It can be affected by changing requirements, meaning it may need to be updated or modified as
the needs of users change.
It can be impacted by bugs and other issues, meaning it may need to be tested and debugged to
ensure it works as intended.
Making use of abstractions involves
Hiding complicated details Benefits of Abstraction:
Showing only what's necessary Simpler Development
Making complex things simple to use Better Code Quality
So Non technical person use software withour knowing the complex part of Faster Development
software

Basic software design principles

Abstraction
Making use of abstractions involves hiding the coding complexities and redundant details behind
high-level abstractions and not getting into them till the pont when you absolutely need to do
that.
Because of abstraction-based design concepts it is possible for to reduce the amount of
irrelevant data, accelerate your development process, and in general, improve the quality of
your programming outcomes.

Refinement
Another one of the principles of software design is refinement, which involves eliminating
structural impurities by moving from higher levels of software design (abstractions) to lower
levels in a sequential manner.
The idea is that refinement is an incremental process in which a team of software engineers will
drill down to get more technical details at every increment. In this way, software design is
consistently improved and expanded without wasting time on irrelevant or periphary issues.

Modularity
Modularity refers to the division of software into separate modules, each of which are named and
addressed differently and then get integrated later to get a completely functional software. This is
the only property that makes it possible for a program to be intellectually manageable. Single large
programs tend to be rather hard to understand and read because of the huge quantity of reference
variables, control paths, global variables, etc.
Summary
Modularity makes it easier to understand, manage, and build software by
breaking it into smaller, separate pieces that can be worked on individually
and then combined to create a fully functional program
PROBLEM PARTIONING
If the problem is small, you can tackle the entire problem at one time. But for a larger
problem, you should follow the divide and conquer approach. Slice the problem into
smaller pieces that can be handled easily on their own.
These pieces can’t be completely independent of each other due to the fact that they
need to come together to form the system. They need to communicate and co-operate
with each other in order to solve the problem.
The advantages of problem partitioning are that the software becomes easier to test,
modify, maintain, and expand.
Summary
Problem partitioning means breaking a big problem
into smaller parts to make it easier to solve. These
parts are connected and must work together, making
the final solution easier to test, improve, and maintain
 To protect data, security practices should be used in every part
of software development, from start to finish.
Data Protection focuses on keeping data secure throughout
Data Protection software development.

It is critical for data to be protected from unauthorized access. For that reason, secure software
development life-cycle principles need to be applied and propagated throughout the entire software
structure
Refactoring
Refactoring is all about bringing improvements to internal software structure without having any effect on
its behavior or functions. Refactoring is an integral part of the perpetual software maintenance process
and it involves frequently reviewing and improving the code to make it lighter and more powerful.
KISS (keep it simple stupid!)
While this principle isn’t limited to software design, it is still very important in this field. You should avoid
complexity and write code that is easy to implement and maintain
Summary:
Data Protection focuses on keeping data secure throughout software development.
Refactoring improves code quality without changing how the software works.
KISS encourages simplicity, making code easier to understand and manage.
Software development principles
1. Agile
Agile software development is a group of principles based on iterative development, where teams
collaborate to deliver value in shorter timescales, ensuring flexibility and responsiveness to change.
The Agile methodology splits complex projects into several phases, enabling teams to deliver in
manageable increments and continuously improve. Planning, executing, and evaluating each project
stage follows a defined process.

2. Architecture-First Approach
Successful software programs typically have solid architectural foundations. The architecture-first
approach underscores the importance of designing a robust architecture in the early stages of
development. By tackling architectural complexities quickly, developers can reduce uncertainties,
improve decision-making, and optimize project productivity. Addressing complex architectural issues early helps developers:
Reduce uncertainties (fewer unknowns later).
Make better decisions (with a clear structure).
Boost productivity (smoother project flow).
3. SOLID Software Design Principles
SOLID represents five essential design rules that guide developers in creating maintainable and scalable
software applications.
•Single Responsibility Principle (SRP): Each class should have one responsibility, enrobing one aspect of
the software’s functionality. The SRP improves design cohesion by helping to avoid responsibility coupling.
•Open/Closed Principle (OCP): Software entities should be open for extension but closed for modification.
As a result, developers can add new features without modifying existing code.
•Liskov Substitution Principle (LSP): A subtype should be replaceable for its base type without affecting the
program’s correctness.
•Interface Segregation Principle (ISP): Clients shouldn’t have to depend on an interface they don’t use.
This principle promotes the creation of small, cohesive interfaces specific to the client’s needs.
Dependency Inversion Principles (DIP): Models shouldn’t be dependent on low-level models. Both should
depend on abstractions. In addition, abstractions shouldn’t rely on details but vice versa.
4. Iterative Life Cycle Process
The iterative life cycle process is a cyclic approach where requirement gathering, design, implementation,
and testing are reviewed to improve the software. The iterative life cycle process allows developers to
identify and eliminate risks in the early stages. Summary
The iterative life cycle process is a repeated approach to development,
where each cycle of planning, building, and testing helps improve the
software and reduce risks early in the project.

5. Component-based Approach
The component-based approach leverages reused and pre-defined components and functions. This
method speeds development, ensures consistency, minimizes errors, and boosts maintainability. As a
result, developers can streamline the development process and create efficient, manageable, and
upgradeable software.
make the software easier to
maintain and upgrade.