Software Design

Software design is a complex and elusive

concept that can refer to various forms such
as code design, program design, or system
design. It encompasses different levels,
including functional, communication, and
operational aspects. As beginners learn
programming fundamentals, they are often
introduced to guidelines that help define
what constitutes a "good program."
Software Design
The design of a program involves a layout that is
inherently created, whether the programmer realizes
it or not. This layout is what the program has been
"designed" to be, and this design activity is
analogous to the way individuals plan their daily
lives. As such, software design is a conscious and
mental activity, much like the careful planning of
daily activities filled with events, travel, and
interactions with others. Despite its inherent
complexity and the difficulty in precisely defining it,
this chapter aims to explore the various contexts in
which software design exists
Software Design
However, software design is one of the most
debated topics in computing due to its
indeterminate nature—it is difficult to define
precisely and is often not governed by
scientific laws or principles. The document
contrasts software design with traditional
engineering design, such as architectural
design, which is guided by specific principles
and methods.
The Nature of Software Design
Software design is inherently iterative and
incremental, especially when software
requirements evolve. Unlike the traditional
"waterfall" model, which assumes that all
software requirements can be defined before
design begins, the reality is that requirements
often change, necessitating a more flexible
approach. This need for iteration and adaptation
is critical for sustaining software design and
ensuring that it remains robust and relevant as
the software evolves
The Nature of Software Design
 Wicked Problems in
The term design Design
references the concept of
"wicked problems," a term coined by Richard
Buchanan in 1992, to describe the complex
and often ill-defined nature of design
challenges. Wicked problems are
characterized by the following:
 Wicked Problems in Design
No clear indication of
No definitive formulation
solutions
There is no single way to define It is difficult to determine when a
or understand the problem solution has been reached

Problem-solving creates new

No right or wrong answers
issues
Solutions are judged based on Addressing one aspect of the
their effectiveness rather than a design may introduce new
binary correct/incorrect measure challenges
 Wicked Problems in
These Design
characteristics highlight the relationship
between determinacy and indeterminacy in design
thinking. Design problems often involve multiple
layers of ambiguity and uncertainty, making them
resistant to simple, linear approaches. Design
thinking, therefore, must embrace this complexity,
acknowledging that design is often about navigating
these "wicked" challenges rather than solving them
definitively.
 Design as a Discipline
Donald Knuth's view of programming as an art
and extends this notion to software design,
suggesting that design can be seen as a
discipline that involves systematic thinking,
strategic planning, and integration of various
elements. Design can significantly shape
human experiences, particularly as it
continues to expand its relevance in
contemporary life and economic activities
 Design as a Discipline
The exploration of design thinking is
essential for understanding and solving
complex problems, as it allows for the
application of divergent and convergent
thinking processes. These processes involve
generating multiple possibilities and
synthesizing them into coherent decisions
that can be practically implemented
 Design as a Discipline
Although software design may not align
perfectly with traditional engineering
processes, it shares several key features, such
as the use of visual communication tools,
standardized forms of documentation, and a
managed design process. Ultimately, software
design is about balancing these diverse
elements to create functional, adaptable, and
sustainable systems
 Software Lifecycle
Software design is Overview
deeply integrated into the broader
software lifecycle, which includes phases like
requirements gathering, design, implementation,
testing, and maintenance. The lifecycle is often
visualized through models like the Waterfall Process
Model, where phases are sequential with clearly
defined goals, milestones, and deliverables. This model
mirrors traditional engineering approaches but has
faced criticism for its lack of flexibility and inability to
adapt to changing requirements.
Waterfall Process of Software
Development
 Unified Process (UP)
The UP Model offersModel
an iterative and incremental
approach to development, dividing the process
into four main phases: Inception, Elaboration,
Construction, and Transition. UP emphasizes
architecture-centric development, particularly
during the Elaboration and Construction phases,
and allows for iterative revisions across all
phases, which contrasts with the rigid structure
of the Waterfall Model.
 Unified Process (UP) Model
Inception Phase Elaboration Phase

Focuses on establishing the Involves detailed analysis, risk

project's scope, goals, and assessment, and architectural
feasibility. design.

Construction Phase Transition Phase

The actual development and Final deployment and fine-tuning

initial testing of the software. before full-scale implementation.
Unified Process (UP) Model
Unified Process (UP) Model
 Agile Design Principles
