Memberi maaf
CHAPTER 2
THE PROCESS
What is it?
When you build a product or system, its important to
go through a series of predictable stepsa road map
that helps you create a timely, high-quality result. The
road map that you follow is called a software
process.
Ketika kita membangun sebuah produk atau sistem,
penting untuk melalui serangkaian langkah-langkah
yang dapat diprediksi, yaitu sebuah road map yang
membantu kita membuat sebuah hasil berkualitas
tinggi dan jelas waktunya. Road map itulah yang kita
sebut sebagai proses s/w.
3
Why is it important?
Because it provides stability, control, and
organization to an activity that can, if left
uncontrolled, become quite chaotic.
Karena proses s/w memberikan stabilitas,
kendali dan organisasi terhadap aktifitas yang
seandainya dibiarkan begitu saja akan
menjadi sangat kacau.
BAUER
[Software engineering is] the establishment
and use of sound engineering principles in
order to obtain economically software that is
reliable and works efficiently on real
machines.
Pembuatan dan penggunaan prinsip
rekayasa untuk memperoleh s/w secara
ekonomis dimana s/w tersebut dapat
dipercaya dan bekerja secara efisien pada
mesin nyata.
9
SWE Layered
Technology
A Generic View of
Software Engineering
12
Correction
Addaptation
Enhancement
Prevention
16
Umbrella activities
Are applied throughout the software process.
Diterapkan pada seluruh proses PL.
Include:
The Process
18
Capability Maturity
Model - SEI
Level 1: Initial. The software process is characterized as ad hoc and
occasionally even chaotic. Few processes are defined, and success
depends on individual effort.
Level 2: Repeatable. Basic project management processes are
established to track cost, schedule, and functionality. The necessary
process discipline is in place to repeat earlier successes on projects
with similar applications.
Level 3: Defined. The software process for both management and
engineering activities is documented, standardized, and integrated into
an organizationwide software process. All projects use a documented
and approved version.
Level 4: Managed. Detailed measures of the software process and
product quality are collected. Both the software process and products
are quantitatively understood and controlled using detailed measures.
Level 5: Optimizing. Continuous process improvement is enabled by
quantitative feedback from the process and from testing innovative
ideas and technologies.
19
Process Maturity
Level 2
Software configuration management
Software quality assurance
Software subcontract management
Software project tracking and oversight
Software project planning
Requirements management
Level 3
Peer reviews
Intergroup coordination
Software product engineering
Integrated software management
Training program
Organization process definition
Organization process focus
20
Process Maturity
Level 4
Software quality management
Quantitative process management
Level 5
Process change management
Technology change management
Defect prevention
21
SOFTWARE PROCESS
MODELS
Often referred to as software engineering
paradigm.
A development strategy that encompasses the
process, methods, and tools layers described
and the generic phases.
Chosen based on the nature of the project
and application, the methods and tools to be
used, and the controls and deliverables that
are required.
22
L. B. S. Raccoon
23
THE LINEAR
SEQUENTIAL MODEL
Sometimes called the classic life cycle
or the waterfall model,
The linear sequential model suggests a
systematic, sequential approachs to
software development that begins at the
system level and progresses through
analysis, design, coding, testing, and
support.
24
THE LINEAR
SEQUENTIAL MODEL
25
Problems Encounter
1. Real projects rarely follow the sequential flow that the
model proposes. Although the linear model can
accommodate iteration, it does so indirectly. As a result,
changes can cause confusion as the project team
proceeds.
2. It is often difficult for the customer to state all
requirements explicitly. The linear sequential model
requires this and has difficulty accommodating the natural
uncertainty that exists at the beginning of many projects.
3. The customer must have patience. A working version of
the program(s) will not be available until late in the project
time-span. A major blunder, if undetected until the working
program is reviewed, can be disastrous.
26
THE PROTOTYPING
MODEL
Often, a customer defines a set of general objectives for software
but does not identify detailed input, processing, or output
requirements. The developer may be unsure of the algorithm
efficiency, the operating system adaptability, or the human/
machine interaction form should take.
Begins with requirements gathering. Developer and customer
meet and define the overall objectives for the software, identify
whatever requirements are known, and outline areas where further
definition is mandatory. A "quick design" then occurs.
The quick design focuses on a representation of those aspects of
the software that will be visible to the customer/user (e.g., input
approaches and output formats). The quick design leads to the
construction of a prototype.
The prototype is evaluated by the customer/ user and used to
refine requirements for the software to be developed. Iteration
occurs as the prototype is tuned to satisfy the needs.
27
28
Problematic issues
1. No one has considered overall software quality or long-term
maintainability. When informed that the product must be rebuilt
so that high levels of quality can be maintained, the customer
cries foul and demands that "a few fixes" be applied to make the
prototype a working product. Too often, software development
management relents.
2. The developer often makes implementation compromises in
order to get a prototype working quickly. An inappropriate
operating system or programming language may be used simply
because it is available and known; an inefficient algorithm may
be implemented simply to demonstrate capability. After a time,
the developer may become familiar with these choices and
forget all the reasons why they were inappropriate. The lessthan-ideal choice has now become an integral part of the
system.
29
31
Drawbacks
For large but scalable projects, RAD requires sufficient human
resources to create the right number of RAD teams.
RAD requires developers and customers who are committed to
the rapid-fire activities necessary to get a system complete in a
much abbreviated time frame. If commitment is lacking from either
constituency, RAD projects will fail.
Not all types of applications are appropriate for RAD. If a system
cannot be properly modularized, building the components
necessary for RAD will be problematic. If high performance is an
issue and performance is to be achieved through tuning the
interfaces to system components, the RAD approach may not
work.
RAD is not appropriate when technical risks are high. This occurs
when a new application makes heavy use of new technology or
when the new software requires a high degree of interoperability
with existing computer programs.
32
EVOLUTIONARY
SOFTWARE PROCESS
MODELS
There is growing recognition that software, like all complex
systems, evolves over a period of time [GIL88].
Business and product requirements often change as
development proceeds, making a straight path to an end
product unrealistic; tight market deadlines make
completion of a comprehensive software product
impossible, but a limited version must be introduced to
meet competitive or business pressure; a set of core
product or system requirements is well understood, but
the details of product or system extensions have yet to be
defined.
In these and similar situations, software engineers need a
process model that has been explicitly designed to
accommodate a product that evolves over time.
33
THE INCREMENTAL
MODEL
The incremental model combines elements of the linear
sequential model (applied repetitively) with the iterative
philosophy of prototyping. Each linear sequence produces
a deliverable increment of the software [MDE93].
For example, word-processing software developed using
the incremental paradigm might deliver basic file
management, editing, and document production functions
in the first increment; more sophisticated editing and
document production capabilities in the second increment;
spelling and grammar checking in the third increment; and
advanced page layout capability in the fourth increment.
It should be noted that the process flow for any increment
can incorporate the prototyping paradigm.
34
35
37
39
THE CONCURRENT
DEVELOPMENT MODEL
The concurrent process model can be represented
schematically as a series of major technical activities,
tasks, and their associated states.
The concurrent process model defines a series of
events that will trigger transitions from state to state
for each of the software engineering activities. For
example, during early stages of design, an
inconsistency in the analysis model is uncovered.
This generates the event analysis model correction
which will trigger the analysis activity from the done
state into the awaiting changes state.
Often used as the paradigm for the development of
client/ server applications.
40
41
COMPONENT-BASED
DEVELOPMENT
Object-oriented technologies provide the technical framework
for a component-based process model for software
engineering. The object oriented paradigm emphasizes the
creation of classes that encapsulate both data and the
algorithms used to manipulate the data. If properly designed
and implemented, object-oriented classes are reusable across
different applications and computer-based system
architectures.
The component-based development (CBD) model (Figure
2.11) incorporates many of the characteristics of the spiral
model. It is evolutionary in nature, demanding an iterative
approach to the creation of software.
However, the component-based development model
composes applications from prepackaged software
components (called classes).
42
43
Following concerns
The development of formal models is currently quite
time consuming and expensive.
Because few software developers have the
necessary background to apply formal methods,
extensive training is required.
It is difficult to use the models as a communication
mechanism for technically unsophisticated
customers.
45
FOURTH GENERATION
TECHNIQUES (4GT)
Encompasses a broad array of software tools that have one
thing in common: each enables the software engineer to specify
some characteristic of software at a high level.
The tool then automatically generates source code based on the
developer's specification.
There is little debate that the higher the level at which software
can be specified to a machine, the faster a program can be built.
The 4GT paradigm for software engineering focuses on the
ability to specify software using specialized language forms or a
graphic notation that describes the problem to be solved in
terms that the customer can understand.
Implementation using a 4GL enables the software developer to
represent desired results in a manner that leads to automatic
generation of code to create those results.
46
Pro Cont
Like all software engineering paradigms, the 4GT
model has advantages and disadvantages.
Proponents claim dramatic reduction in software
development time and greatly improved productivity
for people who build software.
Opponents claim that current 4GT tools are not all
that much easier to use than programming
languages, that the resultant source code produced
by such tools is "inefficient," and that the
maintainability of large software systems developed
using 4GT is open to question.
47
Process Technology
The process models must be adapted for use by a software
project team. Process technology tools have been developed
to help software organizations analyze their current process,
organize work tasks, control and monitor progress, and
manage technical quality [BAN95].
Process technology tools allow a software organization to build
an automated model of the common process framework, task
sets, and umbrella activities.
The model, normally represented as a network, can then be
analyzed to determine typical work flow and examine
alternative process structures that might lead to reduced
development time or cost.
The process technology tool can also be used to coordinate
the use of other computer-aided software engineering tools
that are appropriate for a particular work task.
48
49