lec-20 - WordPress.com
Download
Report
Transcript lec-20 - WordPress.com
SOFTWARE ENGINEERING
Revision
Basic Design Principles
Cohesion
The Liskov Substitution Principle (LSP).
Dependency Inversion Principle (DIP).
The Common Reuse Principle (CRP).
Functional
Layer
Communicational
Coupling
Content Coupling
Common coupling
Data coupling
Routine call coupling
Inclusion or import coupling
External coupling
COMPONENT-LEVEL DESIGN FOR
WEBAPPS
The boundary between content and function is often
blurred when Web-based systems and applications
What is a WebApp component?
A well-defined function that manipulates content or
provides computational or data processing for an end
user
3
Types
Content Design
Content design at the component level focuses on
content objects and the manner in which they may be
packaged for presentation to a WebApp end user.
4
Types Cont.
Functional Design
Modern Web applications deliver increasingly
sophisticated processing functions for example
Provide
computation or data processing capability that
is appropriate for the WebApp’s business domain
Provide
sophisticated database query and access
5
Designing Conventional Components
The design of processing logic is governed by the
basic principles of algorithm design and structured
programming
The design of data structures is defined by the data
model developed for the system
The design of interfaces is governed by the
collaborations that a component must effect
6
Algorithm Design
The closest design activity to coding
The approach:
review
the design description for the component
use stepwise refinement to develop algorithm
use structured programming to implement procedural
logic
use ‘formal methods’ to prove logic
7
Stepwise Refinement
open
walk to door;
reach for knob;
open door;
walk through;
close door.
repeat until door opens
turn knob clockwise;
if knob doesn't turn, then
take key out;
find correct key;
insert in lock;
endif
pull/push door
move out of way;
end repeat
8
Algorithm Design Model
Represents the algorithm at a level of detail that
can be reviewed for quality
options:
graphical
(e.g. flowchart, box diagram)
pseudocode
programming language
decision table
9
Graphical Design Notation
”A picture is worth a thousand words,” but it’s rather
important to know which picture and which 1000
words.
We can use Flow chart for Graphical Design
Notation
10
Rules for Graphical Notations
A box is used to indicate a processing step
A diamond represents a logical condition
Arrows show the flow of control.
11
Program Design Language
Program design language (PDL),
structured English or pseudocode
also called
if condition x
then process a;
else process b;
endif
if-then-else
PDL
easy to combine with source code
machine readable, no need for graphics input
graphics can be generated from PDL
enables declaration of data as well as procedure
easier to maintain
12
Tabular Design Notation
13
Component-Based Development
In the software engineering context, reuse is an idea
both old and new.
Component-based software engineering (CBSE) is a
process that emphasizes the design and construction
of computer-based systems using reusable software
components.”
[CBSE] embodies the “buy, don’t build” philosophy14
Component-Based Development
Number of questions arise in CBSE
Is it possible to construct complex systems by assembling
them from a catalog of reusable software components?
Can this be accomplished in a cost- and time-effective
manner?
Can appropriate incentives be established to
encourage software engineers to reuse rather than
reinvent?
15
Barriers to Reuse
Few companies and organizations have anything that even slightly
resembles a comprehensive software reusability plan.
Although an increasing number of software vendors currently sell
tools or components that provide direct assistance for software
reuse.
Relatively little training is available to help software engineers and
managers understand and apply reuse
Many companies continue to encourage of software development
methodologies which do not facilitate reuse
16
Domain Engineering
The intent of domain engineering is to identify,
construct, catalog, and disseminate a set of
software components that have applicability to
existing and future software in a particular
application domain.
The overall goal is to establish mechanisms that
enable software engineers to share these
components—to reuse them—during work on new
and existing systems.
17