Login | Register
My pages Projects Community openCollabNet

ArgoUML User Manual

A tutorial and reference description

Alejandro Ramirez

Philippe Vanpeperstraete

Andreas Rueckert

Kunle Odutola

Jeremy Bennett

Linus Tolke

Michiel van der Wulp

Copyright © 2004, 2005, 2006, 2007 Michiel van der Wulp

Copyright © 2003 Linus Tolke

Copyright © 2001, 2002 Jeremy Bennett

Copyright © 2001 Kunle Odutola

Copyright © 2000 Philippe Vanpeperstraete

Copyright © 2000 Alejandro Ramirez

Copyright © 2000 Andreas Rueckert

This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later. A copy of this license is included in the section Open Publication License. The latest version is presently available at http://www.opencontent.org/openpub/.

Abstract

This version of the manual is intended to describe the version 0.24 of ArgoUML.

Table of Contents

1. Preface
1. Introduction
1.1. Origins and Overview of ArgoUML
1.1.1. Object Oriented Analysis and Design
1.1.2. The Development of ArgoUML
1.1.3. Finding Out More About the ArgoUML Project
1.2. Scope of This User Manual
1.2.1. Target Audience
1.2.2. Scope
1.3. Overview of the User Manual
1.3.1. Tutorial Manual Structure
1.3.2. Reference Manual Structure
1.3.3. User Feedback
1.4. Assumptions
1. Tutorial
2. Introduction (being written)
3. UML Based OOA&D
3.1. Background to UML
3.2. UML Based Processes for OOA&D
3.2.1. Types of Process
3.2.2. A Development Process for This Tutorial
3.3. Why ArgoUML is Different
3.3.1. Cognitive Psychology
3.3.2. Open Standards
3.3.3. 100% Pure Java
3.3.4. Open Source
3.4. ArgoUML Basics
3.4.1. Getting Started
3.4.2. The ArgoUML User Interface
3.4.3. Output
3.4.4. Working With Design Critics
3.5. The Case Study (To be written)
4. Requirements Capture
4.1. Introduction
4.2. The Requirements Capture Process
4.2.1. Process Steps
4.3. Output of the Requirements Capture Process
4.3.1. Vision Document
4.3.2. Use Case Diagram
4.3.3. The Use Case Specification
4.3.4. Supplementary Requirement Specification
4.4. Using Use Cases in ArgoUML
4.4.1. Actors
4.4.2. Use Cases
4.4.3. Associations
4.4.4. Hierarchical Use Cases
4.4.5. Stereotypes
4.4.6. Documentation
4.4.7. System Boundary Box
4.5. Case Study
4.5.1. Vision Document
4.5.2. Identifying Actors and Use Cases
4.5.3. Associations (To be written)
4.5.4. Advanced Diagram Features (To be written)
4.5.5. Use Case Specifications (To be written)
4.5.6. Supplementary Requirements Specification (To be written)
5. Analysis
5.1. The Analysis Process
5.1.1. Class, Responsibilities, and Collaborators (CRC) Cards
5.1.2. Concept Diagram (To be written)
5.1.3. System Sequence Diagram (To be written)
5.1.4. System Statechart Diagram (To be written)
5.1.5. Realization Use Case Diagram (To be written)
5.1.6. Documents (To be written)
5.2. Class Diagrams (To be written)
5.2.1. The Class Diagram (To be written)
5.2.2. Advanced Class Diagrams (To be written)
5.3. Creating Class Diagrams in ArgoUML
5.3.1. Classes
5.3.2. Associations (To be written)
5.3.3. Class Attributes and Operations (To be written)
5.3.4. Advanced Class Features (To be written)
5.4. Sequence Diagrams (To be written)
5.4.1. The Sequence Diagram (To be written)
5.4.2. Identifying Actions (To be written)
5.4.3. Advanced Sequence Diagrams (To be written)
5.5. Creating Sequence Diagrams in ArgoUML
5.5.1. Sequence Diagrams
5.5.2. Actions (To be written)
5.5.3. Advanced Sequence Diagrams (To be written)
5.6. Statechart Diagrams (To be written)
5.6.1. The Statechart Diagram (To be written)
5.6.2. Advanced Statechart Diagrams (To be written)
5.7. Creating Statechart Diagrams in ArgoUML
5.7.1. Statechart Diagrams (To be written)
5.7.2. States (To be written)
5.7.3. Transitions (To be written)
5.7.4. Actions (To be written)
5.7.5. Advanced Statechart Diagrams (To be written)
5.8. Realization Use Cases (To be written)
5.9. Creating Realization Use Cases in ArgoUML (To be written)
5.10. Case Study (To be written)
5.10.1. CRC Cards
5.10.2. Concept Class Diagrams (To be written)
5.10.3. System Sequence Diagrams (To be written)
5.10.4. System Statechart Diagrams (To be written)
5.10.5. Realization Use Cases (To be written)
6. Design
6.1. The Design Process (To be written)
6.1.1. Class, Responsibilities, and Collaborators (CRC) Cards
6.1.2. Package Diagram (To be written)
6.1.3. Realization Class Diagrams (To be written)
6.1.4. Sequence Diagrams and Collaboration Diagrams (To be written)
6.1.5. Statechart Diagrams and Activity Diagrams (To be written)
6.1.6. Deployment Diagram (To be written)
6.1.7. Documents (To be written)
6.2. Package Diagrams (To be written)
6.2.1. The Package Diagram (To be written)
6.2.2. Advanced Package Diagrams (To be written)
6.3. Creating Package Diagrams in ArgoUML
6.3.1. Packages
6.3.2. Relationships between packages (To be written)
6.3.3. Advanced Package Features (To be written)
6.4. More on Class Diagrams (To be written)
6.4.1. The Class Diagram (To be written)
6.4.2. Advanced Class Diagrams (To be written)
6.5. More on Class Diagrams in ArgoUML (To be written)
6.5.1. Classes (To be written)
6.5.2. Class Attributes and Operations (To be written)
6.5.3. Advanced Class Features
6.6. Sequence and Collaboration Diagrams (To be written)
6.6.1. More on the Sequence Diagram (To be written)
6.6.2. The Collaboration Diagram (To be written)
6.6.3. Advanced Collaboration Diagrams (To be written)
6.7. Creating Collaboration Diagrams in ArgoUML (To be written)
6.7.1. Collaboration Diagrams (To be written)
6.7.2. Messages (To be written)
6.7.3. Advanced Collaboration Diagrams (To be written)
6.8. Statechart Diagrams (To be written)
6.8.1. The Statechart Diagram (To be written)
6.8.2. Advanced Statechart Diagrams (To be written)
6.9. Creating Statechart Diagrams in ArgoUML (To be written)
6.9.1. Statechart Diagrams (To be written)
6.9.2. States (To be written)
6.9.3. Transitions (To be written)
6.9.4. Actions (To be written)
6.9.5. Advanced Statechart Diagrams (To be written)
6.10. Activity Diagrams (To be written)
6.10.1. The Activity Diagram (To be written)
6.11. Creating Activity Diagrams in ArgoUML (To be written)
6.11.1. Activity Diagrams (To be written)
6.11.2. Action States (To be written)
6.12. Deployment Diagrams (To be written)
6.12.1. The Deployment Diagram (To be written)
6.13. Creating Deployment Diagrams in ArgoUML (To be written)
6.13.1. Nodes (To be written)
6.13.2. Components (To be written)
6.13.3. Relationships between nodes and components (To be written)
6.14. System Architecture (To be written)
6.15. Case Study (To be written)
6.15.1. CRC Cards (To be written)
6.15.2. Packages (To be written)
6.15.3. Class Diagrams (To be written)
6.15.4. Sequence Diagrams (To be written)
6.15.5. Collaboration Diagrams (To be written)
6.15.6. Statechart Diagrams (To be written)
6.15.7. Activity Diagrams (To be written)
6.15.8. The Deployment Diagram (To be written)
6.15.9. The System Architecture (To be written)
7. Code Generation, Reverse Engineering, and Round Trip Engineering
7.1. Introduction
7.2. Code Generation
7.2.1. Generating Code from the Static Structure
7.2.2. Generating code from interactions and state machines
7.3. Code Generation in ArgoUML
7.3.1. Static Structure
7.3.2. Interactions and statechart diagrams
7.4. Reverse Engineering
7.5. Round-Trip Engineering
2. User Interface Reference
8. Introduction
8.1. Overview of the Window
8.2. General Mouse Behavior in ArgoUML
8.2.1. Mouse Button Terminology
8.2.2. Button 1 Click
8.2.3. Button 1 Double Click
8.2.4. Button 1 Motion
8.2.5. Shift and Ctrl modifiers with Button 1
8.2.6. Alt with Button 1: Panning
8.2.7. Ctrl with Button 1: Constrained Drag
8.2.8. Button 2 Actions
8.2.9. Button 2 Double Click
8.2.10. Button 2 Motion
8.3. General Information About Panes
8.3.1. Re-sizing Panes
8.4. The status bar
9. The Toolbar
9.1. File operations
9.2. Edit operations
9.3. View operations
9.4. Create operations
10. The Menu bar
10.1. Introduction
10.2. Mouse Behavior in the Menu Bar
10.3. The File Menu
10.3.1. New
10.3.2. Open Project...
10.3.3. Save Project
10.3.4. Save Project As...
10.3.5. Revert to Saved
10.3.6. Import XMI...
10.3.7. Export XMI...
10.3.8. Import Sources...
10.3.9. Page Setup...
10.3.10. Print...
10.3.11. Export Graphics...
10.3.12. Export All Graphics...
10.3.13. Notation
10.3.14. Properties
10.3.15. Most Recent Used Files
10.3.16. Exit
10.4. The Edit Menu
10.4.1. Select
10.4.2. Remove From Diagram
10.4.3. Delete From Model
10.4.4. Configure Perspectives...
10.4.5. Settings...
10.5. The View Menu
10.5.1. Goto Diagram...
10.5.2. Find...
10.5.3. Zoom
10.5.4. Adjust Grid
10.5.5. Adjust Snap
10.5.6. Page Breaks
10.5.7. XML Dump
10.6. The Create Menu
10.6.1. New Use Case Diagram
10.6.2. New Class Diagram
10.6.3. New Sequence Diagram
10.6.4. New Collaboration Diagram
10.6.5. New Statechart Diagram
10.6.6. New Activity Diagram
10.6.7. New Deployment Diagram
10.7. The Arrange Menu
10.7.1. Align
10.7.2. Distribute
10.7.3. Reorder
10.7.4. Size To Fit Contents
10.7.5. Layout
10.8. The Generation Menu
10.8.1. Generate Selected Classes ...
10.8.2. Generate All Classes...
10.8.3. Generate Code for Project... (To be Written)
10.8.4. Settings for Generate for Project... (To be Written)
10.9. The Critique Menu
10.9.1. Toggle Auto-Critique
10.9.2. Design Issues...
10.9.3. Design Goals...
10.9.4. Browse Critics...
10.10. The Tools Menu
10.11. The Help Menu
10.11.1. System Information
10.11.2. About ArgoUML
11. The Explorer
11.1. Introduction
11.2. Mouse Behavior in the Explorer
11.2.1. Button 1 Click
11.2.2. Button 1 Double Click
11.2.3. Button 1 Motion
11.2.4. Button 2 Actions
11.2.5. Button 2 Double Click
11.3. Keyboard Behavior in the Explorer
11.4. Perspective Selection
11.5. Configuring Perspectives
11.5.1. The Configure Perspectives dialog
11.6. Context Sensitive Menu
11.6.1. Create Diagram
11.6.2. Copy Diagram to Clipboard as Image
11.6.3. Add to Diagram
11.6.4. Delete From Model
11.6.5. Set Source Path... (To be written)
11.6.6. Add Package
11.6.7. Add All Classes in Namespace
12. The Editing Pane
12.1. Introduction
12.2. Mouse Behavior in the Editing Pane
12.2.1. Button 1 Click
12.2.2. Button 1 Double Click
12.2.3. Button 1 Motion
12.2.4. Shift and Ctrl modifiers with Button 1
12.2.5. Alt with Button 1 motion
12.2.6. Button 2 Actions
12.2.7. Button 2 Double Click
12.2.8. Button 2 Motion
12.3. Keyboard Behavior in the Editing Pane
12.3.1. Nudging a model element
12.3.2. Moving across the model elements
12.4. The tool bar
12.4.1. Layout Tools
12.4.2. Annotation Tools
12.4.3. Drawing Tools
12.4.4. Use Case Diagram Specific Tools
12.4.5. Class Diagram Specific Tools
12.4.6. Sequence Diagram Specific Tools
12.4.7. Collaboration Diagram Specific Tools
12.4.8. Statechart Diagram Specific Tools
12.4.9. Activity Diagram Specific Tools
12.4.10. Deployment Diagram Specific Tools
12.5. The Broom
12.6. Selection Action Buttons
12.7. Clarifiers
12.8. The Drawing Grid
12.9. The Diagram Tab
12.10. Pop-Up Menus
12.10.1. Critiques
12.10.2. Ordering
12.10.3. Add
12.10.4. Show
12.10.5. Modifiers
12.10.6. Multiplicity
12.10.7. Aggregation
12.10.8. Navigability
12.11. Notation
12.11.1. Notation Languages
12.11.2. Notation Editing on the diagram
12.11.3. Notation Parsing
13. The Details Pane
13.1. Introduction
13.2. To Do Item Tab
13.2.1. Wizards
13.2.2. The Help Button
13.3. Properties Tab
13.4. Documentation Tab
13.5. Presentation Tab
13.6. Source Tab
13.7. Constraints Tab
13.7.1. The Constraint Editor
13.8. Stereotype Tab
13.9. Tagged Values Tab
13.10. Checklist Tab
14. The To-Do Pane
14.1. Introduction
14.2. Mouse Behavior in the To-Do Pane
14.2.1. Button 1 Click
14.2.2. Button 1 Double Click
14.2.3. Button 2 Actions
14.2.4. Button 2 Double Click
14.3. Presentation Selection
14.4. Item Count
15. The Critics
15.1. Introduction
15.1.1. Terminology
15.1.2. Design Issues
15.2. Uncategorized
15.3. Class Selection
15.3.1. Wrap DataType
15.3.2. Reduce Classes in diagram <diagram>
15.3.3. Clean Up Diagram
15.4. Naming
15.4.1. Resolve Association Name Conflict
15.4.2. Revise Attribute Names to Avoid Conflict
15.4.3. Change Names or Signatures in a model element
15.4.4. Duplicate End (Role) Names for an Association
15.4.5. Role name conflicts with member
15.4.6. Choose a Name (Classes and Interfaces)
15.4.7. Choose a Unique Name for a model element (Classes and Interfaces)
15.4.8. Choose a Name (Attributes)
15.4.9. Choose a Name (Operations)
15.4.10. Choose a Name (States)
15.4.11. Choose a Unique Name for a (State related) model element
15.4.12. Revise Name to Avoid Confusion
15.4.13. Choose a Legal Name
15.4.14. Change a model element to a Non-Reserved Word
15.4.15. Choose a Better Operation Name
15.4.16. Choose a Better Attribute Name
15.4.17. Capitalize Class Name
15.4.18. Revise Package Name
15.5. Storage
15.5.1. Revise Attribute Names to Avoid Conflict
15.5.2. Add Instance Variables to a Class
15.5.3. Add a Constructor to a Class
15.5.4. Reduce Attributes on a Class
15.6. Planned Extensions
15.6.1. Operations in Interfaces must be public
15.6.2. Interfaces may only have operations
15.6.3. Remove Reference to Specific Subclass
15.7. State Machines
15.7.1. Reduce Transitions on <state>
15.7.2. Reduce States in machine <machine>
15.7.3. Add Transitions to <state>
15.7.4. Add Incoming Transitions to <model element>
15.7.5. Add Outgoing Transitions from <model element>
15.7.6. Remove Extra Initial States
15.7.7. Place an Initial State
15.7.8. Add Trigger or Guard to Transition
15.7.9. Change Join Transitions
15.7.10. Change Fork Transitions
15.7.11. Add Choice/Junction Transitions
15.7.12. Add Guard to Transition
15.7.13. Clean Up Diagram
15.7.14. Make Edge More Visible
15.7.15. Composite Association End with Multiplicity > 1
15.8. Design Patterns
15.8.1. Consider using Singleton Pattern for <class>
15.8.2. Singleton Stereotype Violated in <class>
15.8.3. Nodes normally have no enclosers
15.8.4. NodeInstances normally have no enclosers
15.8.5. Components normally are inside nodes
15.8.6. ComponentInstances normally are inside nodes
15.8.7. Classes normally are inside components
15.8.8. Interfaces normally are inside components
15.8.9. Objects normally are inside components
15.8.10. LinkEnds have not the same locations
15.8.11. Set classifier (Deployment Diagram)
15.8.12. Missing return-actions
15.8.13. Missing call(send)-action
15.8.14. No Stimuli on these links
15.8.15. Set Classifier (Sequence Diagram)
15.8.16. Wrong position of these stimuli
15.9. Relationships
15.9.1. Circular Association
15.9.2. Make <association> Navigable
15.9.3. Remove Navigation from Interface via <association>
15.9.4. Add Associations to <model element>
15.9.5. Remove Reference to Specific Subclass
15.9.6. Reduce Associations on <model element>
15.9.7. Make Edge More Visible
15.10. Instantiation
15.11. Modularity
15.11.1. Classifier not in Namespace of its Association
15.11.2. Add Elements to Package <package>
15.12. Expected Usage
15.12.1. Clean Up Diagram
15.13. Methods
15.13.1. Change Names or Signatures in <model element>
15.13.2. Class Must be Abstract
15.13.3. Add Operations to <class>
15.13.4. Reduce Operations on <model element>
15.14. Code Generation
15.14.1. Change Multiple Inheritance to interfaces
15.15. Stereotypes
15.16. Inheritance
15.16.1. Revise Attribute Names to Avoid Conflict
15.16.2. Remove <class>'s Circular Inheritance
15.16.3. Class Must be Abstract
15.16.4. Remove final keyword or remove subclasses
15.16.5. Illegal Generalization
15.16.6. Remove Unneeded Realizes from <class>
15.16.7. Define Concrete (Sub)Class
15.16.8. Define Class to Implement <interface>
15.16.9. Change Multiple Inheritance to interfaces
15.16.10. Make Edge More Visible
15.17. Containment
15.17.1. Remove Circular Composition
15.17.2. Duplicate Parameter Name
15.17.3. Two Aggregate Ends (Roles) in Binary Association
15.17.4. Aggregate End (Role) in 3-way (or More) Association
15.17.5. Wrap DataType
3. Model Reference
16. Top Level Model Element Reference
16.1. Introduction
16.2. The Model
16.2.1. Model Details Tabs
16.2.2. Model Property Toolbar
16.2.3. Property Fields For The Model
16.3. Datatype
16.3.1. Datatype Details Tabs
16.3.2. Datatype Property Toolbar
16.3.3. Property Fields For Datatype
16.4. Enumeration
16.4.1. Enumeration Details Tabs
16.4.2. Enumeration Property Toolbar
16.4.3. Property Fields For Enumeration
16.5. Enumeration Literal
16.6. Stereotype
16.6.1. Stereotype Details Tabs
16.6.2. Stereotype Property Toolbar
16.6.3. Property Fields For Stereotype
16.7. Tag Definition
16.8. Diagram
16.8.1. Diagram Details Tabs
16.8.2. Diagram Property Toolbar
16.8.3. Property Fields For Diagram
17. Use Case Diagram Model Element Reference
17.1. Introduction
17.1.1. ArgoUML Limitations Concerning Use Case Diagrams
17.2. Actor
17.2.1. Actor Details Tabs
17.2.2. Actor Property Toolbar
17.2.3. Property Fields For Actor
17.3. Use Case
17.3.1. Use Case Details Tabs
17.3.2. Use Case Property Toolbar
17.3.3. Property Fields For Use Case
17.4. Extension Point
17.4.1. Extension Point Details Tabs
17.4.2. Extension Point Property Toolbar
17.4.3. Property Fields For Extension Point
17.5. Association
17.6. Association End
17.7. Dependency
17.8. Generalization
17.8.1. Generalization Details Tabs
17.8.2. Generalization Property Toolbar
17.8.3. Property Fields For Generalization
17.9. Extend
17.9.1. Extend Details Tabs
17.9.2. Extend Property Toolbar
17.9.3. Property Fields For Extend
17.10. Include
17.10.1. Include Details Tabs
17.10.2. Include Property Toolbar
17.10.3. Property Fields For Include
18. Class Diagram Model Element Reference
18.1. Introduction
18.1.1. Limitations Concerning Class Diagrams in ArgoUML
18.2. Package
18.2.1. Package Details Tabs
18.2.2. Package Property Toolbar
18.2.3. Property Fields For Package
18.3. Datatype
18.4. Enumeration
18.5. Stereotype
18.6. Class
18.6.1. Class Details Tabs
18.6.2. Class Property Toolbar
18.6.3. Property Fields For Class
18.7. Attribute
18.7.1. Attribute Details Tabs
18.7.2. Attribute Property Toolbar
18.7.3. Property Fields For Attribute
18.8. Operation
18.8.1. Operation Details Tabs
18.8.2. Operation Property Toolbar
18.8.3. Property Fields For Operation
18.9. Parameter
18.9.1. Parameter Details Tabs
18.9.2. Parameter Property Toolbar
18.9.3. Property Fields For Parameter
18.10. Signal
18.10.1. Signal Details Tabs
18.10.2. Signal Property Toolbar
18.10.3. Property Fields For Signal
18.11. Reception (to be written)
18.12. Association
18.12.1. Three-way and Greater Associations and Association Classes
18.12.2. Association Details Tabs
18.12.3. Association Property Toolbar
18.12.4. Property Fields For Association
18.13. Association End
18.13.1. Association End Details Tabs
18.13.2. Association End Property Toolbar
18.13.3. Property Fields For Association End
18.14. Dependency
18.14.1. Dependency Details Tabs
18.14.2. Dependency Property Toolbar
18.14.3. Property Fields For Dependency
18.15. Generalization
18.16. Interface
18.16.1. Interface Details Tabs
18.16.2. Interface Property Toolbar
18.16.3. Property Fields For Interface
18.17. Abstraction
18.17.1. Abstraction Details Tabs
18.17.2. Abstraction Property Toolbar
18.17.3. Property Fields For Abstraction
19. Sequence Diagram Model Element Reference
19.1. Introduction
19.1.1. Limitations Concerning Sequence Diagrams in ArgoUML
19.2. Object
19.2.1. Object Details Tabs
19.2.2. Object Property Toolbar
19.2.3. Property Fields For Object
19.3. Stimulus
19.3.1. Stimulus Details Tabs
19.3.2. Stimulus Property Toolbar
19.3.3. Property Fields For Stimulus
19.4. Stimulus Call
19.5. Stimulus Create
19.6. Stimulus Destroy
19.7. Stimulus Send
19.8. Stimulus Return
19.9. Link
19.9.1. Link Details Tabs
19.9.2. Link Property Toolbar
19.9.3. Property Fields For Link
20. Statechart Diagram Model Element Reference
20.1. Introduction
20.1.1. Limitations Concerning Statechart Diagrams in ArgoUML
20.2. State
20.2.1. State Details Tabs
20.2.2. State Property Toolbar
20.2.3. Property Fields For State
20.3. Action
20.3.1. Action Details Tabs
20.3.2. Action Property Toolbar
20.3.3. Property Fields For Action
20.4. Composite State
20.5. Concurrent Region
20.6. Submachine State
20.7. Stub State
20.8. Transition
20.8.1. Transition Details Tabs
20.8.2. Transition Property Toolbar
20.8.3. Property Fields For Transition
20.9. Event
20.9.1. Event Details Tabs
20.9.2. Event Property Toolbar
20.9.3. Property Fields For Event
20.10. Guard
20.10.1. Guard Details Tabs
20.10.2. Guard Property Toolbar
20.10.3. Property Fields For Guard
20.11. Pseudostate
20.11.1. Pseudostate Details Tabs
20.11.2. Pseudostate Property Toolbar
20.11.3. Property Fields For Pseudostate
20.12. Initial State
20.13. Final State
20.13.1. Final State Details Tabs
20.13.2. Final State Property Toolbar
20.13.3. Property Fields For Final State
20.14. Junction
20.15. Choice
20.16. Fork
20.17. Join
20.18. Shallow History
20.19. Deep History
20.20. Synch State
20.20.1. Synch State Details Tabs
20.20.2. Synch State Property Toolbar
20.20.3. Property Fields For Synch State
21. Collaboration Diagram Model Element Reference
21.1. Introduction
21.1.1. Limitations Concerning Collaboration Diagrams in ArgoUML
21.2. Classifier Role
21.2.1. Classifier Role Details Tabs
21.2.2. Classifier Role Property Toolbar
21.2.3. Property Fields For Classifier Role
21.3. Association Role
21.3.1. Association Role Details Tabs
21.3.2. Association Role Property Toolbar
21.3.3. Property Fields For Association Role
21.4. Association End Role
21.4.1. Association End Role Details Tabs
21.4.2. Association End Role Property Toolbar
21.4.3. Property Fields For Association End Role
21.5. Message
21.5.1. Message Details Tabs
21.5.2. Message Property Toolbar
21.5.3. Property Fields For Message
22. Activity Diagram Model Element Reference
22.1. Introduction
22.1.1. Limitations Concerning Activity Diagrams in ArgoUML
22.2. Action State
22.2.1. Action State Details Tabs
22.2.2. Action State Property ToolBar
22.2.3. Property fields for action state
22.3. Action
22.4. Transition
22.5. Guard
22.6. Initial State
22.7. Final State
22.8. Junction (Decision)
22.9. Fork
22.10. Join
22.11. ObjectFlowState
23. Deployment Diagram Model Element Reference
23.1. Introduction
23.1.1. Limitations Concerning Deployment Diagrams in ArgoUML
23.2. Node
23.2.1. Node Details Tabs
23.2.2. Node Property Toolbar
23.2.3. Property Fields For Node
23.3. Node Instance
23.3.1. Node Instance Details Tabs
23.3.2. Node Instance Property Toolbar
23.3.3. Property Fields For Node Instance
23.4. Component
23.4.1. Component Details Tabs
23.4.2. Component Property Toolbar
23.4.3. Property Fields For Component
23.5. Component Instance
23.5.1. Component Instance Details Tabs
23.5.2. Component Instance Property Toolbar
23.5.3. Property Fields For Component Instance
23.6. Dependency
23.7. Class
23.8. Interface
23.9. Association
23.10. Object
23.11. Link
24. Built In DataTypes, Classes, Interfaces and Stereotypes
24.1. Introduction
24.1.1. Package Structure
24.1.2. Exposure in the model
24.2. Built In Datatypes
24.3. Built In Classes
24.3.1. Built In Classes From java.lang
24.3.2. Built In Classes From java.math
24.3.3. Built In Classes From java.net
24.3.4. Built In Classes From java.util
24.4. Built In Interfaces
24.5. Built In Stereotypes
Glossary
A. Supplementary Material for the Case Study
A.1. Introduction
A.2. Requirements Documents (To be written)
A.2.1. Vision Document (To be written)
A.2.2. Use Case Specifications (To be written)
A.2.3. Supplementary Requirements Specification (To be written)
B. UML resources
B.1. The UML specs (To be written)
B.2. UML related papers (To be written)
B.2.1. UML action specifications (To be written)
B.3. UML related websites (To be written)
C. UML Conforming CASE Tools
C.1. Other Open Source Projects (To be written)
C.2. Commercial Tools (To be written)
D. The C++ Module
D.1. Modeling for C++
D.1.1. Class tagged values
D.1.2. Attribute tagged values
D.1.3. Parameters
D.1.4. Preserved sections
E. Limits and Shortcomings
E.1. Diagram Canvas Size
E.2. Missing functions
F. Open Publication License
F.1. Requirements On Both Unmodified And Modified Versions
F.2. Copyright
F.3. Scope Of License
F.4. Requirements On Modified Works
F.5. Good-Practice Recommendations
F.6. License Options
F.7. Open Publication Policy Appendix:
G. The CRC Card Methodology
G.1. The Card
G.2. The Group
G.3. The Session
G.4. The Process
Index

