Smyle: A Tool for Synthesizing Distributed Models from Scenarios by Learning [chapter]

Benedikt Bollig, Joost-Pieter Katoen, Carsten Kern, Martin Leucker
2008 Lecture Notes in Computer Science  
This paper presents Smyle, a tool for synthesizing asynchronous and distributed implementation models from sets of scenarios that are given as message sequence charts (MSCs). The latter specify desired or unwanted behavior of the system to be. Provided with such positive and negative example scenarios, Smyle employs dedicated learning techniques and propositional dynamic logic (PDL) over MSCs to generate a system model that conforms with the given examples. Synthesizing distributed systems from
more » ... user-specified scenarios is becoming increasingly en vogue [7] . There exists a wide range of approaches for synthesizing implementation models from a priori given scenarios [6, 11, 8, 5, 14, 15] . The approaches mainly differ in their specification language, the inference procedure, and the final implementation model. Several of them employ MSCs as specification language because they are standardized by the ITU Z.120 [9] and adopted by the UML as sequence diagrams. Other approaches try to utilize more expressive notations like triggered MSCs [14] , high-level MSCs [6], or live sequence charts [8] . On the one hand, more expressive power results in richer specifications. On the other hand, however, it is just this great expressiveness that disqualifies them for non-professional or a fortiori unexperienced users, which are overstrained by these formalisms. As requirements specifications over and over demonstrate, human beings strongly prefer to express scenarios in terms of simple pictures including the acting entities and their interaction. Due to this reason, we will restrict to so-called basic MSCs, only, which consist of processes (i.e., vertical axes denoting evolution of time) and messages (i.e., horizontal or slanted arrows between processes signifying asynchronous information exchange). Many approaches to synthesizing distributed systems typically model synchronous communication, infer labeled transition systems, and use standard automata-theoretic solutions to project the global system onto its local components. As can be shown easily, this results in missing or implied behavior that was not stipulated by the user. In contrast, we regard asynchronous communication behavior and derive a distributed model in terms of a message passing automaton (MPA), which models the asynchronous communication in a natural manner deploying FIFO channels. It consist of one local automaton for every process involved in the system. Harel in his recent article [7] states that it is an intrinsically difficult task to "[...] distribute the intuitive played-in behavior [...]" and it is still a dream to employ scenario-based programming. Nevertheless we try to converge to this vision using the tool Smyle presented in this paper.
doi:10.1007/978-3-540-85361-9_15 fatcat:zwzioofm7jcgbd5mwq53r6zemm