SAMS TEACH YOURSELF UML in 24 Hours

Joseph Schmuller

GRAPPLE
Guidelines for Rapid APPLication Engineering

RAD³ Structure

1. Requirements gathering
• Discover business processes
  Understanding of client’s business processes and an important outcome is that the analyst gains a working vocabulary in a subset of the client’s terminology.
• Perform domain analysis
  The analyst hast to get comfortable in the client’s world. The object modeler listens for nouns and makes each noun a class or attributes and verbs become operations of the classes.
• Identify cooperating systems
  System Engineer produces a deployment diagram as the work-products
• Discover system requirements
  Object modeler should be refining the class diagram derived earlier. The work product is a package diagram represents a high-level area of system functionality (E.g. “assist with customer service”. Each package groups a set of use cases (E.g. “retrieve customer history” and “interact with customer”)
• Present results to client
  Require the client’s approval at this point, in order for development to proceed.
2. Analysis
• Understand System Usage
• Flesh out use cases
• Refine the Class Diagrams
• Analyze Changes of State in Objects
• Define the Interactions Among Objects
• Analyze Integration with Cooperating System
3. Designs
• Develop and Refine Object Diagrams
• Develop Component Diagrams
• Plan for Deployment
• Design and Prototype User interface
• Design Tests
• Begin Documentation
4. Development
• Construct Code
• Test Code
• Construct User Interfaces, Connect to Code and Test
• Complete Documentation
5. Deployment
• Plan for backup and recovery
• Install the Finished System on Appropriate Hardware
• Test the Installed System
• Celebrate

GRAPPLE with the Problem

1. Discovering Business Processes

Activity shows the steps and decision points that occur within the behavior of an object, or within a business process. Each steps is a rounded rectangle (more oval shaped than the representation of a state and each decision point is a diamond.

Activity diagram could turn into a swinlane diagram.

2. Performing a Domain Analysis

Class shows the entities in a system or a domain and how those entities relate to one another. Each class is represented as a named rectangle.

Object shows instances of the classes and their interrelationships. Each object is represented as a named rectangle

· Developing the Initial Class Diagram, all nouns classes

· Grouping the Classes

• Associations with the Customer
• Forming Aggregates and Composites
• Filling Out the Classes with nouns and verbs
• Model Dictionary

3 Gathering System Requirements

Developing the Vision

Component models the software components of a system. Each component appears as a rectangle with two smaller overlaid rectangles on its left border

Set of requirements that appears as use case arranged in the packages

E.g.

For the waiter package, the use case were

Take an order

Transmit the order to the kitchen

Change the order.

For the chef packages, the use cases were

4. Developing the Use Cases

Use case shows system usage. Each use case appears as an ellipse, and each actor as a stick figure

The use case Analysis

• A brief description of the scenario
• Assumptions for the scenario
• The actor who initiates the use case
• Preconditions for the use case
• System-related steps in the scenario
• Post conditions when the scenario is complete
• The actor who benefits from the use case

Notify Chef About Party Status

Description

Via the network, the waiter tells the chef that a customer is almost finished with the appetizer

Assumptions

1. The waiter is in the customer’s serving area

2. The server can gauge the customer’s progress

3. The system has a user-interface screen for customer status

4.The system transmits message from palmtop to kitchen PC and vice versa

Preconditions

The customer is partially finished with the appetizer

Post conditions

The chef ahs initiated the final stages of completing the main course

Steps

On the palmtop computer, the server activates the interface screen for customer status

The user interface brings up a list of the tables in the server’s serving area.

.

.

.

.

6. Getting into Interactions and State Changes

Sequence visualizes how the objects in a system interact with one another over time. The objects are laid out across the top, and time precedes form the top to the diagram to the bottom. Arrows are messages that go from objects to objects

State captures the state of an object during a specific time period. A state is represented as a rounded rectangle, a transition between states as a line connection those states.

7. Designing Look, Feel, and Deployment

From Use Cases to User Interfaces

The UML makes no specific recommendations regarding diagrams for GUI designs. However it suggests that state diagrams are useful when we discuss user interfaces.

Collaboration is another way of visualizing how objects work together over time. Objects may be anywhere in the diagram. Messages from one object to another appear as line connecting the objects. Each line is numbered according to its placement in the sequence of messages and shows information that pertains to the nature of the message.

Deployment represents the physical architecture of a computer-based system. It can show each computer and device in the system and the components that reside in each computer. The computer or node is represented as a cube with the individual components within.

Understanding Design Patterns

A parameterized class has unbound parameters. Binding these parameters results in the creation of a class. Any UML classifier can be parameterized. A parameterized collaboration serves as the representation of a design pattern-a solution that’s useful in a variety of domains.

One design pattern, the “Chain of Responsibility”, deals with objects passing a request from one to another until one object can handle it. This pattern comes from the best-known book on design patterns, written by a group of authors referred to as the “Gang of Four”.

Design patterns afford a number of advantages, they enable designers to easily reuse proven solutions, incorporate solid components into designs, and clearly document the systems they create.