using Quick Sequence Diagram Editor for sequence diagrams

Question

Anyone have experience with Quick Sequence Diagram Editor? The combination of instant display + text source code + Java implementation is very attractive to me, but I can't quite figure out how to make the syntax do what I want, and the documentation's not very clear. Here's a contrived example:

al:Actor
bill:Actor
atm:ATM[a]
bank:Bank[a]

al:atm.give me $10
atm:al has $3=bank.check al's account balance
al:atm.what time is it
atm:al.it's now
atm:al.stop bugging me
atm:al.you only have $3
atm:bill.and don't you open your mouth
bill:atm.who asked you?
bill:atm.give me $20
al:atm.hey, I'm not finished!
atm:bill has $765=bank.check bill's account balance
atm:yes I'm sure, bill has $765=bank.hmm are you sure?
atm:bill.here's $20, now go away
atm:great, he's a cool dude=bank.I just gave Bill $20
al:atm.what about my $10?
atm:al.read my lips: you only have $3

Here's the result from QSDE in single-threaded mode:

and in multi-threaded mode:

I guess I'm not clear what starts/ends those vertical bars. I have a situation which is single-threaded, but there's state involved, and all the messages are asynchronous. I guess that means I should use an external object to represent that state and its lifetime. What I want is for one timeline to represent the message sequence

1. al:atm.give me $10
2. atm:bank.check al's account balance
3. bank:atm.al has $3
4. atm:al.you only have $3

and another timeline to represent the message sequence

1. bill:atm.give me $20
2. atm:bank.check bill's account balance
3. bank:atm.bill has $765
4. atm:bank.hmm are you sure?
5. bank:atm.yes I'm sure, bill has $765
6. atm:bill.here's $20, now go away
7. atm:bank.I just gave Bill $20
8. bank:atm.great, he's a cool dude

with the other "wisecracks" representing other miscellaneous messages that I don't care about right now.

Is there a way to do this with QSDE?

Answer 1

Al and Bill are human. How can a human being possibly be part of a single-threaded situation? Human beings, in contrast to procedures, do not stand still until another procedure returns. They can trigger computational activities and receive signals from a computer, but they do not go down to a thread's stack.

The documentation clearly states (cited from Multithreading Help):

"A newly spawned thread can be distinguished from older threads by the colour of its corresponding lifelines."

"As a rule, a message sent by an actor to an object (dynamically) spawns a new thread."

So this is where your vertical bars come from.

If you want single- or dual-threaded situations, you should use objects, not actors.

Answer 2

pha oole..This is wrongly done. just use it oomban

Answer 3

When a new thread is started (and a message from an user always starts a new thread) it does not stop until it is explicitly stopped or until the diagram ends. E.g. atm:stop terminates the atm thread

here a first attempt (everything in multithreaded mode):

al:Actor
bill:Actor
atm:ATM[a]
bank:Bank[a]

al:atm.give me $10
atm:al has $3=bank.check al's account balance
atm:al.you only have $3
atm:stop

bill:atm.give me $20
atm:bill has $765=bank.check bill's account balance
atm:yes I'm sure, bill has $765=bank.hmm are you sure?
atm:bill.here's $20, now go away
atm:great, he's a cool dude=bank.I just gave Bill $20

another version with asynchronous messages

(arguably the messages should be asynchronous, since they are transmitted over the network. Anyway now all arrows look the same)

">" at the start of a message starts a new thread (all messages from users and processes start a new thread by default.)

"&" at the end means that the call returns immediately, and the new thread is not shown. you can use this to simulate sending messages to existing threads. (all messages TO users and processes always return immediately by default. )

al:Actor
bill:Actor
atm:ATM[a]
bank:Bank[a]

al:atm.give me $10
atm:>bank.check al's account balance
bank:>atm.al has $3&
bank:stop
atm:al.you only have $3
atm:stop

bill:atm.give me $20
atm:>bank.check bill's account balance
bank:>atm.bill has $765&
bank:stop

atm:>bank.hmm are you sure?
bank:>atm.yes I'm sure, bill has $765&
bank:stop

atm:bill.here's $20, now go away
atm:>bank.I just gave Bill $20
bank:>atm.great, he's a cool dude&
bank:stop

The full example with all the wisecracks

it is unclear from the example when exactly a thread in ATM should stop. ATM seems to be acting more like a user or process, not an object. So the example does not necessarily make sense

al:Actor
bill:Actor
atm:ATM[a]
bank:Bank[a]

al:atm[a].give me $10
atm:al has $3=bank.check al's account balance

al:atm.what time is it
atm:al.it's now
atm:stop

atm:al.stop bugging me
atm:al.you only have $3

atm:bill.and don't you open your mouth
bill:atm.who asked you?&
atm:stop

bill:atm.give me $20
al:atm.hey, I'm not finished!&
atm:bill has $765=bank.check bill's account balance
atm:yes I'm sure, bill has $765=bank.hmm are you sure?
atm:bill.here's $20, now go away
atm:great, he's a cool dude=bank.I just gave Bill $20
atm:_
atm:stop

al:atm.what about my $10?
atm:al.read my lips: you only have $3