A WSDL-based type system for asynchronous WS-BPEL processes

We tackle the problem of providing rigorous formal foundations to current software engineering technologies for web services, and especially to WSDL and WS-BPEL, two of the most used XML-based standard languages for web services. We focus on a simplified fragment of WS-BPEL sufficiently expressive to model asynchronous interactions among web services in a network context. We present this language as a process calculus-like formalism, that we call ws-calculus, for which we define an operational semantics and a type system. The semantics provides a precise operational model of programs, while the type system forces a clean programming discipline for integrating collaborating services. We prove that the operational semantics of ws-calculus and the type system are ‘sound’ and apply our approach to some illustrative examples. We expect that our formal development can be used to make the relationship between WS-BPEL programs and the associated WSDL documents precise and to support verification of their conformance.     

An institution theory of formal meta-modelling in graphically extended BNF

Meta-modelling plays an important role in model driven software development.In this paper,a graphic extension of BNF (GEBNF) is proposed to define the abstract syntax of graphic modelling languages.Fro...     

An agile approach to language modelling and development

We have developed novel techniques for component-based specification of programming languages. In our approach, the semantics of each fundamental programming construct is specified independently, using an inherently modular framework such that no reformulation is needed when constructs are combined. A language specification consists of an unrestricted context-free grammar for the syntax of programs, together with an analysis of each language construct in terms of fundamental constructs. An open-ended collection of fundamental constructs is currently being developed. When supported by appropriate tools, our techniques allow a more agile approach to the design, modelling, and implementation of programming and domain-specific languages. In particular, our approach encourages language designers to proceed incrementally, using prototype implementations generated from specifications to test tentative designs. The components of our specifications are independent and highly reusable, so initial language specifications can be rapidly produced, and can easily evolve in response to changing design decisions. In this paper, we outline our approach, and relate it to the practices and principles of agile modelling.     

On the reuse and recommendation of model refactoring specifications

