Unit IV:

Design Engineering

Prepared By:
Prof.Shraddha J.Pawar
• I- Design Concepts:
 Design within the Context of Software Engineering

 The Design Process,

● Software Quality Guidelines and Attributes,
● Quality Guidelines, Quality Attributes

 Design Concepts
● Abstraction
● Architecture
● Design Patterns
● Separation of Concerns
● Modularity
● Information Hiding
● Functional Independence
● Refinement
● Aspects
● Refactoring
 Object-Oriented Design Concepts
● Design Classes

 The Design Model

● Data Design Elements
● Architectural Design Elements
● Interface Design Elements
● Component Level Design Elements
● Deployment-Level Design Elements

 Component Level Design for Web Apps

 Content Design at the Component
• Level
 Functional Design at the Component Level
• II- Architectural Design :
 Software Architecture
● What is Architecture?
● Why is Architecture Important?

 Architectural Styles
● A brief Taxonomy of Architectural Styles.

 Suggested Free Open Source Tool:

• Smart Draw
 About Software Design
• The design phase of software development deals with transforming
the customer requirements as described in the SRS documents into a
form implementable using a programming language.
• Design phase is a critical stage where developers create a blueprint
for how the software will be structured and function.
• Software design is the first step in SDLC, which moves the focus from
problem domain to solution(in the form of design) domain.
• It tries to specify how to fulfill the requirement mentioned in SRS.
• Done by software design engineer or UI/UX designer.
Objectives of Software Design:
• Correctness : Software design should be correct as per
requirement.(SRS document)
• Completeness : The design should have all components like data
structures, modules, and external interfaces, etc.
• Efficiency : Resources (s/w, h/w)should be used efficiently by the
program.
• Flexibility : Able to modify on changing needs.
• Consistency : There should not be any inconsistency(missing and
wrong info) in the design.
• Maintainability: The design should be so simple so that it can be
easily maintainable by other designers.
Software quality guidelines
• A design is generated using the recognizable(use case diagram) architectural
styles and compose a good design characteristic of components and it is
implemented in evolutionary manner for testing.
• A design of the software must be modular i.e the software must be logically
partitioned into elements. (generate module by module)
• In design, the representation of data , architecture, interface and components
should be distinct.
• A design must carry appropriate data structure and recognizable data patterns.
• Design components must show the independent functional characteristic. (each
and every component having diff characteristic)
• A design creates an interface that reduce the complexity of connections between
the components. (log in page)
• A design must be derived using the repeatable method.
• The notations(user, components, features)should be use in design which can
effectively communicates its meaning.
 Quality attributes
The attributes of design name as 'FURPS' are as follows:
• Functionality: It evaluates the feature set and capabilities
(requirements)of the program.
• Usability: It is accessed by considering the factors such as human
factor , consistency and documentation. (use each and every person)
• Reliability: It is evaluated by measuring parameters like frequency
and security of failure, output result accuracy, the mean-time-to-
failure(MTTF), recovery from failure and the the program
predictability.
• Performance: It is measured by considering processing speed,
response time, resource consumption, throughput and efficiency.(eg.
Social media app)
• Supportability:
- It combines the ability to extend the program(new feature),
adaptability, serviceability. These three term defines the
maintainability.
- Testability, compatibility and configurability are the terms using
which a system can be easily installed and found the problem easily.
- Supportability also consists of more attributes such as compatibility,
extensibility, modularity, reusability, robustness, security, portability,
scalability.
 Software Design Process