Preface

Software design is a cognitively challenging task. Designers must manually enter designs, but the primary difficulty is decision-making rather than data-entry. If designers improved their decision-making capabilities, it would result in better designs.

Current CASE tools provide automation and graphical user interfaces that reduce the manual work of entering a design and transforming a design into code. They aid designers in decision-making mainly by providing visualization of design diagrams and simple syntactic checks. Also many CASE tools provide substantial benefits in the area of version control and concurrent design mechanisms. One area of design support that has been not been well supported is analysis of design decisions.

Current CASE tools are usable in that they provide a GUI that allows designers to access all the features provided by the tool. And they support the design process in that they allow the designer to enter diagrams in the style of popular design methodologies. But they typically do not provide process support to guide the designer through the design task. Instead, designers typically start with a blank page and must remember to cover every aspect of the design.

ArgoUML is a domain-oriented design environment that provides cognitive support of object-oriented design. ArgoUML provides some of the same automation features of a commercial CASE tool, but it focuses on features that support the cognitive needs of designers. These cognitive needs are described by three cognitive theories:

  1. reflection-in-action;

  2. opportunistic design; and

  3. comprehension and problem solving.

ArgoUML is based directly on the UML 1.4 specification. The core model repository is an implementation of the Java Metadata Interface (JMI) which directly supports MOF and uses the machine readable version of the UML 1.4 specification provided by the OMG.

