44 research outputs found
Static Generation of UML Sequence Diagrams
UML sequence diagrams are visual representations of object interactions in a system and can provide valuable information for program comprehension, debugging, maintenance, and software archeology. Sequence diagrams generated from legacy code are independent of existing documentation that may have eroded. We present a framework for static generation of UML sequence diagrams from object-oriented source code. The framework provides a query refinement system to guide the user to interesting interactions in the source code. Our technique involves constructing a hypergraph representation of the source code, traversing the hypergraph with respect to a user-defined query, and generating the corresponding set of sequence diagrams. We implemented our framework as a tool, StaticGen (supporting software: StaticGen), analyzing a corpus of 30 Android applications. We provide experimental results demonstrating the efficacy of our technique (originally appeared in the Proceedings of Fundamental Approaches to Software Engineering—20th International Conference, FASE 2017, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2017, Uppsala, Sweden, April 22–29, 2017)
Software quality tools and techniques presented in FASE’17
Software quality assurance aims to ensure that the software product meets the quality standards expected by the customer. This special issue of Software Tools for Technology Transfer is concerned with the foundations on which software quality assurance is built. It introduces the papers that focus on this topic and that have been selected from the 20th International Conference on Fundamental Approaches to Software Engineering (FASE’17)
Generalising Projection in Asynchronous Multiparty Session Types
Multiparty session types (MSTs) provide an efficient methodology for specifying and verifying message passing software systems. In the theory of MSTs, a global type specifies the interaction among the roles at the global level. A local specification for each role is generated by projecting from the global type on to the message exchanges it participates in. Whenever a global type can be projected on to each role, the composition of the projections is deadlock free and has exactly the behaviours specified by the global type. The key to the usability of MSTs is the projection operation: a more expressive projection allows more systems to be type-checked but requires a more difficult soundness argument.
In this paper, we generalise the standard projection operation in MSTs. This allows us to model and type-check many design patterns in distributed systems, such as load balancing, that are rejected by the standard projection. The key to the new projection is an analysis that tracks causality between messages. Our soundness proof uses novel graph-theoretic techniques from the theory of message-sequence charts. We demonstrate the efficacy of the new projection operation by showing many global types for common patterns that can be projected under our projection but not under the standard projection operation
Spreadsheet-based Configuration of Families of Real-Time Specifications
Model checking real-time systems is complex, and requires a careful trade-off
between including enough detail to be useful and not too much detail to avoid
state explosion. This work exploits variability of the formal model being
analysed and the requirements being checked, to facilitate the model-checking
of variations of real-time specifications. This work results from the
collaboration between academics and Alstom, a railway company with a concrete
use-case, in the context of the VALU3S European project. The configuration of
the variability of the formal specifications is described in MS Excel
spreadsheets with a particular structure, making it easy to use also by
developers. These spreadsheets are processed automatically by our prototype
tool that generates instances and runs the model checker. We propose the
extension of our previous work by exploiting analysis over valid combination of
features, while preserving the simplicity of a spreadsheet-based interface with
the model checker.Comment: In Proceedings TiCSA 2023, arXiv:2310.1872
White-box validation of quantitative product lines by statistical model checking and process mining
We propose a novel methodology for validating software product line (PL)
models by integrating Statistical Model Checking (SMC) with Process Mining
(PM). Our approach focuses on the feature-oriented language QFLan in the PL
engineering domain, allowing modeling of PLs with rich cross-tree and
quantitative constraints, as well as aspects of dynamic PLs like staged
configurations. This richness leads to models with infinite state-space,
requiring simulation-based analysis techniques like SMC. For instance, we
illustrate with a running example involving infinite state space. SMC involves
generating samples of system dynamics to estimate properties such as event
probabilities or expected values. On the other hand, PM uses data-driven
techniques on execution logs to identify and reason about the underlying
execution process. In this paper, we propose, for the first time, applying PM
techniques to SMC simulations' byproducts to enhance the utility of SMC
analyses. Typically, when SMC results are unexpected, modelers must determine
whether they stem from actual system characteristics or model bugs in a
black-box manner. We improve on this by using PM to provide a white-box
perspective on the observed system dynamics. Samples from SMC are fed into PM
tools, producing a compact graphical representation of observed dynamics. The
mined PM model is then transformed into a QFLan model, accessible to PL
engineers. Using two well-known PL models, we demonstrate the effectiveness and
scalability of our methodology in pinpointing issues and suggesting fixes.
Additionally, we show its generality by applying it to the security domain.Comment: Pre-print Special Issue on Managing Variability in Complex
Software-Intensive Systems of the Journal of Systems and Softwar
Avoiding Unnecessary Information Loss: Correct and Efficient Model Synchronization Based on Triple Graph Grammars
Model synchronization, i.e., the task of restoring consistency between two
interrelated models after a model change, is a challenging task. Triple Graph
Grammars (TGGs) specify model consistency by means of rules that describe how
to create consistent pairs of models. These rules can be used to automatically
derive further rules, which describe how to propagate changes from one model to
the other or how to change one model in such a way that propagation is
guaranteed to be possible. Restricting model synchronization to these derived
rules, however, may lead to unnecessary deletion and recreation of model
elements during change propagation. This is inefficient and may cause
unnecessary information loss, i.e., when deleted elements contain information
that is not represented in the second model, this information cannot be
recovered easily. Short-cut rules have recently been developed to avoid
unnecessary information loss by reusing existing model elements. In this paper,
we show how to automatically derive (short-cut) repair rules from short-cut
rules to propagate changes such that information loss is avoided and model
synchronization is accelerated. The key ingredients of our rule-based model
synchronization process are these repair rules and an incremental pattern
matcher informing about suitable applications of them. We prove the termination
and the correctness of this synchronization process and discuss its
completeness. As a proof of concept, we have implemented this synchronization
process in eMoflon, a state-of-the-art model transformation tool with inherent
support of bidirectionality. Our evaluation shows that repair processes based
on (short-cut) repair rules have considerably decreased information loss and
improved performance compared to former model synchronization processes based
on TGGs.Comment: 33 pages, 20 figures, 3 table
Asynchronous Multiparty Session Type Implementability is Decidable - Lessons Learned from Message Sequence Charts
Multiparty session types (MSTs) provide efficient means to specify and verify asynchronous message-passing systems. For a global type, which specifies all interactions between roles in a system, the implementability problem asks whether there are local specifications for all roles such that their composition is deadlock-free and generates precisely the specified executions. Decidability of the implementability problem is an open question. We answer it positively for global types with sender-driven choice, which allow a sender to send to different receivers upon branching and a receiver to receive from different senders. To achieve this, we generalise results from the domain of high-level message sequence charts (HMSCs). This connection also allows us to comprehensively investigate how HMSC techniques can be adapted to the MST setting. This comprises techniques to make the problem algorithmically more tractable as well as a variant of implementability that may open new design space for MSTs. Inspired by potential performance benefits, we introduce a generalisation of the implementability problem that we, unfortunately, prove to be undecidable
Value-dependent session design in a dependently typed language
Session Types offer a typing discipline that allows protocol specifications to be used during type-checking, ensuring that implementations adhere to a given specification. When looking to realise global session types in a dependently typed language care must be taken that values introduced in the description are used by roles that know about the value. We present Sessions, a Resource Dependent Embedded Domain Specific Language (EDSL) for describing global session descriptions in the dependently typed language Idris. As we construct session descriptions the values parameterising the EDSLs’ type keeps track of roles and messages they have encountered. We can use this knowledge to ensure that message values are only used by those who know the value. Sessions supports protocol descriptions that are computable, composable, higher-order, and value-dependent. We demonstrate Sessions expressiveness by describing the TCP Handshake, a multi-modal server providing echo and basic arithmetic operations, and a Higher-Order protocol that supports an authentication interaction step.Publisher PD