Declarative Language Research Articles

Combining Flexibility and Data Handling in Business Process Models

Flexibility and data handling are two hot topics in current research on business process models. However, these issues are tackled separately through declarative languages and artifact-centric approaches, respectively. It follows that the situations in which the choice of the task to perform is a human decision affected by the presence of suitable input entities are not adequately handled; unfortunately, these situations are common in several industrial processes such as build-to-order ones. An integrated approach able to combine flexibility and data handling is needed and to this end this paper presents a notation named ENTA (ENtities and TAsks): it makes both business entities and tasks first-class citizens in process models and it provides high-level descriptions of the tasks in terms of intended effects and constraints to be met. Some examples of order handling processes are used to explain the issues of entity selection and task selection: deciding which customer orders can be associated with the same supplier order is a case of entity selection while deciding whether to generate a new supplier order for the customer orders selected or to add them to an existing supplier order is a case of task selection.

Conformance checking and diagnosis for declarative business process models in data-aware scenarios

A business process (BP) consists of a set of activities which are performed in coordination in an organizational and technical environment and which jointly realize a business goal. In such context, BP management (BPM) can be seen as supporting BPs using methods, techniques, and software in order to design, enact, control, and analyze operational processes involving humans, organizations, applications, and other sources of information. Since the accurate management of BPs is receiving increasing attention, conformance checking, i.e., verifying whether the observed behavior matches a modelled behavior, is becoming more and more critical. Moreover, declarative languages are more frequently used to provide an increased flexibility. However, whereas there exist solid conformance checking techniques for imperative models, little work has been conducted for declarative models. Furthermore, only control-flow perspective is usually considered although other perspectives (e.g., data) are crucial. In addition, most approaches exclusively check the conformance without providing any related diagnostics. To enhance the accurate management of flexible BPs, this work presents a constraint-based approach for conformance checking over declarative BP models (including both control-flow and data perspectives). In addition, two constraint-based proposals for providing related diagnosis are detailed. To demonstrate both the effectiveness and the efficiency of the proposed approaches, the analysis of different performance measures related to a wide diversified set of test models of varying complexity has been performed.

Declarative platform for high-performance network traffic analytics

This paper presents Scalanytics, a declarative platform that supports high-performance application layer analysis of network traffic. Scalanytics uses (1) stateful network packet processing techniques for extracting application layer data from network packets, (2) a declarative rule-based language called Analog for compactly specifying analysis pipelines from reusable modules, and (3) a task-stealing architecture for processing network packets at high throughput within these pipelines, by leveraging multi-core processing capabilities in a load-balanced manner without the need for explicit performance profiling. In a cluster of machines, Scalanytics further improves throughput through the use of a consistent-hashing based load partitioning strategy. Our evaluation on a 16-core machine demonstrate that Scalanytics achieves up to 11.4 $$\times $$ × improvement in throughput compared with the best uniprocessor implementation. Moreover, Scalanytics outperforms the Bro intrusion detection system by an order of magnitude when used for analyzing SMTP traffic. We further observed increased throughput when running Scalanytics pipelines across multiple machines.

Using Timed Automata for a Priori Warnings and Planning for Timed Declarative Process Models

Many processes are characterized by high variability, making traditional process modeling languages cumbersome or even impossible to be used for their description. This is especially true in cooperative environments relying heavily on human knowledge. Declarative languages, like Declare, alleviate this issue by not describing what to do step-by-step but by defining a set of constraints between actions that must not be violated during the process execution. Furthermore, in modern cooperative business, time is of utmost importance. Therefore, declarative process models should be able to take this dimension into consideration. Timed Declare has already previously been introduced to monitor temporal constraints at runtime, but it has until now only been possible to provide an alert when a constraint has already been violated without the possibility of foreseeing and avoiding such violations. In this paper, we introduce an extended version of Timed Declare with a formal timed semantics for the entire language. The semantics degenerates to the untimed semantics in the expected way. We also introduce a translation to timed automata, which allows us to detect inconsistencies in models prior to execution and to early detect that a certain task is time sensitive. This means that either the task cannot be executed after a deadline (or before a latency), or that constraints are violated unless it is executed before (or after) a certain time. This makes it possible to use declarative process models to provide a priori guidance instead of just a posteriori detecting that an execution is invalid. We also outline how a Declare model with time can be used in resource planning and how Declare has been integrated into CPN Tools.

CodeCloud: A platform to enable execution of programming models on the Clouds

