Search

Following the Model-Driven Architecture (MDA),a system description consists of several models,i.e.views of the system.This paper is concerned with formal conformance tests between different models.It stresses the need for formal semantical foundations of all languages that are used to express models.In particular,we classify conformance tests for implementation models

Memory transactions provide programmers with a convenient abstraction for concurrent programs: a keyword such as atomic designating a region of code that appears, from the perspective of concurrent threads, to execute atomically. Unfortunately, existing implementations in the form of software transactional memory STM are often ineffective due to their monolithic nature: every single read or write access is automatically tracked and recorded. In this statement, we advocate a transactional model of programming without a heavyweight software transactional memory, and describe some related, open research challenges. We suggest that a model based on persistent data structures could permit a variety of transactional algorithms to coexist in a library of composable transactional objects. Applications are constructed by snapping these objects together to form atomic transactions, in much the same way that today's Java programmers compose their applications from libraries such as java.util.concurrent. We report preliminary results developing this library in ScalaSTM, and discuss the challenges ahead.

The Boogie Verification Debugger (BVD) is a tool that lets users explore the potential program errors reported by a deductive program verifier. The user interface is like that of a dynamic debugger, but the debugging happens statically without executing the program. BVD integrates with the program-verification engine Boogie. Just as Boogie supports multiple language front-ends, BVD can work with those front-ends through a plug-in architecture. BVD plugins have been implemented for two state-of-the-art verifiers, VCC and Dafny.

We describe a foundation for refinement calculus where pro- grams and systems are described as contracts, carried out by a collection of interacting agents. The contract states explicitly what the agents are allowed to do, and who is to blame if things go wrong. A contract can be analyzed from the point of view of any participating agent or coalition of agents, to see what kind of goals the agents can achieve by following the contract. We give an intuitive overview of contracts in this setting, and then continue to describe the mathematical and logical foundations of the calculus. We show how contracts provide a unified framework for a number of seemingly different paradigms in computer science, such as concurrency, interactivity, games, temporal behavior vs input-output computation and high level system design.

The authors introduce a graphical notation for representing general dynamical systems and demonstrate its use in three commonly occurring systems in the biosciences. They also indicate how the notation is used to facilitate the acquisition and transfer by students of skills in constructing equations from a verbal description of a system.

The concept of data parallelism is a pervasive force throughout parallel processing. Although a certain level of processing-element autonomy can help performance, the fact is that many parallele algorithms, applications, and compiler analysis techniques focus on identifying a set of data objects that can be processed using loosely synchronous parallelism. Thus, it is not surprising that a large number of communication libraries support at least a few synchronized aggregate operations on data. The Aggregate Function Application Program Interface (AFAPI) library was initially designed to be a portable high-level interface to the various types of PAPERS cluster hardware, so one would expect it to work well using this custom hardware, and it does work well. In this paper, we show that the AFAPI is also an efficient programming model for other types of parallel systems, especially shared memory multiprocessors. For many operations AFAPI can outperform threads libraries and other more traditional shared memory programming models.

If you suppose that it would be pointless to simulate proof-on-paper; if you imagine that all the problems of interactive theorem-proving are solved; if you are sure that making a user interface is a matter of bolting a bit of Tcl/Tk onto a theorem-proving engine; if you believe the more buttons the better in a graphical user interfaces — read no further, lest your prejudices be disturbed!

Formal verification aims to improve the quality of software by detecting errors before they do harm. At the basis of formal verification is the logical notion of correctness, which purports to capture whether or not a program behaves as desired. We suggest that the boolean partition of software into correct and incorrect programs falls short of the practical need to assess the behavior of software in a more nuanced fashion against multiple criteria. We therefore propose to introduce quantitative fitness measures for programs, specifically for measuring the function, performance, and robustness of reactive programs such as concurrent processes. This article describes the goals of the ERC Advanced Investigator Project QUAREM. The project aims to build and evaluate a theory of quantitative fitness measures for reactive models. Such a theory must strive to obtain quantitative generalizations of the paradigms that have been success stories in qualitative reactive modeling, such as compositionality, property-preserving abstraction and abstraction refinement, model checking, and synthesis. The theory will be evaluated not only in the context of software and hardware engineering, but also in the context of systems biology. In particular, we will use the quantitative reactive models and fitness measures developed in this project for testing hypotheses about the mechanisms behind data from biological experiments.