• The software design process can be divided into the following 3 levels of
phases of design:
- Interface Design: Interface design is the specification of the interaction
between a system and its environment. Scenario and Behavioral based
diagram used . the internal of the systems are completely ignored.(front
end)
- Architectural Design : Architectural design is the specification of the major
components of a system, their responsibilities, properties, interfaces, and
the relationships and interactions between them. Class and flow based
diagram used.(middle end)
- Detailed Design: Design is the specification of the internal elements of all
major system components, their properties, relationships, processing, and
often their algorithms and the data structures. (back end)
Software Design Concepts
1) Abstraction(Hide Irrelevant data)
- Abstraction is used to hide background details or unnecessary
implementation about the data, so users can see only required
information.
Type 1: Procedural Abstraction:
-There is collection of subprograms.
-One is hidden group another is visible group of functionalities.
Example: Television
Type 2: Data Abstraction:
-Collection of data that describe data objects.
-Show representation data and hide manipulation data.
-Examples: data structure program directly used push(),pop(),top() and
empty() methods.
2) Architecture:
- Architecture simply means a technique to design a structure of
program module.
- The architecture is the structure of program modules where they
interact with each other in a specialized way.
-Structural Properties: Architectural design represent different types of
components, modules, objects and relationship between these.
-Extra-Functional properties: how design architecture achieve
requirements of performance, capacity, reliability, security, adaptability
and other system characteristics.(fulfilled with these requirements)
-Families of related system: the architectural design should draw
repeatable patterns. They have ability to reuse repeatable blocks.(eg.
void display())
3) Design Pattern (a Repeated form):
A pattern simply means a repeated form or design in which the same
shape is repeated several times to form a pattern.
The pattern in the design process means the repetition of a solution to
a common recurring problem within a certain context.
4) Modularity:
- Modularity simply means dividing the system or project into smaller
parts to reduce the complexity of the system or project.
- modularity in design means subdividing a system into smaller parts
so that these parts can be created independently and then use these
parts in different systems to perform different functions.
- After developing the modules , they are integrated together to meet
the software requirements.
- Modularizing a design helps to effective development , accommodate
changes easily, conduct testing, debugging efficiently and conduct
maintenance work easily.
5) Information Hiding (Hide the Information):
- Information hiding simply means to hide the information so that it
cannot be accessed by an unwanted party.
- Modules should be specified and design in such a way that the data
structures and algorithm details of one module are not accessible to
other modules.
- They pass only much information to each other ,which is required to
accomplish the software functions.
- The way of hiding unnecessary details in modules is referred to as
information hiding.
- Example: Creating Gmail account
6) Functional Independence:
- The functional independence is the concept of separation and related
to the concept of modularity , abstraction and information hiding.
Criteria 1: Coupling
- The degree in which module is “connected ”to other module in the
system.(connection of one module to another module)
- Low coupling necessary in good software.
Criteria2: Cohesion
- The degree in which module perform functions in inner module in the
system(perform the function within a module)
- High cohesion necessary in good software.
7) Refinement(removes impurities):
- Refinement simply means to refine something to remove any
impurities if present and increase the quality.
- system in a detailed manner which means elaborating a system or
software.
- Refinement is very necessary to find out any error if present and then
to reduce it.
- A program is established for refining levels of procedural details.
- A hierarchy is established by decomposing a statement of function in
a stepwise manner till the programming language statement are
reached.
- Example: Addition of two nos
8) Refactoring(Reconstruct something):
- Refactoring simply means reconstructing something in such a way
that it does not affect the behavior of any other features.
- Refactoring is the process of changing the internal software system in
a way that it does not change the external behavior of the code still
improves its internal structure.
- When software is refactored the existing design is examined for
redundancy(duplicate data) , unused design elements, unnecessary
design algorithm, poorly constructed data, inappropriate data
structure or any other design failure that can be corrected for better
design.
9) Object Oriented Design Concepts:
1) Object :All entities involved in the solution design are known as objects. For example,
person, banks, company, and users are considered as objects. Every entity has some
attributes associated with it and has some methods to perform on the attributes.
• For example, in a banking system:
• Person: An object representing an individual customer. Attributes could include name,
age, address, and account information. Methods might include deposit, withdraw, and
check Balance.
• Bank: An object representing a financial institution. Attributes could include name,
location, and assets. Methods might include create Account, close Account, and calculate
Interest.
• Company: An object representing a business entity. Attributes could include name,
industry, and revenue. Methods might include calculate Profit, hire Employee.
• User: An object representing someone interacting with the system. Attributes could
include username, password, and permissions. Methods might include login, logout, and
change Password.
• Each object interacts with other objects and the system as a whole through well-defined
interfaces, using messages to communicate and collaborate. This approach helps in
organizing and managing the complexity of software systems
2) Class:
- a class serves as a blueprint or template for creating objects. It defines
the properties (attributes) and behaviors (methods) that all instances
(objects) of that class will have.
- Classes provide a way to organize and structure code in a modular and
reusable manner. They allow for abstraction, encapsulation, and
inheritance.
- By defining classes, you can create a clear and consistent model of
your system's entities and their interactions.
3) Polymorphism:
- It lets you use the same name for methods in different classes, but
these methods can do different things depending on the object
calling them.
- For example, imagine you have a bunch of animals: dogs, cats, and
birds. You want them all to make a sound, but each one makes a
different sound. With polymorphism, you can have a method called
“Makesound()” in each animal class, but when you call
“Makesound()” on a dog object, it barks, and when you call it on a cat
object, it meows.
- makes your code more flexible, because you can treat different
objects the same way even though they behave differently.
- This flexibility makes your software easier to understand, maintain,
and extend over time.
4) Encapsulation:
- It bundles together data (variables) and methods (functions) into a
single unit, called a class.
- This unit is like a box that keeps everything related to an object neatly
organized and hidden from outside interference.
- it promotes code organization, reusability, and maintainability by
keeping related functionality together and hiding implementation
details.
- It also enhances security and robustness by controlling access to the
object's internals, ensuring that data is manipulated safely and
consistently.
 5) Inheritance :