Refactorings can be used to improve the structure of software artefacts while preserving the semantics of the encapsulated information. Various types of refactorings have been proposed and implemented for programming languages (e.g., Java or C#). With the advent of (MDSD), a wealth of modelling languages rises and the need for restructuring models similar to programs has emerged. Since parts of these modelling languages are often very similar, we consider it beneficial to reuse the core transformation steps of refactorings across languages. In this sense, reusing the abstract transformation steps and the abstract participating elements suggests itself. Previous work in this field indicates that refactorings can be specified generically to foster their reuse. However, existing approaches can handle certain types of modelling languages only and solely reuse refactorings once per language. In this paper, a novel approach based on role models to specify generic refactorings is presented. Role models are suitable for this problem since they support declaration of roles which have to be played in a certain context. Assigned to generic refactoring, contexts are different refactorings and roles are the participating elements. We discuss how this resolves the limitations of previous works, as well as how specific refactorings can be defined as extensions to generic ones. The approach was implemented in our tool Refactory based on the (EMF) and evaluated using multiple modelling languages and refactorings. In addition, this paper investigates on the recommendation of refactoring specifications. This is motivated by the fact that language designers have many possibilities to enable refactorings in their modelling languages with regard to the language structures. To overcome this problem and to support language designers in deciding which refactorings to enable, we propose a solution and a prototypical implementation.     

Code generation for a family of executable modelling notations

We are investigating semantically configurable model-driven engineering (MDE). The goal of this work is a modelling environment that supports flexible, configurable modelling notations, in which specifiers can configure the semantics of notations to suit their needs and yet still have access to the types of analysis tools and code generators normally associated with MDE. In this paper, we describe semantically configurable code generation for a family of behavioural modelling notations. The family includes variants of statecharts, process algebras, Petri Nets, and SDL88. The semantics of this family is defined using template semantics, which is a parameterized structured operational semantics in which parameters represent semantic variation points. A specific notation is derived by instantiating the family’s template semantics with parameter values that specify semantic choices. We have developed a code-generator generator (CGG) that creates a suitable Java code generator for a subset of derivable modelling notations. Our prototype CGG supports 26 semantics parameters, 89 parameter values, and 7 composition operators. As a result, we are able to produce code generators for a sizable family of modelling notations, though at present the performance of our generated code is about an order of magnitude slower than that produced by commercial-grade generators.     

Semantics of OCL specified with QVT

The Object Constraint Language (OCL) has been for many years formalized both in its syntax and semantics in the language standard. While the official definition of OCL’s syntax is already widely accepted and strictly supported by most OCL tools, there is no such agreement on OCL’s semantics, yet. In this paper, we propose an approach based on metamodeling and model transformations for formalizing the semantics of OCL. Similarly to OCL’s official semantics, our semantics formalizes the semantic domain of OCL, i.e. the possible values to which OCL expressions can evaluate, by a metamodel. Contrary to OCL’s official semantics, the evaluation of OCL expressions is formalized in our approach by model transformations written in QVT. Thanks to the chosen format, our semantics definition for OCL can be automatically transformed into a tool, which evaluates OCL expressions in a given context. Our work on the formalization of OCL’s semantics resulted also in the identification and better understanding of important semantic concepts, on which OCL relies. These insights are of great help when OCL has to be tailored as a constraint language of a given DSL. We show on an example, how the semantics of OCL has to be redefined in order to become a constraint language in a database domain.

Mechanised support for sound refinement tactics

ArcAngel is a tactic language devised to facilitate and automate program developments using Morgan’s refinement calculus. It is especially well suited for the specification of high-level refinement strategies, and equipped with a formal semantics that additionally permits reasoning about tactics. In this paper, we present an implementation of ArcAngel for the ProofPower theorem prover. We discuss the underlying design, explain how it implements the semantics of ArcAngel, and examine the interplay between ArcAngel tactics and the native reasoning support of the prover. We also discuss several extensions of ArcAngel that have been entailed by our implementation effort. They are of practical importance and provide a unification of the related tactic languages Angel and ArcAngel C. Our main result is a mechanisation that reflects directly the ArcAngel semantics, and can be used with any programming model for refinement. The approach can be used to support other formal tactic languages using other theorem provers.     

Scope control and grammatical dependencies

This paper develops a semantics with control over scope relations using Vermeulen’s stack valued assignments as information states. This makes available a limited form of scope reuse and name switching. The goal is to have a general system that fixes available scoping effects to those that are characteristic of natural language. The resulting system is called Scope Control Theory, since it provides a theory about what scope has to be like in natural language. The theory is shown to replicate a wide range of grammatical dependencies, including options for, and constraints on, ‘donkey’, ‘binding’, ‘movement’, ‘Control’ and ‘scope marking’ dependencies.     

From human-centred to human-context centred approach: looking back over ‘the hills’, what has been gained and lost?

The cornerstone of the human-centred tradition lies in two notions: socially useful production and human machine symbiosis. However, only the latter became in focus in the successive user-centred design approaches. The paper makes a critical ‘flash-back’ to various human centred design approaches since the 1970s. In addition, it explores the sustainability challenges facing the current situation and suggests that ‘human-centredness’ should be extended to ‘human-context centred’ approach in order to recognize the challenges of the sustainability. Finally, the paper discuss the possibilities to develop and use narrative and modelling simulation methods including both qualitative and quantitative tools in a combined approach to meet the challenges of sustainable development within such a human-context centred approach.     

Artificial Neural Networks Manipulation Server: Research on the Integration of Databases and Artificial Neural Networks

This paper proposes a new whole and distributed integration approach between Artificial Neural Networks (ANNs) and Databases (DBs) taking into account the different stages of the former’s lifecycle (training, test and running). The integration architecture which has been developed consists of an ANN Manipulation Server (AMS) based on a client-server approach, which improves the ANNs’ manipulation and experimentation capabilities considerably, and also those of their training and test sets, together with their modular reuse among possibly remote applications. Moreover, the chances of integrating ANNs and DBs are analysed, proposing a new level of integration which improves the integration features considerably. This level has not been contemplated yet at full reach in any of the commercial or experimental tools analysed up to the present date. Finally, the application of the integration architecture which has been developed to the specific domain of Environmental Impact Assessments (EIAs) is studied. Thus, the versatility and efficacy of that architecture for developing ANNs is tested. The enormous complexity of the functioning of the patterns which rule the environment’s behaviour, and the great number of variables involved, make it the ideal domain for experimenting on the application of ANNs together with DBs.     

Nivel: a metamodelling language with a formal semantics

Much work has been done to clarify the notion of metamodelling and new ideas, such as strict metamodelling, distinction between ontological and linguistic instantiation, unified modelling elements and deep instantiation, have been introduced. However, many of these ideas have not yet been fully developed and integrated into modelling languages with (concrete) syntax, rigorous semantics and tool support. Consequently, applying these ideas in practice and reasoning about their meaning is difficult, if not impossible. In this paper, we strive to add semantic rigour and conceptual clarity to metamodelling through the introduction of Nivel, a novel metamodelling language capable of expressing models spanning an arbitrary number of levels. Nivel is based on a core set of conceptual modelling concepts: class, generalisation, instantiation, attribute, value and association. Nivel adheres to a form of strict metamodelling and supports deep instantiation of classes, associations and attributes. A formal semantics is given for Nivel by translation to weight constraint rule language (WCRL), which enables decidable, automated reasoning about Nivel. The modelling facilities of Nivel and the utility of the formalisation are demonstrated in a case study on feature modelling.

Object modelling languages: An evaluation and some key expectations for the future

Object modelling languages are graphical semi-formal specification languages. They are tools to capture and formalise requirements in the earlier phases of software development, as well as providing support for describing designs, software architecture and even detailed implementations later in the process. One can consider these languages to have reached some level of maturity, especially because their precursors, the Object-Oriented Analysis and Design methods, have now been used and tested intensively in industry for many years. In addition, these modelling languages have been the subject of many improvements by the scientific community. Nevertheless, some dissatisfaction persists. In this paper, we aim to re-analyse several parts of the deep structure of two leading object modelling languages: OML and UML, in order to show how they can really increase software quality. Their structure is based on metamodelling, which is the way the semantics of these two languages is expressed. This structure is also the source of a proliferation of modelling constructs (for example, different forms of inheritance associated with distinct notational elements) whose use must clearly influence, in particular, reusability — a key expectation in a software engineering process. More generally, we identify some deficiencies in these languages, which allows us to highlight some appropriate evolutionary paths. In discussing dynamic metamodelling and scalability, we specifically outline that a main current drawback is the difficulty of implementing these languages in Computer-Aided Software Engineering tools. This revised version was published online in June 2006 with corrections to the Cover Date.     

A real-time profile for UML

This paper describes an approach for real-time modelling in UML, focusing on analysis and verification of time and scheduling-related properties. To this aim, a concrete UML profile, called the ωprofile, is defined, dedicated to real-time modelling by identifying a set of relevant concepts for real-time modelling which can be considered as a refinement of the standard SPT profile. The profile is based on a rich concept of event representing an instant of state change, and allows the expression of duration constraints between occurrences of events. These constraints can be provided in the form of OCL-like expressions annotating the specification or by means of state machines, stereotyped as ‘observers’. A framework for modelling scheduling issues is obtained by adding a notion of resource and a notion of execution time. For proving the relevance of these choices, the profile has been implemented in a validation tool and applied to case studies. It has a formal semantics and is sufficiently general and expressive to define a semantic underpinning for other real-time profiles of UML which in general define more restricted frameworks. In particular, most existing profiles handling real-time issues define a number of predefined attributes representing particular durations or constraints on them and their semantic interpretation can be expressed in the OMEGA-RT profile. This work has been partially supported by the IST-2002-33522 OMEGA project. VERIMAG is an academic research laboratory associated with CNRS, Université Joseph Fourier and Institut Nationale Polytechnique de Grenoble.     

Language components for modular DSLs using traits

Recent advances in tooling and modern programming languages have progressively brought back the practice of developing domain-specific languages as a means to improve software development. Consequently, the problem of making composition between languages easier by emphasizing code reuse and componentized programming is a topic of increasing interest in research. In fact, it is not uncommon for different languages to share common features, and, because in the same project different DSLs may coexist to model concepts from different problem areas, it is interesting to study ways to develop modular, extensible languages. Earlier work has shown that traits can be used to modularize the semantics of a language implementation; a lot of attention is often spent on embedded DSLs; even when external DSLs are discussed, the main focus is on modularizing the semantics. In this paper we will show a complete trait-based approach to modularize not only the semantics but also the syntax of external DSLs, thereby simplifying extension and therefore evolution of a language implementation. We show the benefits of implementing these techniques using the Scala programming language.     

Unification of Four Versions of Program Semantics

Computing Science is a new subject, and we have not yet achieved the unification of theories that should support a proper understanding of its structure. CAR Hoare and He Jifeng, 1998. In this paper we use Priestley duality and Jónsson/Tarski duality to translate between four versions of program semantics: the relational model, predicate transformer semantics, information systems, and powerdomains. Our point of entry is the relational model, a kind of Kripke semantics, in which programs are thought of as input-output relations over a structured state space. Specifically, we present the state space as a certain kind of Priestley space, and programs as certain structure-preserving relations over such a space. We then derive, in circular fashion, a predicate transformer semantics from the relational model, an information system from the predicate transformer semantics, a powerdomain from the information system, and the original relational model back again from the powerdomain. The information system is also shown to be related to Hoare logic. To clarify the intuition behind this approach we present a case study, which is a ‘Priestley version’ of the so-called universal domain due to Plotkin, and we explicate various ideas about properties of programs and predicates in terms of this case study. Received April 1997 / Accepted in revised form February 1998     

Evolutionary optimization of robotic assembly operation sequencing with collision-free paths

Many problems in the lifecycle of product and production development (PPD) can be formulated as optimization problems. But in most of the real-world cases, they are too complex to be solved by analytical models or classical optimization methods. CAx and virtual manufacturing (VM) tools are on the other hand being employed to create virtual representation of products and processes before any physical realization is conducted. Synergy of these two domains is of interest in this paper where planning a process with the minimum cycle-time for assembling a spot welded sheet-metal product is desired. The methodology suggests an extendible virtual manufacturing-based optimization approach using evolutionary algorithms. Accordingly, a novel toolset with integration of evolutionary optimization and a commercial VM environment is developed. More specifically, the latest feature which takes advantage of the collision avoidant segment path planning functionality of the VM tool and integrates it with the sequence optimizer is described.     

Cognitive and synthetic behavior of avatars in intelligent virtual environments

In intelligent virtual environments (IVEs), it is a challenging research issue to provide the intelligent virtual actors (or avatars) with the ability of visual perception and rapid response to virtual world events. Modeling an avatar’s cognitive and synthetic behavior appropriately is of paramount important in IVEs. We propose a new cognitive and behavior modeling methodology that integrates two previously developed complementary approaches. We present expression cloning, walking synthetic behavior modeling, and an autonomous agent cognitive model for driving an avatar’s behavior. Facial expressions are generated using our own-developed rule-based state transition system. Facial expressions are further personalized for individuals by expression cloning. An avatar’s walking behavior is modeled using a skeleton model that is implemented by seven-motion sequences and finite state machines (FSMs). We discuss experimental results demonstrating the benefits of our approach.     

Simplifying environmental model reuse

The environmental modelling community has developed many models with varying levels of complexity and functionality. Many of these have overlapping problem domains, have very similar ‘science’ and yet are not compatible with each other. The modelling community recognises the benefits to model exchange and reuse, but often it is perceived to be easier to (re)create a new model than to take an existing one and adapt it to new needs.Many of these third party models have been incorporated into the Agricultural Production Systems Simulator (APSIM), a farming systems modelling framework. Some of the issues encountered during this process were system boundary issues (the functional boundary between models and sub-models), mixed programming languages, differences in data semantics, intellectual property and ownership.This paper looks at these difficulties and how they were overcome. It explores some software development techniques that facilitated the process and discusses some guidelines that can not only make this process simpler but also move models towards framework independence.     

Comparing approaches to free dcpo-algebra constructions

Algebraic structures play an important rôle for the semantics of programming languages. One application is the use of free algebra constructions for modelling computational effects in categorical frameworks for denotational semantics, as proposed by Plotkin and Power. It is well-known that, for abstract reasons, free algebra constructions are available in the category of dcpos and Scott continuous maps. However, only very recently, this construction has been investigated in concrete settings to obtain explicit characterisations of free dcpo algebras. Thereby three approaches have been developed: one order-theoretic approach by Jung, Moshier and Vickers, and two topological approaches, one by Keimel and Lawson the other by Battenfeld. In this paper we compare these approaches. In particular, we show that the order-theoretic approach can be translated into the topological setting where it is generalised by Keimel and Lawson’s approach. Furthermore, we explain the problems in comparing the order-theoretic approach with Battenfeld’s approach. Finally, we show that the two topological approaches differ on a more general scale.