1. Introduction
The requirements definition tells us what the system should do. UML (a standard accepted by the OMG, Object Management Group) organizes these requirements as:
- Use-case diagrams
- Activity diagrams
- Use-case descriptions
From requirements to functional models
- Develop use cases from the requirements — how the system interacts with users; a diagram (visual) + description (text) of discrete user activities.
e.g., “User logs in”, “Customer places order”. - Develop activity diagrams from the use cases — business processes step by step, plus the movement of objects (data) between steps.
e.g., Login → Validate → Show dashboard.
⚠ Use-case + activity diagrams are logical models: they describe what happens, not how it’s implemented. The same model works whether the system is manual or automated.
| Artifact | Gives you |
|---|---|
| Use-case diagram | Big picture / bird’s-eye view (overview) |
| Activity diagram | Detailed steps inside each process (detailed flow) |
| Use-case description | Full textual documentation |
2. Business Process Identification with Use-Case Diagrams
Definition (Use case)
Describes how the system behaves from the user’s perspective after the user requests a specific action.
- Focuses on a single action (login, place order).
- Shows only visible steps — what the user sees, not the code/database/logic inside.
2.1 Elements of a Use-Case Diagram
| Element | Rules | Notation |
|---|---|---|
| Actor | Person or system that derives benefit from and is external to the subject; labeled with its role; placed outside the boundary; can specialize another actor (hollow arrowhead) | Stick figure, or rectangle with <<actor>> for non-human |
| Use case | A major piece of functionality; placed inside the boundary; labeled with a verb–noun phrase; can include/extend another use case | Oval |
| Subject boundary | Name inside or on top; represents the scope (a system or a single business process) | Rectangle |
| Association | Links an actor with the use case(s) it interacts with | Solid line (with multiplicities, e.g. *) |
| Include | Base use case always uses the included one; arrow from base → used | Dashed arrow <<include>> |
| Extend | Optional behavior; arrow from extension → base | Dashed arrow <<extend>> |
| Generalization | Specialized use case (or actor) → general one | Solid line, hollow triangle at the general end |
⚠ Arrow directions are the classic trap: include points to the included use case; extend points to the base use case.
2.2 Example 1 — Appointment System
flowchart LR Patient(["🧍 Patient"]) Management(["🧍 Management"]) Doctor(["🧍 Doctor"]) subgraph AS[Appointment System] MA((Manage Appointments)) PS((Produce Schedules)) RA((Record Availability)) end Patient ---|"* — *"| MA Management ---|"* — *"| PS Doctor ---|"* — *"| RA
Extending it with include / extend / generalization:
flowchart TB subgraph AS[Appointment System] MA((Manage Appointments)) MOA((Make Old Patient Appt)) MNA((Make New Patient Appt)) UPI((Update Patient Information)) MPA((Make Payment Arrangements)) end MOA -->|generalization| MA MNA -->|generalization| MA MNA -.->|"«include»"| MPA UPI -.->|"«extend»"| MOA
- Make New Patient Appt always requires payment arrangements → include (base → included).
- Updating patient info happens only if it changed → extend (extension → base).
- Both make-appointment use cases are special kinds of Manage Appointments → generalization.
2.3 Example 2 — Library Book Collection Management System
flowchart LR Librarian(["🧍 Librarian"]) Borrower(["🧍 Borrower"]) PO["«actor»<br/>Personnel Office"] RO["«actor»<br/>Registrar Office"] subgraph L[Library Book Collection Management System] POB((Process Overdue Books)) MBC((Maintain Book Collection)) BB((Borrow Books)) SC((Search Collection)) RB((Return Books)) end Librarian --- POB Librarian --- MBC Borrower --- BB Borrower --- SC Borrower --- RB BB --- PO BB --- RO
Personnel Office and Registrar Office are non-human actors (external systems used to validate ID cards).
3. Business Process Modeling with Activity Diagrams
Activity diagrams can model anything from a high-level business workflow (many use cases) down to a single use case or even one method. This chapter focuses on high-level business processes.
- A business process consists of several activities; the diagram shows their sequence.
- Activity diagrams are:
- Abstract — general processes, not details
- Independent of objects — behavior, not structure
- Flexible — any type of process
3.1 Elements of an Activity Diagram
| Element | Meaning | Notation |
|---|---|---|
| Action | Simple, non-decomposable piece of behavior; labeled verb + noun | Rounded rectangle |
| Activity | A set of actions — can be subdivided | Rounded rectangle |
| Object node | An object connected to object flows; labeled with class name | Rectangle (name underlined) |
| Control flow | Sequence of execution; attaches only to actions/activities | Solid arrow |
| Object flow | Flow of an object between actions/activities | Dashed arrow |
| Initial node | Beginning of the actions | Filled circle ● |
| Final-activity node | Stops all control and object flows | Bull’s-eye ◉ |
| Final-flow node | Stops one specific flow | Circle with ✕ |
| Decision node | Test condition — flow goes down only one path; branches labeled with [guard] | Diamond (1 in, many out) |
| Merge node | Rejoins paths created by a decision | Diamond (many in, 1 out) |
| Fork node | Splits into parallel/concurrent flows (all paths run) | Thick bar (1 in, many out) |
| Join node | Rejoins parallel flows into one | Thick bar (many in, 1 out) |
| Swimlane | Rows/columns assigning activities to the responsible person/object | Labeled lane |
⚠ Decision vs. fork: decision paths are mutually exclusive (one is taken); fork paths are not (all run concurrently). Merge pairs with decision; join pairs with fork.
3.2 Guidelines for Creating Activity Diagrams
- Set the scope of the activity being modeled.
- Identify the activities; connect them with flows.
- Identify any decisions.
- Identify potential parallelism.
- Draw the diagram.
3.3 Creating an Activity Diagram
- Choose a business process identified previously (review the requirements definition, use-case diagram, other documentation).
- Identify the set of activities.
- Identify control flows and nodes.
- Identify object flows and nodes.
- Lay out and draw (minimize crossing lines).
Worked example — Manage Appointments (built from the Make Old Patient Appt flow):
flowchart TD S((●)) --> G[Get Patient Information] G --> D1{Info changed?} D1 -->|"[yes]"| U[Update Patient Info] D1 -->|"[no]"| M1{" "} U --> M1 M1 --> D2{Request type?} D2 -->|"[new]"| N[Make New Appointment] D2 -->|"[cancel]"| C[Cancel Appointment] D2 -->|"[change]"| CH[Change Appointment] N --> M2{" "} C --> M2 CH --> M2 M2 --> F[Provide Results to Patient] F --> E((◉)) N -.->|object flow| AP[Appointment]
Info changed?andRequest type?are decision nodes with guard conditions.- The empty diamonds are merge nodes bringing the branches back together.
Appointmentis an object node reached by an object flow (dashed).
Worked example — Add Apartment (Campus Housing), a simple sequential flow:
flowchart TD S((●)) --> A[Capture Location] --> B[Capture Number of Bedrooms] --> C[Capture Monthly Rent] --> D[Add Apartment] --> E((◉))
4. Business Process Documentation with Use Cases and Descriptions
4.1 Use Cases (recap)
- The starting point for all UML diagrams — everything else is built from them.
- Depict activities performed by users: what the user can do and how the system responds.
- Each use case describes only ONE function.
4.2 Types of Use Cases
By level of detail
- Overview — high-level, basic info only; used early to understand requirements (big picture).
- Detailed — complete and precise, includes all steps and flows; based on activity diagrams.
By purpose
- Essential — what should happen; no technical details; implementation-independent.
- Real — how it actually happens; includes tools, systems, concrete steps.
| Overview | Detail | |
|---|---|---|
| Essential | High-level overview of issues essential to understanding required functionality | Detailed description of issues essential to understanding required functionality |
| Real | High-level overview of a specific set of steps on the real (implemented) system | Detailed description of a specific set of steps on the real (implemented) system |
Example. “Customer pays for order” is essential. “Customer taps card on the POS terminal; terminal sends request to bank API” is real.
4.3 Elements of a Use-Case Description
- Overview: Name, ID number, Type, Primary actor, Brief description, Importance level, Stakeholder(s) & interests, Trigger (what starts it; external or temporal).
- Relationships: association, include, extend, generalization.
- Flow of events:
- Normal flow — usual set of activities
- Sub-flows — pieces of the normal flow, to simplify it
- Alternate / exceptional flows — non-normal or error cases
- Optional characteristics (complexity, time, …).
4.4 Use-Case Writing Guidelines
- Write clearly — subject–verb–object (“User enters password”).
- Show who acts — every step names its initiator (user or system).
- Stay neutral — independent observer’s view (no “I”/“we”).
- Same level of abstraction — don’t mix very detailed and very general steps.
- Complete transaction in four steps:
- Primary actor sends a request (with data) to the system.
- System validates the request.
- System processes it and may update its state.
- System returns the result to the user.
- KISS — Keep It Simple, Stupid.
- Iterate — review and refine until analysts and users agree there are enough use cases to start identifying candidate classes. New use cases may appear while identifying classes.
4.5 Creating Use-Case Descriptions
- Overview — primary actor, type, stakeholders & interests, importance, brief description, trigger, relationships.
- Normal flow — main steps.
- Keep steps simple — consistent size and level of detail.
- Alternate flows — exceptions and different paths.
- Review for correctness and completeness.
- Iterate.
4.6 Example 1 — Borrow Books
| Field | Value |
|---|---|
| Name / ID / Importance | Borrow Books / 1 / High |
| Primary actor | Borrower |
| Type | Detail, Essential |
| Stakeholders | Borrower — wants to check out books; Librarian — ensures borrower only gets books deserved |
| Brief description | How books are checked out of the library |
| Trigger / Type | Borrower brings books to check-out desk / External |
| Associations | Borrower, Personnel Office, Registrar’s Office |
Normal flow
- The Borrower brings books to the Librarian at the check-out desk.
- The Borrower provides the Librarian their ID card.
- The Librarian checks the validity of the ID card:
- Student → validate against Registrar’s database
- Faculty/Staff → validate against Personnel database
- Guest → validate against the Library’s Guest database
- The Librarian checks for overdue books and/or fines.
- The Borrower checks out the books.
Alternate/exceptional flows
- 4a. ID card invalid → request rejected.
- 5a. Overdue books or fines → request rejected.
4.7 Example 2 — Make Old Patient Appt
| Field | Value |
|---|---|
| ID / Importance | 2 / Low |
| Primary actor | Old Patient |
| Type | Detail, Essential |
| Stakeholders | Old Patient — make/change/cancel an appointment; Doctor — patient’s needs met in a timely manner |
| Trigger / Type | Patient calls to make, change or cancel an appointment / External |
| Relationships | Association: Old Patient · Extend: Update Patient Information · Generalization: Manage Appointments |
Normal flow
- Patient contacts the office regarding an appointment.
- Patient provides the Receptionist with name and address.
- If the Patient’s information has changed → execute Update Patient Information.
- If payment arrangements changed → execute Make Payment Arrangements.
- Receptionist asks: new, cancel, or change? → run S-1, S-2 or S-3.
- Receptionist provides the results to the Patient.
Sub-flows
- S-1 New: ask for possible times → match with available slots → schedule.
- S-2 Cancel: ask for old appointment time → find it in the file → cancel.
- S-3 Change: perform S-2 then S-1.
Alternate flows
- S-1, 2a1: Receptionist proposes alternative times.
- S-1, 2a2: Patient picks one or decides not to make an appointment.
⚠ Notice how S-3 reuses S-1 and S-2 — sub-flows keep the normal flow short and avoid repetition.
4.8 Example 3 — Add Apartment (Campus Housing)
Use-case diagram, activity diagram and description all describe the same process:
flowchart LR AO(["🧍 Apartment Owner"]) ST(["🧍 Student"]) subgraph CHS[Campus Housing System] AA((Add Apartment)) DA((Delete Apartment)) SR((Search Available Rental Units)) end AO --- AA AO --- DA ST --- SR
| Field | Value |
|---|---|
| ID / Importance / Type | 1 / High / Detail, Essential |
| Primary actor | Apartment Owner |
| Stakeholders | Apartment Owner — advertise apartment; Campus Housing Service — enable owners to rent |
| Trigger | Apartment Owner wants to add an available apartment (External) |
| Normal flow | 1. Capture location · 2. Capture number of bedrooms · 3. Capture monthly rent · 4. Add apartment to the listing |
Each activity in the activity diagram (§3.3) maps 1-to-1 to a normal-flow step — exactly what V&V checks below.
5. Verifying & Validating Functional Models
Use cases must be verified and validated before structural and behavioral modeling.
5.1 Walkthroughs
A review meeting of all diagrams and models by the development team and the client.
| Role | Responsibility |
|---|---|
| Facilitator | Organizes the meeting (schedule, set-up) |
| Presenter | Explains the representation being reviewed |
| Recorder (scribe) | Takes notes, records errors |
5.2 Rules for V&V
| # | Rule | Check |
|---|---|---|
| 1 | Match steps | Every action/activity in the activity diagram appears in the use-case description’s flows |
| 2 | Include all objects | Every object node in the activity diagram is mentioned in the description |
| 3 | Same order | Description steps follow the activity diagram’s sequence |
| 4 | One description only | Each use case has exactly one description |
| 5 | Actor consistency | All actors in the description appear in the use-case diagram |
| 6 | Stakeholders (optional, local policy) | Stakeholders may also appear on the diagram |
| 7 | Relationship consistency | All relationships in the description appear in the use-case diagram |
| 8 | Diagram rules | All standard UML rules are respected |
Worked example — checking Add Apartment
- Rule 1 & 3: activities Capture Location → Bedrooms → Rent → Add Apartment = normal-flow steps 1→4, same order ✓
- Rule 5: actor Apartment Owner is on the use-case diagram ✓
- Rule 7: only an association with Apartment Owner — shown on the diagram ✓