This paper presents a platform that supports the execution of scientific applications covering different programming models (such as Master/Slave, Parallel/MPI, MapReduce and Workflows) on Cloud infrastructures. The platform includes (i) a high-level declarative language to express the requirements of the applications featuring software customization at runtime, (ii) an approach based on virtual containers to encapsulate the logic of the different programming models, (iii) an infrastructure manager to interact with different IaaS backends, (iv) a configuration software to dynamically configure the provisioned resources and (v) a catalog and repository of virtual machine images. By using this platform, an application developer can adapt, deploy and execute parallel applications agnostic to the Cloud backend.

Mathematical programming: Turing completeness and applications to software analysis

Mathematical programming is Turing complete, and can be used as a general-purpose declarative language. We present a new constructive proof of this fact, and showcase its usefulness by discussing an application to finding the hardest input of any given program running on a Minsky Register Machine. We also discuss an application of mathematical programming to software verification obtained by relaxing one of the properties of Turing complete languages.

High-Speed Packet Processing using Reconfigurable Computing

Internet applications, notably streaming video, demand extremely high communication speeds in core networks, currently 100 Gbps and moving toward 400 Gbps and beyond. Data packets must be processed at these rates, presenting serious challenges for traditional computing approaches. This article presents a tool chain that maps a domain-specific packet-processing language called PX to high-performance reconfigurable-computing architectures based on field-programmable gate array (FPGA) technology. PX is a declarative language with object-oriented semantics. A customized computing architecture is generated to match the exact requirements expressed in the PX description. The architecture includes components for packet parsing and editing, and for table lookups. It is expressed in a register transfer level (RTL) description, which is then processed using standard FPGA implementation tools. The architecture is dynamically programmable via custom firmware updates when the packet-processing system is in operation. The authors illustrate the language, tool chain, and implementation results through a practical example involving a 100-Gbps OpenFlow implementation.

Translate the Stateflow Models into Alloy for Safety Analysis

Safety analysis is widely appreciated for critical systems. Model-based safety analysis is emerged under the background of mode-based development. For automated model-based safety analysis, extended models should be translated into script of input of formal analyzer. Consequently, many translation systems are constructed. In this paper, we explore the translating method between Stateflow models and Alloy, which is a declarative specification language for expressing complex structural constraints and behavior in a software system. Concrete translation systems could be built based on the method.

A rule-based ontological framework for the classification of molecules.

BackgroundA variety of key activities within life sciences research involves integrating and intelligently managing large amounts of biochemical information. Semantic technologies provide an intuitive way to organise and sift through these rapidly growing datasets via the design and maintenance of ontology-supported knowledge bases. To this end, OWL—a W3C standard declarative language— has been extensively used in the deployment of biochemical ontologies that can be conveniently organised using the classification facilities of OWL-based tools. One of the most established ontologies for the chemical domain is ChEBI, an open-access dictionary of molecular entities that supplies high quality annotation and taxonomical information for biologically relevant compounds. However, ChEBI is being manually expanded which hinders its potential to grow due to the limited availability of human resources.ResultsIn this work, we describe a prototype that performs automatic classification of chemical compounds. The software we present implements a sound and complete reasoning procedure of a formalism that extends datalog and builds upon an off-the-shelf deductive database system. We capture a wide range of chemical classes that are not expressible with OWL-based formalisms such as cyclic molecules, saturated molecules and alkanes. Furthermore, we describe a surface ‘less-logician-like’ syntax that allows application experts to create ontological descriptions of complex biochemical objects without prior knowledge of logic. In terms of performance, a noticeable improvement is observed in comparison with previous approaches. Our evaluation has discovered subsumptions that are missing from the manually curated ChEBI ontology as well as discrepancies with respect to existing subclass relations. We illustrate thus the potential of an ontology language suitable for the life sciences domain that exhibits a favourable balance between expressive power and practical feasibility.ConclusionsOur proposed methodology can form the basis of an ontology-mediated application to assist biocurators in the production of complete and error-free taxonomies. Moreover, such a tool could contribute to a more rapid development of the ChEBI ontology and to the efforts of the ChEBI team to make annotated chemical datasets available to the public. From a modelling point of view, our approach could stimulate the adoption of a different and expressive reasoning paradigm based on rules for which state-of-the-art and highly optimised reasoners are available; it could thus pave the way for the representation of a broader spectrum of life sciences and biomedical knowledge.

Modeling constraint-based processes: A supervisory control theory application