- It allows you to create new classes based on existing ones, forming a
hierarchical relationship where subclasses inherit attributes and
methods from their parent or superclass.
- it enhances the flexibility, extensibility, and maintainability of software
systems by enabling the creation of specialized classes that inherit and
extend the functionality of more general classes
6) Abstraction:
- In object-oriented design, complexity is handled using abstraction.
Abstraction is the removal of the irrelevant and the amplification of
the essentials.

Advantages is that faster, low cost development and creates a high

quality software.
 Coupling
• Coupling refers to the degree of interdependence or number of
relations between software modules.
• Two modules that are tightly coupled are strongly dependent on each
other.
• However, two modules that are loosely coupled are not much
dependent on each other.
• A good design is the one that has low coupling.
• High coupling generates more error because they shared large
number of data.
Types of Coupling
• Type 1: Data Coupling:
- When data of one module is passed to another module, this is called
data coupling via arguments

• Type 2:Stamp Coupling:

- modules are stamp coupled if they communicate using composite
data items such as structure, objects, etc.
- Module 2 access all the algo, data structure used in module 1 this is
call stamp coupling.
- No junk or unused data shared between the two coupling modules.
• Type 3: Control Coupling:
- It handles functional flow between software modules.
- Control Coupling exists among two modules if data from one module
is used to direct the structure of instruction execution in another.
Eg . Module1 –set flag =1 then only
module 2 perform action.
- Module 1 control all the functionalities
Of module 2
• Type 4: External Coupling:
- External Coupling arises when two modules share an externally
import data format, communication protocols, or device interface
- This is related to communication to external tools and devices. (two
or more module used same external tools, library file, import file)
• Type 5: Common Coupling:
-Two modules are common coupled if they share information through
some global data items.( both module Share same data)

• Type 6: Content Coupling:

- Content Coupling exists among two modules if they share same
content like function , method, e.g. a branch from one module into
another module.
- When a change in one module the other modules needs to be
updated as well.(when we change on one module then its affect on
another module)
 Cohesion
• In computer programming, cohesion defines to the degree to which
the elements of a module belong together or interrelated.
• Thus, cohesion measures the strength of relationships between
pieces of functionality within a given module.
• A good software design will have high cohesion.
Types of Cohesion
Type 1: Function cohesion:
- If a single module aims to perform all the similar types of
functionalities through its different elements.
- The purpose of functional cohesion in single minded ,high, strong and
focused.

• Type 2:Sequence Cohesion:

- Output of one element treats as an input to the other elements inside
the same module.
- Example: enter the number-> perform addition of that numbers->
display addition.
• Type 3: Communication cohesion:
- If all the elements of a module are working on the same input and
output data and are accessing that data through the same data
structures.
- Example: update record in the database and send it to the printer.

• Type 4:Procedural cohesion:

- All parts of a procedure execute in particular sequence of steps for
achieving goal.(sequential steps of action)
- Example: calling one function to another function, loop statements,
reading records.
• Type 5: Temporal Cohesion:
- The activities related in time, where all methods executed at same
time.
- Temporal cohesion is found in the modules of initialization and
termination.
- Example: counter =0,open student file, clear(), initializing the array
etc.

• Type 6: Logical cohesion:

- If all the elements of the module perform a similar operation.
- Example : Error handling, sorting
• Type 5: Coincidental cohesion:
- it performs a set of tasks that are associated with each other very
loosely.
- Example: Calculator: ADD, SUB, MUL, DIV (these task are not related
each other)
Why high cohesion and low coupling generate
good design?
• Due to low coupling:
- readability: modules are easy to understand not complex.
- Maintainability: changes in one module little impact on other.
- Modularity: enhance modules development
- Scalability: adding new module remove exiting one easy.
- Testability: modules are easy to test debug.
• Due to high cohesion:
- readability: related functions easy to understand.
- Reusability: easily reuse module in another system.
- Reliability: generate overall improvement of system.
- Testability: modules are easy to test and debug.
 Design Model
• The design phase of software development, transforming the
customer requirement as describe in the SRS documents into design
forms.
• Designing a model is an important phase and is a multi- process that
represent the data structure, program structure, interface
characteristic and procedural details.
• There are four types of design elements /modules
1) Data design elements/ model(Abstarction)
2) User interface design elements/ model
3) Architectural design elements/ model
4) Component level design element / model
 User Interface Design model
• User interface is the front-end application view to which user interacts with
the software.
• It determines how commands are given to the computer or the program
and how data is displayed on the screen.
• How user interact with particular software their feature, functionalities.
• The software becomes more popular if its user interface is:
1) Attractive
2) Simple to use
3) Responsive in short time
4) Clear to understand
5) Consistent on all interfacing screens
 Types of User Interface
1) Text-based User Interface or Command Line Interface
- Text based interface primarily used keyboard handling data.
- Command line interface provide command prompt or coding tools
where the user types the command towards the system.
- The user needs to remember the syntax of the command and its use.
- It is used by technical people or programmers.
2) Graphical User Interface:
- It is provides the simple interactive interface to interest to interact
with the system.
- GUI can be a combination of both hardware and software.
- It is easy to learn as compared to the command line interface.
- It provides multiple windows to the user simultaneously to interact
with system.
User Interface Design process
 User Interface Design Process
1) GUI Requirement gathering: designer analyze all functional and non
functional requirements mentioned and discussed with customer.
2) User Analysis: Designer studies who is going to use the software GUI.
The target audience matters as the details change according to the
knowledge level of the user.
3) Task Analysis: Designer analyze tasks, sub tasks, and flow of the system.
4) GUI design and implementation: Designer generate actual GUI design by
using different implementation tools like visual studio, wavemaker etc.
5) Testing : GUI testing done by inner designer team, organization and
different stockholders in project.
 User Interface Design Principles
1 )User Familiarity: the interface should be based of user oriented
terms and concepts Eg. In windows os, Document, Rename, Folder,
Power etc. (easily understand by each and every user)
2) Consistency: the system command and menus should have the same
format and parameter. Example: Group of fonts, sizes, colors etc.
3) Minimal surprise: users never like to see the system working in an
unexpected manner .
They get frustrated in such cases . Develop as per the user tendency.
Example: Group of similar types of features, In MS words , File- New,
Open, Save , Print, Close, Restart system
4) Recoverability: users most often make mistakes while working with
the system , these mistakes can be reduced but cannot be completely
eliminated. Example: Undo, Rename
5)User Diversity: The user interface should provide appropriate
interaction facilities for the various types of the system user.
Example. Larger font , smaller font ,privacy setting etc.

6)User guidance: the user interface should provide meaningful

feedback when errors occur and provide different levels of the and
advice. Example. User manual, Forgot password etc.
 User Interface Design Golden Rules
• Place Users in Control
- The user should be able to easily enter and exit the mode.
- Allow users to use either the keyboard or mouse (flexible)
- Display descriptive messages and text(Helpful)(example: enter ID,
PWD)
- Hide technical information from users.
- Allow users to customize the interface like short cut keys.
- Allow users to directly manipulate interface objects.(handle each and
every function)
- User must be able to interrupt the sequence to do some other
work(multiple function use same time)
• Reduce Users’ Memory Load
- Relieve short-term memory (remember)
- Provide visual layout of the interface (inform)
- Provide defaults, undo, and redo (forgiving)
- Provide interface shortcuts (frequency)
- Define shortcuts (keys)that are (intuitive)
- Promote visual clarity (organize)
- Disclose information in a hierarchical and similar type of function
added in one group.
• Make the Interface Consistent( every function perform meaningful
task)
- Meaningful user tasks performed.
- Maintain consistency within and across products.
- Keep interaction results the same as per the user expectations.
 User Interface Define Issues