In this position paper we present the design and prototypical implementation of a framework for BDI-style agents defined as Haskell functions, supporting both the explicit representation of beliefs and backtracking (at the level of individual agents), and asynchronous communication via message passing. The communication layer is separated from the layers implementing the features of individual agents through different stacked monads, while beliefs are represented through atomic or structured values depending on the user’s needs. Our long-term goal is to develop a framework for purely functional BDI agents, which is currently missing, in order to take advantage of the features of the functional paradigm, combined with the flexibility of an agent-oriented approach.

Textual concrete syntaxes for models are beneficial for many reasons. They foster usability and productivity because of their fast editing style, their usage of error markers, autocompletion and quick fixes. Several frameworks and tools from different communities for creating concrete textual syntaxes for models emerged during recent years. However, these approaches failed to provide a solution in general. Open issues are incremental parsing and model updating as well as partial and federated views. On the other hand incremental parsing and the handling of abstract syntaxes as leading entities has been solved within the compiler construction communities many years ago. In this short paper we envision an approach for the mapping of concrete textual syntaxes that makes use of the incremental parsing techniques from the compiler construction world. Thus, we circumvent problems that occur when dealing with concrete textual syntaxes in a UUID based environment.

This short paper (poster) summarises my presentation [6] at this workshop [1] in September 2002. It also reflects some of the discussions at (and some new insights since) the workshop, before this summary went into print.

This short paper introduces TRAP, a small but powerful compiler development system based on the object-oriented, dynamic language Python. Employing a very high level language as a compiler tool’s base language reduces the need for additional tool support and importing library functionality to a minimum. Python in particular has the additional advantage of being a powerful and already quite popular general-purpose component integration framework, which can be utilized both for incorporating subcomponents and for embedding the compiler developed into a larger system. Exploiting these strengths, TRAP enables rapid prototyping and development of compilers – in particular, translators for medium-complexity special purpose languages – on a very high level of abstraction.

It's no secret that instantiating frameworks can be a tedious process. In this position paper, we propose our solution to the problem, which consists of providing an application programmer with a language that supports high level abstractions, and automatically instantiating the underlying frameworks based on the code written in that language. Application programmers use only the language, not the underlying frameworks. While this hides the frameworks' abstractions, we can maintain the open architecture of the frameworks by making the interesting objects from the hidden frameworks available again as meta-objects at the language level. This leads to a system where objects (e.g. pattern participants) live at three different levels of abstraction: the objects that are hidden in the underlying frameworks, the base-level language objects, and the meta-level language objects that are incarnations of the interesting objects from the underlying frameworks.

We show some of the specific problems for testing software introduced by the object-oriented features of Ada 95, and focus on specification-based testing, since this strategy is the key strategy for testing object-oriented software. We present a theory for testing software by refinement of an exhaustive test set into a finite test set using three reduction hypothesis. We also show how the Oracle problem can be partially solved using some particular features of Ada 95. Slides: http://lgl.epfl.ch/pub/Papers/barbey-testing_ada95_oop-slides.ps

The current strategies for testing object-oriented software all lack the formal basis which is necessary to perform this task efficiently. We propose the adaptation to object-oriented software of an existing theory of testing for stateless ADTs, to find errors in a class by checking that its implementation meets its specification. We present shortly in an informal way an object-oriented language, CO-OPN/2, in which language we will write the specification. We introduce a notion of test that takes into account the possible and impossible sequences of call of class methods. We examine the black-box test procedure, and give techniques to select a finite and pertinent test set from an exhaustive test set, including all the possible behaviors of the class under test, by applying test reduction hypothesis. We also study the construction of an oracle, the procedure that analyses the results of the tests, adapted to object-oriented software.

