12,404 research outputs found
Recommended from our members
AUnit - a testing framework for alloy
textWriting declarative models of software designs and analyzing them to detect defects is an effective methodology for developing more dependable software systems. However, writing such models correctly can be challenging for practitioners who may not be proficient in declarative programming, and their models themselves may be buggy. We introduce the foundations of a novel test automation framework, AUnit, which we envision for testing declarative models written in Alloy -- a first-order, relational language that is supported by its SAT-based analyzer. We take inspiration from the success of the family of xUnit frameworks that are used widely in practice for test automation, albeit for imperative or object-oriented programs. The key novelty of our work is to define a basis for unit testing for Alloy, specifically, to define the concepts of test case and test coverage as well as coverage criteria for declarative models. We reduce the problems of declarative test execution and coverage computation to partial evaluation without requiring SAT solving. Our vision is to blend how developers write unit tests in commonly used programming languages with how Alloy users formulate their models in Alloy, thereby facilitating the development and testing of Alloy models for both new Alloy users as well as experts. We illustrate our ideas using a small but complex Alloy model. While we focus on Alloy, our ideas generalize to other declarative languages (such as Z, B, ASM).Electrical and Computer Engineerin
Transformation As Search
In model-driven engineering, model transformations are con- sidered a key element to generate and maintain consistency between re- lated models. Rule-based approaches have become a mature technology and are widely used in different application domains. However, in var- ious scenarios, these solutions still suffer from a number of limitations that stem from their injective and deterministic nature. This article pro- poses an original approach, based on non-deterministic constraint-based search engines, to define and execute bidirectional model transforma- tions and synchronizations from single specifications. Since these solely rely on basic existing modeling concepts, it does not require the intro- duction of a dedicated language. We first describe and formally define this model operation, called transformation as search, then describe a proof-of-concept implementation and discuss experiments on a reference use case in software engineering
Automated Workarounds from Java Program Specifications based on SAT Solving
The failures that bugs in software lead to can sometimes be bypassed by the so-called workarounds: when a (faulty) routine fails, alternative routines that the system offers can be used in place of the failing one, to circumvent the failure. Existing approaches to workaround-based system recovery consider workarounds that are produced from equivalent method sequences, automatically computed from user-provided abstract models, or directly produced from user-provided equivalent sequences of operations. In this paper, we present two techniques for computing workarounds from Java code equipped with formal specifications, that improve previous approaches in two respects. First, the particular state where the failure originated is actively involved in computing workarounds, thus leading to repairs that are more state specific. Second, our techniques automatically compute workarounds on concrete program state characterizations, avoiding abstract software models and user-provided equivalences. The first technique uses SAT solving to compute a sequence of methods that is equivalent to a failing method on a specific failing state, but which can also be generalized to schemas for workaround reuse. The second technique directly exploits SAT to circumvent a failing method, building a state that mimics the (correct) behaviour of a failing routine, from a specific program state too. We perform an experimental evaluation based on case studies involving implementations of collections and a library for date arithmetic, showing that the techniques can effectively compute workarounds from complex contracts in an important number of cases, in time that makes them feasible to be used for run-time repairs. Our results also show that our state-specific workarounds enable us to produce repairs in many cases where previous workaround-based approaches are inapplicable.Fil: Uva, Marcelo Ariel. Universidad Nacional de RĂo Cuarto; ArgentinaFil: Ponzio, Pablo Daniel. Consejo Nacional de Investigaciones CientĂficas y TĂ©cnicas. Centro CientĂfico TecnolĂłgico Conicet - CĂłrdoba; Argentina. Universidad Nacional de RĂo Cuarto; ArgentinaFil: Regis, Germán. Universidad Nacional de RĂo Cuarto; ArgentinaFil: Aguirre, Nazareno Matias. Consejo Nacional de Investigaciones CientĂficas y TĂ©cnicas. Centro CientĂfico TecnolĂłgico Conicet - CĂłrdoba; Argentina. Universidad Nacional de RĂo Cuarto; ArgentinaFil: Frias, Marcelo Fabian. Consejo Nacional de Investigaciones CientĂficas y TĂ©cnicas. Centro CientĂfico TecnolĂłgico Conicet - CĂłrdoba; Argentina. Instituto TecnolĂłgico de Buenos Aires; Argentin
Clafer: Lightweight Modeling of Structure, Behaviour, and Variability
Embedded software is growing fast in size and complexity, leading to intimate
mixture of complex architectures and complex control. Consequently, software
specification requires modeling both structures and behaviour of systems.
Unfortunately, existing languages do not integrate these aspects well, usually
prioritizing one of them. It is common to develop a separate language for each
of these facets. In this paper, we contribute Clafer: a small language that
attempts to tackle this challenge. It combines rich structural modeling with
state of the art behavioural formalisms. We are not aware of any other modeling
language that seamlessly combines these facets common to system and software
modeling. We show how Clafer, in a single unified syntax and semantics, allows
capturing feature models (variability), component models, discrete control
models (automata) and variability encompassing all these aspects. The language
is built on top of first order logic with quantifiers over basic entities (for
modeling structures) combined with linear temporal logic (for modeling
behaviour). On top of this semantic foundation we build a simple but expressive
syntax, enriched with carefully selected syntactic expansions that cover
hierarchical modeling, associations, automata, scenarios, and Dwyer's property
patterns. We evaluate Clafer using a power window case study, and comparing it
against other notations that substantially overlap with its scope (SysML, AADL,
Temporal OCL and Live Sequence Charts), discussing benefits and perils of using
a single notation for the purpose
αRby—An Embedding of Alloy in Ruby
We present αRby—an embedding of the Alloy language in Ruby—and demonstrate the benefits of having a declarative modeling language (backed by an automated solver) embedded in a traditional object-oriented imperative programming language. This approach aims to bring these two distinct paradigms (imperative and declarative) together in a novel way. We argue that having the other paradigm available within the same language is beneficial to both the modeling community of Alloy users and the object-oriented community of Ruby programmers. In this paper, we primarily focus on the benefits for the Alloy community, namely, how αRby provides elegant solutions to several well-known, outstanding problems: (1) mixed execution, (2) specifying partial instances, (3) staged model finding
Model Checker Execution Reports
Software model checking constitutes an undecidable problem and, as such, even
an ideal tool will in some cases fail to give a conclusive answer. In practice,
software model checkers fail often and usually do not provide any information
on what was effectively checked. The purpose of this work is to provide a
conceptual framing to extend software model checkers in a way that allows users
to access information about incomplete checks. We characterize the information
that model checkers themselves can provide, in terms of analyzed traces, i.e.
sequences of statements, and safe cones, and present the notion of execution
reports, which we also formalize. We instantiate these concepts for a family of
techniques based on Abstract Reachability Trees and implement the approach
using the software model checker CPAchecker. We evaluate our approach
empirically and provide examples to illustrate the execution reports produced
and the information that can be extracted
Evaluation of Kermeta for Solving Graph-based Problems
Kermeta is a meta-language for specifying the structure and behavior of graphs of interconnected objects called models. In this paper,\ud
we show that Kermeta is relatively suitable for solving three graph-based\ud
problems. First, Kermeta allows the specification of generic model\ud
transformations such as refactorings that we apply to different metamodels\ud
including Ecore, Java, and Uml. Second, we demonstrate the extensibility\ud
of Kermeta to the formal language Alloy using an inter-language model\ud
transformation. Kermeta uses Alloy to generate recommendations for\ud
completing partially specified models. Third, we show that the Kermeta\ud
compiler achieves better execution time and memory performance compared\ud
to similar graph-based approaches using a common case study. The\ud
three solutions proposed for those graph-based problems and their\ud
evaluation with Kermeta according to the criteria of genericity,\ud
extensibility, and performance are the main contribution of the paper.\ud
Another contribution is the comparison of these solutions with those\ud
proposed by other graph-based tools
Joining lead wires to thin platinum alloy films
A two step process of joining a lead wire to .000002 m thick platinum alloy film which rests upon an equally thin alumina insulating layer which is adhered to a metal substrate is described. Typically the platinum alloy film forms part of a thermocouple for measuring the surface temperature of a gas turbine airfoil. In the first step the lead wire is deformed 30 to 60% at room temperature while the characteristic one million ohm resistance of the alumina insulating layer is monitored for degradation. In the second step the cold pressed assembly is heated at 865 to 1025 C for 4 to 75 hr in air. During the heating step any degradation of insulating layer resistance may be reversed, provided the resistance was not decreased below 100 ohm in the cold pressing
Extending Nunchaku to Dependent Type Theory
Nunchaku is a new higher-order counterexample generator based on a sequence
of transformations from polymorphic higher-order logic to first-order logic.
Unlike its predecessor Nitpick for Isabelle, it is designed as a stand-alone
tool, with frontends for various proof assistants. In this short paper, we
present some ideas to extend Nunchaku with partial support for dependent types
and type classes, to make frontends for Coq and other systems based on
dependent type theory more useful.Comment: In Proceedings HaTT 2016, arXiv:1606.0542
Heat exchanger and method of making
A heat exchange of increased effectiveness is disclosed. A porous metal matrix is disposed in a metal chamber or between walls through which a heat-transfer fluid is directed. The porous metal matrix has internal bonds and is bonded to the chamber in order to remove all thermal contact resistance within the composite structure. Utilization of the invention in a rocket chamber is disclosed as a specific use. Also disclosed is a method of constructing the heat exchanger
- …