1) Response Time: Time between request and response of the system.
If the response time is too long, then the user becomes frustrated.
2) Error handling: poor error message may result in rejecting the
product.
3) Help facilities: user requires help(option not given) when he need
some information and he cannot find it then the user is in trouble.
4) Application accessibility: it states whether the application is simple
to interact with or not .special guidelines are given to user while
interacting with software.
 Architectural Design Model
• It is serve as a blueprint for a system.(everything have mention one dia)
• The architecture focuses on the early design decisions.
• Each style will describe a system category that consists of :
- A set of components(eg: a database, computational modules) that will
perform a function required by the system.
- The set of connectors will help in coordination, communication, and
cooperation between the components.(complete work flow of project)
- Conditions that how components can be integrated to form the system.
- Semantic models that help the designer to understand the overall
properties of the system.
 Importance of Software Architecture
1) Security: the system is secured against malicious users by
encryption or any other security measures due to layered software
architecture.
2) Performance: it handle request and response of the page in
minimum time.
3) Maintainability: it uses easily modifiable and replaceable
components which is easy to change them over time according to
the new requirements.
4) Safety: avoid critical functionalities in small components and
improve communication of the system.
5) Availability: it includes corresponding components , functionalities
for handling the occurrence of any type of error.
 Decision of Architectural Design
• It is the process differs as the system differs depending upon the type
of system being developed.
• There are some common decision that should be taken care of in any
design process
- How can the system be distributed across the network?(state
,country, international level ,organization level)
- Which approach can be used to structure the system?
- Which architectural styles are suitable for the proposed system?
- How can software architecture be documented?
- How can be system be decomposed into modules?
- What control strategy must be used to control the operation of the
components in the system?
- How can architectural design be analyzed?
 Architectural styles:
• The use of architectural styles is to establish a structure for all the
components of the system.
1) Data Centered Architecture
2) Data flow Architecture
3) Object oriented Architecture
4) Layered Architecture
1] Data centered architectures:
• A data store will reside at the center of this architecture and is
accessed frequently by everyone
• Update, add, delete or modify the data present within the store.
• It is widely used in DBMS, Library information system etc.
• Advantage of Data centered architecture
- Repository of data is independent of clients(every user perform
action )
- It may be simple to add additional clients.
- Modification can be very easy .

• Advantage of Data centered architecture

- Data replication or duplication is possible.(every operation perform at
a time)
- Changes in data structure highly affect the clients.
 2] Data flow architectures:
• this kind of architecture is used when input data is transformed into
output data through a series of computational manipulative
components.
• Pipe is a connector which passes the data directionally from one filter
to the next.
• Filter is a component reads the data from its input pipes and perform
its function.(different action ,function, manupulation)
• This data and places the result on all output pipes
Example of Data flow architecture
• Advantages of Data Flow architecture
- With this design, concurrent execution is supported.

• Disadvantages of Data Flow architecture

- It does not allow applications that require greater user
engagement.(eg website server down)
3] Object Oriented architecture:
• Object are the foundation building blocks for all kinds of software
application.
- Object: Instance of class . example: student ,person
- Class : it define all the attribute, which represent the functionality of
the object
- Encapsulation: binding similar types of elements of an abstraction.
- Abstraction: removal of irrelevant data
- Inheritance: deriving new class with exiting one
- Polymorphism: it has multiple forms.
- message passing: sending and receiving data among object through
function parameter
• The components of a system encapsulate data and the operations
that must be applied to manipulate the data.
• Object-oriented architecture is a way of designing software where we
organize our code into "objects.“
• These objects bundle together both the data they need to work with
and the functions, or "operations," that can be performed on that
data.
• By encapsulating data and operations within objects, we can create
modular, reusable code that's easier to understand, maintain, and
extend.
• This approach is a fundamental principle of object-oriented
programming (OOP), which is widely used in modern software
development.
 4] Layered architecture:
• Data moves from one level to another level for processing is called
layered architecture.
• Number of different layers are defined every layer performing well
defined set of operations.
• Outer layer components manage the user interface operations.
• Inner layer components will perform the operating system interfacing.
• Intermediate layers provide utility services and application software
functions.
• Example : E-commerce web application development like amazon.
 Architectural Views
