59 research outputs found
Model Transformation Testing and Debugging: A Survey
Model transformations are the key technique in Model-Driven Engineering (MDE) to manipulate and construct models. As a consequence, the correctness of software systems built with MDE approaches relies mainly on the correctness of model transformations, and thus, detecting and locating bugs in model transformations have been popular research topics in recent years. This surge of work has led to a vast literature on model transformation testing and debugging, which makes it challenging to gain a comprehensive view of the current state of the art.
This is an obstacle for newcomers to this topic and MDE practitioners to apply these approaches. This paper presents a survey on testing and debugging model transformations based on the analysis of \nPapers~papers on the topics. We explore the trends, advances, and evolution over the years, bringing together previously disparate streams of work and providing a comprehensive view of these thriving areas. In addition, we present a conceptual framework to understand and categorise the different proposals. Finally, we identify several open research challenges and propose specific action points for the model transformation community.This work is partially supported by the European Commission (FEDER) and Junta de Andalucia under projects APOLO (US-1264651) and
EKIPMENT-PLUS (P18-FR-2895), by the Spanish Government (FEDER/Ministerio de Ciencia e Innovación – Agencia Estatal de Investigación) under projects HORATIO (RTI2018-101204-B-C21), COSCA (PGC2018-094905-B-I00) and LOCOSS (PID2020-114615RB-I00), by the Austrian Science Fund (P 28519-N31, P 30525-N31), and by the Austrian Federal Ministry for Digital and Economic Affairs and the National Foundation for Research, Technology and Development (CDG
Efficient Static Analysis of Marlowe Contracts
SMT solvers can verify properties automatically and efficiently, and they offer increasing
flexibility on the ways those properties can be described. But it is hard to predict how those ways of describing the properties affect the computational cost of verifying them.
In this paper, we discuss what we learned while implementing and optimising the static analysis for Marlowe, a domain specific language for self-enforcing financial smart-contracts that can be deployed on a blockchain
Aggressive aggregation
Among the first steps in a compilation pipeline is the construction of an Intermediate Representation
(IR), an in-memory representation of the input program. Any attempt to program
optimisation, both in terms of size and running time, has to operate on this structure. There may
be one or multiple such IRs, however, most compilers use some form of a Control Flow Graph
(CFG) internally. This representation clearly aims at general-purpose programming languages,
for which it is well suited and allows for many classical program optimisations. On the other
hand, a growing structural difference between the input program and the chosen IR can lose
or obfuscate information that can be crucial for effective optimisation. With today’s rise of a
multitude of different programming languages, Domain-Specific Languages (DSLs), and computing
platforms, the classical machine-oriented IR is reaching its limits and a broader variety of
IRs is needed. This realisation yielded, e.g., Multi-Level Intermediate Representation (MLIR),
a compiler framework that facilitates the creation of a wide range of IRs and encourages their
reuse among different programming languages and the corresponding compilers.
In this modern spirit, this dissertation explores the potential of Algebraic Decision Diagrams
(ADDs) as an IR for (domain-specific) program optimisation. The data structure remains the
state of the art for Boolean function representation for more than thirty years and is well-known
for its optimality in size and depth, i.e. running time. As such, it is ideally suited to represent
the corresponding classes of programs in the role of an IR. We will discuss its application in
a variety of different program domains, ranging from DSLs to machine-learned programs and
even to general-purpose programming languages.
Two representatives for DSLs, a graphical and a textual one, prove the adequacy of ADDs
for the program optimisation of modelled decision services. The resulting DSLs facilitate
experimentation with ADDs and provide valuable insight into their potential and limitations:
input programs can be aggregated in a radical fashion, at the risk of the occasional exponential
growth. With the aggregation of large Random Forests into a single aggregated ADD, we
bring this potential to a program domain of practical relevance. The results are impressive:
both running time and size of the Random Forest program are reduced by multiple orders of
magnitude. It turns out that this ADD-based aggregation can be generalised, even to generaliii
purpose programming languages. The resulting method achieves impressive speedups for a
seemingly optimal program: the iterative Fibonacci implementation.
Altogether, ADDs facilitate effective program optimisation where the input programs allow
for a natural transformation to the data structure. In these cases, they have proven to be an
extremely powerful tool for the optimisation of a program’s running time and, in some cases,
of its size. The exploration of their potential as an IR has only started and deserves attention in
future research
Taming complexity of industrial printing systems using a constraint-based DSL: An industrial experience report
Flexible printing systems are highly complex systems that consist of printers, that print individual sheets of paper, and finishing equipment, that processes sheets after printing, for example, assembling a book. Integrating finishing equipment with printers involves the development of control software that configures the devices, taking hardware constraints into account. This control software is highly complex to realize due to (1) the intertwined nature of printing and finishing, (2) the large variety of print products and production options for a given product, and (3) the large range of finishers produced by different vendors. We have developed a domain-specific language called CSX that offers an interface to constraint solving specific to the printing domain. We use it to model printing and finishing devices and to automatically derive constraint solver-based environments for automatic configuration. We evaluate CSX on its coverage of the printing domain in an industrial context, and we report on lessons learned on using a constraint-based DSL in an industrial context
CirC: Compiler infrastructure for proof systems, software verification, and more
Cryptographic tools like proof systems, multi-party computation, and fully
homomorphic encryption are usually applied to computations expressed as
systems of arithmetic constraints. In practice, this means that these
applications rely on compilers from high-level programming languages
(like C) to such constraints. This compilation task is challenging, but
not entirely new: the software verification community has a rich literature
on compiling programs to logical constraints (like SAT or SMT). In this
work, we show that building shared compiler infrastructure for compiling
to constraint representations is possible, because these representations
share a common abstraction: stateless, non-uniform, non-deterministic
computations that we call existentially quantified circuits, or EQCs.
Moreover, we show that this shared infrastructure is useful, because
it allows compilers for proof systems to benefit from decades of work
on constraint compilation techniques for software verification.
To make our approach concrete we create CirC, an infrastructure for building
compilers to EQCs. CirC makes it easy to compile to new EQCs: we build support
for three, R1CS (used for proof systems), SMT (used for verification and
bug-finding), and ILP (used for optimization), in ≈2000 LOC. It\u27s also easy
to extend CirC to support new source languages: we build a feature-complete
compiler for a cryptographic language in one week and ≈900 LOC, whereas the
reference compiler for the same language took years to write, comprises ≈24000
LOC, and produces worse-performing output than our compiler. Finally, CirC
enables novel applications that combine multiple EQCs. For example, we build
the first pipeline that (1)Â automatically identifies bugs in programs, then
(2)Â automatically constructs cryptographic proofs of the bugs\u27 existence
- …