D. Harel and R. Marelly,
Come , Let's Play: Scenario-Based
Programming Using LSCs and the Play-Engine,
(Includes CD with the Play-Engine Software. See the special book
This book is no longer in print at
Springer-Verlag. It can be downloaded in its entirety here:
Part I. Prelude
1.1 What are We Talking About?
1.2 What are We Trying to Do?
1.3 What's in the Book?
- Setting the Stage
2.1 Modeling and Code Generation
2.3 Inter-Object vs. Intra-Object Behavior
2.4 Live Sequence Charts (LSCs)
2.5 Testing, Verification and Synthesis
2.6 The Play-In/Play-Out Approach
- An Example-Driven Overview
3.1 The Sample System
3.2 Playing In
3.3 Playing Out
3.4 Using Play-Out for Testing
3.5 Transition to Design
3.7 Smart Play-Out
Part II. Foundations
- The Model: Object Systems
4.1 Application Types
4.2 Object Properties
4.3 And a Bit More Formally...
- The Language: Live Sequence Charts (LSCs)
5.1 Constant LSCs
5.2 Playing In
5.3 The General Play-Out Scheme
5.5 Combining Locations and Messages
5.6 And a Bit More Formally...
5.7 Bibliographic Notes
- The Tool: The Play-Engine
6.1 Bibliographic Notes
Part III. Basic Behavior
- Variables and Symbolic Messages
7.1 Symbolic Scenarios
7.2 Enriching the Partial Order
7.3 Playing Out
7.4 And a Bit More Formally...
7.5 Bibliographic Notes
- Assignments and Implemented Functions
8.1 Using Implemented Functions
8.3 Playing Out
8.4 And a Bit More Formally...
9.1 Cold Conditions
9.2 Hot Conditions
9.3 Playing In
9.4 Playing Out
9.5 And a Bit More Formally...
9.6 Bibliographic Notes
- Branching and Subcharts
10.1 The If-Then-Else Construct
10.3 Nondeterministic Choice
10.4 Playing In
10.5 Playing Out
10.6 And a Bit More Formally...
10.7 Bibliographic Notes
Part IV. Advanced Behavior: Multiple Charts
- Executing Multiple Charts
11.1 Simultaneous Activation of Multiple Charts
11.2 Overlapping Charts
11.3 And a Bit More Formally...
- Testing with Existential Charts
12.1 Specifying Test Scenarios
12.2 Monitoring LSCs
12.3 Recording and Replaying
12.4 On-line Testing
12.5 Executing and Monitoring LSCs in the Play-Engine
12.6 And a Bit More Formally...
12.7 Bibliographic Notes
Part V. Advanced Behavior: Richer Constructs
13.1 Using Loops
13.2 Playing In
13.3 Playing Out
13.4 Using Variables Within Loops
13.5 Executing and Monitoring Dynamic Loops
13.6 And a Bit More Formally...
13.7 Bibliographic Notes
- Transition to Design
14.1 The Design Phase
14.2 Incorporating Internal Objects
14.3 Calling Object Methods
14.4 Playing Out
14.5 External Objects
14.6 And a Bit More Formally...
14.7 Bibliographic Notes
- Classes and Symbolic Instances
15.1 Symbolic Instances
15.2 Classes and Objects
15.3 Playing with Simple Symbolic Instances
15.4 Symbolic Instances in the Main Chart
15.5 Quantified Binding
15.6 Reusing a Scenario Prefix
15.7 Symbolic Instances in Existential Charts
15.8 An Advanced Example: NetPhone
15.9 And a Bit More Formally...
15.10 Bibliographic Notes
- Time and Real-Time Systems
16.1 An Example
16.2 Adding Time to LSCs
16.3 Hot Timing Constraints
16.4 Cold Timing constraints
16.5 Time Events
16.6 Playing In
16.7 Playing Out
16.8 Unification of Clock Ticks
16.9 The Time-Enriched NetPhone Example
16.10 And a Bit More Formally...
16.11 Bibliographic Notes
- Forbidden Elements
17.1 Example: A Cruise Control System
17.2 Forbidden Messages
17.3 Generalized Forbidden Messages
17.4 Symbolic Instances in Forbidden Messages
17.5 Forbidden Conditions
17.6 Scoping Forbidden Elements
17.7 Playing Out
17.8 Using Forbidden Elements with Time
17.9 A Tolerant Semantics for LSCs
17.10 And a Bit More Formally...
17.11 Bibliographic Notes
Part VI. Enhancing the Play-Engine
- Smart Play-Out (with H. Kugler)
18.2 Being Smart Helps
18.3 The General Approach
18.4 The Translation
18.5 Current Limitations
18.6 Satisfying Existential Charts
18.7 Bibliographic Notes
- Inside and Outside the Play-Engine
19.1 The Engine's Environment
19.2 Playing In
19.3 Playing Out
19.4 Recording Runs and Connecting External Applications
19.5 Additional Play-Engine Features
- A Play-Engine Aware GUI Editor
20.1 Who Needs a GUI Editor?
20.2 GUIEdit in Visual Basic
20.3 What Does GUIEdit Do?
20.4 Incorporating Custom Controls
20.5 GUIEdit As a Proof of Concept
20.6 Bibliographic Notes
- Future Research Directions
21.1 Object Refinement and Composition
21.2 Object Model Diagrams, Inheritance and Interfaces
21.3 Dynamic Creation and Destruction of Objects
21.4 Structured Properties and Types
21.5 Linking Multiple Engines
Part VII. Appendices
- Formal Semantics of LSCs
A.1 System Model and Events
A.2 LSC Specification
A.3 Operational Semantics
- XML Description of a GUI Application
- The Play-Engine Interface
C.1 Visual Basic Code
- The GUI Application Interface
D.1 Visual Basic Code
- The Structure of a (Recorded) Run
Back to Top
This book does not tell a story. Instead, it is about stories.
Or rather, in technical terms, it is about scenarios. Scenarios of system
behavior. It concentrates on reactive systems, be they
software or hardware, or combined computer-embedded systems, including
distributed and real-time systems.
We propose a different way to program such systems, centered on inter-object
scenario-based behavior. The book describes a language, two techniques,
and a supporting tool. The language is a rather broad extension of live
sequence charts (LSCs), the original version
of which was proposed in 1998 by W. Damm and the first listed author of
this book. The first of the two techniques, called play-in,
is a convenient way to "play in" scenario-based behavior directly
from the system's graphical user interface (GUI). The second technique,
play-out, makes it possible to execute, or "play-out",
the behavior on the GUI as if it were programmed in a conventional intra-object
state-base fashion. All this is implemented in full in our tool, the Play-Engine.
The book can be viewed as offering improvements in some of the phases
of known system development life cycles, e.g., requirements capture and
analysis, prototyping, and testing. However, there is a more radical way
to view the book, namely, as proposing an alternative way to programming
reactivity, which, being based on inter-object scenarios, is a lot closer
to how people think about systems and their behavior.
We are excited by the apparent potential of this work. However, whether
or not it is adopted and becomes really useful, what kinds of systems
are the ideas most fitting for, and how we should develop methodologies
for large-scale applications, all remain to a large extent open questions.
Whatever the case, we hope that the book triggers further research and
Note on the Software
The Play-Engine tool is available with the book for free, and the attached
CD contains most of the files needed for using the software. However,
some of the ideas behind the play-in and play-out methods are patent pending,
and both the relevant intellectual property and the Play-Engine software
itself are owned by the Weizmann Institute of Science. In order to obtain
the remaining parts of the software, please visit the book's website,
www.wisdom.weizmann.ac.il/~playbook, where you will be asked to sign an
appropriate license agreement and to register your details.
A reservation is in order here: the Play-Engine is not a commercial product
(at least at the time of writing), and should be regarded as a research-level
tool. Thus, its reliability and ease of use are less than what would be
expected from professional software, and we cannot be held responsible
for its performance. Nevertheless, we will make an effort to correct bugs
and to otherwise improve and modify the tool, posting periodical updates
on the website. In fact we have already made some slight changes in the
software since the text of the book was finalized a few weeks ago; these
are all documented in the User Guide that is attached to the software.
We would be grateful of readers would use the appropriate locations on
the website to report any errors, both in the software and in the text
of the book.
So, please do come and visit the site, sign in, download, play, and enjoy...
Back to Top