Sule Lamido University Kafin Hausa

Faculty of Computing & Information

Technology
Department Of Computer
Science
CSC: 433
Software Engineering
Session
2024/2025 Lecture 1
 General Introduction of Software
Engineering
Software Engineering is a framework for building
software and is an engineering approach to
software development. Also, a software
engineering is defined as a systematic, disciplined
and quantifiable approach for the development,
operation and maintenance of software. 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
 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 executables 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.
Software Product
 Software Design

Software design is defined as a process of

problem solving and planning for a software solution.
The first step for software design is to define the aim
and characteristics of the software. Then, in the next
step, the software is developed based on a plan for a
solution.

The software design phase is the first step

in SDLC (Software Design Life Cycle), which moves
the concentration from the problem domain to the
Software Design Levels
 Objectives of Software Design
Following are the purposes of Software
design:
1. Correctness: Software design should be correct as per
requirement.
2. Completeness: The design should have all
components like data structures, modules, and external
interfaces, etc.
3. Efficiency: Resources should be used efficiently
by the program.
4. Flexibility: Able to modify on changing needs.
5. Consistency: There should not be any
inconsistency in the design.
6. Maintainability: The design should be so simple
so that it can be easily maintainable by other
designers.
 Software Design Principles

Software design principles are concerned with providing

means to handle the complexity of the design process
effectively. Effectively managing the complexity will not
only reduce the effort needed for design but can also
reduce the scope of introducing errors during design.
1. Problem Partitioning:
For small problem, we can handle the entire problem at once
but for the significant problem, divide the problems and
conquer the problem it means to divide the problem into
smaller pieces so that each piece can be captured separately.
For software design, the goal is to divide the problem into
manageable pieces.
 Benefits of Problem Partitioning
o Software is easy to understand
o Software becomes simple
o Software is easy to test
o Software is easy to modify
o Software is easy to maintain
o Software is easy to expand
2) Abstraction:
An abstraction is a tool that enables a designer to consider a
component at an abstract level without bothering about the
internal details of the implementation. Abstraction can be used for
existing element as well as the component being designed.
Here, there are two common abstraction mechanisms
 Functional Abstraction
 Data Abstraction
o Functional Abstraction:
i. A module is specified by the method it performs.
ii. The details of the algorithm to accomplish the functions are not
visible to the user of the function.
Functional abstraction forms the basis for Function oriented
design approaches.
o Data Abstraction:
Details of the data elements are not visible to the users of
3) Modularity:
Modularity specifies to the division of software into separate
modules which are differently named and addressed and are
integrated later on in to obtain the completely functional
software. It is the only property that allows a program to be
intellectually manageable. Single large programs are difficult
to understand and read due to a large number of reference
variables, control paths, global variables, etc. The desirable
properties of a modular system are:

i. Each module is a well-defined system that can be used with

other applications.
ii. Each module has single specified objectives.
iii.Modules can be separately compiled and saved in the library.
iv.Modules should be easier to use than to build.
Advantages of Modularity
There are several advantages of Modularity:

i. It allows large programs to be written by several or different

people
ii. It encourages the creation of commonly used routines to be
placed in the library and used by other programs.
iii.It simplifies the overlay procedure of loading a large
program into main storage.
iv.It provides more checkpoints to measure progress.
v. It provides a framework for complete testing, more
accessible to test
vi.It produced the well designed and more readable program.
Disadvantages of Modularity
There are several disadvantages of Modularity:

i. Execution time maybe, but not certainly, longer

ii. Storage size perhaps, but is not certainly, increased
iii.Compilation and loading time may be longer
iv.Inter-module communication problems may be
increased
v. More linkage required, run-time may be longer,
more source lines must be written, and more
documentation has to be done
4)Strategy of Design
A good system design strategy is to organize the program
modules in such a method that are easy to develop and
latter too, change. Structured design methods help
developers to deal with the size and complexity of
programs. Analysts generate instructions for the developers
about how code should be composed and how pieces of
code should fit together to form a program.

