Towards a decision-aware declarative process modeling language for knowledge-intensive processes

Modeling loosely framed and knowledge-intensive business processes with the currently available process modeling languages is very challenging. Some lack the flexibility to model this type of processes, while others are missing one or more perspectives needed to add the necessary level of detail to the models. In this paper we have composed a list of requirements that a modeling language should fulfil in order to adequately support the modeling of this type of processes. Based on these requirements, a metamodel for a new modeling language was developed that satisfies them all. The new language, called DeciClare, incorporates parts of several existing modeling languages, integrating them with new solutions to requirements that had not yet been met. Deciclare is a declarative modeling language at its core, and therefore, can inherently deal with the flexibility required to model loosely framed processes. The complementary resource and data perspectives add the capability to reason about, respectively, resources and data values. The latter makes it possible to encapsulate the knowledge that governs the process flow by offering support for decision modeling. The abstract syntax of DeciClare has been implemented in the form of an Ecore model. Based on this implementation, the language-domain appropriateness of the language was validated by domain experts using the arm fracture case as application scenario.     

JavaLog: a framework-based integration of Java and Prolog for agent-oriented programming

Intelligent agent development has imposed new challenges on the necessary language support. Object-oriented languages have been proposed as an appropriate tool, although logic-oriented languages are more adequate for managing mental attitudes. Multi-paradigm languages supporting encapsulation of actions, hiding of private knowledge and flexible manipulation of knowledge are, certainly, a good alternative for programming agents. However, a unique language to support flexible and efficient development of multi-agent systems confronts with the tradeoffs imposed by expressive power, efficiency and support technology. An alternative to conciliate these tradeoffs is not to think about a single language but an incrementally compatible family of agent-oriented multi-paradigm languages. In this work we present an approach based on object-oriented framework technology for integrating object and logic paradigms in such a way that new language features can be incrementally added to the core language. This core language is based on logic modules integrated as object abstractions in the object paradigm. JavaLog is a materialization of this framework integrating Java and Prolog. This core was extended to provide multi-threading support, mobility and temporal-logic operators to Prolog. MoviLog, the mobile part of the family provides a novel mobility mechanism, reactive mobility by failure, which enables virtual Prolog databases distributed across Web sites.     

A collection of method fragments automated with model transformations in agent-oriented modeling

The Foundation for Intelligent Physical Agents (FIPA) Methodology Technical Committee recommends the method engineering approach for Multi-agent System (MAS) development. This approach consists in defining method fragments for agent-oriented software engineering, and then developers combine these fragments to define customized development processes. In this line of research, the contribution of this paper is a collection of novel method fragments that are assisted with model transformations, in order to allow engineers to better develop MASs in an automated way. Some of these fragments also include explicit advices for incorporating artificial intelligence in the development. In the experiments, two processes have been composed with these method fragments for two different agent-oriented methodologies (i.e. Ingenias and Adelfe). This paper shows how these processes are respectively used to develop two known MASs (i.e. Delphi MAS and Timetable MAS). Furthermore, the presented approach is evaluated with 24 developers that were randomly divided into two groups. Each developer designed a MAS satisfying the same common requirements. One group applied the current approach, while the other group did not. The results show that this approach reduces the 63.3% of the designing time in average forMASs.     

Statistical language modeling with a class-basedn-multigram model

In this paper, we present a stochastic language-modeling tool which aims at retrieving variable-length phrases (multigrams), assuming n -gram dependencies between them, hence the name of the model: n -multigram. The estimation of the probability distribution of the phrases is intermixed with a phrase-clustering procedure in a way which jointly optimizes the likelihood of the data. As a result, the language data are iteratively structured at both a paradigmatic and a syntagmatic level in a fully integrated way. We evaluate the 2-multigram model as a statistical language model on ATIS, a task-oriented database consisting of air travel reservations. Experiments show that the 2-multigram model allows a reduction of 10% of the word error rate on ATIS with respect to the usual trigram model, with 25% fewer parameters than in the trigram model. In addition, we illustrate the ability of this model to merge semantically related phrases of different lengths into a common class.     

