computer science

The Software Development Life Cycle (SDLC)
For Small To Medium Database Applications
computer science tutorial
seminar topic
newidea
computer science engineering
power of computer
magic of computer
computerinformation
TABLE OF CONTENTS

INTRODUCTION ....................................................................................................... 4
THE SDLC WATERFALL ............................................................................ 4
ALLOWED VARIATIONS .............................................................................. 5
OTHER SDLC MODELS............................................................................. 6
REFERENCES ........................................................................................... 7
GENERIC STAGE ..................................................................................................... 8
KICKOFF PROCESS ................................................................................... 8
INFORMAL ITERATION PROCESS ................................................................. 9
FORMAL ITERATION PROCESS.................................................................... 9
IN-STAGE ASSESSMENT PROCESS ........................................................... 10
STAGE EXIT PROCESS ............................................................................ 11
SDLC STAGES ...................................................................................................... 12
OVERVIEW ............................................................................................. 12
PLANNING STAGE ................................................................................... 13
REQUIREMENTS DEFINITION STAGE.......................................................... 14
DESIGN STAGE....................................................................................... 16
DEVELOPMENT STAGE ............................................................................ 17
INTEGRATION & TEST STAGE................................................................... 18
INSTALLATION & ACCEPTANCE STAGE...................................................... 19
CONCLUSION......................................................................................................... 20
SCOPE RESTRICTION .............................................................................. 20
PROGRESSIVE ENHANCEMENT................................................................. 20
PRE-DEFINED STRUCTURE ...................................................................... 21
INCREMENTAL PLANNING.........................................................................22

INTRODUCTION

This document describes the Software Development LifeCycle (SDLC) for small
to medium database application development efforts. This chapter presents an
overview of the SDLC, alternate lifecycle models, and associated references. The
following chapter describes the internal processes that are common across all
stages of the SDLC, and the third chapter describes the inputs, outputs, and
processes of each stage. Finally, the conclusion describes the four core concepts
that form the basis of this SDLC.
THE SDLC WATERFALL
Small to medium database software projects are generally broken down into six
stages:
Project
Planning
Requirements
Definition
Design
Development
Integration
& Test
Installation
& Acceptance

The relationship of each stage to the others can be roughly described as a
waterfall, where the outputs from a specific stage serve as the initial inputs for the
following stage.
During each stage, additional information is gathered or developed, combined
with the inputs, and used to produce the stage deliverables. It is important to note
that the additional information is restricted in scope; “new ideas” that would take
The Software Development Life Cycle (SDLC) REF-0-02
For small to medium database applications Version 1.0d
5
the project in directions not anticipated by the initial set of high-level
requirements are not incorporated into the project. Rather, ideas for new
capabilities or features that are out-of-scope are preserved for later consideration.
After the project is completed, the Primary Developer Representative (PDR) and
Primary End-User Representative (PER), in concert with other customer and
development team personnel develop a list of recommendations for enhancement

of the current software.
PROTOTYPES
The software development team, to clarify requirements and/or design elements,
may generate mockups and prototypes of screens, reports, and processes.
Although some of the prototypes may appear to be very substantial, they're
generally similar to a movie set: everything looks good from the front but there's
nothing in the back.
When a prototype is generated, the developer produces the minimum amount of
code necessary to clarify the requirements or design elements under
consideration. No effort is made to comply with coding standards, provide robust
error management, or integrate with other database tables or modules. As a result,
it is generally more expensive to retrofit a prototype with the necessary elements
to produce a production module then it is to develop the module from scratch
using the final system design document.
For these reasons, prototypes are never intended for business use, and are
generally crippled in one way or another to prevent them from being mistakenly
used as production modules by end-users.

