Tracking differences between IFC product models: A generic approach for fully-concurrent systems

Author(s):  
G. Arthaud ◽  
S. Soubra
Informatica ◽  
2017 ◽  
Vol 28 (3) ◽  
pp. 525-545 ◽  
Author(s):  
Marcin Szpyrka ◽  
Grzegorz J. Nalepa ◽  
Krzysztof Kluza

Author(s):  
Michele Loporcaro

The book addresses grammatical gender in Romance, and its development from Latin. It works with the toolbox of current linguistic typology, and asks the fundamental question of how the Latin grammatical gender system gradually changed into those of the Romance languages. To answer this question, the book capitalizes on the pervasive dialect variation of which the better-known standard Romance languages only represent a fragment. Indeed, inspection of dialect variation across time and space forces one to dismiss the handbook account proclaiming that the neuter gender, contrasting with masculine and feminine in Latin, was eradicated from spoken Latin by late Empire times. Both Late Latin evidence and data from several modern dialects show that this never happened, and that the vulgate account proceeds from unwarranted back-projection of the data from modern languages like French and Italian. Rather, the neuter underwent transformations which are the main culprit for the differences in the gender system observed today between, say, Romanian, Sursilvan, Neapolitan, and Asturian, to cite just a few types of system which turn out to differ significantly. A precondition for establishing the database for diachronic investigation is a detailed description of many such systems, which reveals data whose interest transcends the diachronic issue under consideration: the book thus addresses systems where ‘husbands’ are feminine and others where ‘wives’ are masculine; discusses dialects where nouns overtly mark gender, but only in certain syntactic contexts; and proposes an analysis according to which one Romance language (Asturian) has split inherited grammatical gender into two concurrent systems.


2021 ◽  
Vol 178 (3) ◽  
pp. 229-266
Author(s):  
Ivan Lanese ◽  
Adrián Palacios ◽  
Germán Vidal

Causal-consistent reversible debugging is an innovative technique for debugging concurrent systems. It allows one to go back in the execution focusing on the actions that most likely caused a visible misbehavior. When such an action is selected, the debugger undoes it, including all and only its consequences. This operation is called a causal-consistent rollback. In this way, the user can avoid being distracted by the actions of other, unrelated processes. In this work, we introduce its dual notion: causal-consistent replay. We allow the user to record an execution of a running program and, in contrast to traditional replay debuggers, to reproduce a visible misbehavior inside the debugger including all and only its causes. Furthermore, we present a unified framework that combines both causal-consistent replay and causal-consistent rollback. Although most of the ideas that we present are rather general, we focus on a popular functional and concurrent programming language based on message passing: Erlang.


2021 ◽  
Vol 43 (1) ◽  
pp. 1-46
Author(s):  
David Sanan ◽  
Yongwang Zhao ◽  
Shang-Wei Lin ◽  
Liu Yang

To make feasible and scalable the verification of large and complex concurrent systems, it is necessary the use of compositional techniques even at the highest abstraction layers. When focusing on the lowest software abstraction layers, such as the implementation or the machine code, the high level of detail of those layers makes the direct verification of properties very difficult and expensive. It is therefore essential to use techniques allowing to simplify the verification on these layers. One technique to tackle this challenge is top-down verification where by means of simulation properties verified on top layers (representing abstract specifications of a system) are propagated down to the lowest layers (that are an implementation of the top layers). There is no need to say that simulation of concurrent systems implies a greater level of complexity, and having compositional techniques to check simulation between layers is also desirable when seeking for both feasibility and scalability of the refinement verification. In this article, we present CSim 2 a (compositional) rely-guarantee-based framework for the top-down verification of complex concurrent systems in the Isabelle/HOL theorem prover. CSim 2 uses CSimpl, a language with a high degree of expressiveness designed for the specification of concurrent programs. Thanks to its expressibility, CSimpl is able to model many of the features found in real world programming languages like exceptions, assertions, and procedures. CSim 2 provides a framework for the verification of rely-guarantee properties to compositionally reason on CSimpl specifications. Focusing on top-down verification, CSim 2 provides a simulation-based framework for the preservation of CSimpl rely-guarantee properties from specifications to implementations. By using the simulation framework, properties proven on the top layers (abstract specifications) are compositionally propagated down to the lowest layers (source or machine code) in each concurrent component of the system. Finally, we show the usability of CSim 2 by running a case study over two CSimpl specifications of an Arinc-653 communication service. In this case study, we prove a complex property on a specification, and we use CSim 2 to preserve the property on lower abstraction layers.


2016 ◽  
Vol 51 (1) ◽  
pp. 733-747 ◽  
Author(s):  
Krishnendu Chatterjee ◽  
Amir Kafshdar Goharshady ◽  
Rasmus Ibsen-Jensen ◽  
Andreas Pavlogiannis

Sign in / Sign up

Export Citation Format

Share Document