Furthermore, it is our goal to provide comprehensive support for OCL (the Object Constraint Language) and XMI (the XML Model Interchange format).

ArgoUML was originally developed by a small group of people as a research project. ArgoUML has many features that make it special, but it does not implement all the features that commercial CASE tools provide.

The current version (0.24) of ArgoUML implements all the diagram types of the UML 1.4 standard (versions of ArgoUML prior to 0.20 implemented the UML 1.3 standard). It is written in Java and runs on every computer which provides a Java 2 platform of Java 1.4 or newer. It uses the open file formats XMI (XML Metadata Interchange format) (for model information) and PGML (Precision Graphics Markup Language) (for graph information) for storage. When ArgoUML implements UML 2.0, PGML will be replaced by the UML Diagram Interchange specification.

This manual is the cumulative work of several people and has been evolving over several years. Connected to the release 0.10 of ArgoUML, Jeremy Bennett, wrote a lot of the new material that was added to the earlier versions by Alejandro Ramirez, Philippe Vanpeperstraete and Andreas Rueckert. He also added things from some of the other documents namely the developers cookbook by Markus Klink and Linus Tolke, the Quick Guide by Kunle Odutola, and the FAQ by Dennis Daniels. Connected to the release 0.14 changes were made by Linus Tolke, and by Michiel van der Wulp. These changes were mostly to adopt the manual to the new functions and appearance of ArgoUML version 0.14, and introduction of the index. The users and developers that have contributed by providing valuable input, such as review comments or observations while reading and using this manual are too many to name.