ALLOWED VARIATIONS
In some cases, additional information is made available to the development team
that requires changes in the outputs of previous stages. In this case, the
development effort is usually suspended until the changes can be reconciled with
the current design, and the new results are passed down the waterfall until the
project reaches the point where it was suspended.
The PER and PDR may, at their discretion, allow the development effort to
continue while previous stage deliverables are updated in cases where the impacts
are minimal and strictly limited in scope. In this case, the changes must be
carefully tracked to make surOTHER SDLC MODELS
The waterfall model is one of the three most commonly cited lifecycle models.
Others include the Spiral model and the Rapid Application Development (RAD)
model, often referred to as the Prototyping model.
SPIRAL LIFECYCLE
The spiral model starts with an initial pass through a standard waterfall lifecycle,
using a subset of the total requirements to develop a robust prototype. After an
evaluation period, the cycle is initiated again, adding new functionality and
releasing the next prototype. This process continues, with the prototype becoming
larger and larger with each iteration. Hence, the “spiral.”
The theory is that the set of requirements is hierarchical in nature, with additional
functionality building on the first efforts. This is a sound practice for systems
where the entire problem is well defined from the start, such as modeling and
simulating software. Business-oriented database projects do not enjoy this
advantage. Most of the functions in a database solution are essentially
independent of one another, although they may make use of common data. As a
result, the prototype suffers from the same flaws as the prototyping lifecycle
described below. For this reason, the software development team has decided
against the use of the spiral lifecycle for database projects.e all their impacts are appropriately handled.

6
OTHER SDLC MODELS
The waterfall model is one of the three most commonly cited lifecycle models.
Others include the Spiral model and the Rapid Application Development (RAD)
model, often referred to as the Prototyping model.
SPIRAL LIFECYCLE
The spiral model starts with an initial pass through a standard waterfall lifecycle,
using a subset of the total requirements to develop a robust prototype. After an
evaluation period, the cycle is initiated again, adding new functionality and
releasing the next prototype. This process continues, with the prototype becoming
larger and larger with each iteration. Hence, the “spiral.”
The theory is that the set of requirements is hierarchical in nature, with additional
functionality building on the first efforts. This is a sound practice for systems
where the entire problem is well defined from the start, such as modeling and
simulating software. Business-oriented database projects do not enjoy this
advantage. Most of the functions in a database solution are essentially
independent of one another, although they may make use of common data. As a
result, the prototype suffers from the same flaws as the prototyping lifecycle
described below. For this reason, the software development team has decided
against the use of the spiral lifecycle for database projects.
RAPID APPLICATION DEVELOPMENT (RAD) / PROTOTYPING LIFECYCLE
RAD is, in essence, the “try before you buy” approach to software development.
The theory is that end users can produce better feedback when examining a live
system, as opposed to working strictly with documentation. RAD-based
development cycles have resulted in a lower level of rejection when the
application is placed into production, but this success most often comes at the
expense of a dramatic overruns in project costs and schedule.
The RAD approach was made possible with significant advances in software
development environments to allow rapid generation and change of screens and
other user interface features. The end user is allowed to work with the screens
online, as if in a production environment. This leaves little to the imagination, and
a significant number of errors are caught using this process.
The down side to RAD is the propensity of the end user to force scope creep into
the development effort. Since it seems so easy for the developer to produce the
basic screen, it must be just as easy to add a widget or two. In most RAD lifecycle
failures, the end users and developers were caught in an unending cycle of
enhancements, with the users asking for more and more and the developers trying
to satisfy them. The participants lost sight of the goal of producing a basic, useful
system in favor of the siren song of glittering perfection.

For this reason, the software development team does not use a pure RAD
approach, but instead blends limited prototyping in with requirements and design
development during a conventional waterfall lifecycle. The prototypes developed
are specifically focused on a subset of the application, and do not provide an
integrated interface. The prototypes are used to validate requirements and design
elements, and the development of additional requirements or the addition of user
interface options not readily supported by the development environment is
actively discouraged.

REFERENCES
The following standards were used as guides to develop this SDLC description.
The standards were reviewed and tailored to fit the specific requirements of small
database projects.
• ANSI/IEEE 1028: Standard for Software Reviews and Audits
• ANSI/IEEE 1058.1: Standard for Software Project Management Plans
• ANSI/IEEE 1074: Standard for Software Lifecycle Processes
• SEI/CMM: Software Project Planning Key Process Area
This document makes extensive use of terminology that is specific to software
engineering. A glossary of standard software engineering terms is available online
at:
• http://www.elucidata.org/refs/seglossary.pdf

GENERIC STAGE
Each of the stages of the development lifecycle follow five standard internal
processes. These processes establish a pattern of communication and
documentation intended to familiarize all participants with the current situation,
and thus minimize risk to the current project plan. This generic stage description
is provided to avoid repetitive descriptions of these internal processes in each of
the following software lifecycle stage descriptions. The five standard processes
are Kickoff, Informal iteration, Formal iteration, In-stage assessment, and Stage
exit:
Kickoff
Process
Informal
Iteration
Formal
Iteration
In-Stage
Assessment
Stage
Exit
SDLC Stage

