Software Design Methodologies

Topic 2.1: Structured Design

Structured Design is a software development methodology that focuses on

breaking down a complex system into smaller, more manageable modules.
Key Principles:
 Modularity: Dividing the system into smaller, independent modules
with well-defined interfaces. This enhances code reusability,
1

maintainability, and testability. 2

 Cohesion: Ensuring that each module has a single, well-defined

purpose and that all the elements within a module are closely related. 3

High cohesion is desirable. 4

 Coupling: Minimizing the interdependencies between modules. Loose

coupling makes the system more flexible and easier to change. 5

Techniques:
 Data Flow Diagrams (DFDs): Graphical representations of the flow
of data through a system. They help visualize how data is processed
6

and transformed. 7

 Structure Charts: Hierarchical diagrams that represent the

relationships between modules in a system. They show how modules
8

interact and call each other. 9

 Top-down design: Breaking down a large problem into smaller, more

manageable subproblems. 10

 Abstraction: Focusing on the essential aspects of a system while

ignoring irrelevant details. 11

Benefits of Structured Design:

 Improved code readability and maintainability: Well-structured
code is easier to understand, modify, and debug. 12

 Reduced development time and costs: By breaking down complex

problems into smaller, more manageable parts, development time can
be reduced, and errors can be identified and corrected more easily.
 Increased reliability and stability: Well-structured systems are less
prone to errors and more robust.
 Enhanced reusability: Modular design allows for the reuse of code
components in different parts of the system or in other projects. 13

In essence, Structured Design aims to create software systems that

are:
 Modular: Easy to understand, maintain, and modify. 14

 Reliable: Less prone to errors and more robust.

 Efficient: Perform their tasks effectively and efficiently.
 Reusable: Components can be reused in other projects.
Note: While Structured Design has been influential, modern software
development methodologies like object-oriented programming and agile
development have evolved and incorporated many of its principles while
addressing some of its limitations.

 Waterfall Model & V-Model

Waterfall Model - This SDLC model is considered to be the oldest and
most forthright. We finish with one phase and then start with the next,
with the help of this methodology. Why the name waterfall? Because
each of the phases in this model has its own mini-plan and each stage
waterfalls into the next. A drawback that holds back this model is that
even the small details left incomplete can hold an entire process.
V-Model - This model can be considered as an extension of the
waterfall model, as it includes tests at each stage of development. Just
like the case with waterfall, this process can run into obstructions.

 Functional Decomposition
Functional decomposition is a term that engineers use to describe a set
of steps in which they break down the overall function of a device,
system, or process into its smaller parts. This is usually accomplished
through thoughtful analysis and team discussions of project
information and the result is a chart that describes the problem and or
solutions in increasing detail.
https://engineering.purdue.edu/Engr/EPICS/k12/Teachers/Teacher-
Toolbox/1.20-Teacher-Toolbox-Functional-Decomposition.pdf

 Data flow diagrams

A data flow diagram (DFD) is a visual representation of the flow
of data through an information system or business process. DFDs make
complex systems easier to understand and are a popular resource for
software engineering, systems analysis, process improvement,
business management and agile software development.
A data flow diagram uses graphical symbols to illustrate the paths,
processes and storage repositories for data from the point it enters a
system until it exits. This visual model helps professionals identify
ways to improve the efficiency and effectiveness of existing systems
and processes, and create new ones.
https://www.ibm.com/think/topics/data-flow-diagram#:~:text=A
%20data%20flow%20diagram%20(DFD)%20is%20a%20visual
%20representation%20of,management%20and%20agile%20software
%20development.

Topic 2.2: Object oriented design (OOD)

Object-Oriented Design (OOD) is a software development approach that

models a system as a collection of interacting objects. It's a powerful
paradigm that emphasizes modularity, reusability, and maintainability in
software development.
Key Concepts in OOD:
 Objects:
 o Represent real-world entities (e.g., a car, a customer, a bank
account).
o Have properties (attributes) that describe their characteristics
(e.g., color, speed, balance).
o Have behaviors (methods) that define what they can do (e.g.,
accelerate, deposit, withdraw).

 Classes:
o Blueprints or templates for creating objects.

o Define the properties and methods that objects of that class will
have.

 Encapsulation:
o Bundling data (attributes) and methods that operate on that data
within a single unit (the class).
o Protects data integrity by controlling access to internal details.

 Abstraction:
o Simplifying complex systems by focusing on essential features
and ignoring irrelevant details.
o For example, a car can be abstracted as a vehicle with methods
like "start" and "stop," without needing to know the intricate
details of the engine.

 Inheritance:
o Allows a new class (subclass or derived class) to inherit
properties and methods from an existing class (superclass or
base class). 1

o Promotes code reusability and establishes a hierarchy of classes.

 Polymorphism:
o The ability of objects of different classes to be treated as objects
of a common superclass.
o Enables flexibility and allows for diverse behaviors within a
system.

Benefits of OOD:
 Modularity: Breaks down complex systems into smaller, more
manageable units.
 Reusability: Encourages code reuse through inheritance and
polymorphism.
 Maintainability: Easier to modify and update code with minimal
impact on other parts of the system.
 Flexibility: Adaptable to changing requirements and new features.
  Improved Code Quality: Leads to more robust, reliable, and
maintainable software.
OOD in Practice:
 Use Case Diagrams: Visualize user interactions with the system.
 Class Diagrams: Model the classes, their attributes, and their
relationships (inheritance, associations).
 Sequence Diagrams: Illustrate the interactions between objects in a
system.

OOD is a powerful approach to software development that has revolutionized

how software is designed and built. By focusing on objects and their
interactions, developers can create more modular, flexible, and maintainable
software systems.

 Concept of OOP: classes, objects, inheritance, polymorphism,

encapsulation, and abstraction
1. Class:
A class is a user-defined data type. It consists of data members and
member functions, which can be accessed and used by creating an
instance of that class. It represents the set of properties or methods
that are common to all objects of one type. A class is like a blueprint
for an object.
For Example: Consider the Class of Cars. There may be many cars
with different names and brands but all of them will share some
common properties like all of them will have 4 wheels, Speed Limit,
Mileage range, etc. So here, Car is the class, and wheels, speed limits,
mileage are their properties.
2. Object:
It is a basic unit of Object-Oriented Programming and represents the
real-life entities. An Object is an instance of a Class. When a class is
defined, no memory is allocated but when it is instantiated (i.e. an
object is created) memory is allocated. An object has an identity, state,
and behavior. Each object contains data and code to manipulate the
data. Objects can interact without having to know details of each
other’s data or code, it is sufficient to know the type of message
accepted and type of response returned by the objects.
For example “Dog” is a real-life Object, which has some characteristics
like color, Breed, Bark, Sleep, and Eats.

Object

3. Inheritance:
Inheritance is an important pillar of OOP(Object-Oriented
Programming). The capability of a class to derive properties and
characteristics from another class is called Inheritance. When we write
a class, we inherit properties from other classes. So when we create a
class, we do not need to write all the properties and functions again
and again, as these can be inherited from another class that possesses
it. Inheritance allows the user to reuse the code whenever possible and
reduce its redundancy.

4. Polymorphism:
The word polymorphism means having many forms. In simple words,
we can define polymorphism as the ability of a message to be
displayed in more than one form. For example, A person at the same
time can have different characteristics. Like a man at the same time is
a father, a husband, an employee. So the same person posses different
behavior in different situations. This is called polymorphism.

5. Encapsulation:
Encapsulation is defined as the wrapping up of data under a single
unit. It is the mechanism that binds together code and the data it
manipulates. In Encapsulation, the variables or data of a class are
hidden from any other class and can be accessed only through any
member function of their class in which they are declared. As in
encapsulation, the data in a class is hidden from other classes, so it is
also known as data-hiding.
 6. Data Abstraction:
Data abstraction is one of the most essential and important features of
object-oriented programming. Data abstraction refers to providing only
essential information about the data to the outside world, hiding the
background details or implementation. Consider a real-life example of
a man driving a car. The man only knows that pressing the accelerators
will increase the speed of the car or applying brakes will stop the car,
but he does not know about how on pressing the accelerator the speed
is increasing, he does not know about the inner mechanism of the car
or the implementation of the accelerator, brakes, etc in the car. This is
what abstraction is.
https://www.geeksforgeeks.org/introduction-of-object-oriented-
programming/

 Object Oriented Analysis and Design

Object-Oriented Analysis & Design (OOAD) is a way to design computer

programs using objects. Objects have data & functions that work together.
OOAD helps make programs easier to understand, reuse & maintain. It's
used a lot in software development.

Object-oriented analysis (OOA) focuses on figuring out what the system

needs to do. It looks at the problem & breaks it down into objects. Each
object represents something in the real world, like a person, place, thing, or
event. OOA defines the object's attributes (data) & behaviors (methods). The
goal is to model the system so it matches how users see things in the real
world.

Object-oriented design (OOD) takes the OOA model & adds details needed to
implement it in a specific programming language & environment. OOD
defines the object classes, their relationships (like inheritance & association),
& their interfaces & collaborations. It fills in the technical details like data
structures & algorithms. The OOD model has enough detail for programmers
to write the actual code.

https://www.naukri.com/code360/library/object-oriented-analysis-and-design-
ooad

 UML (Unified Modeling Language) diagrams: class, sequence, and use

case diagrams

UML, short for Unified Modeling Language, is a standardized modeling

