EventJava: An Extension of Java for Event Correlation

Event correlation is an important component in business performance management. Simple rule-based event correlation engines, like Zurich Correlation Engine (ZCE), usually accept input events that include only name-value pairs. However, when input events are in XML format, the ZCE needs to be adapted to accept complex/structural events. In this paper, we present a model-driven approach to derive solutions for adapting the new type of events, so that the light weight correlation engine can still be used for event monitoring and correlation.

Event-driven Process Chain (EPC) is a known business process modeling language which is primarily renowned for efficient modeling of business requirements. It is a semi-formal modeling language which is commonly verified though various formal mechanism for simple atomic events. However, the complexity of business requirements cannot be modeled through EPC atomic events alone especially in case of real time systems. Therefore, the complex events patterns like Event Time, Event location, Event Cardinality, Event Sequence, Event Exclusion, Event Trend and Data dependency are introduced in EPC from the novel area of complex event processing. However, to the best of our knowledge, there is no mechanism available in EPC to model and verify such complex events. Therefore, in this paper, we investigate the verification possibilities of both (atomic and complex) events in the context of Timed-Automata (TA) and Time Petri Nets (TPN). Particularly, we try to map the semantics of simple and complex events with the corresponding concepts of TA and TPN. It is analyzed that the simple EPC events can be formalized through TA and TPN but limited support is available for complex events. The restaurant process case study has been used for further investigation of complex events. It has been concluded that TA formalism is more suitable than TPN for the verification of complex events in EPC.

Ubiquitous computing, with a dramatic increase in the event monitoring capabilities of wireless devices and sensors, requires more complex temporal and spatial resolution in event correlation. In this chapter, we describe two aspects of event correlation to support such environments: event modelling including spatio-temporal information, and composite event semantics with interval-based semantics for efficient indexing, filtering, and matching. It includes a comparative study of existing event correlation work. The described durative event model, combined with interval-semantics, provides a new vision for data processing in ubiquitous computing. This makes it possible to extend the functionality of simple publish/subscribe filters to stateful subscriptions, parametrisation, and computation of aggregates, while maintaining high scalability.

Illegal parking prediction is a crucial problem to help stakeholders with better urban planning and management. Existing works advance the field by capturing complex traffic correlations from spatial and temporal perspectives using deep learning models, and achieve state-of-the-art performance. However, current works do not consider the unique perspective from the illegal parking data collection process carried out by patrol officers, which can reflect a wealth of knowledge gained from each officer's on-the-ground experiences for more effective patrol. In this paper, we propose a novel behavior-aware hypergraph convolutional network named BHIPP for city-wide illegal parking prediction. To better represent the correlations of illegal parking events from patrol officers' perspective, we construct a new patrol hypergraph integrating patrol officers' experience alongsie multi-source contextual information. Additionally, we design a behavior-aware hypergraph convolutional network, which captures the complex and high-order illegal parking event correlations with officers' patrol behaviors explicitly considered. Further, we introduce a spatial-temporal illegal parking approximation module to estimate parking violations in under-patrolled regions using both historical and multi-source contextual data. Extensive experiments on real-world datasets demonstrate the superiority of our proposed BHIPP compared with a broad range of state-of-the-art baseline models across varying spatial-temporal granularities, from both regression and ranking aspects.

The US Department of Energy's open-cycle, coal-fired Magnetohydrodynamic (MHD)/Heat Recovery Seed Recovery (HRSR) development proram requires field use instrumentation with a non-intrusive measuring capability to diagnose problems occurring in advanced MHD power trains and HRSR cycles during actual test operation without distorting the conditions being measured. The diagnostic development program in direct support of the major MHD/HRSR test facilities is described. These optical diagnostic systems are designed to characterize the internal operating environment of the MHD/HRSR components through non-intrusive, real-time, on-line analysis. The present stage of development of each instrument is discussed. A performance evaluation of these packaged, microprocessor-controlled, optical diagnostic system is presented in relation to their field-operation.

The Radiation Incident Safety Committee: Supporting Cancer Programs in the Delivery of High Quality Radiation Treatment