KICKOFF PROCESS
Each stage is initiated by a kickoff meeting, which can be conducted either in
person, or by Web teleconference. The purpose of the kickoff meeting is to
review the output of the previous stage, go over any additional inputs required by
that particular stage, examine the anticipated activities and required outputs of the
current stage, review the current project schedule, and review any open issues.
The PDR is responsible for preparing the agenda and materials to be presented at
this meeting. All project participants are invited to attend the kickoff meeting for
each stage.

INFORMAL ITERATION PROCESS
Most of the creative work for a stage occurs here. Participants work together to
gather additional information and refine stage inputs into draft deliverables.
Activities of this stage may include interviews, meetings, the generation of
prototypes, and electronic correspondence. All of these communications are
deemed informal, and are not recorded as minutes, documents of record,
controlled software, or official memoranda.
The intent here is to encourage, rather than inhibit the communication process.
This process concludes when the majority of participants agree that the work is
substantially complete and it is time to generate draft deliverables for formal
review and comment.

FORMAL ITERATION PROCESS
In this process, draft deliverables are generated for formal review and comment.
Each deliverable was introduced during the kickoff process, and is intended to
satisfy one or more outputs for the current stage. Each draft deliverable is given a
version number and placed under configuration management control.
As participants review the draft deliverables, they are responsible for reporting
errors found and concerns they may have to the PDR via electronic mail. The
PDR in turn consolidates these reports into a series of issues associated with a
specific version of a deliverable. The person in charge of developing the
deliverable works to resolve these issues, then releases another version of the
deliverable for review. This process iterates until all issues are resolved for each
deliverable. There are no formal check off / signature forms for this part of the
process. The intent here is to encourage review and feedback.
At the discretion of the PDR and PER, certain issues may be reserved for
resolution in later stages of the development lifecycle. These issues are
disassociated from the specific deliverable, and tagged as "open issues." Open
issues are reviewed during the kickoff meeting for each subsequent stage.
Once all issues against a deliverable have been resolved or moved to open status,
the final (release) draft of the deliverable is prepared and submitted to the PDR.
When final drafts of all required stage outputs have been received, the PDR
reviews the final suite of deliverables, reviews the amount of labor expended
against this stage of the project, and uses this information to update the project

At the discretion of the PDR and PER, certain issues may be reserved for
resolution in later stages of the development lifecycle. These issues are
disassociated from the specific deliverable, and tagged as "open issues." Open
issues are reviewed during the kickoff meeting for each subsequent stage.
Once all issues against a deliverable have been resolved or moved to open status,
the final (release) draft of the deliverable is prepared and submitted to the PDR.
When final drafts of all required stage outputs have been received, the PDR
reviews the final suite of deliverables, reviews the amount of labor expended
against this stage of the project, and uses this information to update the project
plan.
The project plan update includes a detailed list of tasks, their schedule and
estimated level of effort for the next stage. The stages following the next stage

IN-STAGE ASSESSMENT PROCESS
This is the formal quality assurance review process for each stage. In a small
software development project, the deliverables for each stage are generally small
enough that it is not cost effective to review them for compliance with quality
assurance standards before the deliverables have been fully developed. As a
result, only one in-stage assessment is scheduled for each stage.
This process is initiated when the PDR schedules an in-stage assessment with the
independent Quality Assurance Reviewer (QAR), a selected End-user Reviewer
(usually a Subject Matter Expert), and a selected Technical Reviewer.
These reviewers formally review each deliverable to make judgments as to the
quality and validity of the work product, as well as its compliance with the
standards defined for deliverables of that class. Deliverable class standards are
defined in the software quality assurance section of the project plan.
The End-user Reviewer is tasked with verifying the completeness and accuracy of
the deliverable in terms of desired software functionality. The Technical
Reviewer determines whether the deliverable contains complete and accurate
technical information.
The QA Reviewer is tasked solely with verifying the completeness and
compliance of the deliverable against the associated deliverable class standard.
The QAR may make recommendations, but cannot raise formal issues that do not
relate to the deliverable standard.
Each reviewer follows a formal checklist during their

Each reviewer follows a formal checklist during their review, indicating their
level of concurrence with each review item in the checklist. Refer to the software
quality assurance plan for this project for deliverable class standards and
associated review checklists. A deliverable is considered to be acceptable when