A very preliminary presentation of this paper was done at the rump session of CRYPTO ’86 and kindly played by Gus Simmons (Sandia). The full paper will be complete description of some cycling experiments applied to DES using only very fast software for the computations. Using only software permitted many measures and tests.

The logit-log method (Rodbard and Lewald 1970) remains the most popular method for RIA data reduction in use today (Fig. 1). It has the virtue of simplicity (Rodbard 1979). The method can be implemented graphically, using special logit-log graph paper. It can be implemented using a small programmable handheld calculator or computer (Davis et al. 1980). Even the smallest microcomputers can easily perform this method with proper weighting and detailed statistical analysis. A weighted linear regression can even be performed by special “macro” programs for popular spreadsheet programs. The logit-log method has been incorporated into numerous commercial systems (β- and γ-counters). When the logit-log method “works” (which is probably about 90%–95% of the time) everything is fine. Unfortunately, in about 5%–10% of assays, the logit-log method fails to provide an adequate description of the RIA dose-response curve. What should the assayist do when the logit-log method fails? Since numerous alternatives are available, each with its own advantages and limitations, the assayist is often faced with a bewildering situation (Rodbard 1979). Are we to try all possible methods, using a trial-and-error approach? When will we be able to say that we have a “good” method, an “adequate” or “optimal” method? Is there a systematic approach? Are we to be restricted to the curve-fitting methods implemented in commercial, turnkey, “black box” approaches to data analysis? This chapter will attempt to provide a simple, rational approach to the question, “what should I do when the logit-log method fails?”

Several Computer Interpretable Guidelines (CIGs) languages have been proposed by the health community. Even though these CIG languages share common ideas each language has to be provided with his own mechanism of verification. In an earlier work we have shown that a DECLARE model can be used for checking the conformance of a PROforma CIG. In this paper, we show that the same model can also be used for checking the conformance of a similar CIG expressed in the GLIF language. Besides, as the GLIF model has been expressed in terms of a Coloured Petri Net (CPN), we also elaborate on the experiences obtained when applying the model checking techniques supported by CPN tools.

Linear Temporal Logic (LTL) on finite traces has proven to be a good basis for the analysis and enactment of flexible constraint-based business processes. The Declare language and system benefit from this basis. Moreover, LTL-based languages like Declare can also be used for runtime verification. As there are often many interacting constraints, it is important to keep track of individual constraints and combinations of potentially conflicting constraints . In this paper, we operationalize the notion of conflicting constraints and demonstrate how innovative automata-based techniques can be applied to monitor running process instances. Conflicting constraints are detected immediately and our toolset (realized using Declare and ProM) provides meaningful diagnostics.

This paper constitutes a short introduction to parametric verification of concurrent systems. It originates from two 1-day tutorial sessions held at the Petri nets conferences in Torun (2016) and Zaragoza (2017). A video of the presentation is available at https://www.youtube.com/playlist?list=PL9SOLKoGjbeqNcdQVqFpUz7HYqD1fbFIg, consisting of 14 short sequences. The paper presents not only the basic formal concepts tackled in the video version, but also an extensive literature to provide the reader with further references covering the area.

In this paper a system static structure modeling formalization and formalization of static models based on topological functioning model (TFM) is proposed. TFM uses mathematical foundations that holistically represent complete functionality of the problem and application domains. By using TFM within software development process it is possible to do formal analysis of a business system and in a formal way to model the static structure of the system. After construction of the TFM of a system’s functioning a problem domain object model is defined by performing transformation of defined TFM. By making further transformations of TFM and by using TFM within software development it is possible to introduce more formalism in the Unified Modeling Language (UML) diagrams and in their construction. In this paper we have introduced topology into the UML class diagrams.