To design a system, there are two possible approaches:

 Top-down Approach
 Bottom-up Approach
1. Top-down Approach: This approach starts with the
identification of the main components and then
decomposing them into their more detailed sub-
components.
2. Bottom-up Approach: A bottom-up approach begins with
the lower details and moves towards up the hierarchy, as shown
in figure 6. This approach is suitable in case of an existing
system.
Software Architecture in Software Engineering

Software engineering, which abides by engineering

principles and best practices, is creating, testing, and
deploying computer programs to address real-world
issues. With the express purpose of increasing quality,
time, and budget efficiency, combined with the
guarantee of structured testing and engineer
certification, the area of software engineering employs
a disciplined and organized approach to software
development.
 In software engineering, the basic infrastructure
on which the entire development process is built is
software architecture. Just as in a physical building with
its architecture, a good software architecture helps
create structure, organization, and direction for larger
software systems. This article discusses the relevance/
importance of software architecture, its guiding
principles, and several architectural patterns that have
impacted the software engineering discipline.

Software architecture forms the basis of any

software project and serves as an extensive framework
for building, implementing, and maintaining software
i. Scalability: A good software design makes it easier for
software to expand or change to ensure scalability.
Therefore, it allows handling extra work without
remodelling the system or adding new functions.

ii. Maintainability: A good design that separates concerns

and modular components provides easier maintenance. It
enhances efficiency in debugging, upgrading, and
improvising the software, thus reducing the probability of
an error.

iii. Flexibility: The software architecture should be strong to

enable changes to fit in and adjust to new technology.
They enable one to introduce new technologies or ways
without overthrowing the system.
iv. Interoperability: The software architecture decisions also
affect how the software system can connect with other
systems, services, or APIs. Good architecture ensures
smooth communication with other software components.

v. Software quality assurance: Software quality is important

because of the imposition of best practices, design patterns,
and architectural standards known as software architecture.
 Key Principles of Software Architecture
Developers must follow several key concepts to produce an
efficient software architecture:

Modularity: The software system must be divided into different

stand-alone blocks or parts. Such a modular strategy
encourages reusability, thus making both development and
maintenance easier.
Separation of Concerns: The various parts of a system, like the
data store, the user interface, and the business logic, need to
be well laid out. Involvement is discussed in this paper. The
division of this group decreases the reliance on the system
and its maintenance ability.
Abstraction: Abstracting involves masking complex
Decomposability: Complicated systems or issues should be
divided into smaller, easily manageable units. As a result,
development tests and maintenance become easier.
Flexibility: Therefore, the architecture must be versatile and
consider future developments. Therefore, adding or subtracting
items or changing specifications should easily avoid a big
disruption during work processes.
 Typical Architectural Forms
Over time, several architectural patterns that are individually
appropriate for particular software projects have arisen over time.
The following are some of the most typical architectural patterns:

MVC (Model-View-Controller): The three interdependent

components of MVC are Model (data and business logic), View
(presentation and user interface), and Controller (handling user
input). This is a common strategy adopted by many web and
desktop applications.
Layered Architecture: The program is split into numerous layers
with different responsibilities. Some layers include the display,
business logic, and data access layers.
Microservices: The microservices design facilitates the division
of a system into several small and independent services. They
can also develop, run, and scale them independently. This is a
good strategy for large and complex applications.
Event-Driven Architecture: It links message and event
components here in this case. The actor model is appropriate
for reactive real-time processes, distributed systems, and event
processing for non-functional requirements.
Component-Based Architecture: This approach enables one to
develop reusable components with different functionalities
within the same software. It will help you create flexible plans
that are easy to understand.
 Evolution in Software Architecture
Technology and industrial evolution have prompted the evolution
of software architecture, which now meets the new requirements.
The present state of software architecture is being shaped by
several trends and developments, including:

I. Cloud-Native Architecture: The notion of software