Agile methodologies, such as the Scrum Model,
diverge from traditional models by promoting a
continuous, evolutionary design process that does
not necessarily begin with a fully defined
architecture. Agile design assumes that software
requirements will evolve, requiring ongoing
adjustments to the design and code. This approach
is more responsive to change but can also lead to
risks if not carefully managed.
Scrum Model
 Design and Architectural
The Stability
debate continues over the relevance of
traditional design processes, given the
instability of software requirements in modern
development environments. Agile practices
emphasize flexibility, but this can sometimes
lead to concerns about the stability and long-
term sustainability of the software architecture.
Software Design
in the Context of
Analytical
Thinking
Designing software is recognized as a
cognitive process, often engaging the brain
at a deep level where design decisions are
made by balancing various trade-offs and
considering different design aspects.
Analytical thinking in design involves
navigating ambiguity, handling uncertainty,
and iterating on potential solutions until a
suitable design is achieved.
Cognitive Aspects of Design
Design thinking involves both divergent
thinking (exploring multiple possibilities)
and convergent thinking (narrowing down
choices to a final decision). This process is
iterative and requires continuous feedback
to refine the design. Good designers
maintain a broad perspective, focusing on
the bigger picture while also managing
detailed aspects of the system's design.
Iterative and Convergent-Divergent Thinking
Design Thinking Framework
Operating on Knowledge Domain: Involves using rapid
modeling, simulations, and tolerating ambiguity to explore design
possibilities

Operating on Concept Domain: Engages in coupling design

subjects with iterative focus, thinking socially, and utilizing multiple
languages or perspectives to inform design decisions

This dual approach to design thinking allows for a systematic,

intelligent process where designers generate, evaluate, and specify
software elements that meet functional requirements
Illustration of design thinking
Divergent thinking is crucial for
evaluating potential design patterns and
their interactions, ensuring that the
design is both innovative and practical.
It also helps balance the need for
structural stability with the flexibility
required to adapt to changing
requirements.
Importance of Divergent Thinking
Software Design
in the Context of
Communication
 Role of Communication in
Software Design
Communication is a fundamental aspect of
software design, particularly when it comes
to conveying architectural decisions and the
rationale behind them to various
stakeholders
Role of Communication in Software
Architectural Views- These Design
are Iterative Process- Architectural
used to represent different views must be updated
perspectives on the system's iteratively, allowing for frequent
design, tailored to the needs of feedback and revisions to ensure
different stakeholders. For that all stakeholder needs are
example, a layered view might addressed.
show the interaction between
components, while a process flow
view could depict the sequence
of operations within a system.
Evolutionary process leading to software
architecture and its validation cycles
An architectural view of
component layers
A process flow of a self-checkout
process
 Tools and Documentation
Tools like UML (Unified Modeling Language) aid in
visualizing and communicating design concepts,
though their necessity in the design process is still
debated. Effective communication through
documentation is critical, particularly in ensuring
that design decisions are understood and validated
by stakeholders. Documentation must be thorough,
covering not just the design but also the rationale
behind it and any potential trade-offs considered.
 Challenges in
ConveyingCommunication
complex architectural conceptsto
diverse stakeholders requires clarity and
precision. Miscommunication can lead to
misunderstandings, making it essential to
document design processes carefully and
consistently.
Software Design
in the Context of
Design
Formalism
 Evolution of Design Paradigms

Design paradigms have shifted over time,

from structured, procedural design
methods to more modern, object-oriented
approaches. Today, there is a growing
emphasis on paradigm-neutral design,
which can adapt to various programming
languages and frameworks.
 Evolution of Design Paradigms

Scientific Process in Design: There's a

push to formalize software design, making
it more akin to mathematical proofs. This
involves using "formal software-building
ingredients" like APIs, frameworks, and
general-purpose software services.
 Formal Ingredients in Software
Design
Formalizing design involves understanding the
relationships between different components
and how they interact at various levels, from
bytes and bits to higher-level abstractions.
The goal is to create design models that are
both rigorous and adaptable, capable of
addressing complex transformations across
different layers of the software architecture.
State-wise
Representations
These are used to model how
data transforms and flows
through the software system,
providing a structured approach
to capturing the functional
operations of the software
 Continued Exploration

The formalization of software design is still an

area of active research. There is ongoing
debate over the balance between theoretical
design frameworks and practical application,
with discussions often touching on
philosophical aspects of design.
THANK
YOU!
DO YOU HAVE ANY
QUESTIONS?