Come, Let's Play

D. Harel and R. Marelly,

Come, Let's Play: Scenario-Based Programming Using LSCs and the Play-Engine, Springer-Verlag, 2003.

(Includes CD with the Play-Engine Software. See the special book webpage.)

This book is no longer in print at Springer-Verlag.  It can be downloaded in its entirety here:  Download Book

Preface
~ Book info. from Amazon
~ Book info. from Barnes & Noble

Table of Contents

      Part I. Prelude

  1. Introduction
    1.1 What are We Talking About?
    1.2 What are We Trying to Do?
    1.3 What's in the Book?
  2. Setting the Stage
    2.1 Modeling and Code Generation
    2.2 Requirements
    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
  3. 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.6 Time
    3.7 Smart Play-Out

Part II. Foundations

  1. The Model: Object Systems
    4.1 Application Types
    4.2 Object Properties
    4.3 And a Bit More Formally...
  2. The Language: Live Sequence Charts (LSCs)
    5.1 Constant LSCs
    5.2 Playing In
    5.3 The General Play-Out Scheme
    5.4 Playing-Out
    5.5 Combining Locations and Messages
    5.6 And a Bit More Formally...
    5.7 Bibliographic Notes
  3. The Tool: The Play-Engine
    6.1 Bibliographic Notes


Part III. Basic Behavior

  1. 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
  2. Assignments and Implemented Functions
    8.1 Using Implemented Functions
    8.2 Assignments
    8.3 Playing Out
    8.4 And a Bit More Formally...
  3. Conditions
    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
  4. Branching and Subcharts
    10.1 The If-Then-Else Construct
    10.2 Subcharts
    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

  1. Executing Multiple Charts
    11.1 Simultaneous Activation of Multiple Charts
    11.2 Overlapping Charts
    11.3 And a Bit More Formally...
  2. 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

  1. Loops
    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
  2. 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
  3. 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
  4. 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
  5. 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

  1. Smart Play-Out (with H. Kugler)
    18.1 Introduction
    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
  2. 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
  3. 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
  4. 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

  • A Formal Semantics of LSCs
    A.1 System Model and Events
    A.2 LSC Specification
    A.3 Operational Semantics
  • B XML Description of a GUI Application
  • C The Play-Engine Interface
    C.1 Visual Basic Code
  • D The GUI Application Interface
    D.1 Visual Basic Code

  • The Structure of a (Recorded) Run
     

    References


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 experimentation.

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, 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