RAD (Rapid Application Development)

RAD consists of five segments:

	Requirements gathering
This segment consists of a several actions. Before moving on to actions, it is important to know that if you don't understand what the client wants, you'll never build the right system.

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.

	Analysis
Now the team drills down into the results of the Requirements segment and increases its understanding of the problem. In fact, some of the actions begin during the Requirements segment, while the object modelere begins refining the class diagram.

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.