Towards a deductive object-oriented database language

A language for databases with sets, tuples, lists, object identity and structural inheritance is proposed. The core language is logic-based with a fixpoint semantics. Methods with overloading and methods evaluated externally providing extensibility of the language are considered. Other important issues such as updates and the introduction of explicit control are discussed.     

Towards a language for concurrent processes

In this paper we shall discuss concurrency in programming languages, with a view towards designing a process-oriented language which, by its inherent parallelism, is well suited to exploit the forthcoming generation of distributed processor networks. We shall start by discussing the traditional approach towards managing concurrency, with ‘monitors’ co-ordinating the interactions of ‘processes’, and shall demonstrate that this approach actually degrades concurrency by imposing sequentiality during interactions because it is based on the premise of co-ordinating secure access to shared resources. As a tool for interprocess communication it is felt that the ‘monitor’ is too far removed from the abstract nature of the problem, and so, as a purely engineering solution, it imposes too broad and too prolonged an exclusion to be acceptable in general. Instead we turn to a simpler, and ultimately more powerful notion of ‘message passing’ between parallel processes. We shall show how, if the message system is polymorphic, any data value, however large it is, can pass freely between any pair of processes. By making the processes themselves values in the language we shall discover that message networks can come into being dynamically, and tailor themselves to their applications as and when necessary by ‘short-circuiting’ extensive communications paths. We shall also see how, if the message system is inherently asynchronous, the degree of the parallelism in a system can be enhanced, not degraded, as more and elaborate communications paths develop, the only sequentiality in the system as a whole being imposed by synchronizing processes, not the message passing system itself. After discussing the various built-in system facilities that permit processes to dynamically find out about and study one another, thus permitting processes to set up and thereafter supervise whole subsystems, we shall round off by discussing the advantages of introducing the machines themselves into the language, making it possible for processes to become aware of, and then ‘migrate’ within, the topological structure of a multi-processor distributed network, moving closer to their application, or just to a less-loaded processor, as the need arises. To conclude we shall contrast this new-style process-oriented language with various existing programming languages which have experimented with concurrency, either implicitly or explicitly, in order to see if, and if so how, this new style is any simpler and more powerful than its precursors.     

Towards a toolkit for building language implementations

The current work of the authors in the area of software tools for automatic construction of compilers is described. This focuses on attempts to provide for automatic production of the semantic-analysis and intermediate-code-generation parts of the Cigale compiler-writing system, developed at the University of Nice. This work relies on use of the Amsterdam Compiler Kit (ACK) to ensure a full set of optimizers and code generators based on a semi-universal intermediate language, and, therefore, emphasizes the filling of the gap between parsing and the intermediate language. It is intended as a pragmatic contribution to the automation of the production of true compilers (rather than mere program evaluators) that generate efficient machine code.     

Towards a more familiar relational retrieval language

The aim of this paper is to present the results of an investigation in so-called relational retrieval languages. These languages are often used by non-programmers employing as information model or external schema the normalized relational model. The relational retrieval languages known to the author contain two aspects which are specially inconvenient for a non-mathematician, namely in the majority of non-trivial questions one needs a long and complicated query formulation and the forced use of variables. In this paper a relational retrieval language will be discussed, which offers a solution to avoid these inconveniences.     

Towards a seamless integration between process modeling descriptions at business and production levels: work in progress