architecture is influenced as cloud computing grows in
adoption. This strategy focuses on designing cloud-specific
applications that exploit the scalability and flexibility of the
cloud.
II. Serverless computing: Serverless architecture is a type of
cloud-native design. This allows programmers to focus solely
on writing code without being involved in managing
III. Containerization: Tools such as Docker and Kubernetes
have transformed how software is packaged and deployed in
that they are the source of containers. Containers'
standardized and portable nature guarantees that
applications can be executed reliably on various systems.
IV. Event-Driven Microservices: The use of microservices, an
event-driven approach to forming large and complex
systems, has become a rather popular one. Event-driven
microservices using asynchronous communication or event
sourcing help design more flexible and robust systems.
V. Integration of AI and ML: The software is evolving towards
supporting specific AI elements, such as data pipelines and
model serving.
VI. Blockchain-based architectures: Software structures such
 Software Architecture Challenges
Although software architecture has many advantages, it also has its
share of difficulties:

o Complexity: The more complex the architecture of software

systems becomes, the harder it is to design and maintain them.
However, it's important to keep a simple and modular
architecture for fear of overloading.
o Changing Requirements: Software architectures must be
adaptive to the evolving requirements of users and businesses.
This calls for combining rigidity with elasticity.
o Security issues: Lack of proper architectural design can lead to
vulnerabilities and security breaches. Security should be
considered at all levels of the architecture.
o Cost considerations: Certain system operational cost decisions
can also be influenced by some of the architecture choices. The
balance between price and performance must be struck.
o Documentation and Communication: Good documentation of
the architectures and effective communication between the
development team ensures that everyone understands and follows
the architectures properly.
Architectural Design in Software Engineering

Architectural Design
For the program to represent software design, architectural design
is required. "The process of defining a collection of hardware and
software components and their interfaces to establish the
framework for the development of a computer system. The
following tasks are carried out by an architectural design. One of
these numerous architectural styles can be seen in software
designed for computer-based
Every style shall outline asystems.
system category made up of the
following:
 A collection of parts (such as computing modules and databases)
that together will carry out a task that the system needs.
 The connector set will facilitate the parts' cooperation, coordination,
and communication.
 Requirements that specify how parts can be combined to create a
system.
 Semantic models aid in the designer's comprehension of the
system's general characteristics.
Software requirements should be converted into an
architecture that specifies the components and top-level
organization of the program. This is achieved through
architectural design, also known as system design, which serves
as a "blueprint" for software development. Architectural design
is "the process of defining a collection of hardware and software
components and their interfaces to establish the framework for
developing a computer system," The software requirements
document is examined to create this framework, and a
methodology for supplying implementation details is designed.
The system's constituent parts and their inputs, outputs,
 Components of Architectural Design
High-level organizational structures and connections between
system components are established during architectural design's
crucial software engineering phase. It is the framework for the
entire software project and greatly impacts the system's
effectiveness, maintainability, and quality. The following are some
essential components of software engineering's architectural
design:

 System Organization: The architectural design defines how

the system will be organized into various components or
modules. This includes identifying the major subsystems, their
responsibilities, and how they interact.
 Abstraction and Decomposition: Architectural design
involves breaking down the system into smaller, manageable
 Design Patterns: Using design patterns, such as Singleton,
Factory, or Model-View-Controller (MVC), can help standardize and
optimize the design process by providing proven solutions to
common architectural problems.
 Architectural Styles: There are various architectural styles, such
as layered architecture, client-server architecture, microservices
architecture, and more. Choosing the right style depends on the
specific requirements of the software project.
 Data Management: Architectural design also addresses how
data will be stored, retrieved, and managed within the system.
This includes selecting the appropriate database systems and
defining data access patterns.
 Interaction and Communication: It is essential to plan how
various parts or modules will talk to and interact with one another.
This includes specifying message formats, protocols, and APIs.
 Scalability: The architectural plan should consider the
system's capacity for expansion and scalability. Without
extensive reengineering, it ought to be able to handle
increased workloads or user demands.
 Security: The architectural design should consider security
