unit-iv design engineering prof.deshmukh santosh s. (mca sit) design process and design quality...

Unit-IV Design Engineering

Prof.Deshmukh Santosh S. (MCA SIT)

Design Process and design quality Design Concepts The Design Model Introduction to Pattern-Based Software DesignArchitectural Design: Software Architecture Data Design and Architectural DesignUser Interface Design: Rules User Interface Analysis and Steps in Interface Design Design Evaluation

Software design is a process of problem solving and planning for a software solution.

After the purpose and specifications of software are determined, software developers will design to develop a plan for a solution.

The software development phase consists of design, coding and testing.

The development phase takes 75% or more of the total software development cost.

The aim of the design activity is to transform the requirements specified in the SRS document in to a format that can be easily implemented using a suitable programming language or any implementation tool.


Design Process : Software design is an iterative process through which

requirements are translated into a “blueprint” for constructing the software.

The design is represented at a high level of abstraction— a level that can be directly traced to the specific system objective and more detailed data, functional, and behavioral requirements.

Software design is an iterative process Requirements are translated “blueprint” for constructing the

software.


A design should display an architectural structure. A design should be modular. A design should contain distinct representations of data,

architecture, interfaces, & components. A design should lead to data structures that are appropriate for

the objects to be implemented. A design should lead to components that exhibit independent

functional characteristics A design should lead to interfaces that reduce the complexity of

connections between modules & external environment. A design should be derived using a repeatable method , driven

by information obtained during SW requirement analysis.


Design Principles : The design process should not suffer from ‘tunnel vision’ : A good designer should consider alternative approaches, judging

each based on the requirements of the problem, the resources available to do the job.

The design should be traceable to the analysis Model : Because a single element of the design model often traces to

multiple requirements, it is necessary to have a means for tracking how requirements have been satisfied by the design model.

The design should not reinvent(create) the wheel : Systems are constructed using a set of design patterns, many

of which have likely been encountered before. These patterns should always be chosen as an alternative to

reinvention.


The design should ‘minimize the intellectual distance” between the SW and the problem as it exists in the real world.

The design should exhibit uniformity & integration : A design is uniform if it appears that one person developed the

entire thing. Rules of style and format should be defined for a design team before

design work begins. A design is integrated if care is taken in defining interfaces between

design components. The design should be structured to accommodate change : The design should be structured to degrade gently, even when

abnormal data, events, or operating conditions are encountered . Design is not coding, coding is not design : Even when detailed procedural designs are created for program

components, the level of abstraction of the design model is higher than source code


The design should be assessed for Quality as it is being created, not after the fact.

The design should be reviewed to minimize conceptual (semantic) errors :

A design team should ensure that major conceptual elements of the design (omission, ambiguity, inconsistency) have been addressed before worrying about the syntax of the design model.

When these design principles are properly applied, the software engineer creates a design that exhibits both external and internal quality factors.

External quality factors are those properties of the software that can be readily observed by users.

Internal quality factors are of importance to software engineers. They lead to a high-quality design from the technical perspective.


Design Concepts : Software design is both a process and a model. The design process is a sequence of steps that enable the designer

to describe all aspects of the software to be built. The design model that is created for software provides a variety

of different views of the computer software. The Fundamental software design concepts provide the necessary

framework for "getting it right.“Abstraction RefinementModularityArchitecture


Abstraction When we consider a modular solution to any problem, many levels

of abstraction can be modelled. At the highest level of abstraction, a solution is stated in broad

terms using the language of the problem environment. At lower levels of abstraction, a more procedural orientation is

taken. Problem-oriented terminology is coupled with implementation-

oriented terminology in an effort to state a solution.

Procedural abstractionData abstractionControl abstraction


Procedural abstraction = a named sequence of instructions that has a specific & limited function

Data abstraction = a named collection of data that

describes a data objectControl abstraction = implies a program control

mechanisms without specify internal details


Refinement Stepwise refinement is a top-down design strategy originally

proposed by Niklaus Wirth. A program is developed by successively refining levels of

procedural detail. A hierarchy is developed by decomposing a macroscopic

statement of function (a procedural abstraction) in a stepwise fashion until programming language statements are reached.