ArgoUML is available for free and can be used in commercial settings. For terms of use, see the license agreement presented when you download ArgoUML. We are providing the source code for ArgoUML for you to review, customize to your needs, and improve. Over time, we hope that ArgoUML will evolve into a powerful and useful tool for everyone to use.

This User Manual is aimed at the working designer, who wishes to make use of ArgoUML. The manual is presently written assuming familiarity with UML, but eventually it will support those new to UML.

The manual is written in DocBook/XML and available as both HTML and PDF.

The ArgoUML project welcomes those who want to get more involved. Look at the project website to find out more.

Tell us what you think about this User Manual! Your comments will help us improve things. See Section 1.3.3, “User Feedback” .

Chapter 1. Introduction

1.1. Origins and Overview of ArgoUML

1.1.1. Object Oriented Analysis and Design

Over the past decade, Object Oriented Analysis and Design (OOA&D) has become the dominant software development paradigm. With it has come a major shift in the thought processes of all involved in the software development life cycle.

Programming language support for objects began with Simula 67, but it was the emergence in the 1980's of hybrid languages, such as C++, Ada and Object Pascal that allowed OOA&D to take off. These languages provided support for both OO and procedural programming. Object Oriented programming became mainstream.

An OO system is designed and implemented as a simulation of the real world using software artifacts. This premise is as powerful as it is simple. By using an OO approach to design a system can be designed and tested (or more correctly simulated) without having to actually build the system first.