Existing languages provide good support for typeful programming of stand-alone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper, we discuss programming-language support for such systems, focussing on their typing and naming issues. We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately built programs. The main features are (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type safety of associated values, for example, values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility. These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language run-time from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries.

Existing languages provide good support for typeful programming of standalone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper we discuss programminglanguage support for such systems, focussing on their typing and naming issues.We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately-built programs. The main features are: (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type-safety of associated values, e.g. values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility.These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language runtime from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries.

Anomaly detection is very important for modern network service. Yet it is still a big challenge to conduct effective anomaly detection due to the high rate of service data and the complex correlations among them. Owing to the powerful query language and performance potential, complex event processing (CEP) is very suitable for this situation. In this paper, we present NEPnet, a high-performance and scalable monitoring system, which can process events for anomaly detection of network service in real time. NEPnet is based on CEP and provides a SQL-like language supporting various event correlations. On accepting user-defined queries as input, NEPnet builds a tree-based monitoring net for detailed anomaly detection. Considering the anomaly features of network service, the monitoring net utilizes limit trigger, predicate index and route table for different types of processing nodes in it. Our preliminary experiment results show that NEPnet can effectively detect anomaly of network service, with a high-speed of 100,000 events per second and 3~6 times faster than Esper, a general CEP engine.

Event processing will play an increasingly important role in constructing distributed applications that can immediately react to critical events. In this paper we describe the CEDR language for expressing complex event queries that filter and correlate events to match specific patterns, and transform the relevant events into new composite events for the use of monitoring applications. Stream-based execution of these standing queries offers instant insight for users to see what is occurring in their systems and to take time-critical actions.KeywordsEvent TypeEvent ProcessingComposite EventEvent PatternPattern DetectionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In the context of statically typed, class-based languages , we investigate classes that can be extended with trait composition. A trait is a collection of methods without state; it can be viewed as an incomplete stateless class . Traits can be composed in any order, but only make sense when imported by a class that provides state variables and additional methods to disambiguate conflicting names arising between the imported traits. We introduce FeatherTrait Java (FTJ), a conservative extension of the simple lightweight class-based calculus Featherweight Java (FJ) with statically typed traits . In FTJ, classes can be built using traits as basic behavioral bricks; method conflicts between imported traits must be resolved explicitly by the user either by (i) aliasing or excluding method names in traits, or by (ii) overriding explicitly the conflicting methods in the class or in the trait itself. We present an operational semantics with a lookup algorithm, and a sound type system that guarantees that evaluating a well-typed expression never yields a message-not-understood run-time error nor gets the interpreter stuck. We give examples of the increased expressive power of the trait-based inheritance model. The resulting calculus appears to be a good starting point for a rigorous mathematical analysis of typed class-based languages featuring trait-based inheritance.

Traditionally, the organizational IT landscape is split between Business Process engines that are developed to handle process execution workloads and Complex Event Processing engines designed to search for event correlations in real time to derive actionable insights. For the benefit of process trustworthiness, this work focuses on combining the two engines, resulting in an enriched form of a process log that serves as an input to recently developed eXplainable Artificial Intelligence frameworks, yielding more adequate explanations for process execution outcomes. A designated methodology and a test scheme were created to systematically implement and evaluate our overall approach and its effectiveness in gaining situation-aware explainability. Specifically, we demonstrate our approach using a dataset populated for an illustrative process example, replaying its trace log against the PROTON CEP engine and feeding the result as an input for the SHAP explainer.KeywordseXplainable Artificial IntelligenceComplex Event ProcessingBusiness Processes ManagementSituation-Aware eXplainability

This thesis proposes a novel way of performing type checking, whose results are incremental, depending on the provided local information. This new way of type checking is called co-contextual, where all context information of expressions, methods, classes, etc., is removed. Instead, we introduce corresponding structures using requirements. Standard type systems are translated to the co-contextual ones systematically using dualism as technique. Type systems play an important role to prevent execution errors from occurring during runtime. They are used to check programs statically for potential errors. Programs are type checked against a given set of rules. Depending on these rules programs are well-typed or not. The set of these rules is called typing rules. Each type rule associates types to the constructs of a program given a certain context. There can be different forms of contexts, depending on the features of the typed programming language. Functional languages use a typing context of variables and their types; object-oriented (OO) languages use additional class tables. Class tables are used for example to ensure that method and class declarations are well-typed. Type checking is performed top-down. While traversing the syntax tree of a program, typing contexts are extended with information on the expressions and their types. In case of OO, class tables are extended with clauses from class declarations, including the class members, i.e., fields, methods, or constructors. Contexts are passed through the nodes of the syntax tree in order to coordinate type checking between them. Therefore, while traversing the syntax tree top-down, the type checker creates dependencies between otherwise independent subexpressions. This way, it inhibits incrementalization and parallelization of type checking. That is, a change to a node of the syntax tree would require to redo the type check of the whole syntax tree. In this thesis a novel formulation of type systems is proposed, in order to remove dependencies between subexpressions. We propose a co-contextual formulation of typing rules that depends only on the local program constructs, e.g., expressions, methods, classes. The co-contextual typing rules have as conclusion a type and sets of requirements. That is, contexts and class tables are replaced by the dual concept of context and class table requirements. In addition, operations on contexts and class tables are replaced by new dual operations on requirements. The co-contextual type checker traverses a syntax tree bottom-up and merges context requirements of independently checked subexpressions. We describe a method for systematically constructing a co-contextual formulation of type rules from a regular context-based formulation and we show how co-contextual type rules give rise to incremental type checking. We derive co-contextual type checkers for functional and OO languages. As a representative of functional languages we consider PCF and extensions of it: records, parametric polymorphism, structural subtyping and let-polymorphism. Also, we investigate featherweight java (FJ) as the basis of OO languages and extensions of it: method overloading and generics. We build a1 co-contextual type checker for FJ enabling key features of OO languages: subtype polymorphism, nominal typing and implementation inheritance. The dualism between the co-contextual and contextual type systems preserves the correctness of the contextual calculus. That is, we prove the correctness of the co-contextual calculus via the equivalence between contextual type rules and their co-contextual formulations. We implemented an incremental type checker for PCF along with a performance evaluation showing that co-contextual type checking has performance comparable to standard context-based type checking, and incrementalization can improve performance significantly. Regarding FJ, we implemented a co-contextual type checker with incrementalization and compared its performance against javac on a number of realistic programs. Our performance evaluation shows significant speedups for the co-contextual type checker with incrementalization in comparison to javac.

Management architectures as well as protocols for accessing managed entities and exchanging management information are well developed in standards. On the other hand developments in open distributed processing (ODP) are of recognized importance for network and service management. Their generic features fit well into the geographically extended, multiple vendor and heterogeneous environment of communication networks. As a third ongoing development asynchronous transfer mode (ATM) broadband integrated services digital networks (B-ISDN) offer challenging problems for resource allocation, network performance and quality of service (QoS) evaluation in real time. The paper shows how performance monitoring and evaluation for ATM networks can greatly profit from the features of a distributed system environment (DSE). The extreme flexibility offered by the ATM principle requires a rich and reusable set of servers accomplishing coordinated performance evaluation tests. DSE transparencies are an excellent match to corresponding management applications (MA) requirements, so that tests can be performed in a distributed, flexible and adaptable way under a conceptually simple architecture. The paper draws extensively from a non-distributed counterpart, i.e. an existing sophisticated ATM test and analysis tool developed under the "Research for Advanced Communications in Europe" (RACE) program, R1083 PARASOL project.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

In this study we take an ‘above the clause’ perspective on the conceptualisation of complex events of Irish English and Modern Irish within a functional Role and Reference Grammar perspective, using corpus based data. Functional models of language generally assume some layered structure of the clause, the noun phrase and the word. (Nolan 2012a, 2012b; Van Valin 2005). While excellent work has heretofore been achieved at clause level, the description of important linguistic phenomena above the clause has often been somewhat neglected. In this regard, a central part of the grammar of every human language is the encoding of events and their participants in a clause. This motivates an ‘above the clause’ perspective to characterise the balance between uniformity of encoding and variability in encoding within and across languages. In the functional-cognitive paradigm, form and meaning are not separated into self-contained components. Instead, syntactic structures of varying degrees of complexity and abstraction are paired with their corresponding semantic structures. We argue that the interaction of semantic relations with the hierarchy of clausal linkage is at the strongest pole with the semantic relations covering phase and modifying subevents. We also argue that light verb constructions are formed pre-syntactically in the lexicon using and defend this by applying certain criteria as a diagnostic. The function of light verbs in these constructions is to modulate the realisation of event and sub-event semantics into syntax. We provide evidence of the dynamicity in conceptualising a complex event, considered as complex predication across constructions, in Irish English and Modern Irish.