language consisting of an integrated set of diagrams, developed to help
system and software developers for specifying, visualizing, constructing, and
documenting the artifacts of software systems, as well as for business
modeling and other non-software systems.

Class Diagram

Class diagrams are the main building block of any object-oriented solution. It
shows the classes in a system, attributes, and operations of each class and
the relationship between each class.
In most modeling tools, a class has three parts. Name at the top, attributes
in the middle and operations or methods at the bottom. In a large
system with many related classes, classes are grouped together to create
class diagrams. Different relationships between classes are shown by
different types of arrows.

Use Case Diagram

As the most known diagram type of the behavioral UML types, Use
case diagrams give a graphic overview of the actors involved in a
system, different functions needed by those actors and how these
different functions interact.
It’s a great starting point for any project discussion because you can
easily identify the main actors involved and the main processes of the
system. You can create use case diagrams using our tool and/or get
started instantly using our use case templates.
Sequence Diagram

Sequence diagrams in UML show how objects interact with each other and
the order those interactions occur. It’s important to note that they show the
interactions for a particular scenario. The processes are represented
vertically and interactions are shown as arrows.

https://creately.com/blog/diagrams/uml-diagram-types-
examples/

Topic 2.3 Agile and Iterative Design

 Scrum methodology and principles

Why is it Called Scrum? The Scrum methodology complements what is

referred to as the agile approach to project management – a means of
“breaking down large projects into more manageable tasks, which are
completed in short iterations throughout the project life cycle.” The Scrum
framework relies on constant collaboration, so teams can easily complete a
task within an allotted time before moving on to the next project phase.

The Six Principles of Scrum

The Scrum framework relies on six basic principles, guidelines that must be
followed throughout every project. Must is the keyword, as Scrum followers
are adamant that each principle remains intact and adhered to, lest the team
lose focus or the project suffer any setbacks.

The six principles are:

1. Control over the empirical process.

In Scrum, the empirical process is based on observation of hard evidence

and experimentation rather than theory. There are three main ideas to
empirical process control: transparency, inspection, and adaptation.

2. Self-organization.
As the Scrum process relies on many individuals, self-organization is
essential. Everyone involved is empowered to work independently, and the
self-organization principle allows for greater buy-in among all parties, while
making it easier to assess individual contributions.

3. Collaboration.

Scrum is a collaborative process, as evidenced by the many roles involved

(more on that below). This principle also focuses on three dimensions of
collaboration: awareness, articulation, and appropriation.

4. Value-based prioritization.

This principle involves organizing and prioritizing tasks based on their value
and how they need to be completed.

5. Time-boxing.

In Scrum, tasks are completed in “sprints,” with specific lengths of time

assigned to each one. Other elements, including “sprint planning” and daily
meetings, are also given specific start and stop times. This time-boxing
ensures that all involved know how much time is allocated to each step, with
the goal of eliminating wasted time and delays.

6. Iterative development.

This final principle speaks to the understanding that a project may need to
be refined multiple times during the development process. Iterative
development allows the team to make adjustments and manage change
easier.

https://www.uagc.edu/blog/what-is-scrum

 Agile design practices: continuous integration, rapid prototyping

What is Agile Design?

Agile design is a flexible and iterative approach that applies Agile principles
to the realm of design and user experience. This methodology comes from
the Agile framework, which emphasizes adaptability, collaboration and
customer feedback. Agile design diverges from traditional design
processes as it incorporates a mindset of managing unpredictability and
complexity in project environments.

What is continuous integration?

Continuous integration is an agile and DevOps best practice of routinely

integrating code changes into the main branch of a repository, and testing
the changes, as early and often as possible. Ideally, developers will integrate
their code daily, if not multiple times a day.

Benefits of continuous integration

Investing in CI results in fast feedback on code changes. Fast as in "within

minutes" fast. A team that relies primarily on manual testing may get
feedback in a couple hours, but in reality, comprehensive test feedback
comes a day–or several days–after the code gets changed. And by that time
more changes have occurred, making bug-fixing an archeological expedition
with developers digging through several layers of code to get at the root of
the problem.
What is rapid prototyping?

Rapid prototyping is the process where the designer creates a prototype that
simulates the future application/website. A prototype is interactive, which is
what makes it look and function almost like the final product. However, there
is no actual working code behind the prototype, which is where the part
‘rapid’ comes from.

 User stories and feedback loops

What are Agile feedback loops?

Agile feedback loops come in the form of recurring meetings, best

practices, automation tools, and other tactics to keep an open flow of
communication and collaboration.

Feedback loops are built into the Agile application development process to:

 Maintain communication throughout the development process

 Gather feedback (good and bad) on the app from different teams
 Identify areas for improvement
 Increase developer productivity
 Accelerate the application development lifecycle
 Build the highest quality app possible