Unit 4: Design Engineering

Design Concepts: Design within the Context of Software Engineering, The Design Process, Software
Quality Guidelines and Attributes, Design Concepts - Abstraction, Architecture, design Patterns,
Separation of Concerns, Modularity, Information Hiding, Functional Independence, Refinement,
Aspects, Refactoring, Object-Oriented Design Concept, Design Classes, The Design Model , Data
Design Elements, Architectural Design Elements, Interface Design Elements, Component-Level Design
Elements, Component Level Design for Web Apps, Content Design at the Component Level,
Functional Design at the Component Level, Deployment-Level Design Elements.
Architectural Design: Software Architecture, What is Architecture, Why is Architecture Important,
Architectural Styles, A brief Taxonomy of Architectural Styles.
Design

* Software designing is a process of translating analysis model into the design model.
* The architectural design defines the relationship between major structural elements of the
software. The architectural styles and design patterns can be used to achieve the
requirements defined for the system.
Design Process

* It is an iterative process.
* It is a process in which the requirements are translated into the blueprint of the software.

* Throughout the software design process the quality of the software is assessed by considering certain
characteristics of the software design.
Software Quality Guidelines and Attributes

* Quality Guidelines:
-> Each component of design should posses good design characteristics.
-> The implementation of design should be evolutionary
-> The design should be modular
-> A design should be derived by using a reputable method.
-> A design should use a notation that must lead to effective communication and understandings.
-> Everything should be clean and clear.
-> A design should represent independent functional characteristics.

* Quality Attributes
-> FURPS
-> Functionality
# It is an important aspect of any software.
# It is generally evaluated using feature set and capabilities of that software.
# Functions should be general and should work only on the particular set of inputs.

-> Usability
# It is best evaluated by considering following factors:
$ Human Factors
$ Overall asthetics

-> Realibility
# It is measured using following parameters;
$ Frequency and severity of failure.
$ Accuracy of output results.
$ Mean time to failure
$ Recovery from failure.

-> Performance
# In this the response time, computational time, time complexity and other factors are measured.
# It can be evaluated using following factors-
$ Speed
$ Response Time
$ Resource Consumption
$ Throughput
$ Efficiency

-> Supportability
# It is also known as maintainability
# It is the ability to adopt the enhancement or changes made in the software.
# It is measured by following attributes:
$ Extensibility
$ Adaptability
$ Serviceability
 Design Concepts
* Following concepts are evolved over the history of software engineering:
-> Abstraction
-> Architecture
# It means the complete structure of the software.
# Everything is listed under this.
# One goal of the software design is to derive an architectural framework of a system.

-> Patterns
# It is a named nugget (something valuable) of insight which conveys the essence of proven
solution to a recurring problem within a certain context.
# it describes the desin structure that sovles a design problem within a specific context.

-> Modularity
# The software is divided into separately named and addressable components that called as
modules.
# There are five criteria defined for an effective modular system:
$ Modular Decomposibility : A complex problem may be solved very easily by decomposing
into smaller sub problems.
$ Modular Composability : Different modules and components are integrated to produce a
new system
$ Modular Understandability : While integrating a system, if all modules are understood
properly, it becomes very easy to build the system once again.
$ Modular Continuity : IT is always better to make changes module wise instead of
making changes system wise.
$ Modular Protection : Effects of any problems should be on a single module. It should
not propagate outside the module.

-> Information Hiding

# The modules of the larger problem must be specified and designed properly so that information
present within a module should not be available to other modules.

-> Functional Independence

# It is related to modularity, abstraction and information hiding.
# Independent modules are easier to maintain with reduced error propagation.
# By using functional independence functions may be compartmentalized and interfaces are
simplified.
# It is assessed using two qualitative criteria:
$ Cohesion: Cohesion is a measure of how closely related and focused the responsibilities
and elements of a single module or component in a software system are.
$ Coupling: Coupling can be defined as the degree of interdependence of modules.

$ Usually a software should have high cohesion and low coupling. \

-> Refinement
# In this we develop the system and it's components progressively.

-> Refactoring
# It is a reorganisation technique that simplifes design of a component without changing its
function or behaviour.
# Process of changing a software system such that it doesn't affect the external behaviour.
 Importance of Refactoring
Refactoring is important because -
* Improve code redability
* Enhances collaboration
* Facilitates testing
* Enhances maintainability
* Improves performance
* Reduces complexity
 Design Classes
Design classes are defined as the classes that describe some elements of problem domain,
focus on various aspects of problem from user's point of view.

* Goal - # refine the design

# create new set of classes for implementing infrastructure of the software.

* User Interface Class

-> The user interface class defines all the abstractions that are necessary for
Human Computer Interface.

* Business Domain Class

-> These classes identify the attributes and services that are needed to implement
some elements of business domain.

* Process Class
-> Process classes (sometimes referred to as control classes or manager classes)
encapsulate the logic for the processes or workflows in a system.

* Persistent Class
-> These classes represent the data store such as databases which will be
retained as it is even after the execution of the software.

* System Class
-> These classes are responsible for software management and control functions
that are used for system operation.
 Design Model
* The design model can be viewed in two different dimensions.
* This data represented at data design level is refined gradually for implementing the computer based system.

* Architecture Design Elements

-> The architectural design gives the layout for overall view of the software.
-> It can be built from the following sources:
# Data flow models or class diagrams
# Information obtained from application domain
# Architectural patterns and styles.

* Interface Design Component

-> Interface Design represents the detailed design of the software system.
-> In interface design how information flows from one component to other
component of the system is depicted.

* Component level design elements

-> The component level design elements describe the internal details of the
component.
-> In component level design all the local data objects, required data structures
and algorithmic details and procedural details are exposed.
* Deployment level design elements
-> It deals with software working and functions with physical environment.
-> In this we check for various aspects like cross platform support, cross device support, etc.
 Architecture
* Architectural design is backbone of any software system design.
* Architecture in small is related to architecture of individual programs which may be small in size.
* Architecture in large is related to the architecture of complex system that include the overall system, the
program and the components in the program.

* For example - Architecture of Attendance Application

Student
Backend

Enrollment

UI Database
 Architecture Styles
* There are different architecture styles
-> Data centered Architecture Style
# A data store resides at the centre of this architecture and is frequently accessed by other
components that perform various operations.
# New clients can be easily added and removed.

* Data flow architecture

# In this architecture series of transformations are applied to produce
the output data.
# Pipes and filters are used

* Call and return architecture

-> Main Program/subprogram architecture
-> Remote procedure call architecture - the components of main and sub program
are distributed over multiple computers.

* Layered Architecture
-> Different layers are defined and each layer has its own tasks.
-> Each layer are connected to its successor and predecessor

* Object Oriented Architecture

-> Involves classes and objects.