Constraint-based processes require a set of rules that limit their behavior to certain boundaries. In these processes, the control flow is defined implicitly as a set of constraints or rules, and all possibilities that do not violate any of the given constraints are allowed to be executed. The present paper proposes a new approach to deal with constraint-based processes. The proposed approach is based on Supervisory Control Theory, a formal foundation for building controllers for discrete-event systems. The controller proposed in this paper monitors and restricts execution sequences of activities such that constraints are always obeyed. We demonstrate that our approach may be used as a declarative language for constraint-based processes. In order to provide support for users of such processes and to facilitate the using of our control approach, we offer a set of constraints modeled by automata. This set encompasses the constraints frequently needed in workflow system.

The JStar language philosophy

• Relational data plus explicit dependencies allows aggressive parallelization . • Datalog + Negation + Timestamps is a useful parallel programming language . • JStar enables parallelization alternatives without changing the program source. • JStar separates the roles of application and parallelization programmers. This paper introduces the JStar parallel programming language, which is a Java-based declarative language aimed at discouraging sequential programming, encouraging massively parallel programming, and giving the compiler and runtime maximum freedom to try alternative parallelisation strategies. We describe the execution semantics and runtime support of the language, several optimisations and parallelism strategies, with some benchmark results.

Monitoring business constraints with the event calculus

Today, large business processes are composed of smaller, autonomous, interconnected subsystems, achieving modularity and robustness. Quite often, these large processes comprise software components as well as human actors, they face highly dynamic environments and their subsystems are updated and evolve independently of each other. Due to their dynamic nature and complexity, it might be difficult, if not impossible, to ensure at design-time that such systems will always exhibit the desired/expected behaviors. This, in turn, triggers the need for runtime verification and monitoring facilities. These are needed to check whether the actual behavior complies with expected business constraints, internal/external regulations and desired best practices. In this work, we present Mobucon EC, a novel monitoring framework that tracks streams of events and continuously determines the state of business constraints. In Mobucon EC, business constraints are defined using the declarative language Declare. For the purpose of this work, Declare has been suitably extended to support quantitative time constraints and non-atomic, durative activities. The logic-based language Event Calculus (EC) has been adopted to provide a formal specification and semantics to Declare constraints, while a light-weight, logic programming-based EC tool supports dynamically reasoning about partial, evolving execution traces. To demonstrate the applicability of our approach, we describe a case study about maritime safety and security and provide a synthetic benchmark to evaluate its scalability.

From Model Specification to Simulation of Biologically Constrained Networks of Spiking Neurons

A declarative extensible markup language (SpineML) for describing the dynamics, network and experiments of large-scale spiking neural network simulations is described which builds upon the NineML standard. It utilises a level of abstraction which targets point neuron representation but addresses the limitations of existing tools by allowing arbitrary dynamics to be expressed. The use of XML promotes model sharing, is human readable and allows collaborative working. The syntax uses a high-level self explanatory format which allows straight forward code generation or translation of a model description to a native simulator format. This paper demonstrates the use of code generation in order to translate, simulate and reproduce the results of a benchmark model across a range of simulators. The flexibility of the SpineML syntax is highlighted by reproducing a pre-existing, biologically constrained model of a neural microcircuit (the striatum). The SpineML code is open source and is available at http://bimpa.group.shef.ac.uk/SpineML.

The design and implementation of the A3 application-aware anonymity platform

This paper presents the design and implementation of Application-Aware Anonymity (A3), an extensible platform for rapidly prototyping and evaluating anonymity protocols on the Internet. A3 supports the development of highly tunable anonymous protocols that enable applications to tailor their anonymity properties and performance characteristics according to specific communication requirements.To support flexible path construction, A3 uses a declarative language to compactly specify path selection and instantiation policies. We demonstrate that our declarative language is sufficiently expressive to encode novel multi-metric performance constraints as well as existing relay selection algorithms employed by Tor and other anonymity systems, using only a few lines of concise code. We experimentally evaluate A3 using a combination of trace-driven simulations and a deployment on PlanetLab, as well as a case-study of A3-enabled voice-over-IP communication. Our experimental results demonstrate that A3 can flexibly and efficiently support a wide range of path selection and instantiation strategies at low performance overhead.

Are graph databases ready for bioinformatics?

Contact: Lars.Juhl.Jensen@gmail.com

An Efficient Scalable Runtime System for Macro Data Flow Processing Using S-Net