In each step (refinement), one or several instructions of the given program are decomposed into more detailed instructions.

Every refinement step implies some design decisions. It is important that . . .

The programmer be aware of the underlying criteria and of the existence of alternative solutions.


Refinement is actually a process of elaboration. We begin with a statement of function (or description of

information) that is defined at a high level of abstraction. That is, the statement describes function or information

conceptually but provides no information about the internal workings of the function or the internal structure of the

information. Refinement helps the designer to disclose low-level details

as design progresses.


Modularity software is divided into separately named and addressable

components, often called modules, that are integrated to satisfy problem requirements.

The system is decomposed into a number of modules Software architecture and design patterns represent modularity

and there are 5 criteria to evaluate a design method with respect to its ability to define effective modular system.

Modular decomposability : It provides a systematic approach for decomposing the problem

into sub problems. If a design method provides a systematic mechanism for

decomposing the problem into sub problems, it will reduce the complexity of the overall problem


Modular composability : It enables existing(reusable) design components to be assembled into a

new system. If a design method enables existing (reusable) design components to be

assembled into a new system.

Modular understandability: If a module can be understood as a standalone unit (without reference

to other modules), it will be easier to build and easier to change.

Modular continuity: If small changes to the system requirements result in changes to

individual modules, rather than system wide changes, the impact of change-induced side effects will be minimized.

Modular protection : If an abnormal condition occurs within a module and its effects are

constrained within that module.


Introduction to Pattern-Based Software Design : In software engineering, a design pattern is a general reusable

solution to a commonly occurring problem within a given context in software design.

A design pattern is not a finished design that can be transformed directly into source or machine code.

It is a description or template for how to solve a problem that can be used in many different situations.

Patterns are formalized best practices that the programmer must implement themselves in the application.

There are many types of design patterns: Structural patterns Computational patterns Algorithm strategy patterns


Software Architecture : It is the structure and organization of program components (modules). It is overall structure of the software and the ways in which that

structure provides conceptual integrity for a system. Architecture is the hierarchical structure of program components the

manner in which these components interact and the structure of data that are used by the components.

One goal of software design is to derive an architectural rendering of a system.

This rendering serves as a framework from which more detailed design activities are conducted.

There are five different types of models are used to represent the architectural design :


Structural models :

This aspect of the architectural design representation defines the components of a system (e.g., modules, objects, filters) and the manner in which those components are packaged and interact with one another.

It represent architecture as an organized collection of program components.

Framework models : To identify repeatable architectural design framework that similar to

the types of applications Dynamic models : Dynamic models is behavioral aspects of the program architecture Process models : It is design of the business or technical process of a system Functional models : functional hierarchy of a system


Design Model : To establish a foundation for the creation of the design model that

encompasses representations of data, architecture, interfaces, and components.

The design model was represented as a pyramid. we want to create a software design that is stable. By establishing a broad foundation using data design, a stable mid-

region with architectural and interface design, and a sharp point by applying component-level design.


Software Architecture : The architecture is the hierarchical structure of program components

(modules), the manner in which these components interact and the structure of data that are used by the components.

The architectural design can be represented using one or more of a number of different models.

Structural models represent architecture as an organized collection of program components.

Framework models increase the level of design abstraction by attempting to identify repeatable architectural design frameworks (patterns) that are encountered in similar types of applications.

Dynamic models address the behavioral aspects of the program

architecture, indicating how the structure or system configuration

may change as a function of external events.


Control Hierarchy : Control hierarchy, also called program structure, represents the

organization of program components (modules) and implies a hierarchy of control.

It does not represent procedural aspects of software such as sequence of processes, occurrence or order of decisions, or repetition of operations; nor is it necessarily applicable to all architectural styles.

Different notations are used to represent control hierarchy for those architectural styles that are agreeable to this representation.

The most common is the treelike diagram that represents hierarchical control for call and return architectures.


The data design describes structures that reside within the software. Attributes and relationships between data objects dictate the choice of data structures.

The Architecture Design uses information flowing characteristics, and maps them into the program structure.

The transformation mapping method is applied to exhibit distinct boundaries between incoming and outgoing data.

The data flow diagrams allocate control input, processing and output along three separate modules.