factors like access control, data encryption, and authentication
mechanisms.
 Optimization and performance: The architecture should be
created to satisfy performance specifications. This could entail
choosing the appropriate technologies, optimizing algorithms,
and effectively using resources.
 Concerns with Cross-Cutting: To ensure consistency
throughout the system, cross-cutting issues like logging, error
handling, and auditing should be addressed as part of the
 Extensibility and Flexibility: A good architectural plan
should be adaptable and extensible to make future changes
and additions without seriously disrupting the existing
structure.
 Communication and Documentation: The development
team and other stakeholders must have access to clear
documentation of the architectural design to comprehend the
system's structure and design choices.
 Validation and Testing: Plans for how to test and validate
the system's components and interactions should be included
in the architectural design.
 Maintainability: Long-term maintenance of the design
requires considering factors like code organization, naming
conventions, and modularity.
 Properties of Architectural Design
Properties of Architectural Design
Several significant traits and qualities of architectural design in
software engineering are used to direct the creation of efficient
and maintainable software systems. A robust and scalable
architecture must have these characteristics. Some of the
essential characteristics of architectural design in software
engineering are as follows:

 Modularity:
Architectural design encourages modularity by dividing the software
system into smaller, self-contained modules or components. Because
each module has a clear purpose and interface, modularity makes the
system simpler to comprehend, develop, test, and maintain.
 Scalability:
Scalability should be supported by a well-designed architecture, enabling
the system to handle increased workloads and growth without extensive
 Maintainability:
A software system's architectural design aims to make it maintainable
over time. This entails structuring the system to support quick updates,
improvements, and bug fixes. Maintainability is facilitated by clear
documentation and adherence to coding standards.
 Flexibility:
The flexibility of architectural design should allow for easy adaptation to
shifting needs. It should enable the addition or modification of features
without impairing the functionality of the current features. Design
patterns and clearly defined interfaces are frequently used to accomplish
this.
 Reliability:
A strong architectural plan improves the software system's dependability.
It should reduce the likelihood of data loss, crashes, and system failures.
Redundancy and error-handling procedures can improve reliability.
 Performance:
A crucial aspect of architectural design is performance. It entails fine-
tuning the system to meet performance standards, including
throughput, response time, and resource utilization. Design choices
like data storage methods and algorithm selection greatly influence
performance.
 Security:
Architectural design must take security seriously. The architecture
should include security measures such as access controls, encryption,
authentication, and authorization to safeguard the system from
potential threats and vulnerabilities.
 Distinguishing Concerns:
By enforcing a clear separation of concerns, architectural design
ensures that various system components-such as the user interface,
business logic, and data storage-are arranged and managed
independently. The separation makes maintenance, testing, and
 Interoperability:
The system's ability to communicate with other systems or
components should be considered when designing the
architecture. Interoperable software can be integrated with
other platforms or services, facilitating communication and
teamwork.
 Usability:
The system's usability and user experience should be
considered when making architectural decisions. User
interfaces and workflows must be designed to ensure users
can interact with the software effectively and efficiently.
 Documentation:
Architectural design that works is extensively documented.
Developers and other stakeholders can refer to the
documentation, which explains the design choices,
 Price-Performance:
The architectural plan should take the project's resources and
budget into consideration. It entails choosing technologies,
resources, and development initiatives wisely and economically.
 Validation and Testing:
The architectural design should include plans for evaluating and
verifying the interactions and parts of the system. This
guarantees that the system meets the requirements and
operates as intended.
 Adherence to Standards:
Consistency and interoperability with other systems and tools
are ensured in architectural design by adhering to industry and
organizational standards and best practices.
 Advantages of Architectural Design

Structure and Clarity: The organization of the software system is