• It is generally used to entire architecture that is useful and meaningful
to one or more stakeholder in system.
1) Used case view: users view to handling product as per requirement
. Use case diagram used.
2) Design view: organized design information, significant features,
entities and attributes.
3) Process view(flow of system): describes communication, behavior
and synchronization aspects of the design.
4) Implementation view: it address source code integrators and
developers of project.
5) Deployment view: it describes and explains environment within
system runner and executed.
 Component Level Design Model
• What is component?
- A component is a modular , portable, replaceable and reusable set of
well-defined functionalities.
• What is component level design?
→The component-based architecture focuses on breaking the software
design into small individual modules.
- the component design describes communication, interfaces,
algorithm and functionalities of each component regarding the whole
software design.
- Component level design notations are activity diagram , data flow
diagram, conditional notations and tabular forms
 Benefits of component design
• The major benefit of using the component design is that it makes
every module reusable.
• It also reduces the cost as every module is reusable.
• It is a more reliable as the client gets its interaction with the system
with each module. So it increases the reliability of the entire system.
• The component design makes the system easy to maintain as we
don’t need to make changes in the entire system.
• the design describes each components functionality more clearly.
 Steps of component level design
1) Identify all design classes that corresponds to problem domain.
2) Identify all design classes that corresponds to infrastructure domain.
Ex. GUI class, database management class, OS communication class etc.
3) Elaborate all design classes that are not acquired as reusable
component, Ex. Coupling and cohesion methods like message details
between classes, data type, data structure and data flow between
classes.
4) Describe persistent data source and identify classes ,database
require to manage them. Ex. Classes which data from databases.
5) Develop behavioral representation for a component and class. Ex.
Classes, operations and there interactions through activity and state
diagram
6) Elaborate deployment diagram. Ex. Hardware , OS, server of
components.
7) Factors every component level design representations. Ex. Diff
design solutions that provide good characteristics.
 Component Design
• It has account , customer, order and product this four components.
• Every object is an individual component but is related to each other
at the same time.
1) Customer will go online site and search product.
2) By selecting product ,the customer will place an order.
3) System will store customer and his account information in order
database.
4) The order would be generated against the customer and stored in
the database.
 Component Design View
1) Object oriented view:
• An object – oriented view is a set of collaborating classes in module
mentioned in architectural design.
• It view all the objects, methods,
properties and functionalities mentioned
in classes.
• It also view how classes in each
module are connected with each other.
• It detailed out data structure and
algorithms required for processing
2) Conventional view:
• It is viewed functional element of a program that integrates the all
logical and internal operations performed in class.
• It also view calling and coordinating the request like calling functions ,
parameter passing, data passing between the of other modules.
• They analyze complete view of data flow model and state diagram.
3) Process- related view:
• The process related view majorly focuses on the reusability feature of
the component design.
• Databases and libraries are used to store pre-existed modules.
• This pre-existed data used for creating new modules.
 Component Level Design Guidelines
1) components:
• Naming conventions should be established for components that are
specified as part of the architectural model which is understandable
to all stakeholders .
• Use infrastructure component name that mentioned implementation
details.
2) Interface:
• Recognizes and discover these independent entities as new
components.
• Interfaces provide important information about communication and
collaboration.
3) Dependencies and Inheritance:
• Models any dependencies from left to right and inheritance from
top(base class) to bottom (derived classes).
• Used complete concept of coupling and cohesion of system.
 Component Level Design for WebApps
• What is web Apps Component?
- A well-defined cohesive function that provides data processing for an
end user.
- A cohesive package of content and functionality that provides the end
user with some required capability.
- Web applications include online forms, shopping carts, word
processors, spreadsheets, video and photo editing, file conversion ,
file scanning and emails such as Gmail, yahoo etc.
• Component-level design for webApps often incorporates elements of
1) Content Design
2) Functional design
3) Deployment design
1) Content Design at Component Level(focus in front end content)
- It focus on objects and there collaboration in packaged for
presentation to a webApp end user.
- It should be tuned to the characteristics of the webapp to be built.
- Size and complexity between objects their interrelationships grows, it
may be necessary to organize in a way that allows easier reference
and design.
2) Functional Design at Component Level:
- Perform localized processing to generate content and navigation
capability in a dynamic fashion.(eg. click on submit button data store
in db)
- Provide sophisticated database query and access.
- Establish data interfaces with external corporate systems.
3) Deployment Design at Component Level:
- It indicates how software functionality and subsystem will be
allocated within the physical computing environment that will
support the software.
- Examples: personal computer, internet connectivity , server, control
panel like security etc.