0% found this document useful (0 votes)
47 views15 pages

MODUL 3 Design Engineering

Cohesion and coupling are important concepts in software engineering that refer to how components relate to each other. Cohesion measures how closely related elements within a component are, while coupling measures dependencies between components. There are different types of cohesion and coupling, with high cohesion and low coupling generally being desirable. Architectural design involves decisions about a software system's overall structure, components, and how they interact. Common architectural patterns include data-centered, data-flow, call-and-return, layered, and object-oriented architectures.

Uploaded by

Avishkar Patil
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
47 views15 pages

MODUL 3 Design Engineering

Cohesion and coupling are important concepts in software engineering that refer to how components relate to each other. Cohesion measures how closely related elements within a component are, while coupling measures dependencies between components. There are different types of cohesion and coupling, with high cohesion and low coupling generally being desirable. Architectural design involves decisions about a software system's overall structure, components, and how they interact. Common architectural patterns include data-centered, data-flow, call-and-return, layered, and object-oriented architectures.

Uploaded by

Avishkar Patil
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 15

(Z魔王)

MODUL 3 Design Engineering


1.What is Cohesion & Coupling? Explain the types of coupling with
example. 10M
Cohesion and Coupling are two important concepts in software engineering
that refer to how the various components of a system are related to each other.
Cohesion refers to the degree to which the elements within a module or
component of a system work together to achieve a single, well-defined
purpose. High cohesion means that the elements within a module or
component are closely related and work together effectively, while low
cohesion means that the elements within a module or component are loosely
related and may not work together effectively.

Coupling refers to the degree to which one module or component of a system


depends on another. High coupling means that there are strong dependencies
between modules or components, while low coupling means that there are few
dependencies between modules or components.
(Z魔王)

There are several types of coupling:


1. Content Coupling: This occurs when one module or component directly
modifies or accesses the content of another module or component. This
is considered the strongest and most undesirable type of coupling.
2. Common Coupling: This occurs when multiple modules or components
access a global variable or data structure. This is also considered a strong
type of coupling. An example of common coupling would be several
modules accessing the same database.
3. Control Coupling: This occurs when one module or component passes
control information to another module or component. This is considered
a moderate type of coupling.
4. Stamp Coupling: This occurs when modules or components share a
complex data structure, but only use part of it. This is considered a weak
type of coupling
5. Data Coupling: This occurs when modules or components share data
through parameters or return values. This is considered the weakest and
most desirable type of coupling.
(Z魔王)

There are several types of cohesion in software engineering:


1. Functional Cohesion: This is the most desirable type of cohesion. It
occurs when the elements within a module or component are related
and work together to perform a single, well-defined function
2. Sequential Cohesion: This occurs when the elements within a module or
component are related and work together to perform a sequence of
operations.
3. Communicational Cohesion: This occurs when the elements within a
module or component are related and work together to perform a set of
related operations that involve the same data
4. Procedural Cohesion: This occurs when the elements within a module or
component are related and work together to perform a set of related
operations that may involve different data
5. Temporal Cohesion: This occurs when the elements within a module or
component are related and work together to perform a set of operations
that must be performed in a specific sequence or time frame.
(Z魔王)

2.Discuss Abstraction, Information hiding &Functional


independence.

Abstraction
An abstraction is a tool that enables a designer to consider a component at an abstract
level without bothering about the internal details of the implementation. Abstraction
can be used for existing element as well as the component being designed.

Here, there are two common abstraction mechanisms


1. Functional Abstraction
2. Data Abstraction

Functional Abstraction
i. A module is specified by the method it performs.
ii. The details of the algorithm to accomplish the functions are not visible to the
user of the function.
Functional abstraction forms the basis for Function oriented design approaches.

Data Abstraction
Details of the data elements are not visible to the users of data. Data Abstraction forms
the basis for Object Oriented design approaches.

Information hiding:
The fundamental of Information hiding suggests that modules can be characterized
by the design decisions that protect from the others, i.e., In other words, modules
should be specified that data include within a module is inaccessible to other modules
that do not need for such information.

The use of information hiding as design criteria for modular system provides the most
significant benefits when modifications are required during testing's and later during
software maintenance. This is because as most data and procedures are hidden from
other parts of the software, inadvertent errors introduced during modifications are less
likely to propagate to different locations within the software.

Functional Independence:
Functional independence is achieved by developing functions that perform only one
kind of task and do not excessively interact with other modules. Independence is
important because it makes implementation more accessible and faster. The
independent modules are easier to maintain, test, and reduce error propagation and
(Z魔王)

can be reused in other programs as well. Thus, functional independence is a good


design feature which ensures software quality.

It is measured using two criteria:

o Cohesion: It measures the relative function strength of a module.


o Coupling: It measures the relative interdependence among modules.

3. Principles of Software Design