To fulfill increasing requirements in the manufacturing sector, companies are facing several challenges. Three major challenges have been identified regarding time-to-market, vertical feedback loops, and level of automation. Grafchart, a graphical language aimed for supervisory control applications, can be used from the process-planning phase, through the implementation phase and all the way to the phase for execution of the process control logics, on the lower levels of the automation triangle along the life cycle axis. This work in progress examines that the same process-based engineering approach can be used on the higher levels of the automation triangle along the enterprise axis interconnecting both axes. By splitting the execution engine and the visualization engine of Grafchart various different visualization tools could potentially be used, however connected by the shared Grafchart semantics. Traditional Business languages (e.g. BPMN) could therefore continue to be used for the process-planning phase whereas traditional production languages (e.g. Grafchart or other sequential function charts-like languages) could be used for the execution. Since they are connected through the semantics, advantages regarding the three identified challenges could be achieved: time-to-market could be reduced, the time delays in the vertical feedback loops could be reduced by Key Performance Indicator visualization and eventing, and the level of automation could be increased.     

Towards a dynamic modeling of the predator prey problem

This article addresses a new dynamic optimization problem (DOP) based on the Predator-Prey (PP) relationship in nature. Indeed, a PP system involves two adversary species where the predator’s objective is to hunt the prey while the prey’s objective is to escape from its predator. By analogy to dynamic optimization, a DOP can be seen as a predation between potential solution(s) in the search space, which represents the predator, and the moving optimum, as the prey. Therefore we define the dynamic predator-prey problem (DPP) whose objective is to keep track of the moving prey, so as to minimize the distance to the optimum. To solve this problem, a dynamic approach that continuously adapts to the changing environment is required. Accordingly, we propose a new evolutionary approach based on three main techniques for DOPs, namely: multi-population scheme, random immigrants, and memory of past solutions. This hybridization of methods aims at improving the evolutionary approaches ability to deal with DOPs and to restrain as much as possible their drawbacks. Our computational experiments show that the proposed approach achieves high performance for DPP and and competes with state of the art approaches.     

Towards a bipartite graph modeling of the internet topology

Modeling the properties of the Internet topology aims at generating large scale artificial IP networks that mimic properties of real ones for simulation purposes. Current models typically consider the Internet as a simple graph where edges are point-to-point connections between routers. This approach does not take into account point-to-multipoint connections that exist at lower layers in the network, e.g. layer-2 clouds, such as Ethernet switches or MPLS networks. Instead, such physical point-to-multipoint connections are modeled as several logical IP level point-to-point connections.     

Towards a verified compiler prototype for the synchronous language SIGNAL

SIGNAL belongs to the synchronous languages family which are widely used in the design of safety-critical real-time systems such as avionics, space systems, and nuclear power plants. This paper reports a compiler prototype for SIGNAL. Compared with the existing SIGNAL compiler, we propose a new intermediate representation (named S-CGA, a variant of clocked guarded actions), to integrate more synchronous programs into our compiler prototype in the future. The front-end of the compiler, i.e., the translation from SIGNAL to S-CGA, is presented. As well, the proof of semantics preservation is mechanized in the theorem prover Coq. Moreover, we present the back-end of the compiler, including sequential code generation and multithreaded code generation with time-predictable properties. With the rising importance of multi-core processors in safetycritical embedded systems or cyber-physical systems (CPS), there is a growing need for model-driven generation of multithreaded code and thus mapping on multi-core. We propose a time-predictable multi-core architecture model in architecture analysis and design language (AADL), and map the multi-threaded code to this model.     

Towards a natural language semantics without functors and operands

The paper sets out to offer an alternative to the function/argument approach to the most essential aspects of natural language meanings. That is, we question the assumption that semantic completeness (of, e.g., propositions) or incompleteness (of, e.g., predicates) exactly replicate the corresponding grammatical concepts (of, e.g., sentences and verbs, respectively). We argue that even if one gives up this assumption, it is still possible to keep the compositionality of the semantic interpretation of simple predicate/argument structures. In our opinion, compositionality presupposes that we are able to compare arbitrary meanings in term of information content. This is why our proposal relies on an ‘intrinsically’ type free algebraic semantic theory. The basic entities in our models are neither individuals, nor eventualities, nor their properties, but ‘pieces of evidence’ for believing in the ‘truth’ or ‘existence’ or ‘identity’ of any kind of phenomenon. Our formal language contains a single binary non-associative constructor used for creating structured complex terms representing arbitrary phenomena. We give a finite Hilbert-style axiomatisation and a decision algorithm for the entailment problem of the suggested system.     