The final publication is available at Springer via http://dx.doi.org/10.1007/978-3-540-68262-2_13, Revised Selected Papers of the Third International Conference, WEBIST 2007, Barcelona, Spain, March 3-6, 2007, This paper shows our model-driven approach for the formal construction and validation of Digital Libraries (DLs). We have defined a Domain Specific Visual Language (DSVL) called VisMODLE, which allows the description of a DL using five different viewpoints: services, behaviour, collections, structure and society. From a meta-model based description of the different viewpoints, we have generated a modelling environment for VisMODLE. We have provided the environment with a code generator that produces XUL code for the DL’s user interface and composes the application using predefined components that implement the different services. Moreover, we have also added validation and simulation capabilities to the environment. Using the behavioural models (state-machine based), we can visually animate the system. In addition, the combined behaviour of actors and services can be transformed into a Petri net for further analysis., Work sponsored by projects MODUWEB (TIN2006-09678) and MOSAIC (TIC2005-08225-C07-06) of the Spanish Ministry of Science and Education

Meta programming can be facilitated by the ability to represent program fragments in concrete syntax instead of abstract syntax. The resulting meta programs are more self-documenting. One caveat in concrete meta programming is the syntactic separation between the meta language and the object language. To solve this problem, many meta programming systems use quoting and anti-quoting to indicate precisely where level switches occur. These "syntactic hedges" can obfuscate the concrete program fragments. This paper describes an algorithm for inferring quotes, such that the meta programmer no longer needs to explicitly indicate transitions between the meta and object languages.

This paper presents ATL (ATLAS Transformation Language): a hybrid model transformation language that allows both declarative and imperative constructs to be used in transformation definitions. The paper describes the language syntax and semantics by using examples. ATL is supported by a set of development tools such as an editor, a compiler, a virtual machine, and a debugger. A case study shows the applicability of the language constructs. Alternative ways for implementing the case study are outlined. In addition to the current features, the planned future ATL features are briefly discussed.

The design and implementation of a capability secure multi-paradigm language should be guided from its conception by proven principles of secure language design. In this position paper we present the Oz-E project, aimed at building an Oz-like secure language, named in tribute of E [MMF00] and its designers and users who contributed greatly to the ideas presented here. We synthesize the principles for secure language design from the experiences with the capability-secure languages E and the W7-kernel for Scheme 48 [Ree96]. These principles will be used as primary guidelines during the project. We propose a layered structure for Oz-E and discuss some important security concerns, without aiming for completeness at this early stage.

Industrial-size specifications/models (whose state space is often infinite) can not be model checked in a direct way -- a verification model of a system is model checked instead. Program transformation is a way to build a finite-state verification model that can be submitted to a model checker. Abstraction is another technique that can be used for the same purpose. This paper presents a transformation of SDL timers aimed at the reduction of the infinite domain of timer values to a finite one with preserving the behaviour of a system. A timer abstraction is proposed to further reduce the state space. We discuss the ideas behind these transformations and argue their correctness.

In this paper we introduce inheritance in deductive object databases and define an operator for hierarchically composing deductive objects with state evolution capabilities. Evolution of such objects models the expected transactional behavior while preserving many important features of deductive databases. Deductive objects can be organized in ISA schemas where each object may inherit or redefine the rules defined in other objects. The resulting inheritance mechanism handles both the deductive and the update/transactional issues. Our framework accommodates several types of inheritance such as overriding, extension, and refinement. Besides presenting the language, this paper defines its semantics and provides a description of the interpreter for the language that has been implemented.