It is the development during the 1990's of tools to support Object Oriented analysis and design that moved this approach into the mainstream. When coupled with the ability to design systems at a very high level, a tool based OOA&D approach has enabled the implementation of more complex systems than previously possible.

The final driver that has propelled OOA&D has been its suitability for modeling graphical user interfaces. The popularity of object based and object oriented graphical languages such as Visual Basic and Java reflect the effectiveness of this approach.

1.1.2. The Development of ArgoUML

During the 1980's a number of OOA&D process methodologies and notations were developed by different research teams. It became clear there were many common themes and, during the 1990's, a unified approach for OOA&D notation was developed under the auspices of the Object Management Group. This standard became known as the Unified Modeling Language (UML), and is now the standard language for communicating OO concepts.

ArgoUML was conceived as a tool and environment for use in the analysis and design of object-oriented software systems. In this sense it is similar to many of the commercial CASE tools that are sold as tools for modeling software systems. ArgoUML has a number of very important distinctions from many of these tools.

  1. It is free.

  2. ArgoUML draws on research in cognitive psychology to provide novel features that increase productivity by supporting the cognitive needs of object-oriented software designers and architects.

  3. ArgoUML supports open standards extensively - UML, XMI, SVG, OCL and others.

  4. ArgoUML is a 100% pure Java application. This allows ArgoUML to run on all platforms for which a reliable port of the Java2 platform is available.

  5. ArgoUML is an open source project. The availability of the source ensures that a new generation of software designers and researchers now have a proven framework from which they can drive the development and evolution of CASE tool technologies.

