10640301
Smart play-out
We describe "smart play-out", a new method for executing and analyzing scenario based behavior, which is part of the Play-In/Play-Out methodology and the Play-Engine tool. Behavior is "played in" directly from the system's GUI, and as this is being done the Play-Engine continuously constructs Live Sequence Charts (LSCs), a powerful extension of sequence diagrams. Later, behavior can be "played out" freely from the GUI, and the tool executes the LSCs directly, thus driving the system's behavior. An inherent difficulty in constructing a ``play-out" mechanism is how to resolve the nondeterminism allowed by the LSC specification in order to obtain an executable model. Smart play-out, is a recent strengthening of the play-out mechanism, which addresses this problem by using powerful verification methods, mainly model-checking, to execute and analyze the LSCs, helping the execution to avoid deadlocks and violations. Thus, smart play-out utilizes verification techniques to run programs, rather than to verify a program with respect to given requirements, as in traditional verification approaches. The ideas appear to be relevant in various stages of system development, including requirements specification and analysis, implementation and testing.
1037525
Graph Drawing by High-Dimensional Embedding
We present a novel approach to the aesthetic drawing of undirected graphs. The method has two phases: first embed the graph in a very high dimension and then project it into the 2-D plane using principal components analysis. Running time is linear in the graph size, and experiments we have carried out show the ability of the method to draw graphs of 105 nodes in few seconds. The new method appears to have several advantages over classical methods, including a significantly better running time, a useful inherent capability to exhibit the graph in various dimensions, and an effective means for interactive exploration of large graphs.
346060
A Multi-scale Algorithm for the Linear Arrangement Problem
Finding a linear ordering of the vertices of a graph is a common problem arising in diverse applications. In this paper we present a linear-time algorithm for this problem, based on the multi-scale paradigm. Experimental results are similar to those of the best known approaches, while the running time is significantly better, enabling it to deal with much larger graphs. The paper contains a general multi-scale construction, which may be used for a broader range of ordering problems.
1830823
Playing with time: on the specification and execution of time-enriched LSCs
We extend live sequence charts (LSCs), a highly expressive variant of sequence diagrams, with timing constructs, thus making the language suitable for specifying the behavioral requirements of time-intensive systems. We follow R. Alur and T.A. Henzinger (see Software Tools for Technology Transfer, vol.1, p.86-109, 1997) in basing the extension on a single clock object. We have implemented the extension in full in our play-engine tool, which provides user-friendly ways to play in the timing constraints, together with a powerful mechanism that can execute, or play out, the time-enriched requirements directly, without the need for an intra-object system model. It seems that in addition to many advantages in testing and requirements engineering, for some kinds of systems this could lead to the requirements actually serving as the final implementation.
122739950
Graph Drawing by High-Dimensional Embedding
47242941
A Fast Multi-scale Method for Drawing Large Graphs
We present a multi-scale layout algorithm for the aesthetic drawing of undirected graphs with straight-line edges. The algorithm is extremely fast, and is capable of drawing graphs of substantially larger size than any other algorithm we are aware of. For example, the algorithm achieves optimal drawings of 1000 vertex graphs in about 2 seconds. The paper contains graphs with over 6000 nodes. The proposed algorithm embodies a new multi-scale scheme for drawing graphs, which was motivated by the recently published multi-scale algorithm of Hadany and Harel [7]. It can significantly improve the speed of essentially any force-directed method (regardless of that method's ability of drawing weighted graphs or the continuity of its cost-function).
1551133
LSCs: Breathing Life into Message Sequence Charts
While message sequence charts (MSCs) are widely used in industry to document the interworking of processes or objects, they are expressively weak, being based on the modest semantic notion of a partial ordering of events as defined, e.g., in the ITU standard. A highly expressive and rigorously defined MSC language is a must for serious, semantically meaningful tool support for use-cases and scenarios. It is also a prerequisite to addressing what we regard as one of the central problems in behavioral specification of systems: relating scenario-based inter-object specification to state-machine intra-object specification. This paper proposes an extension of MSCs, which we call live sequence charts (or LSCs), since our main extension deals with specifying “liveness”, i.e., things that must occur. In fact, LSCs allow the distinction between possible and necessary behavior both globally, on the level of an entire chart and locally, when specifying events, conditions and progress over time within a chart. This makes it possible to specify forbidden scenarios, for example, and enables naturally specified structuring constructs such as subcharts, branching and iteration.