A semantic framework for metamodel-based languages

In the model-based development context, metamodel-based languages are increasingly being defined and adopted either for general purposes or for specific domains of interest. However, meta-languages such as the MOF (Meta Object Facility)—combined with the OCL (Object Constraint Language) for expressing constraints—used to specify metamodels focus on structural and static semantics but have no built-in support for specifying behavioral semantics. This paper introduces a formal semantic framework for the definition of the semantics of metamodel-based languages. Using metamodelling principles, we propose several techniques, some based on the translational approach while others based on the weaving approach, all showing how the Abstract State Machine formal method can be integrated with current metamodel engineering environments to endow language metamodels with precise and executable semantics. We exemplify the use of our semantic framework by applying the proposed techniques to the OMG metamodelling framework for the behaviour specification of the Finite State Machines provided in terms of a metamodel.     

A framework for multiple coordination languages

The Web has become a world of services offered by Web agents. Although they provide attractive value in isolated operation, collaboration amongst Web agents from different origins could lead to more sophisticated services. Enabling for such an interworking would be the integration of platforms on which these agents operate. We take two coordination languages, namely Linda and KQML, and develop a model and framework which allows it to describe and implement both languages.     

Parallel programming with logic languages: A survey

Formal properties of logic languages are largely studied; however, their impact on the practice of software design and programming is currently minimal. In this paper we survey some interesting representatives of the family of logic languages aiming at comparing the different capabilities they offer for designing and programming parallel systems. The logic languages Prolog, Aurora, Flat Concurrent Prolog, Parlog, GHC, and DeltaProlog were chosen, because a suitable set of relevant examples has been published, mostly by the language designers themselves. A number of sample programs is used to expose and compare the languages with respect to their object oriented programming capabilities for multiprocess coordination, interprocess communication, and resource management. Special attention is devoted also to metaprogramming as well, seen as a useful technique for specifying and building the operating environments of the languages themselves. The paper ends with a discussion on positive and negative features found comparing these languages, and indicates some guidelines to be followed in the design of new logic languages.     

A framework for evolution of modelling languages

In model-driven engineering, evolution is inevitable over the course of the complete life cycle of complex software-intensive systems and more importantly of entire product families. Not only instance models, but also entire modelling languages are subject to change. This is in particular true for domain-specific languages, whose language constructs are tightly coupled to an application domain.The most popular approach to evolution in the modelling domain is a manual process, with tedious and error-prone migration of artefacts such as instance models as a result. This paper provides a taxonomy for evolution of modelling languages and discusses the different evolution scenarios for various kinds of modelling artefacts, such as instance models, meta-models, and transformation models. Subsequently, the consequences of evolution and the required remedial actions are decomposed into primitive scenarios such that all possible evolutions can be covered exhaustively. These primitives are then used in a high-level framework for the evolution of modelling languages.We suggest that our structured approach enables the design of (semi-)automatic modelling language evolution solutions.     

A framework for evolution of modelling languages

In model-driven engineering, evolution is inevitable over the course of the complete life cycle of complex software-intensive systems and more importantly of entire product families. Not only instance models, but also entire modelling languages are subject to change. This is in particular true for domain-specific languages, whose language constructs are tightly coupled to an application domain.The most popular approach to evolution in the modelling domain is a manual process, with tedious and error-prone migration of artefacts such as instance models as a result. This paper provides a taxonomy for evolution of modelling languages and discusses the different evolution scenarios for various kinds of modelling artefacts, such as instance models, meta-models, and transformation models. Subsequently, the consequences of evolution and the required remedial actions are decomposed into primitive scenarios such that all possible evolutions can be covered exhaustively. These primitives are then used in a high-level framework for the evolution of modelling languages.We suggest that our structured approach enables the design of (semi-)automatic modelling language evolution solutions.     

A generic framework for modeling resources with UML

Current wisdom encourages designers to first focus on the logical aspects of their problem and then defer platform and technology issues until the concluding phases of development. This behavior is reasonable, considering that devising logically sound solutions is frequently the most difficult aspect of development. Unfortunately-and this has been understated to date-there are many situations in which this approach is inappropriate. Real-time software design is one domain where this situation is particularly obvious because the domain's requirements force software to interact with the physical world in some way. Recently, a generic object oriented framework has been proposed for modeling both physical and logical resources. Although the framework is generic, it is mainly used with the industry-standard Unified Modeling Language (UML). By providing a standard means for representing resources and their attributes, it becomes possible to seamlessly transfer UML models of real-time systems between design and specialized analysis tools. The author shows how developers can use the OMG's UML to model resources and thus predict crucial system properties before fully implementing a system     

Differential interaction nets

We introduce interaction nets for a fragment of the differential lambda-calculus and exhibit in this framework a new symmetry between the of course and the why not modalities of linear logic, which is completely similar to the symmetry between the tensor and par connectives of linear logic. We use algebraic intuitions for introducing these nets and their reduction rules, and then we develop two correctness criteria (weak typability and acyclicity) and show that they guarantee strong normalization. Finally, we outline the correspondence between this interaction nets formalism and the resource lambda-calculus.     

A general framework for reasoning about change