represented in a clear and organized manner by architectural
design. It outlines the elements, their connections, and their
duties. This clarity makes it easier for developers to comprehend
how various system components work together and contribute to
their functionality. Comprehending this concept is essential for
effective development and troubleshooting.
Modularity: In architectural design, modularity divides a system
into more manageable, independent modules or components.
Because each module serves a distinct purpose, managing,
testing, and maintaining it is made simpler. Developers can work
on individual modules independently, improving teamwork and
lessening the possibility of unexpected consequences from
Scalability: A system's scalability refers to its capacity to
accommodate growing workloads and expand over time. Thanks to
an architectural design that supports scalability, the system can
accommodate more users, data, and transactions without requiring
a major redesign. Systems that must adjust to shifting user needs
and business requirements must have this.
Maintenance and Expandability: The extensibility and
maintenance of software are enhanced by architectural design.
Upgrades, feature additions, and bug fixes can be completed
quickly and effectively with an organized architecture. It lowers the
possibility of introducing new problems during maintenance, which
can greatly benefit software systems that last a long time.
Performance Optimization: Performance optimization
ensures the system meets parameters like response times
and resource usage. Architectural design allows choosing
effective algorithms, data storage plans, and other
Security: An essential component of architectural design is
security. Access controls, encryption, and authentication are a
few security features that can be incorporated into the
architecture to protect sensitive data and fend off attacks and
vulnerabilities. A secure system starts with a well-designed
architecture.
Reliability: When a system is reliable, it operates as planned and
experiences no unplanned malfunctions. By structuring the
system to handle errors and recover gracefully from faults,
architectural design helps minimize failures. Moreover, it makes
it possible to employ fault-tolerant and redundancy techniques
to raise system reliability.
Interoperability: The system's capacity to communicate
with other systems or services is known as interoperability.
The ability of the system's components to communicate
with other systems via accepted protocols and data
Disadvantages of Architectural Design
Initial Time Investment: Developing a thorough architectural
design can take a while, particularly for complicated projects. The
project may appear to be delayed during this phase as developers
and architects devote time to planning and making decisions.
Over-Engineering: When features or complexity in the
architectural design are redundant or unnecessary for the
project's objectives, it's known as over-engineering.
Rigidity: It can be difficult to adjust an architecture that is too rigid
to new requirements or technological advancements. The
architecture may make it more difficult for the system to adapt
and change to meet changing business needs if it is overly rigid
and does not permit changes.
Complexity: Comprehending and maintaining complex architectural
designs can be challenging, particularly for developers not part of
the original design process. Because it is more difficult to manage
and troubleshoot, an excessively complex architecture may lead to
inefficiencies and increased maintenance costs.
Misalignment with Requirements: Occasionally, there may be a
discrepancy between the architectural plan and the actual project
specifications, leading to needless complications or inefficiencies.
This misalignment may require additional labour and modifications
to guarantee the system achieves its objectives.
Resistance to Change: Even when required, significant changes
may encounter resistance once an architectural design is
established. This might result from the money spent on the current
architecture or worries about possible project delays.
Resource Intensive: A complex architectural design may require
specialized resources to develop and maintain, such as architects,
Communication Challenges: Interpreting architectural design
documents can be difficult, especially if they are unclear or not
efficiently shared with all team members and stakeholders. Deviations
from the intended design may result from misunderstandings or
misinterpretations.
Risk of Overlooked Issues: There's a chance that, in extremely
complex architectural designs, possible problems or challenges will be
missed, resulting in unforeseen issues during implementation. Later in
the development process, these problems might appear, delaying
things and requiring more work.
Resource Intensive: A complex architectural design may require
specialized resources to develop and maintain, such as architects,
documentation efforts, and quality assurance. Project costs and
management overhead may arise due to these increased resource
demands.
Communication Challenges: Interpreting architectural design
documents can be difficult, especially if they are unclear or not
efficiently shared with all team members and stakeholders. Deviations
from the intended design may result from misunderstandings or
misinterpretations.
Risk of Overlooked Issues: There's a chance that, in extremely
complex architectural designs, possible problems or challenges will be
missed, resulting in unforeseen issues during implementation. Later in
the development process, these problems might appear, delaying
things and requiring more work.