Data Design :Data design is the first and most important design activity.

Here the main issue is to select the appropriate data structure. That is the Data design focuses on the definition of data structures.Architectural Design :Architectural design defines the relationship among the major structural elements.

Here the main objective is to develop a modular structure and represent the control relationship between modules.

Procedural Design transforms structural elements into a procedural descriptions.

Procedural design starts after data design and architectural design. Here we need to define the algorithmic details and is stated in

natural language such as English


Interface Design The Interface Design describes internal and external program

interfaces, as well as the design of human interface. Internal and external interface designs are based on the

information obtained from the analysis model. The procedural design describes structured programming

concepts using graphical, tabular and textual notations. These design mediums enable the designer to represent

procedural detail, that facilitates translation to code. This blueprint for implementation forms the basis for all

subsequent software engineering work.


Process Dimension (Progression)

Ab

stra

ctio

n D

imen

sion

Data/ClassElements

InterfaceElements

ArchitecturalElements

Component-levelElements

Deployment-levelElements

Dimensions of the Design Model

Analysis model

Design model

Low

High

31

The design model can be viewed in two different dimensions(Horizontally) :The process dimension indicates the evolution of the parts of the design model as each design task is executed. (Vertically) :The abstraction dimension represents the level of detail as each element of the analysis model is transformed into the design model and then iteratively refined.

Elements of the design model use many of the same UML diagrams used in the analysis model.

The diagrams are refined and elaborated as part of the designMore implementation-specific detail is provided.Emphasis is placed on

Architectural structure and style. Interfaces between components and the outside world. Components that reside within the architecture.(More on next slide)

Design model elements are not always developed in a sequential fashion Preliminary architectural design sets the stage. It is followed by interface design and component-level design,

which often occur in parallel. The design model has the following layered elements….. Data/class design Architectural design Interface design Component-level design

A fifth element that follows all of the others is deployment-level design

33

Design Elements : Data/class design :

Creates a model of data and objects that is represented at a high level of abstraction

Architectural design : Represents the overall layout of the software.

Interface design : Tells how information flows into and out of the system and how it is

communicated among the components defined as part of the architecture.

Includes the user interface, external interfaces, and internal interfaces. Component-level design elements :

Describes the internal detail of each software component by way of data structure definitions, algorithms, and interface specifications.

Deployment-level design elements : Indicates how software functionality and subsystems will be

allocated within the physical computing environment that will support the software.

34

Pattern-based Software Design Mature engineering disciplines make use of thousands of design patterns

for such things as buildings, highways, electrical circuits, factories, weapon systems, vehicles, and computers

Design patterns also serve a purpose in software engineering Architectural patterns :

Define the overall structure of software. Indicate the relationships among subsystems and software components Define the rules for specifying relationships among software elements.

Design patterns : Address a specific element of the design such as an aggregation of

components or solve some design problem, relationships among components, or the mechanisms for effecting inter-component communication

Consist of creational, structural, and behavioural patterns Coding patterns :

Describe language-specific patterns that implement an algorithmic or data structure element of a component, a specific interface protocol, or a mechanism for communication among components

User Interface Design:User interface design creates an effective communication

medium between a human and a computer. Interface design focuses on three areas of concern:

a) The design of interfaces between software components.

b) The design of interfaces between the software and other nonhuman producers and consumers of information (i.e., other external entities).

c) The design of the interface between a human (i.e., the user) and the computer.

A software engineer designs the user interface by applying an iterative process that draws on predefined design principles.


What are the steps in Interface Design? User interface design begins with the identification of user, task,

and environmental requirements. Once user tasks have been identified, user scenarios are created

and analyzed to define a set of interface objects and actions. These form the basis for the creation of screen layout that

describes graphical design and placement of icons, definition of descriptive screen text, specification and titling for windows, and specification of major and minor menu items.

Golden Rules in Interface Design : 1. Place the user in control. 2. Reduce the user’s memory load. 3. Make the interface consistent. These golden rules actually form the basis for a set of user interface

design principles that guide this important software design activity.Prof.Deshmukh Santosh S. (MCA SIT)

1. Place the user in control.

Define interaction modes in a way that does not force a user into unnecessary or undesired actions :