Towards the integration of reputation management in OpenID

OpenID is an open standard providing a decentralized authentication mechanism to end users. It is based on a unique URL (Uniform Resource Locator) or XRI (Extensible Resource Identifier) as identifier of the user. This fact of using a single identifier confers this approach an interesting added-value when users want to get access to different services in the Internet, since users do not need to create a new account on every website they are visiting. However, OpenID providers are normally used as a point to store certain personal attributes of the end users too, which might be of interest for any service provider willing to make profit from collecting that personal information. The definition of a reputation management solution integrated as part of the OpenID protocol can help users to determine whether a given service provider is more or less reliable before interacting with it and transferring their private information. This paper is providing the definition of a reputation framework that can be applied to the OpenID SSO (Single Sign-On) standard solution. It also defines how the protocol itself can be enhanced so OpenID providers can collect (and provide) recommendations from (to) users regarding different service providers and thus enhancing the users' experience when using OpenID. Besides the definition, a set of tests has been performed validating the feasibility of the framework.     

Shopping behavior recognition using a language modeling analogy

Automatic understanding and recognition of human shopping behavior has many potential applications, attracting an increasing interest in the marketing domain. The reliability and performance of the automatic recognition system is highly influenced by the adopted theoretical model of behavior. In this work, we address the analogy between human shopping behavior and a natural language. The adopted methodology associates low-level information extracted from video data with semantic information using the proposed behavior language model. Our contribution on the action recognition level consists of proposing a new feature set which fuses Histograms of Optical Flow (HOF) with directional features. On the behavior level we propose combining smoothed bi-grams with the maximum dependency in a chain of conditional probabilities. The experiments are performed on both laboratory and real-life datasets. The introduced behavior language model achieves an accuracy of 87% on the laboratory data and 76% on the real-life dataset, an improvement of 11% and 8% respectively over the baseline model, by incorporating semantic knowledge and capturing correlations between the basic actions.     

Towards modeling popularity of microblogs

As one kind of social media, microblogs are widely used for sensing the real-world. The popularity of microblogs is an important measurement for evaluation of the influencial of pieces of information. The models and modeling techniques for popularity of microblogs are studied in this paper. A huge data set based on Sina Weibo, one of the most popular microblogging services, is used in the study. First, two different types of popularity, namely number of retweets and number of possible views are defined, while their relationships are discussed. Then, the temporal dynamics, including lifecycles and tipping-points, of tweets’ popularity are studied. For modeling the temporal dynamics, a piecewise sigmoid model is used. Empirical studies show the effectiveness of our modeling methods.     

Debugging measurement systems using a domain-specific modeling language

Capturing physical data in the context of measurement systems is a demanding process that often requires many repetitions with different settings. To assist in this activity, a domain-specific modeling language (DSML) called Sequencer has been developed to enable the improved definition of measurement procedures. With Sequencer, the level of abstraction has been raised and sophisticated changes in measurement procedures are now enabled. Although there are numerous DSMLs like Sequencer in the existing literature, there are some obstacles working against the more widespread adoption of DSMLs in practice. One challenge is the lack of supporting tools for DSMLs, which would improve the capabilities of end-users of such languages. For instance, support for debugging a model expressed in a DSML is often neglected. The lack of a debugger at the proper abstraction level limits the domain experts in discovering and locating bugs in a model. In this paper, Sequencer is presented together with debugging facilities (called Ladybird) that are integrated in a modeling environment. Ladybird supports different execution modes (e.g., steps, breakpoints, animations, variable views, and stack traces) that can be helpful during the debugging of a model. Ladybird's primary contribution is in showing the value of error detection in complicated industrial environments, such as data acquisition in automotive testing. The paper contributes to a discussion of the implementation details of DSML debugging facilities and how such a debugger can be reused to support domains other than the measurement context of Sequencer.