---
title: "Explain online order sequence diagram"
subject: "Object Oriented Analysis and Design"
chapter: 2
key: "semester_6/object_oriented_analysis_and_design:order-processing-sequence-diagram-explain"
source: https://www.bctengineer.com/q/semester_6/object_oriented_analysis_and_design/order-processing-sequence-diagram-explain
site: BCT Engineering
---

# Explain online order sequence diagram

Object Oriented Analysis and Design · Chapter 2: Object Oriented Analysis

- Asked in: 2070 Magh, 8 marks
- Video: [1.3.6 – UML Sequence Diagram - Object-Oriented Design](https://www.youtube.com/watch?v=7JyUQL0KQ4w) — Pham Thuy Hang
- Answer checked by Claude Opus 5.5 (high effort) on 2026-10-14
- Page: https://www.bctengineer.com/q/semester_6/object_oriented_analysis_and_design/order-processing-sequence-diagram-explain
- Whole chapter: https://www.bctengineer.com/md/semester_6/object_oriented_analysis_and_design/chapter-2

## Question

The model depicts the online order processing system as illustrated in fig.1. Explain in detail of the diagram type with every symbols being used and semantics of this diagram.
[Figure fig.1: sequence diagram with an actor and lifelines :OrderTaker, :CreditCardAgent, :OrderFulfillment, :BillingAgent. Messages: submitOrder (actor to :OrderTaker), processCard (:OrderTaker to :CreditCardAgent), placeOrder (:OrderTaker to :OrderFulfillment), triggerBill (:OrderFulfillment to :BillingAgent, asynchronous), acknowledgeOrder (return to the actor). A note reads "See Credit Failure for a variation of this scenario."]

## Short answer

This sequence diagram shows interaction among objects in time order. Symbols: actor, lifelines with object boxes, activation bars, synchronous messages (solid arrowhead), asynchronous message (open arrowhead) to trigger bill, dashed return arrow, and a note for alternate scenario. Semantics: after submitOrder, OrderTaker processes card synchronously, then places order; OrderFulfillment triggers billing asynchronously; finally acknowledgment is returned.

## Answer

The figure is a UML **sequence diagram**. It shows the interaction among objects for one scenario of order processing, with messages arranged in time order from top to bottom.

```text
 Actor    :OrderTaker  :CreditCard  :Order      :Billing
                        Agent       Fulfillment  Agent
   |submitOrder|           |            |          |
   |---------->|           |            |          |
   |          [ ]processCard|           |          |
   |          [ ]--------->[ ]          |          |
   |          [ ]<- - - - -[ ]          |          |
   |          [ ]placeOrder             |          |
   |          [ ]---------------------->[ ]        |
   |          [ ]                       [ ]triggerBill
   |          [ ]                       [ ]- - - ->[ ]
   |<- - - - -[ ] acknowledgeOrder       |          |
```
Note: "See Credit Failure for a variation of this scenario."

#### Symbols used
| Symbol | Meaning |
|---|---|
| Actor (stick figure or box) | External user/system starting the scenario |
| Object box `:OrderTaker` | An anonymous instance of a class (`name:Class`, name omitted) at the top |
| Lifeline (dashed vertical line) | Existence of the object over time |
| Activation bar (thin rectangle) | Period when the object is active (focus of control) |
| Solid arrow with filled head | Synchronous message (caller waits) |
| Arrow with open/stick head | Asynchronous message (caller continues) |
| Dashed arrow | Return message |
| Note (folded corner) | Comment; here a pointer to another scenario |

#### Semantics (reading the diagram)
1. The actor sends `submitOrder` to `:OrderTaker`, which becomes active.
2. `:OrderTaker` sends `processCard` to `:CreditCardAgent` to validate and charge the card, and waits for the result (synchronous).
3. If the card is accepted, `:OrderTaker` sends `placeOrder` to `:OrderFulfillment`.
4. `:OrderFulfillment` sends `triggerBill` to `:BillingAgent` as an **asynchronous** message: it does not wait for billing to finish, and billing proceeds on its own.
5. `:OrderTaker` returns `acknowledgeOrder` to the actor, confirming the order.
6. The note says the failure case (card rejected) is shown in a separate diagram "Credit Failure".

The diagram shows **what** collaborates and **in which order**, and identifies the operations (`processCard`, `placeOrder`, `triggerBill`) the classes must provide.

## Check yourself

The answer's key points as multiple-choice questions, with the correct option and why.

1. What does the vertical direction of a UML sequence diagram represent?
   A. Time order of messages, from top to bottom
   B. Class inheritance levels
   C. Physical location of the objects
   D. Priority of the objects
   Answer: A. Messages are arranged in time order from top to bottom, showing the order of the interaction in one scenario. (Key point: Diagram type and time ordering)

2. In the diagram, what does an activation bar on a lifeline show?
   A. That the object has been destroyed
   B. The period when the object is active (focus of control)
   C. That the message is asynchronous
   D. That the object is an actor
   Answer: B. The thin rectangle on the dashed lifeline marks the time the object is active. (Key point: Lifeline and activation bar)

3. triggerBill from :OrderFulfillment to :BillingAgent is asynchronous. What does this mean?
   A. The sender waits until billing is finished
   B. It is a return message
   C. The sender continues without waiting for billing to finish
   D. The message is sent only if the card fails
   Answer: C. An asynchronous message (open arrowhead) lets the caller continue while billing proceeds on its own. (Key point: Asynchronous message)

4. What does the note 'See Credit Failure for a variation of this scenario' tell the reader?
   A. The order is always rejected
   B. The card is validated by the actor
   C. The diagram is incomplete and wrong
   D. The card-rejected case is shown in a separate diagram
   Answer: D. The note is a comment pointing to another scenario (card rejected), so this diagram shows only the success path. (Key point: Scenario flow and the note)

## Related in Object Oriented Analysis and Design

- [Map sequence diagram to pseudo code](https://www.bctengineer.com/question.md?key=semester_6%2Fobject_oriented_analysis_and_design%3Aorder-model-mapping-pseudocode) — Object Oriented Analysis and Design, chapter 4
- [Food ordering system sequence diagram](https://www.bctengineer.com/question.md?key=semester_6%2Fobject_oriented_analysis_and_design%3Afood-ordering-system-sequence-diagram) — Object Oriented Analysis and Design, chapter 2
- [External actors and library system sequence diagram](https://www.bctengineer.com/question.md?key=semester_6%2Fobject_oriented_analysis_and_design%3Aexternal-actors-library-system-sequence-diagram) — Object Oriented Analysis and Design, chapter 2
- [Money transfer sequence diagram questions](https://www.bctengineer.com/question.md?key=semester_6%2Fobject_oriented_analysis_and_design%3Amoney-transfer-sequence-diagram) — Object Oriented Analysis and Design, chapter 2
- [Event management system summary and class diagram](https://www.bctengineer.com/question.md?key=semester_6%2Fobject_oriented_analysis_and_design%3Aoems-executive-summary-class-diagram) — Object Oriented Analysis and Design, chapter 2

## Related in other subjects

- [Block diagram reduction of Fig. 2(a): G1–G3, H1, H2](https://www.bctengineer.com/question.md?key=semester_3%2Fcontrol_systems%3Abdr-g1g2g3-h1h2-2066) — Control Systems, chapter 3, asked 2×
- [Digital communication system; Shannon-Fano for six symbols](https://www.bctengineer.com/question.md?key=semester_6%2Fcommunication_systems%3Adcs-block-shannon-fano-six) — Communication Systems, chapter 6
- [Five GPSS block diagram symbols](https://www.bctengineer.com/question.md?key=semester_8%2Fsimulation_and_modeling%3Agpss-block-symbols) — Simulation and Modeling, chapter 9, asked 2×
- [Plot sequence; properties of LTI system](https://www.bctengineer.com/question.md?key=semester_7%2Fdigital_signal_analysis_and_processing%3Aplot-sequence-lti-properties) — Digital Signal Analysis and Processing, chapter 1
