Software Engineering

UNIT III
2. Architecture- design a structure of something

The complete structure of the software is known as software architecture.

Structure provides conceptual integrity for a system in a number of ways.
The architecture is the structure of program modules where they interact with
each other in a specialized way.
The components use the structure of data.
The aim of the software design is to obtain an architectural framework of a
system.
The more detailed design activities are conducted from the framework.
Pattern- a repeated form
Design patterns represent the best practices used by
experienced object-oriented software developers. Design
patterns are solutions to general problems that software
developers faced during software development. These solutions
were obtained by trial and error by numerous software
developers over quite a substantial period of time.
Def: “A pattern is a named nugget of insight which conveys
the essence of a proven solution o a recurring problem within
a certain context amidst competing concerns”
4. Modularity- subdivide the system

Modularity simply means to divide the system or project into smaller parts to
reduce the complexity of the system or project. In the same way, modularity in
design means to subdivide 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.

It is necessary to divide the software into components known as modules.

“Modularity is the single attribute of software that allows a program to be

intellectually manageable”
5. Information Hiding- hide the information

Information hiding simply means to hide the information so

that it cannot be accessed by an unwanted party. In software
design, information hiding is achieved by designing the
modules in a manner that the information gathered or
contained in one module is hidden and it cant be accessed by
any other modules.
Functional independence occurs where modules address a specific
and constrained range of functionality. The modules provide
interfaces only to this functionality. By constraining their functionality,
the modules require the help of fewer other modules to carry out their
functionality.
The functional independence of a module can be judged using two
concepts: cohesion and coupling:
cohesion is the degree to which a module performs only one
function.
coupling is the degree to which a module requires other modules to
perform its function.
Refinement- removes impurities

Refinement simply means to refine something to remove any

impurities if present and increase the quality. The refinement
concept of software design is actually a process of developing or
presenting the software or system in a detailed manner that
means to elaborate a system or software. Refinement is very
necessary to find out any error if present and then to reduce it.
• Refactoring is the activity of changing the software's internal structure without
changing its external behaviour. It is specifically concerned with improving the
software's internal structure.
a refactoring neither adds nor removes functionality.
• Refactoring enables us to evolve the code slowly over time, to take an iterative and
incremental approach to implementation.
These are the types of refactoring:
• Code refactoring.
• Database refactoring.
• User interface (UI) refactoring.
Examples of UI refactoring include Align Entry Fields, Apply Common Button Size, Apply
Common Font, Indicate Format, Reword in Active Voice, and Increase Color Contrast.
 9. Design Classes
A set of design classes refine the analysis class by providing design details.
There are five different types of design classes and each type represents the layer of the design architecture
these are as follows:

1. User interface classes: These classes are designed for Human Computer Interaction(HCI).
These interface classes define all abstraction which is required for Human Computer Interaction(HCI).

2. Business domain classes: These classes are commonly refinements of the analysis classes.
These classes are recognized as attributes and methods which are required to implement
the elements of the business domain.
3. Process classes
It implement the lower level business abstraction which is needed to completely manage the business domain
class.

4. Persistence classes
It shows data stores that will persist behind the execution of the software.

5.System Classes
System classes implement software management and control functions that allow to operate and communicate
in computing environment and outside world.
 The characteristic of well formed designed class are as follows:

1. Complete and sufficient:

A design class must be the total encapsulation of all attributes and methods
which are required to exist for the class.
2. Primitiveness: The method in the design class should fulfil one service for
the class. If service is implemented with a method then the class should not
provide another way to fulfil same thing.
3. High cohesion: A cohesion design class has a small and focused set of
responsibilities. For implementing the set of responsibilities the design classes
are applied single-mindedly to the methods and attribute.
4. Low-coupling: All the design classes should collaborate with each other in a
design model. The minimum acceptable of collaboration must be kept in this
model. If a design model is highly coupled then the system is difficult to
implement, to test and to maintain over time.
 THE DESIGN MODEL
• The design model can be viewed in two different
dimensions.
• (Horizontally) The process dimension
• It indicates the evolution of the parts of the design model as each
design task is executed.
• (Vertically) The abstraction dimension
• It represents the level of detail as each element of the analysis model
is transformed into the design model and then iteratively refined.
• The elements of the design model use many of the same
UML diagrams that were used in the analysis model.