UML is the most prevalent OO modeling language and Java is one of the most productive OO development platforms. Jason Robbins and the rest of his research team at the University of California, Irvine leveraged these benefits in creating ArgoUML. The result is a solid development tool and environment for OO systems design. Further, it provides a test bed for the evolution of object oriented CASE tools development and research.

A first release of ArgoUML was available in 1998 and more than 100,000 downloads by mid-2001 show the impact that this project has made, being popular in educational and commercial fields.

1.1.3. Finding Out More About the ArgoUML Project

1.1.3.1. How ArgoUML is Developed

Jason Elliot Robbins founded the Argo Project and provided early project leadership. While Jason remains active in the project, he has handed off project leadership. The project continues to move forward strongly. There are more than 300 members on the developer mailing list (see http://argouml.tigris.org/servlets/ProjectMailingListList), with a couple of dozen of those forming the core development group.

The developer mailing list is the place where all the discussion on the latest tasks takes place, and developers discuss the directions the project should take. Although controversial at times, these discussions are always kept nice and friendly (no flame-wars and such), so newbies should not hesitate and participate in them. You'll always get a warm welcome there.

If you want to learn how the project is run and how to contribute to it, go the the ArgoUML Web Site Developer Zone and read through the documentation there. The Developers' Cookbook was written specifically for this purpose.

1.1.3.2. More on Infrastructure

Besides the developer mailing list, there's also a mailing for users (see The ArgoUML Mailing List List ), where we can discuss problems from a user perspective. Developers also read this list, so highly qualified help will generally be provided.

Before posting to this list, you should take a look at the user FAQ maintained by Ewan R. Grantham.

More information on ArgoUML and other UML related topics is also available on the ArgoUML website, maintained by Linus Tolke.

1.2. Scope of This User Manual

1.2.1. Target Audience

The current release of this document is aimed at experienced users of UML in OOA&D (perhaps with other tools) who wish to transfer to ArgoUML.

Future releases will support designers who know OOA&D, and wish to adopt UML notation within their development process.

A long term goal is to support i) those who are learning design and wish to start with an OOA&D process that uses UML notation, and ii) people interested in modularized code design with a GUI.