While specifications of queries usually are of a declarative nature (since the work of Codd in the early seventies), specifications of transactions mainly are of an operational and descriptive nature. Especially descriptions of complex transactions (such as cascading deletes) tend to be very operational. Declarative specifications of transactions usually suffer from the so-called frame problem or do not have a clear semantics. Often these descriptions turn out to be nondeterministic as well. A problematic consequence is that the semantics of transactions and of several related notions is often unclear or even ambiguous. For a database designer this surely is not a good starting point for building applications. Another tendency we recognize is that the current literature on transactions is mainly driven by technical solutions offered by research prototypes and commercial systems and not so much by advanced specification requirements from a user's or database designer's point of view. In our opinion, the research questions should (also) include what kind of complex transactions (advanced) users would like to specify (and not only what e.g. the expressive power of a given technical solution is), and how these specifications can be translated to implementations in the currently available (advanced) database management systems. And, moreover, was it not our purpose (with the introduction of 4GL's and the like) to become declarative instead of operational, concentrating on the "what" instead of the "how"? This paper offers a general framework for declarative specifications of transactions, including complex ones. Transactions on a state space u are considered as functions from u into u. We also take the influence of static and dynamic constraints on the alleged transactions into account. This leads to the notion of the adaptation of a transaction. Applications of our theory included in this paper are the declarative specification of cascading deletes and the distinction between allowable and available transitions. Basic set theory is our main vehicle.

A failed attempt to verify a program's correctness can result in reports of genuine errors, spurious warnings, and timeouts. The main challenge in debugging a verification failure is to determine whether the complaint is genuine or spurious, and to obtain enough information about the failed verification attempt to debug the error. To help a user with this task, this paper presents an extension of the Dafny IDE that seamlessly integrates the Dafny verifier, a dynamic symbolic execution engine, a verification debugger, and a technique for diagnosing timeouts. The paper also reports on experiments that measure the utility of the combined use of these complementary tools.

In the functional programming world, it is common to embed a domain specific language DSL in a general purpose language. Unfortunately, the extra abstraction layer provided by the DSL is lost when a type error occurs, and internals leak to users of the DSL. This paper presents specialized type rules, a way to influence which part of the program is blamed and how the particular error message is worded. These type rules match part of the programming language abstract syntax tree AST and guide the type checker in order to provide custom diagnostics. Our goal is to enable DSL writers to keep their high-level abstractions throughout the whole development experience. Specialized type rules have already been considered in the literature: we enhance them by providing a mechanism to allow type rules to depend on partial type information. The technique presented in this paper can be readily applied to any type engine which uses constraints to perform its duty. We refine the workings of the type engine by including a second gathering pass in case an error is found. In that second pass, partial type information can be used to select a type rule. In particular, we have implemented our techniques in a type engine based on the OutsideInX framework, which underlies the Haskell GHC compiler since version 7.

International audience; This paper targets the generation of distributed applications with safety guarantees. The proposed approach starts from graphical specification formalisms allowing the architectural and behavioral description of component systems. From this point, the user can automatically verify application properties using model-checking techniques. Finally, the specified and verified component model can be translated into executable Java code. We implement our approach in a tool suite distributed as an Eclipse plugin. This paper also illustrates our approach by modeling and verifying Peterson's leader election algorithm.

International audience; In this paper, we define a multi-type calculus for inquisitive logic, which is sound, complete and enjoys Belnap-style cut-elimination and subformula property. Inquisitive logic is the logic of inquisitive semantics, a semantic framework developed by Groenendijk, Roelofsen and Ciardelli which captures both assertions and questions in natural language. Inquisitive logic adopts the so-called support semantics (also known as team semantics). The Hilbert-style presentation of inquisitive logic is not closed under uniform substitution, and some axioms are sound only for a certain subclass of formulas, called flat formulas. This and other features make the quest for analytic calculi for this logic not straightforward. We develop a certain algebraic and order-theoretic analysis of the team semantics, which provides the guidelines for the design of a multi-type environment accounting for two domains of interpretation, for flat and for general formulas, as well as for their interaction. This multi-type environment in its turn provides the semantic environment for the multi-type calculus for inquisitive logic we introduce in this paper.

Edited under the auspices of the Association of Logic, Language and Information (FoLLI), this book constitutes the refereed proceedings of the 20th anniversary of the International Conference on Logical Aspects of Computational Linguistics, LACL 2016, held in LORIA Nancy, France, in December 2016. The 19 contributed papers, presented together with 4 invited papers and 6 abstracts, were carefully reviewed and selected from 38 submissions. The focus of the conference is the use of type theoretic, proof theoretic, and model theoretic methods for describing and formalising natural language syntax, semantics, and pragmatics as well as the implementation of the corresponding tools.

In many applications in computer science and artificial intelligence, logical formulas are used as a formal representation to represent and/or specify various objects and relationships among them. Transforming logical formulas into informal propositional statements, e.g., declarative sentences and mathematical formulas, is important as well as transforming informal propositional statements into logical formulas. When people obtain new logical formulas as results of deduction/reasoning based on logic, investigating the obtained formulas is also not an easy task for them. Although information systems with proving, e.g., automated theorem proving systems, formal verification systems, etc., are used in various field, in the future, information systems with reasoning, e.g., automated theorem finding systems, will also be developed and used in various fields. Thus, a tool to support bidirectional transformation between informal propositional statements and logical formulas will be demanded at that time. This paper presents an implementation of a bidirectional transformation supporting tool for formalization with logical formulas. The paper also shows application of the tool in a case study of automated theorem finding with forward reasoning.

Language embedding is a method to implement a new language within the framework of an existing programming language. This method is known to speed up the development process compared to standalone languages using classical compiler technology. On the other hand, embedded languages may not be that convenient for the end-users as standalone ones with own concrete syntax. This paper describes a method that uses the flexibility of language embedding in the experimental phase of the language design process, then, once the language features are mature enough, adds concrete syntax and turns the language to a standalone one. Lessons learnt from a project, run in industry-university cooperation and using the presented method, are discussed. Based on these results, a cost model is established that can be used to estimate the potential benefits of this method in case of future language design projects.

International audience; An object-oriented computation model is presented which is designed for modelling and describing a wide variety of concurrent systems. In this model, three types of message passing are incorporated. An overview of a programming language called ABCL/1, whose semantics faithfully reflects this computation model, is also presented. Using ABCL/1, a simple scheme of distributed problem solving is illustrated. Furthermore, we discuss the reply destination mechanism and its applications. A distributed “same fringe” algorithm is presented as an illustration of both the reply destination mechanism and the future type message passing which is one of the three message passing types in our computation model.

DecSerFlow is a declarative language to specify business processes. It consists of a set of temporal predicates that can be translated into LTL but limited to finite sequences. This paper focuses on the “conformance problem”: Given a set of DecSerFlow constraints, is there an execution sequence that satisfies all given constraints? This paper provides syntactic characterizations of conformance for several subclasses of DecSerFlow constraints. These characterizations directly lead to efficient (polynomial time) conformance testing. Furthermore, algorithms are developed to generate conforming strings if the set of constraints is conformable. A conformance analyzer is developed based on the syntactic characterizations and the string generating algorithms. Experiments reveal several interesting factors concerning performance and scalability.

The European Summer School in Logic, Language and Information (ESSLLI) is organized every year by the Association for Logic, Language and Information (FoLLI) in different sites around Europe. The main focus of ESSLLI is on the interface between linguistics, logic and computation. ESSLLI offers foundational, introductory and advanced courses, as well as workshops, covering a wide variety of topics within the three areas of interest: Language and Computation, Language and Logic, and Logic and Computation. The 16 papers presented in this volume have been selected among 44 papers presented by talks or posters at the Student Sessions of the 24th and 25th editions of ESSLLI, held in 2012 in Opole, Poland, and 2013 in Dusseldorf, Germany. The papers are extended versions of the versions presented, and have all been subjected to a second round of blind peer review. (Less)

Runtime verification (RV) facilitates detecting the failures of software during its execution. Due to the complexity of RV techniques, there is an increasing interest in achieving abstractness, modularity, and compose-ability in their implementations by means of dedicated linguistic mechanisms. This paper defines a design space to evaluate the existing domain-specific languages for implementing RV techniques, and identifies the shortcomings of a representative set of these languages with respect to the design space. This paper advocates the need for a language composition framework, which offers the necessary mechanisms to achieve abstractness, modularity, and compose-ability in the implementation of domain-specific crosscutting concerns such as the concerns of RV techniques. We explain event modules as novel linguistic abstractions for modular implementation of domain-specific crosscutting concerns. This paper discusses the implementation of event modules in the EventReactor language, and illustrates the suitability of event modules to implement RV techniques by means of two complementary examples.

This paper reports on the implementation of grammar checkers and parsers for highly inflected and under-resourced languages. As classical context free grammar CFG formalism performs poorly on languages with a rich morphological feature system, we have extended the CFG formalism by adding syntactic roles, lexical constraints, and constraints on morpho-syntactic feature values. The formalism also allows to assign morpho-syntactic feature values to phrases and to specify optional constituents. The paper also describes how we are implementing the grammar checker by using two sets of rules --- rules describing correct sentences and rules describing grammar errors. The same engine with a different rule set can be used for the different purposes --- to parse the text or to find the grammar errors. The paper also describes the implementation of Latvian and Lithuanian parsers and grammar checkers and the quality measurement methods used for the quality assessment.

In this paper we consider the problem of translating a core typed functional language, F#(including mutable variables), into scripting languages such as JavaScript or Python. We abstract the most significant characteristics of such scripting languages in an intermediate language (IL for short), which is an imperative language, with constructs for handling safely pieces of code containing free variables. We define an operational semantics for IL and highlight the proof of correctness of the translation.

The actor model inspires several important programming languages. In this model, communicating concurrent actors collaborate to produce a result. A pure actor language tends to turn systems into an organization-free collection of processes, however, even though most applications call for layered and tiered architectures. To address this lack of an organizational principle, programmers invent design patterns. This paper investigates integrating some of these basic patterns via a programming language construct. Specifically, it extends a calculus of communicating actors with a "network" construct so that actors can conduct scoped, tiered conversations. The paper then sketches how to articulate design ideas in the calculus, how to implement it, and how such an implementation shapes application programming.

The dynamic software updating system JRebel from Zeroturnaround has proven to be an efficient mean to improve developer productivity, as it allows developers to change the code of their applications while developing and testing them. Hence, developers no longer have to go through the tedious cycle of serializing application state, halting execution, redeploy the binary, restarting, and de-serializing state before they can test the effect of a code change. However, the current version of JRebel has its limits, as it does not support all kinds of code changes. In this paper, we compare the three most comprehensive dynamic updating systems developed for Java to date. Together, these systems provide comprehensive support for changing class definitions of live objects, including adding, removing and moving fields, methods, classes and interfaces anywhere in the inheritance hierarchy. We then investigate the effects of dynamic updating by performing a dynamic updating experiment on five consecutive revisions of the classical arcade game Breakout using the dynamic updating system Gosh! (Prior to the acquisition by zeroturnaround.com known as Javeleon.). Based on the result of this experiment we show that dynamic updating of class definitions for live objects may under some circumstances result in different run-time behavior than would be observed after a cold restart of the upgraded application. Finally, we conclude by discussing the implication of integrating the dynamic updating model of Gosh! with JRebel. The successful integration of these two systems will set a new standard for dynamic software updating in Java.

We present a web-based drill system named DIGITAL-WORK which assists learners in mastering some basic formulae using a new interactive math input method. This method enables users to format any mathematical expression in WYSIWYG by converting from colloquial style strings in fuzzy mathematical notation. The purpose of this study is to investigate whether students can smoothly learn basic math formulae with our drill system. In this paper, we report the results from a field survey that was conducted in an actual remedial math class of 20 junior high school students. The results of our survey showed that 85% of them found this system to be more fun than learning on paper.

While supervised statistical semantic parsing methods have received a good amount of attention in recent years, this research has largely been done on small and specialized data sets. This paper introduces a work-in-progress with the objective of examining the applicability of supervised statistical semantic parsing to application-independent data with linguistically motivated meaning representations. The approach discussed in this paper has three key aspects: The circumvention of data scarcity using automatic annotation, experimentation with different types of meaning representations, and the design of a suitable graded evaluation measure.

Calculational proofs--proofs by stepwise formula manipulation--are praised for their rigor, readability, and elegance. It seems desirable to reuse this style, often employed on paper, in the context of mechanized reasoning, and in particular, program verification. This work leverages the power of SMT solvers to machine-check calculational proofs at the level of detail they are usually written by hand. It builds the support for calculations into the programming language and auto-active program verifier Dafny. The paper demonstrates that calculations integrate smoothly with other language constructs, producing concise and readable proofs in a wide range of problem domains: from mathematical theorems to correctness of imperative programs. The examples show that calculational proofs in Dafny compare favorably, in terms of readability and conciseness, with arguments written in other styles and proof languages.

SMT solvers have been recently applied to bounded model checking and satisfiability checking of metric temporal logic. In this paper we consider SOLOIST, an extension of metric temporal logic with aggregate temporal modalities; it has been defined based on a field study on the use of specification patterns in the context of the provisioning of service-based applications. We apply bounded satisfiability checking to perform trace checking of service execution traces against requirements expressed in SOLOIST. In particular, we focus on sparse traces, i.e., traces in which the number of time instants when events occur is very low with respect to the length of the trace. The main contribution of this paper is an encoding of SOLOIST formulae into formulae of the theory of quantifier-free integer difference logic with uninterpreted function and predicate symbols. This encoding paves the way for efficient checking of SOLOIST formulae over sparse traces using an SMT-based verification toolkit. We report on the evaluation of the proposed encoding, commenting on its scalability and its effectiveness.

This paper contains an extended and improved version of the FDMM formalism presented at ICEIS’2012. FDMM is a formalism to describe how meta models and models are defined in the ADOxx approach as used in the Open Models Initiative. It is based on set theory and first order logic statements. In this way, an exact description of ADOxx meta models and corresponding models can be provided. In the paper at hand we extend the description of the formalism by illustrating how the mathematical statements can be used to support the implementation on the ADOxx platform. For this purpose we show how the FDMM constructs are mapped to statements in the ADOxx Library Language (ALL). As an example of the approach, the formalism and the mapping to ALL are applied to a modeling language from the area of risk management.

In our previous work, we developed a reversible programming language and established that every computation in it is a (partial) isomorphism that is reversible and that preserves information. The language is founded on type isomorphisms that have a clear categorical semantics but that are awkward as a notation for writing actual programs, especially recursive ones. This paper remedies this aspect by presenting a systematic technique for developing a large and expressive class of reversible recursive programs, that of logically reversible small-step abstract machines. In other words, this paper shows that once we have a logically reversible machine in a notation of our choice, expressing the machine as an isomorphic interpreter can be done systematically and does not present any significant conceptual difficulties. Concretely, we develop several simple interpreters over numbers and addition, move on to tree traversals, and finish with a meta-circular interpreter for our reversible language. This gives us a means of developing large reversible programs with the ease of reasoning at the level of a conventional small-step semantics.

Hierarchical decomposition is a fundamental principle that encourages the organization of program elements into nested scopes of access, instead of treating all as "global." This paper offers a foundational study of heap decomposition inference, the problem of statically extracting the decomposition hierarchy latent in the runtimes of object-oriented programs, henceforth revealing the compositional nature of the heap. The centerpiece of the paper is Cypress, a sound, precise, and scalable constraint-based ownership type inference coupled with a novel application of linear programming over integers. All constraints in Cypress are linear, and the precision of decomposition --- placing objects to scopes as non-global as possible --- can be reduced to a linear programming problem. Cypress has been implemented as an open-source tool that can decompose real-world Java applications of more than 100K LOC and up to 6000 statically distinct instantiations.