RAD consists of five segments:
Discover Bussines Processes: Here analysts gain an understanding of
the client's bussines processes, by interviewing the client or a knowledgeable
client-designated person and asks the interviewee to go through the relevant process-es
step-by-step.
Product: Activity diagram(s).
Perform Domain Analysis: The analyst interviews the client with the
gola of understanding the major entities in the client's domain. During the conversation
between the client and the anlyst, another team member takes notes. The object modeler
listens for nouns and starts by making each noun a class. Ultimatelly, some nouns will
become attributes. He or she also listens for verbs, which will become operations of the
classes.
Product: High-level class diagram and a set of meeting
notes.
Identify Cooperating Systems: Early in the process the development
team finds out exactly which systems the new system will depend on, and which systems will
depend on it. A system engineer takes care of this action.
Product: Deployment diagram.
Discover System Requirements: In this action team goes through its
first Joint Application Development (JAD) session. This session brings together decision
makers from client's organization, potential users and the members of the development
team. A facilitator moderates the session. The facilitator's job is to elicit from the
decision-makers and the users what they want the system to do. At least two team members
should be taking notes, and the object modeler should be refining the class diagram
derived earlier.
Product: Package diagram.
Present Results to Client: When the team finishes all the Requirements actions, the project manager presents the results to the client.
Understand System Usage: In a JAD session with potential users, the
development team works with the users to discover the actors who initiate each use case
from the Requirements JAD session, and the actors who benefit from those use cases (Actor
can be a system as well as a person).
Product: Use case diagram(s).
Flesh Out Use Cases: Lets continue to work with users. The objective
is to analyze the sequence of steps in each use case.
Product: Text description of the steps in each use case
diagram.
Refine the Class Diagrams: The object modeler, during the JAD sessions
listening all the discussions, refines the class diagram. He or she should be filling in
the names of the associations, abstract classes, multiplicities, generalizations and
aggregations.
Product: Refined class diagram.
Analyze Changes of State in Objects: Also object modeler refines the
model by showing changes of state wherever necessary.
Product: State diagram.
Define the Interactions Among Objects: At this moment development team
has a set of use cases and refined class diagram, it's time to define how the objects
interact. The object modeler develops a set of diagrams which includes state changes.
Product: Sequence and collaboration diagrams.
Analyze Integration with Cooperating Systems: The system engineer,
proceeding in parallel with all the preceding steps, uncovers specific details of the
integration with the cooperating systems. What type of communication is involved? What is
the network architecture? If the system has to access databases, and if which are the
types of databases.
Product: Detailed deployment diagram and if necessary data
models.
![]() |
Design | |
In this segment, the team works with the results of the Analysis segment to design the solution. Design and Analysys should go back and forth until the design is complete. |
Develop and Refine Object Diagrams: Programmers take the class diagram
and generate any necessary object diagrams by examing each operation and developing a
corresponding activity diagram. This activity diagrams will serve as the basis for much of
the coding in the Development segment.
Product: Activity diagrams.
Develop Component Diagrams: In this action programmers also play a
major role. The task here is to visualize the components that will result from the next
segment and show the dependencies among them.
Product: Component diagrams.
Plan for Deployment: After aiming the component diagrams, the system
engineer begins planning for deployment and for integration with cooperating systems.
Created diagram shows where the components will reside.
Product: Part of the deployment diagram developed earlier.
Design and Prototype User Interface: This involves another JAD session
with the users, continuation of the prior JAD sessions. This is a typical indication of
the interplay between Analysis and Design. A GUI analyst works with the users to develop
paper prototypes of screen that correspond to groups of use cases.
Product: Screen shots of the screen prototypes.
Design Tests: Preferably, a developer or test specialist from outside
the development team uses the uses case diagrams to develop test scripts for automated
test tools.
Product: Test scripts.
Begin Documentation: Documentation specialists work with the designers
to begin story-boarding the documentation and arriving at a high-level structure for each
document.
Product: Document structure.
![]() |
Development | |
With enough analysis and design, this segment should go quickly and smoothly. In this segment programmers take over. |
Construct Code: With the class, object, activity and component
diagrams in hand, programmers construct the code for the system.
Product: The code.
Test Code: This action feeds back into the preceding action and vice
versa, until code passes all levels of testing, developed in previous segment (Design
Tests).
Product: Test results.
Construct User Interfaces, Connect to Code and Test: Also and this
action is a connection between Design and Development. Here a GUI specialist construct
aproved interface prototypes and connects them to code. Also and testing the interface
ensures that the interfaces work correctly.
Product: Functioning system, complete with user interfaces.
Complete Documentation: During the development segment, documentation
experts work in parallel with programmers to complete of all documentation.
Product: System documentation.
![]() |
Deployment | |
When development is complete, the system is deployed on the appropriate hardware and integrated with the cooperation systems. |
Plan for Backup and Recovery: This action can start long before the
development segment begins. The system engineer creates a plan for steps to follow in case
the system crashes.
Product: The crash recovery plan.
Install the Finished System on Appropriate Hardware: This step
performs the system engineer with any necessary help from the programmers.
Product: Fully deployed system.
Test the Installed System: After installing the software on
appropriate computer(s), the development team tests the installed system. Does it perform
as it's supposed to? Does the backup and recovery plan work? Results of this tests
determine whether further refinement is necessary.
Product: Test results.
Celebrate: When all of the work is finished, the development team may go somewhere to celebrate for their success.
A skeleton of development process is GRAPPLE
(Guidelines for Rapid APPLication Engineering), which consist of five segments:
Requirements gathering, Analysis, Design, Development and Deployment. Each segment
consists of a number of actions, and each action results in a work-product. UML diagrams
are work products for many of the actions.