Principles Of Software Design:
1. Should not suffer from “Tunnel Vision” –
While designing the process, it should not suffer from “tunnel vision”
which means that is should not only focus on completing or achieving
the aim but on other effects also.
2. Traceable to analysis model –
The design process should be traceable to the analysis model which
means it should satisfy all the requirements that software requires to
develop a high-quality product.
3. Should not “Reinvent The Wheel” –
The design process should not reinvent the wheel that means it should
not waste time or effort in creating things that already exist. Due to this,
the overall development will get increased.
4. Minimize Intellectual distance –
The design process should reduce the gap between real-world problems
and software solutions for that problem meaning it should simply
minimize intellectual distance.
5. Exhibit uniformity and integration –
The design should display uniformity which means it should be uniform
throughout the process without any change. Integration means it should
mix or combine all parts of software i.e. subsystems into one system.
6. Accommodate change –
The software should be designed in such a way that it accommodates the
change implying that the software should adjust to the change that is
required to be done as per the user’s need.
(Z魔王)

7. Degrade gently –
The software should be designed in such a way that it degrades
gracefully which means it should work properly even if an error occurs
during the execution.
8. Assessed or quality –
The design should be assessed or evaluated for the quality meaning that
during the evaluation, the quality of the design needs to be checked and
focused on.
9. Review to discover errors –
The design should be reviewed which means that the overall evaluation
should be done to check if there is any error present or if it can be
minimized.
10.Design is not coding and coding is not design –
Design means describing the logic of the program to solve any problem
and coding is a type of language that is used for the implementation of a
design.

4.Architectural Design:
Architectural design is a critical component of software engineering project
management (SEPM). It involves making decisions about the overall structure
and organization of a software system, including the different components and
how they interact with each other. There are several key concepts and
techniques involved in architectural design, including design decisions, views,
patterns, and application architectures.

Architectural Patterns/styles:
• Common archi. Styles-
1. Data-centered architectures
2. Data-flow architectures
3. Call and return architectures
4. Layered system architectures
5. Object-oriented architectures
(Z魔王)

1.Data-centered architectures
• A data store -center of this architecture & is accessed frequently by
other components that update, add, delete, or otherwise modify data
within the store.
• Client software accesses a central repository.

Advantages-
• Data repository not dependant on clients.
• Clients work independently.
• Adding new clients-easy.
• Modification-easy.

2.Data-flow architectures
– accepts some input & transforms it into some output by applying a sequence
of transformations.
Pipe & Filter pattern-
Each component filter Transforms data & sends to next filter for
additional processing through a connector-pipe(channel).
Batch sequential-
This pattern accepts a batch of data and then applies a series of sequential
components (filters) to transform it.
(Z魔王)

Adv-
• Supports maintainability, reusability, modifiability.
• Concurrent execution supported.

3.Call and return architectures:


It is used to create a program that is easy to scale and modify. Many sub-styles
exist within this category. Two of them are explained below.
• Remote procedure call architecture: This components is used to present
in a main program or sub program architecture distributed among
multiple computers on a network.
• Main program or Subprogram architectures: The main program
structure decomposes into number of subprograms or function into a
control hierarchy. Main program contains number of subprograms that
can invoke other components.
(Z魔王)

4.Layered system architectures:


The components of a system encapsulate data and the operations that
must be applied to manipulate the data. Communication and
coordination between components are accomplished via message
passing.

5.Layered system architectures:


At outer layer, components provide user interface operations. At the
inner layer, components perform OS interfacing. Intermediate layers
provide utility services and application software functions.

Architectural views:
Used to describe system from viewpoints of diff. stakeholders like end users,
developers, sys. Engineer & project manager.
4 +1 view model-
1. Logical View- functionality of sys. Provided to users.
UML diagrams used to describe this view- Class dia., state diagram.
2. Process View- describes sys. Processes & how they communicate &
focuses on runtime behavior of sys.
e.g. activity diagram
(Z魔王)

3. Development view- describes sys from developer’s perspective. e.g.


package diagram
4. Physical view- describes sys from sys. Engineer’s perspective. E.g.
deployment diagram.
5. Scenarios- description of an archi. is illustrated using small set of use
cases or scenarios.

4.User Interface Design:


User interface is the front-end application view to which user interacts in order
to use the software. The software becomes more popular if its user interface is:
• Attractive
• Simple to use
• Responsive in short time
• Clear to understand
• Consistent on all interface screens

There are two types of User Interface:


1. Command Line Interface: Command Line Interface provides a command
prompt, where the user types the command and feeds to the system.
The user needs to remember the syntax of the command and its use.
2. Graphical User Interface: Graphical User Interface provides the simple
interactive interface to interact with the system. GUI can be a
combination of both hardware and software. Using GUI, user interprets
the software.
(Z魔王)

Golden Rules:
The are 3 golden rules stated by Theo Mandel that must be followed during the
design of the interface.
1. Place the user in control
2. Reduce the user’s memory load
3. Make the interface consistent

1.Place the user in control:


• Define the interaction modes in such a way that does not force the user
into unnecessary or undesired actions: The user should be able to easily
enter and exit the mode with little or no effort.
• Provide for flexible interaction: Different people will use different
interaction mechanisms, some might use keyboard commands, some
might use mouse, some might use touch screen, etc, Hence all
interaction mechanisms should be provided.
• Allow user interaction to be interruptible and undoable: When a user is
doing a sequence of actions the user must be able to interrupt the
sequence to do some other work without losing the work that had been
done. The user should also be able to do undo operation.
• Streamline interaction as skill level advances and allow the interaction to
be customized: Advanced or highly skilled user should be provided a
chance to customize the interface as user wants which allows different
interaction mechanisms so that user doesn’t feel bored while using the
same interaction mechanism.
• Hide technical internals from casual users: The user should not be aware
of the internal technical details of the system. He should interact with
the interface just to do his work.
• Design for direct interaction with objects that appear on screen: The user
should be able to use the objects and manipulate the objects that are
present on the screen to perform a necessary task. By this, the user feels
easy to control over the screen.
(Z魔王)

2.Reduce the user’s memory load:


• Reduce demand on short-term memory: When users are involved in
some complex tasks the demand on short-term memory is significant. So
the interface should be designed in such a way to reduce the
remembering of previously done actions, given inputs and results.
• Establish meaningful defaults: Always initial set of defaults should be
provided to the average user, if a user needs to add some new features
then he should be able to add the required features.
• Define shortcuts that are intuitive: Mnemonics should be used by the
user. Mnemonics means the keyboard shortcuts to do some action on
the screen.
• The visual layout of the interface should be based on a real-world
metaphor: Anything you represent on a screen if it is a metaphor for
real-world entity then users would easily understand.
• Disclose information in a progressive fashion: The interface should be
organized hierarchically i.e. on the main screen the information about
the task, an object or some behavior should be presented first at a high
level of abstraction. More detail should be presented after the user
indicates interest with a mouse pick.
3.Make the interface consistent:
• Allow the user to put the current task into a meaningful context: Many
interfaces have dozens of screens. So it is important to provide indicators
consistently so that the user know about the doing work. The user
should also know from which page has navigated to the current page and
from the current page where can navigate.
• Maintain consistency across a family of applications: The development of
some set of applications all should follow and implement the same
design, rules so that consistency is maintained among applications.
• If past interactive models have created user expectations do not make
changes unless there is a compelling reason.
(Z魔王)

Interface Design steps & Analysis:

The analysis and design process of a user interface is iterative and can be
represented by a spiral model. The analysis and design process of user
interface consists of four framework activities.
1. User, task, environmental analysis, and modeling: Initially, the focus is
based on the profile of users who will interact with the system, i.e.
understanding, skill and knowledge, type of user, etc, based on the user’s
profile users are made into categories. From each category requirements
are gathered. Based on the requirements developer understand how to
develop the interface. Once all the requirements are gathered a detailed
analysis is conducted. In the analysis part, the tasks that the user
performs to establish the goals of the system are identified, described
and elaborated. The analysis of the user environment focuses on the
physical work environment. Among the questions to be asked are:
• Where will the interface be located physically?
• Will the user be sitting, standing, or performing other tasks
unrelated to the interface?
(Z魔王)

• Does the interface hardware accommodate space, light, or noise


constraints?
• Are there special human factors considerations driven by
environmental factors?
2. Interface Design: The goal of this phase is to define the set of interface
objects and actions i.e. Control mechanisms that enable the user to
perform desired tasks. Indicate how these control mechanisms affect the
system. Specify the action sequence of tasks and subtasks, also called a
user scenario. Indicate the state of the system when the user performs a
particular task. Always follow the three golden rules stated by Theo
Mandel. Design issues such as response time, command and action
structure, error handling, and help facilities are considered as the design
model is refined. This phase serves as the foundation for the
implementation phase.
3. Interface construction and implementation: The implementation
activity begins with the creation of prototype (model) that enables usage
scenarios to be evaluated. As iterative design process continues a User
Interface toolkit that allows the creation of windows, menus, device
interaction, error messages, commands, and many other elements of an
interactive environment can be used for completing the construction of
an interface.
4. Interface Validation: This phase focuses on testing the interface. The
interface should be in such a way that it should be able to perform tasks
correctly and it should be able to handle a variety of tasks. It should
achieve all the user’s requirements. It should be easy to use and easy to
learn. Users should accept the interface as a useful one in their work.

Design Evaluation Cycle


User Interface Design Activities
• Several acti. Carried out for designing UI.
• Similar to SDLC.
• For gui imple, models used are-waterfall,iterative,spiral.
• Foll. Steps shd be fulfilled by model for gui design & development.
(Z魔王)

• GUI Req. Gathering- Functions as well as nonfun. Req. are gathered from
user & their existing s/w solution.
• User Analysis- study regarding who actually wl use s/w is done. If user
techsavy - advanced & complex gui can be designed. New user- more
informative GUI.
• Task analysis- can be done in hierarchical manner.
The flow of GUI contents is decided by flow of info. Among sub-tasks.
• GUI Design & implementation- After getting complete info. Regarding
tasks & user environment, designers design GUI & imple design &
integrate it with software in background.
• GUI Testing- Imp. Aspects are verified in testing are- usability,
compatibility, user acceptance etc.

You might also like