• The difference is that these diagrams are

• Refined and elaborated as part of design;
• More implementation-specific detail is provided,
• Architectural structure and style, components that reside within
the architecture,
• Interfaces between the components and with the outside world are
all emphasized.
 Data Design Elements
• Customer’s/ User’s View:
• Data Architecting (Creates a model of data that is represented at a
high level of abstraction). (Build Architecture of Data)

• Program Component Level: The design of Data

structure & algorithms.
• Application Level: Translate Data Model into a database.
• Business Level: Data warehouse(Reporting & Analysis of
DB) & Data mining(Analysis).
• At last it means creation of Data Dictionary.
 Architectural Design Elements
Provides an overall view of the software product(Similar like Floor Plan of
house)
The architectural model is derived from three sources:
• (1) Information about the application domain for the software to be built;
• (2) Specific requirements model elements such as data flow diagrams or
analysis classes, their relationships and collaborations for the problem at
hand;
• (3) The availability of architectural styles and patterns
Difference: An architectural style is a conceptual way of how the
system will be created / will work.
An architectural pattern describes a solution for implementing a style
at the level of subsystems or modules and their relationships.
 Interface Design Elements
• The interface design elements for software represent information flows
into and out of the system and how it is communicated among the
components defined as part of the architecture.
For example : A set of detailed drawings (and specifications) for the
doors, windows, and external utilities of a house. These drawings
describe the size and shape of doors and windows, the manner in which
they operate, the way in which utility connections (e.g., water, electrical,
gas, telephone) come into the house and are distributed among the
rooms depicted in the floor plan.
There are three important elements of interface design:
• (1) The user interface (UI);
• (2) External interfaces to other systems, devices, networks, or other producers
or consumers of information;
• (3) Internal interfaces between various design components.
1) UI design (increasingly called usability design) is a major software
engineering action
• Usability design incorporates
• Visual elements (e.g., layout, colour, graphics, interaction mechanisms),
• Ergonomic elements (e.g., information layout and placement, metaphors, UI
navigation),
• Technical elements (e.g., UI patterns, reusable components).
• In general, the UI is a unique subsystem within the overall application
architecture.
•The design of external interfaces requires perfect information about the
entity to which information is sent or received.
•The design of external interfaces should incorporate error checking and
(when necessary) appropriate security features
•For example, the SafeHome security function makes use of a control panel
that allows a homeowner to control certain aspects of the security function.
•In an advanced version of the system, control panel functions may be
implemented via a wireless PDA or mobile phone.
•The ControlPanel class (in Figure ) provides the behavior associated with a
keypad, and therefore, it must implement the operations readKeyStroke ()
and decodeKey ().
•If these operations are to be provided to other classes (in this case,
WirelessPDA and MobilePhone), it is useful to define an interface as shown
in the figure.
•The interface, named KeyPad, is shown as an <<interface>> stereotype or
as a small, labeled circle connected to the class with a line. The interface is
defined with no attributes and the set of operations that are necessary to
achieve the behavior of a keypad.
 Component-Level Design Elements
• The component-level design for software fully describes the internal detail of each
software component.
• Component elements (detailed drawing of each room, wiring, place of switches…)
• Internal details of each software component
• Data structures,
• algorithmic details,
• interface to access component operation (behavior).
 Deployment-Level Design Elements
Deployment-level design elements indicate how software
functionality and subsystems will be allocated within the physical
computing environment that will support the software.
• For example, the elements of the SafeHome product are
configured to operate within three primary computing
environments
• A home-based PC,
• The SafeHome control panel,
• Server housed at CPI Corp. (providing Internet-based access to the
system).
• The diagram shown in Figure is in descriptor form.
• This means that the deployment diagram shows the computing
environment but does not explicitly indicate configuration
details.
• For example, the “personal computer” is not further identified. It
could be a Mac or a Windows-based PC, a Sun workstation, or a
Linux-box.
• These details are provided when the deployment diagram is
revisited in instance form during .
• Each instance of the deployment (a specific, named hardware
configuration) is identified…