1.2.2. Scope

The intention is that this document will provide a comprehensive guide, enabling designers to use ArgoUML to its full extent. It is in two parts.

  • A tutorial manual, showing how to work with ArgoUML

  • A complete reference manual, recording everything you can do with ArgoUML.

Version 0.22 of the document achieved the second of these.

In this guide there are some things you will not find, because they are covered elsewhere.

  • Descriptions of how ArgoUML works on the inside.

  • How to improve ArgoUML with new features and functions.

  • A trouble shooting guide.

  • A summary quick reference to using ArgoUML.

These are covered in the Developers Cookbook, the FAQ, and the Quick Guide.

1.3. Overview of the User Manual

1.3.1. Tutorial Manual Structure

Chapter 2, Introduction (being written) provides an overview of UML based OOA&D, including a guide to getting ArgoUML up and running.

Chapter 4, Requirements Capture through Chapter 7, Code Generation, Reverse Engineering, and Round Trip Engineering then step through each part of the design process from initial requirements capture through to final project build and deployment.

As each UML concept is encountered, its use is explained. Its use within ArgoUML is then described. Finally a case study is used to give examples of the concepts in use.

1.3.2. Reference Manual Structure

Chapter 8, Introduction is an overview of the user interface and provides a summary of the support for the various UML diagram types in ArgoUML. Chapter 10, The Menu bar and Chapter 11, The Explorer describe the menu bar, and each of the sub-windows of the user interface, known as Panes.