An interaction mode is the current state of the interface. if spell check is selected in a word-processor menu, the software

moves to a spell checking mode.

Provide for flexible interaction: Because different users have different interaction preferences,

choices should be provided. For example, software might allow a user to interact via keyboard commands, mouse movement, a digitizer pen, or voice recognition commands.

Allow user interaction to be interruptible and undoable: Even when involved in a sequence of actions, the user should be

able to interrupt the sequence to do something else. The user should also be able to “undo” any action.


Streamline interaction as skill levels advance and allow the interaction to be customized.

Users often find that they perform the same sequence of interactions repeatedly.

Hide technical internals from the casual user. The user interface should move the user into the virtual world of the

application. The user should not be aware of the operating system, file

management functions, or other arcane computing technology. Design for direct interaction with objects that appear on the

screen: The user feels a sense of control when able to manipulate the objects

that are necessary to perform a task in a manner similar to what would occur if the object were a physical thing.


Reduce the User’s Memory Load : Reduce demand on short-term memory: When users are involved in complex tasks, the demand on short-

term memory can be significant. The interface should be designed to reduce the requirement to

remember past actions and results. Establish meaningful defaults : The initial set of defaults should make sense for the average user,

but a user should be able to specify individual preferences. Define shortcuts that are in-built : When mnemonics are used to accomplish a system function, the

mnemonic should be tied to the action in a way that is easy to remember.

The visual layout of the interface should be based on a real world metaphor.


Disclose information in a progressive fashion. The interface should be organized hierarchically. That is,

information about a task, an object, or some behavior should be presented first at a high level of abstraction. Make the Interface Consistent : The interface should present and acquire information in a consistent

fashion. All visual information is organized according to a design standard

that is maintained throughout all screen displays, Input mechanisms are constrained to a limited set that are used

consistently throughout the application, and The mechanisms for navigating from task to task are consistently

defined and implemented.


DESIGN EVALUATION : Once an operational user interface prototype has been created, it

must be evaluated to determine whether it meets the needs of the user.

The user interface evaluation cycle takes the form shown in Figure After the design model has been completed, a first-level prototype

is created. The prototype is evaluated by the user, who provides the designer

with direct comments about the efficiency of the interface. In addition, if formal evaluation techniques are used (e.g.,

questionnaires, rating sheets), the designer may extract information from these data.

Design modifications are made based on user input and the next level prototype is created.

The evaluation cycle continues until no further modifications to the interface design are necessary.



Preliminarydesign

Buildprototype #1

interface

Userevaluatesinterface

Build prototype #n interface

Designmodifications

are made

Evaluationis studied by

designerInterface designis complete

If a design model of the interface has been created, a number of evaluation criteria can be applied during early design reviews:

1) The length and complexity of the written specification of the system and its interface provide an indication of the amount of learning required by users of the system.

2) The number of user tasks specified and the average number of actions per task provide an indication of interaction time and the overall efficiency of the system.

3) The number of actions, tasks, and system states indicated by the design model imply the memory load on users of the system.

4) Interface style, help facilities, and error handling protocol provide a general indication of the complexity of the interface and the degree to which it will be accepted by the user.


Self Learning1) With neat diagram, explain how Analysis model is translated into

Design Model.

2) How we perform Design evaluation explain with suitable diagram.

3) Discuss important design issues involved in designing a web page.

4) Explain Software and Hardware Interface Design for Embedded Systems.

Explain in detail the following : i) Architectural design elements. ii) Component - level design elements. iii) Deployment - level design elements. b) What are the golden rules of interface design? Explain in detail all

the rules.


List and explain the system elements of computer based systems. What are planning practices? Explain the different principles applied in

planning practices. What are the basic guidelines for conducting a collaborative requirements gathering meeting? Draw level 0, level 1 and level 2 data flow diagram for the above

problem statement. How do we go about developing the class based elements of an

analysis model identify class, attributes and operations. Explain the need of requirement prioritization? How the requirements

are prioritized? Explain the following UML diagrams stating purpose and

applicability: i) Use-case diagrams. ii) Activity diagrams.


unit-iv design engineering prof.deshmukh santosh s. (mca sit) design process and design quality...

Documents