S-Net is a declarative coordination language and component technology aimed at radically facilitating software engineering for modern parallel compute systems by near-complete separation of concerns between application (component) engineering and concurrency orchestration. S-Net builds on the concept of stream processing to structure networks of communicating asynchronous components implemented in a conventional (sequential) language. In this paper we present the design, implementation and evaluation of a new and innovative runtime system for S-Net streaming networks. The Front runtime system outperforms the existing implementations of S-Net by orders of magnitude for stress-test benchmarks, significantly reduces runtimes of fully-fledged parallel applications with compute-intensive components and achieves good scalability on our 48-core test system.

Applications and extensions of Alloy: past, present and future

Alloy is a declarative language for lightweight modelling and analysis of software. The core of the language is based on first-order relational logic, which offers an attractive balance between analysability and expressiveness. The logic is expressive enough to capture the intricacies of real systems, but is also simple enough to support fully automated analysis with the Alloy Analyzer. The Analyzer is built on a SAT-based constraint solver and provides automated simulation, checking and debugging of Alloy specifications. Because of its automated analysis and expressive logic, Alloy has been applied in a wide variety of domains. These applications have motivated a number of extensions both to the Alloy language and to its SAT-based analysis. This paper provides an overview of Alloy in the context of its three largest application domains, lightweight modelling, bounded code verification and test-case generation, and three recent application-driven extensions, an imperative extension to the language, a compiler to executable code and a proof-capable analyser based on SMT.

A multitasking architecture for humanoid robot programming

We propose a hierarchical, three-tiered motion programming architecture for humanoid robots that allows for the prioritized coordination of multiple tasks while taking into account the dynamics and other physics-based constraints that underlie typical humanoid robot tasks. We first introduce a data structure for generic humanoid robots based on a general description of what constitutes a humanoid that is workable and practical from a programming perspective, without overly restricting the diversity of humanoid designs. For the low-level language we develop an extension of Brockett's motion description language (MDL) that allows for the prioritized coordination of multiple tasks taking into account the dynamics-based requirements of typical humanoid manipulation tasks. The extended multitasking motion description language (MDLm) inherits the advantages of the original MDL, while making use of change of coordinates and the null space control formalism of Sentis and Khatib (Int J Humanoid Robot 2(4):505---518, 2005). We also develop a high-level language consisting of pre-defined motion primitives that constitute a vocabulary for generating more complex free-space motions and object manipulation tasks. These occupational tasks and free-space motions are derived based on methods and principles for measuring human task performance Drumwright (The Task Matrix: a robot-independent framework for programming humanoids. Ph.D dissertation, University of Southern California, 2007), Karger and Bayha (Engineered work measurement. Industrial Press, New York, 1965). The structure of the high level language is also inspired in part by well-established notation for dance choreography Huang and Hudak (Dance: a declarative language for the control of humanoid robots, 2003) Hutchinson (Labanotation or Kinetography Laban: system of analyzing and recording movement. Oxford University Press, New York, 1972). In the resulting architecture, high-level motion primitives and MDLm are integrated in a balanced and consistent manner that allows for flexible and intuitive programming in an efficient manner. A case study is offered to illustrate our architecture.

Automatic Iranian Vehicle License Plate Recognition System Based on Support Vector Machine (SVM) Algorithms

In the emerging trends the pervasive nature across the computing environment shows that the system is platform independent and device independent. The system development is designed with the help of Structured Query Language and middleware infrastructure that are used to collect the information from various nodes. An essential feature of this proposed middleware architecture suites the device independent as the major supporting capability to the system. This facilitates to add new device types in the system feels easy through the use of device self-description. It mainly focuses on the issues related to the heterogeneity of the different devices composing a pervasive system: This aspect is investigated both at data management and at physical integration levels. Using the nontrivial approach aims at handling the related issues are resolved with the corresponding solution.
 Keyword: Perla, Cloud Monitoring, Middleware, Declarative Language

The expressive power of CHR with priorities

Constraint Handling Rules (CHR) is a committed-choice declarative language which has been originally designed for writing constraint solvers and which is nowadays a general purpose language.Recently the language has been extended by introducing user-definable (static or dynamic) rule priorities. The resulting language allows a better control over execution while retaining a declarative and flexible style of programming.In this paper we study the expressive power of this language. We first show that, in the presence of priorities, differently from the case of standard CHR, considering more than two atoms in the heads of rules does not augment the expressive power of the language. Next we show that also dynamic priorities do not augment the expressive power w.r.t. static priorities. These results are proved by providing explicitly a translation of one language into another one, which preserves a reference semantics.Finally we show that CHR with priorities is strictly more expressive than standard CHR (under the theoretical operational semantics). This result is obtained by adapting to the CHR case a notion of language encoding which allows to compare Turing powerful languages.