Chapter 15, The Critics gives details of all the cognitive critics within the system. Eventually ArgoUML will link directly to this manual when giving advice on critics.

Chapter 16, Top Level Model Element Reference is an overview of the model elements (i.e. the UML entities that can be placed on diagrams) within ArgoUML. The following chapters ( Chapter 17, Use Case Diagram Model Element Reference through Chapter 24, Built In DataTypes, Classes, Interfaces and Stereotypes) describe, the model elements that can be created through each ArgoUML diagram, and their properties, as well as some standard model elements provided with the system.

A complete Glossary is provided. Appendix A, Supplementary Material for the Case Study provides material to supplement the case study used throughout the document. Appendix B, UML resources and Appendix C, UML Conforming CASE Tools identify background information on UML and UML CASE tools. Appendix F, Open Publication License is a copy of the GNU Free Documentation License.

A future ambition is to provide a comprehensive index.

1.3.3. User Feedback

Please tell us what you think about this User Manual. Your comments will help us make improvements. Email your thoughts to the ArgoUML Users Mailing List. In case you would like to add to the missing chapters you should contact the ArgoUML Developer Mailing List to check whether anyone else is working on this part. You can subscribe to either of the mailing lists via the ArgoUML web site.

1.4. Assumptions

This release of the manual assumes the reader is very familiar with UML already. This is reflected in the sparseness of the description of UML concepts in the tutorial.

The case study is described, but not yet fully realized throughout the tutorial. This will be achieved in future releases of the manual.

Part 1. Tutorial

Chapter 2. Introduction (being written)

This tutorial will be taking you through a tour of the use of ArgoUML to model a system.

First you will become familiar with the feel of the product and then we will go through an analysis and development process for a test case. Not every nook and cranny of the product will be demonstrated. That degree of detail is given in the reference materials to be found in subsequent parts of this document.

The state of the model at the end of key sections will be available in .zargo files. These are available so that you can play with various aspects not specifically covered in this tutorial and then restore yourself back to the proper state of the model in your work area. These .zargo files will be identified at the end of the sections whose work they represent.

An ATM (automated teller machine) project has been chosen as a case study to demonstrate the various aspects of modeling that ArgoUML offers. In subsequent sections we are going to develop the ATM example into a complete description in UML. The tutorial, however, will only walk you through part of it.

At this point you should create a directory to contain your project. Name the directory anything you feel is consistent with the rest of your file system. You should name the contents and any subdirectories as directed for reasons that will become apparent.

The case study will be an ATM system. Your company is FlyByNight Industries. You are going to play two roles. That of the Project Manager and that of the Designer Analyst.

We are not going to build a physical ATM, of course. The product that we will build as a case study will be an ATM simulator to be used for testing the design of a physical ATM.

How your company arranges its work into projects is usually determined as much by politics as anything else and is, therefore, out of the scope of this document. We will go into how you structure the project itself once one has been defined.

Chapter 3. UML Based OOA&D

In this chapter, we look at how UML as a notation is used within OOA&D.

3.1. Background to UML

Object orientation as a concept has been around since the 1960's, and as a design concept since 1972. However it was in the 1980's that it started to develop as a credible alternative to a functional approach in analysis and design. We can identify a number of drivers.

  1. The emergence of mainstream OO programming languages like SmallTalk and particularly C++. C++ was a pragmatic OO language derived from C, widely used because of its association with Unix.

  2. The development of powerful workstations, and with them the emergence into the mainstream of windowing operating user environments. Graphical User Interfaces (GUI) have an inherent object structure.

  3. A number of very public major project failures, suggesting that current approaches were not satisfactory.

A number of researchers proposed OOA&D processes, and with them notations. Those that achieved some success include Coad-Yourdon, Booch, Rumbaugh OMT, OOSE/Jacobson, Shlaer-Mellor, ROOM (for real-time design) and the hybrid Jackson Structured Development.

During the early 1990's it became clear that these approaches had many good ideas, often very similar. A major stumbling block was the diversity of notation, meaning engineers tended to be familiar with one OOA&D methodology, rather than the approach in general.

UML was conceived as a common notation, that would be in the interests of all