The capability to represent and use concepts like time and events in computer science is essential to solve a wide class of problems characterized by the notion of change. Real-time, databases and multimedia are just a few of several areas which needs good tools to deal with time. Another area where this concepts are essential is artificial intelligence because an agent must be able to reason about a dynamic environment. In this work a formalism is proposed which allows the representation and use of several features that had been recognized as useful in the attempts to solve such class of problems. A general framework based on a many-sorted logic is proposed centering our attention in issues such as the representation of time, actions, properties, events and causality. The proposal is compared with related work from the temporal logic and artificial intelligence areas. This work complements and enhances previously related efforts on formalizing temporal concepts with the same purpose. Juan Carlos Augusto, Ph.D.: He is a Lecturer in the Department of Computer Science at Universidad Nacional del Sur (Argentina), where he graduated as Licenciado en Ciencias de la Computacion and Doctor en Ciencias de la Computacion. Currently on leave in the Department of Electronics and Computer Science, University of Southampton (United Kingdom). His research interests are focused in the dynamic aspects of computing systems. This involves solving conceptual problems related to the specification of time and change and designing tools to improve systems in several areas of computer science, such as artificial intelligence, databases, multimedia, software verification and real-time systems. He has been conducting research on temporal representation and reasoning since 1993. Throughout these years he had the opportunity to contribute to several research projects as a researcher and has head or co-head of research groups. Other activities and contributions to highlight are the organization of international events, editorial work and supervision of postgraduate students, all of which contributes to the generation and dissemination of knowledge about the dynamic aspects of computing systems.     

A holistic framework for engineering simulation platform development gluing open-source and home-made software resources

The budgetary pressure of engineering simulation platform development is continuing to increase in industry, especially for those scientific institutions, while simulation platform is becoming increasingly important for the researchers in their daily work. Plenty of basic components provided for free by open-source communities can be used to develop simulation platform; however, using open-source components is much more technically difficult than directly utilizing commercial simulation platform. We propose a novel gluing components to tackle the existing difficulties of engineering simulation platform development by using open-source components and home-made resources. In order to reduce the development cost, a holistic framework named TPL.Frame, whose core is the gluing component, is designed to develop engineering simulation platform that consists of SALOME simulation platform, OGRE engine and some other home-made numerical codes. Unlike general commercial simulation solutions, the framework provides not only the basic functionalities, including CAD (Computer-Aided Design) and CAE (Computer-Aided Engineering), but also advanced features, such as real-time 3D visualization, interoperability between FE (Finite Element) method and MB (Multi-Body) dynamics, distributed simulation modeling and other user-defined features. To compare with traditional development method, several cases studied in railway industry are given to demonstrate how to rapidly develop engineering simulation platform using TPL.Frame, thus to prove the effectiveness of the proposed framework.     

The syntax of interactive command languages: A framework for design

Various qualities of simple command languages, such as ease of use and flexibility, are defined in terms of syntax. Certain design attributes—namely style, structure and level of abstraction—are described for command languages, and these attributes are shown to strongly influence the defined qualities. Commands are designed for three functions to show how the design trade-offs are made in light of the qualities and attributes discussed.     

Probabilistic coherence spaces as a model of higher-order probabilistic computation

We study a probabilistic version of coherence spaces and show that these objects provide a model of linear logic. We build a model of the pure lambda-calculus in this setting and show how to interpret a probabilistic version of the functional language PCF. We give a probabilistic interpretation of the semantics of probabilistic PCF closed terms of ground type. Last we suggest a generalization of this approach, using Banach spaces.     

A mathematical framework for the semantics of symbolic languages representing periodic time

In several areas, including Temporal DataBases (TDB), Presburger arithmetic has been chosen as a standard reference for the semantics of languages representing periodic time, and to study their expressiveness. On the other hand, the proposal of most symbolic languages in the AI literature has not been paired with an adequate semantic counterpart, making the task of studying the expressiveness of such languages and of comparing them a very complex one. In this paper, we first define a representation language which enables us to handle each temporal point as a complex object enriched with all the structure it is immersed in, and then we use it in order to provide a Presburger semantics for classes of symbolic languages coping with periodicity. Finally, we use the semantics to compare a few AI and TDB symbolic approaches.     

A new heuristic for scheduling the two-stage flowshop with additional resources

This paper deals with the problem of preemptive scheduling in a two-stage flowshop with parallel unrelated machines at the first stage and a single machine at the second stage. At the first stage, jobs use some additional resources which are available in limited quantities at any time. The resource requirements are of 0–1 type. The objective is the minimization of makespan. The problem is NP-hard. Heuristic algorithms are proposed which solve to optimality the resource constrained scheduling problem at the first stage of the flowshop, and at the same time, minimize the makespan in the flowshop by selecting appropriate jobs for simultaneous processing. Several rules of job selection are considered. The performance of the proposed heuristic algorithms is analyzed by comparing solutions with the lower bound on the optimal makespan. The extensive computational experiment shows that the proposed heuristic algorithms are able to produce near-optimal solutions in short computational time.     

From Flow Logic to static type systems for coordination languages

Coordination languages are often used to describe open-ended systems. This makes it challenging to develop tools for guaranteeing the security of the coordinated systems and the correctness of their interaction. Successful approaches to this problem have been based on type systems with dynamic checks; therefore, the correctness properties cannot be statically enforced. By contrast, static analysis approaches based on Flow Logic usually guarantee properties statically. In this paper, we show how the insights from the Flow Logic approach can be used to construct a type system for statically ensuring secure access to tuple spaces and safe process migration for an extension of the language Klaim.     

Kleene modules and linear languages

A Kleene algebra (K, +, ·, *, 0, 1) is an idempotent semiring with an iteration * as axiomatised by Kozen. We consider left semiring modules (A, +, 0, :) over Kleene algebras. We call such a left semiring module a Kleene module if each linear equation x = a + r : x has a least solution, where : is the product from K × A to A. The linear context-free languages can be viewed as a Kleene module A over a Kleene algebra R of binary regular word relations. Thus, the simultaneous linear fixed-point operator μ on languages can be reduced to iteration * on R and the scalar product :.