BeepBeep is a lightweight runtime monitor for AJAX web applications. It transparently checks in real time whether XML messages received and sent by the application satisfy a predefined interface specification.
Solving Equations on Words with Morphisms and AntimorphismsSylvain Hallé
Word equations are combinatorial equalities between strings of symbols, variables and functions, which can be used to model problems in a wide range of domains. While some complexity results for the solving of specific classes of equations are known, currently there does not exist a systematic equation solver. We present in this paper a reduction of the problem of solving word equations to Boolean satisfiability, and describe the implementation of a general-purpose tool that leverages existing SAT solvers for this purpose. Our solver will prove useful in the resolution of word equations, and in the computer-based exploration of various combinatorial conjectures.
How to Make Awesome SlideShares: Tips & TricksSlideShare
Turbocharge your online presence with SlideShare. We provide the best tips and tricks for succeeding on SlideShare. Get ideas for what to upload, tips for designing your deck and more.
SlideShare is a global platform for sharing presentations, infographics, videos and documents. It has over 18 million pieces of professional content uploaded by experts like Eric Schmidt and Guy Kawasaki. The document provides tips for setting up an account on SlideShare, uploading content, optimizing it for searchability, and sharing it on social media to build an audience and reputation as a subject matter expert.
Monitoring Business Process Compliance Across Multiple Executions with Stream...Sylvain Hallé
The document discusses stream processing and querying of process logs. It defines a process log as a mapping of case identifiers to traces, which are sequences of events. Queries can check properties of individual traces or perform aggregations across multiple traces. Hyper-queries generalize this to operate on the full log. Various methods of incrementally evaluating queries and hyper-queries are discussed as the log is produced, such as processing one case or event at a time. The state of the art in constraint and query languages is reviewed.
A Stream-Based Approach to Intrusion DetectionSylvain Hallé
1) The document proposes an approach to intrusion detection based on runtime verification by running monitors on every suffix of an event stream to detect multiple instances of patterns.
2) It describes techniques to prune redundant monitors by discarding those that remain in the initial state after the first event or reach the same state at the same step.
3) Retaining only the "progressing subsequence" of the stream that visits each new state in order further reduces the number of matches.
Event Stream Processing with BeepBeep 3Sylvain Hallé
Event logs and event streams can be found in software systems of very diverse kinds. Analyzing the wealth of information contained in these logs can serve multiple purposes. In this tutorial, the audience will learn about BeepBeep, a versatile Java library intended to make the processing of event streams (either offline or in realtime) both fun and simple. BeepBeep is the result of more than a decade of research led by a team at Laboratoire d’informatique formelle at Université du Québec à Chicoutimi (Canada). Over the past few years, BeepBeep has been involved in a variety of case studies, and provides built-in support for writing domain-specific languages. Recently, a complete textbook has been published on BeepBeep, testifying to the maturity that the system has acquired.
Smart Contracts-Enabled Simulation for Hyperconnected LogisticsSylvain Hallé
(Slides for a talk given in the journal-first track of the EDOC 2022 conference.)
The combination of the Internet of Things and blockchain-based technologies represents a real opportunity for supply chain and logistics protagonists, who need more dynamic, trustworthy and transparent tracking systems in order to improve their efficiency and strengthen customer confidence. In parallel, hyperconnected logistics promise more efficient and sustainable goods handling and delivery. This chapter shows how the Ethereum blockchain and smart contracts can be used to implement a shareable and secured tracking system for hyperconnected logistics. A simulation using the well-known AnyLogic software tool provides insights on the monitoring of properties depicting shipment lifecycle constraints through a stream of blockchain log events processed by BeepBeep 3, an open source stream processing engine.
Test Suite Generation for Boolean Conditions with Equivalence Class PartitioningSylvain Hallé
Boolean test input generation is the process of finding sets of values for variables of a logical expression such that a given coverage criterion is achieved. This paper presents a formal framework in which evaluating an expression produces a tree structure, and where a coverage criterion is expressed as equivalence classes induced by a particular transformation over these trees. It then defines many well-known coverage criteria as particular cases of this framework. The paper describes an algorithm to generate test suites by a reduction through a graph problem; this algorithm works in the same way regardless of the criterion considered. An experimental evaluation of this technique shows that it produces test suites that are in many cases smaller than existing tools.
Solving Equations on Words with Morphisms and AntimorphismsSylvain Hallé
Word equations are combinatorial equalities between strings of symbols, variables and functions, which can be used to model problems in a wide range of domains. While some complexity results for the solving of specific classes of equations are known, currently there does not exist a systematic equation solver. We present in this paper a reduction of the problem of solving word equations to Boolean satisfiability, and describe the implementation of a general-purpose tool that leverages existing SAT solvers for this purpose. Our solver will prove useful in the resolution of word equations, and in the computer-based exploration of various combinatorial conjectures.
How to Make Awesome SlideShares: Tips & TricksSlideShare
Turbocharge your online presence with SlideShare. We provide the best tips and tricks for succeeding on SlideShare. Get ideas for what to upload, tips for designing your deck and more.
SlideShare is a global platform for sharing presentations, infographics, videos and documents. It has over 18 million pieces of professional content uploaded by experts like Eric Schmidt and Guy Kawasaki. The document provides tips for setting up an account on SlideShare, uploading content, optimizing it for searchability, and sharing it on social media to build an audience and reputation as a subject matter expert.
Monitoring Business Process Compliance Across Multiple Executions with Stream...Sylvain Hallé
The document discusses stream processing and querying of process logs. It defines a process log as a mapping of case identifiers to traces, which are sequences of events. Queries can check properties of individual traces or perform aggregations across multiple traces. Hyper-queries generalize this to operate on the full log. Various methods of incrementally evaluating queries and hyper-queries are discussed as the log is produced, such as processing one case or event at a time. The state of the art in constraint and query languages is reviewed.
A Stream-Based Approach to Intrusion DetectionSylvain Hallé
1) The document proposes an approach to intrusion detection based on runtime verification by running monitors on every suffix of an event stream to detect multiple instances of patterns.
2) It describes techniques to prune redundant monitors by discarding those that remain in the initial state after the first event or reach the same state at the same step.
3) Retaining only the "progressing subsequence" of the stream that visits each new state in order further reduces the number of matches.
Event Stream Processing with BeepBeep 3Sylvain Hallé
Event logs and event streams can be found in software systems of very diverse kinds. Analyzing the wealth of information contained in these logs can serve multiple purposes. In this tutorial, the audience will learn about BeepBeep, a versatile Java library intended to make the processing of event streams (either offline or in realtime) both fun and simple. BeepBeep is the result of more than a decade of research led by a team at Laboratoire d’informatique formelle at Université du Québec à Chicoutimi (Canada). Over the past few years, BeepBeep has been involved in a variety of case studies, and provides built-in support for writing domain-specific languages. Recently, a complete textbook has been published on BeepBeep, testifying to the maturity that the system has acquired.
Smart Contracts-Enabled Simulation for Hyperconnected LogisticsSylvain Hallé
(Slides for a talk given in the journal-first track of the EDOC 2022 conference.)
The combination of the Internet of Things and blockchain-based technologies represents a real opportunity for supply chain and logistics protagonists, who need more dynamic, trustworthy and transparent tracking systems in order to improve their efficiency and strengthen customer confidence. In parallel, hyperconnected logistics promise more efficient and sustainable goods handling and delivery. This chapter shows how the Ethereum blockchain and smart contracts can be used to implement a shareable and secured tracking system for hyperconnected logistics. A simulation using the well-known AnyLogic software tool provides insights on the monitoring of properties depicting shipment lifecycle constraints through a stream of blockchain log events processed by BeepBeep 3, an open source stream processing engine.
Test Suite Generation for Boolean Conditions with Equivalence Class PartitioningSylvain Hallé
Boolean test input generation is the process of finding sets of values for variables of a logical expression such that a given coverage criterion is achieved. This paper presents a formal framework in which evaluating an expression produces a tree structure, and where a coverage criterion is expressed as equivalence classes induced by a particular transformation over these trees. It then defines many well-known coverage criteria as particular cases of this framework. The paper describes an algorithm to generate test suites by a reduction through a graph problem; this algorithm works in the same way regardless of the criterion considered. An experimental evaluation of this technique shows that it produces test suites that are in many cases smaller than existing tools.
Synthia: a Generic and Flexible Data Structure Generator (Long Version)Sylvain Hallé
Synthia is a versatile, modular and extensible Java-based data structure generation library. It is centered on the notion of "pickers", which are objects producing values of a given type on demand. Pickers are stateful and can be given as input to other pickers; this chaining principle can generate objects whose structure follows a complex pattern. The paper describes the core principles and key features of the library, including test input shrinking, provenance tracking, and object mutation.
Test Sequence Generation with Cayley Graphs (Talk @ A-MOST 2021)Sylvain Hallé
The paper presents a theoretical foundation for test sequence generation based on an input specification. The set of possible test sequences is first partitioned according to a generic "triaging" function, which can be created from a state-machine specification in various ways. The notion of coverage metric is then expressed in terms of the categories produced by this function. Many existing test generation problems, such as t-way state or transition coverage, become particular cases of this generic framework. We then present algorithms for generating sets of test sequences providing guaranteed full coverage with respect to a metric, by building and processing a special type of graph called a Cayley graph. An implementation of these concepts is then experimentally evaluated against existing techniques, and shows it provides better performance in terms of running time and test suite size.
Efficient Offline Monitoring of LTL with Bit Vectors (Talk at SAC 2021)Sylvain Hallé
We describe an extension of the BeepBeep stream processing library for the offline verification of arbitrary expressions of Linear Temporal Logic using bitmap manipulations. Experimental results show that, for complex LTL formulæ containing up to 20 operators, event traces can be evaluated at a throughput of millions of events per second and provide a considerable speed-up compared to the current implementation of the tool.
A Generic Explainability Framework for Function CircuitsSylvain Hallé
The document describes a framework for explaining the output of function circuits. It introduces the concept of functions as basic processing units that take inputs and produce outputs. Functions can be composed into circuits where the output of one function is the input of another. The framework represents circuits using designation graphs that trace the propagation of values between function inputs and outputs. It defines derivation operators that take a designation graph and reconstruct the derivation of an output value from input values through the functions in the circuit. This allows explaining how a circuit produced a particular output from its inputs.
Detecting Responsive Web Design Bugs with Declarative SpecificationsSylvain Hallé
Responsive Web Design (RWD) is a concept that is born from the need to provide users with a positive and intuitive experience, no matter what device they use. Complex Cascading Style Sheets (CSS) are used in RWD to smoothly change the appearance of a website based on the window width of the device being used. The paper presents an automated approach for testing these dynamic web applications, where a combination of dynamic crawling and back-end testing is used to automatically detect RWD bugs.
Streamlining the Inclusion of Computer Experiments in Research PapersSylvain Hallé
To run experiments on a computer, you probably write command-line scripts for various tasks: generate your data, save it into files, process and display them as plots or tables to include in a paper. But soon enough, your handful of “quick and dirty” files becomes a bunch of poorly documented scripts that generate and pass around all kinds of obscure temporary files. LabPal is a library that allows you to set up an environment for running experiments, collating their results and processing them.
Writing Domain-Specific Languages for BeepBeepSylvain Hallé
This paper describes a plug-in extension of the BeepBeep 3 event stream processing engine. The extension allows one to write a custom grammar defining a particular specification language on event traces. A built-in interpreter can then convert expressions of the language into chains of BeepBeep processors through just a few lines of code, making it easy for users to create their own domain-specific languages.
Real-Time Data Mining for Event StreamsSylvain Hallé
Information systems produce different types of event logs; in many situations, it may be desirable to look for trends inside these logs. We show how trends of various kinds can be computed over such logs in real time, using a generic framework called the trend distance workflow. Many common computations on event streams turn out to be special cases of this workflow, depending on how a handful of workflow parameters are defined. This process has been implemented and tested in a real-world event stream processing tool, called BeepBeep.
Technologies intelligentes d'aide au développement d'applications web (WAQ 2018)Sylvain Hallé
Surfez sur le web quelques heures, et vous trouverez sûrement un site ou une application qui contient un bogue dans son interface graphique. Que ce soit un bouton qui ne fonctionne pas, un rectangle partiellement caché ou mal positionné, il semble que les problèmes d’interface soient notoirement difficiles à traquer! Des technologies intelligentes pourraient-elles aider les concepteurs et les développeurs à mieux tester leurs interfaces? Au Laboratoire d’informatique formelle de l’Université du Québec à Chicoutimi, nous le croyons. Nous avons développé Cornipickle, un logiciel permettant à un développeur d’énoncer, dans un langage simple et lisible, une foule de contraintes sur le positionnement et le contenu des éléments d’une interface web. Nous verrons comment Cornipickle peut s’intégrer à une application existante, détecter des problèmes, identifier les éléments qui sont fautifs et même suggérer des correctifs. Ceci permet donc à un développeur de gagner beaucoup de temps lors de la recherche des problèmes.
This document provides an overview of BeepBeep 3, an open source event stream query engine developed for processing and analyzing event streams. It describes some key concepts including events, traces, functions, processors, synchronous processing, and various built-in processors like Filter, Window, and Cumulative. Processors can be composed together to perform multi-step queries on event streams. The engine aims to combine strengths from rule-based and complex event processing systems while providing extensibility through additional processor and function palettes.
A "Do-It-Yourself" Specification Language with BeepBeep 3 (Talk @ Dagstuhl 2017)Sylvain Hallé
This talk reviews the basic principles behind the BeepBeep 3 event stream processing engine, and the facilities it provides to help you design you own, domain-specific query language.
Event Stream Processing with Multiple ThreadsSylvain Hallé
The document discusses event stream processing using multiple threads. It presents the problem of processing an input event stream through a computation P to produce an output event stream as a single task. The solution involves splitting the computation P into parts that can be processed in parallel by multiple threads to improve efficiency.
The system is based on connecting simple computing units called processors into a pipeline. New thread-aware processors are introduced, including ones for non-blocking pushing of events, pull pipelines, and preemptive pulling. These allow existing queries to gain multi-threading capabilities with minimal changes. Experimental results on sample queries show speedups from 5% to 400% by adding just one thread-aware processor.
A Few Things We Heard About RV Tools (Position Paper)Sylvain Hallé
This document discusses feedback received about RV tools from various sources. It includes comments on making a profit from clicking buttons, whether the tools can already do certain things, if tasks only require a boolean, writing properties, how long tasks take, and if the data can be considered big data. The document also notes that some of the feedback is not specific to RV tools.
This presentation is an introduction to Complex Event Processing (CEP) intended for an practicioners of Runtime Verification. It first describes typical CEP problems, popular tools and their query languages. It then presents BeepBeep 3, an event stream processor that attempts to bridge the gap between RV and CEP. Thanks to BeepBeep’s generic architecture and flexible input language, queries and properties from both fields can be efficiently processed.
Decentralized Enforcement of Artifact LifecyclesSylvain Hallé
Artifact-centric workflows describe possible executions of a business process through constraints expressed from the point of view of the documents exchanged between principals. A sequence of manipulations is deemed valid as long as every document in the workflow follows its prescribed lifecycle at all steps of the process. So far, establishing that a given workflow complies with artifact lifecycles has mostly been done through static verification, or by assuming a centralized access to all artifacts where these constraints can be monitored and enforced. We present in this paper an alternate method of enforcing document lifecycles that requires neither static verification nor single-point access. Rather, the document itself is designed to carry fragments of its history, protected from tampering using hashing and public-key encryption. Any principal involved in the process can verify at any time that a document’s history complies with a given lifecycle. Moreover, the proposed system also enforces access permissions: not all actions are visible to all principals, and one can only modify and verify what one is allowed to observe.
Chasing Bugs with the BeepBeep Event Stream ProcessorSylvain Hallé
Runtime verification is the process of observing a sequence of events generated by a running system and comparing it to some formal specification for potential violations. We show how the use of the BeepBeep event stream processor can greatly speed up the testing phase of a video game under development, by automating the detection of bugs when the game is being played. This process generalizes to a wide number of other use cases, including web application debugging and network intrusion detection.
Activity Recognition Through Complex Event Processing: First Findings Sylvain Hallé
The activities of daily living of a patient in a smart home environment can be detected to a large extent by the real-time analysis of characteristics of the habitat's electrical consumption. However, reasoning over the conduct of these activities occurs at a much higher level of abstraction than what the sensors generally produce. In this paper, we leverage the concept of Complex Event Processing (CEP), in which low-level data streams are progressively transformed into higher-level ones, to the task of activity recognition. We show how the use of an appropriate representation for each level of abstraction can greatly simplify the process. We also report on the use of an existing event stream processor to successfully implement the complete chain, from low-level sensor data up to a sequence of discrete and high-level actions.
Synthia: a Generic and Flexible Data Structure Generator (Long Version)Sylvain Hallé
Synthia is a versatile, modular and extensible Java-based data structure generation library. It is centered on the notion of "pickers", which are objects producing values of a given type on demand. Pickers are stateful and can be given as input to other pickers; this chaining principle can generate objects whose structure follows a complex pattern. The paper describes the core principles and key features of the library, including test input shrinking, provenance tracking, and object mutation.
Test Sequence Generation with Cayley Graphs (Talk @ A-MOST 2021)Sylvain Hallé
The paper presents a theoretical foundation for test sequence generation based on an input specification. The set of possible test sequences is first partitioned according to a generic "triaging" function, which can be created from a state-machine specification in various ways. The notion of coverage metric is then expressed in terms of the categories produced by this function. Many existing test generation problems, such as t-way state or transition coverage, become particular cases of this generic framework. We then present algorithms for generating sets of test sequences providing guaranteed full coverage with respect to a metric, by building and processing a special type of graph called a Cayley graph. An implementation of these concepts is then experimentally evaluated against existing techniques, and shows it provides better performance in terms of running time and test suite size.
Efficient Offline Monitoring of LTL with Bit Vectors (Talk at SAC 2021)Sylvain Hallé
We describe an extension of the BeepBeep stream processing library for the offline verification of arbitrary expressions of Linear Temporal Logic using bitmap manipulations. Experimental results show that, for complex LTL formulæ containing up to 20 operators, event traces can be evaluated at a throughput of millions of events per second and provide a considerable speed-up compared to the current implementation of the tool.
A Generic Explainability Framework for Function CircuitsSylvain Hallé
The document describes a framework for explaining the output of function circuits. It introduces the concept of functions as basic processing units that take inputs and produce outputs. Functions can be composed into circuits where the output of one function is the input of another. The framework represents circuits using designation graphs that trace the propagation of values between function inputs and outputs. It defines derivation operators that take a designation graph and reconstruct the derivation of an output value from input values through the functions in the circuit. This allows explaining how a circuit produced a particular output from its inputs.
Detecting Responsive Web Design Bugs with Declarative SpecificationsSylvain Hallé
Responsive Web Design (RWD) is a concept that is born from the need to provide users with a positive and intuitive experience, no matter what device they use. Complex Cascading Style Sheets (CSS) are used in RWD to smoothly change the appearance of a website based on the window width of the device being used. The paper presents an automated approach for testing these dynamic web applications, where a combination of dynamic crawling and back-end testing is used to automatically detect RWD bugs.
Streamlining the Inclusion of Computer Experiments in Research PapersSylvain Hallé
To run experiments on a computer, you probably write command-line scripts for various tasks: generate your data, save it into files, process and display them as plots or tables to include in a paper. But soon enough, your handful of “quick and dirty” files becomes a bunch of poorly documented scripts that generate and pass around all kinds of obscure temporary files. LabPal is a library that allows you to set up an environment for running experiments, collating their results and processing them.
Writing Domain-Specific Languages for BeepBeepSylvain Hallé
This paper describes a plug-in extension of the BeepBeep 3 event stream processing engine. The extension allows one to write a custom grammar defining a particular specification language on event traces. A built-in interpreter can then convert expressions of the language into chains of BeepBeep processors through just a few lines of code, making it easy for users to create their own domain-specific languages.
Real-Time Data Mining for Event StreamsSylvain Hallé
Information systems produce different types of event logs; in many situations, it may be desirable to look for trends inside these logs. We show how trends of various kinds can be computed over such logs in real time, using a generic framework called the trend distance workflow. Many common computations on event streams turn out to be special cases of this workflow, depending on how a handful of workflow parameters are defined. This process has been implemented and tested in a real-world event stream processing tool, called BeepBeep.
Technologies intelligentes d'aide au développement d'applications web (WAQ 2018)Sylvain Hallé
Surfez sur le web quelques heures, et vous trouverez sûrement un site ou une application qui contient un bogue dans son interface graphique. Que ce soit un bouton qui ne fonctionne pas, un rectangle partiellement caché ou mal positionné, il semble que les problèmes d’interface soient notoirement difficiles à traquer! Des technologies intelligentes pourraient-elles aider les concepteurs et les développeurs à mieux tester leurs interfaces? Au Laboratoire d’informatique formelle de l’Université du Québec à Chicoutimi, nous le croyons. Nous avons développé Cornipickle, un logiciel permettant à un développeur d’énoncer, dans un langage simple et lisible, une foule de contraintes sur le positionnement et le contenu des éléments d’une interface web. Nous verrons comment Cornipickle peut s’intégrer à une application existante, détecter des problèmes, identifier les éléments qui sont fautifs et même suggérer des correctifs. Ceci permet donc à un développeur de gagner beaucoup de temps lors de la recherche des problèmes.
This document provides an overview of BeepBeep 3, an open source event stream query engine developed for processing and analyzing event streams. It describes some key concepts including events, traces, functions, processors, synchronous processing, and various built-in processors like Filter, Window, and Cumulative. Processors can be composed together to perform multi-step queries on event streams. The engine aims to combine strengths from rule-based and complex event processing systems while providing extensibility through additional processor and function palettes.
A "Do-It-Yourself" Specification Language with BeepBeep 3 (Talk @ Dagstuhl 2017)Sylvain Hallé
This talk reviews the basic principles behind the BeepBeep 3 event stream processing engine, and the facilities it provides to help you design you own, domain-specific query language.
Event Stream Processing with Multiple ThreadsSylvain Hallé
The document discusses event stream processing using multiple threads. It presents the problem of processing an input event stream through a computation P to produce an output event stream as a single task. The solution involves splitting the computation P into parts that can be processed in parallel by multiple threads to improve efficiency.
The system is based on connecting simple computing units called processors into a pipeline. New thread-aware processors are introduced, including ones for non-blocking pushing of events, pull pipelines, and preemptive pulling. These allow existing queries to gain multi-threading capabilities with minimal changes. Experimental results on sample queries show speedups from 5% to 400% by adding just one thread-aware processor.
A Few Things We Heard About RV Tools (Position Paper)Sylvain Hallé
This document discusses feedback received about RV tools from various sources. It includes comments on making a profit from clicking buttons, whether the tools can already do certain things, if tasks only require a boolean, writing properties, how long tasks take, and if the data can be considered big data. The document also notes that some of the feedback is not specific to RV tools.
This presentation is an introduction to Complex Event Processing (CEP) intended for an practicioners of Runtime Verification. It first describes typical CEP problems, popular tools and their query languages. It then presents BeepBeep 3, an event stream processor that attempts to bridge the gap between RV and CEP. Thanks to BeepBeep’s generic architecture and flexible input language, queries and properties from both fields can be efficiently processed.
Decentralized Enforcement of Artifact LifecyclesSylvain Hallé
Artifact-centric workflows describe possible executions of a business process through constraints expressed from the point of view of the documents exchanged between principals. A sequence of manipulations is deemed valid as long as every document in the workflow follows its prescribed lifecycle at all steps of the process. So far, establishing that a given workflow complies with artifact lifecycles has mostly been done through static verification, or by assuming a centralized access to all artifacts where these constraints can be monitored and enforced. We present in this paper an alternate method of enforcing document lifecycles that requires neither static verification nor single-point access. Rather, the document itself is designed to carry fragments of its history, protected from tampering using hashing and public-key encryption. Any principal involved in the process can verify at any time that a document’s history complies with a given lifecycle. Moreover, the proposed system also enforces access permissions: not all actions are visible to all principals, and one can only modify and verify what one is allowed to observe.
Chasing Bugs with the BeepBeep Event Stream ProcessorSylvain Hallé
Runtime verification is the process of observing a sequence of events generated by a running system and comparing it to some formal specification for potential violations. We show how the use of the BeepBeep event stream processor can greatly speed up the testing phase of a video game under development, by automating the detection of bugs when the game is being played. This process generalizes to a wide number of other use cases, including web application debugging and network intrusion detection.
Activity Recognition Through Complex Event Processing: First Findings Sylvain Hallé
The activities of daily living of a patient in a smart home environment can be detected to a large extent by the real-time analysis of characteristics of the habitat's electrical consumption. However, reasoning over the conduct of these activities occurs at a much higher level of abstraction than what the sensors generally produce. In this paper, we leverage the concept of Complex Event Processing (CEP), in which low-level data streams are progressively transformed into higher-level ones, to the task of activity recognition. We show how the use of an appropriate representation for each level of abstraction can greatly simplify the process. We also report on the use of an existing event stream processor to successfully implement the complete chain, from low-level sensor data up to a sequence of discrete and high-level actions.
Activity Recognition Through Complex Event Processing: First Findings
Browser-Based Enforcement of Interface Contracts in Web Applications with BeepBeep (Talk @ CAV 2009)
1. Browser-based Enforcement of
Interface Contracts in Web Applications
with BeepBeep
Sylvain Hallé, Roger Villemaire
University of California Université du Québec à Montréal
Santa Barbara, USA Montréal, CANADA
Sylvain Hallé
2. Some web services
E-Commerce Service
Compute Cloud
PayPal API: billing, express checkout
Shopping: like Amazon
Google Search, Google Maps, GMail, ...
Sylvain Hallé
10. Using web applications
XML request
<cartCreate> MyApplication.com
<item>2</item>
</cartCreate>
<cart>
<id>c</id>
<items>
<item>2</item>
</items>
</cart> XML
response
Sylvain Hallé
22. Constraints on the message trace
You cannot add the same item twice
to the shopping cart
2 2
c
! Atoms are properties over messages...
Sylvain Hallé
23. Constraints on the message trace
You cannot add the same item twice
to the shopping cart
G ( 2
Þ ØF
2
c
(
! Atoms are properties over messages...
! + LTL operators...
Sylvain Hallé
24. Constraints on the message trace
You cannot add the same item twice
to the shopping cart
(
G "i
i
Þ ØF
i
c
(
! Atoms are properties over messages...
! + LTL operators...
! + quantification on elements
Sylvain Hallé
25. Constraints on the message trace
You cannot add the same item twice
to the shopping cart
(
G "i
i
Þ ØF
i
c
(
! Atoms are properties over messages...
! + LTL operators...
! + quantification on elements } LTL-FO+
Sylvain Hallé
36. Adding BeepBeep to a real application
Œ Copy BeepBeep to application folder
http://beepbeep.sourceforge.net
Sylvain Hallé
37. Adding BeepBeep to a real application
Œ Copy BeepBeep to application folder
http://beepbeep.sourceforge.net
Include BeepBeep
Sylvain Hallé
38. Adding BeepBeep to a real application
Œ Copy BeepBeep to application folder
http://beepbeep.sourceforge.net
Include BeepBeep
myapplication.html
<html>
<head>
<title>My Application
</title>
<script type="text/javascript"
href="myapplication.js"/>
</head>
<body>
...
</body>
</html>
Sylvain Hallé
39. Adding BeepBeep to a real application
Œ Copy BeepBeep to application folder
http://beepbeep.sourceforge.net
Include BeepBeep
myapplication.html
<html>
<head>
<title>My Application
</title>
<script type="text/javascript"
href="myapplication.js"/>
<script type="text/javascript"
href="beepbeep.js"/>
</head>
<body>
...
</body>
</html>
Sylvain Hallé
40. Adding BeepBeep to a real application
Œ Copy BeepBeep to application folder
http://beepbeep.sourceforge.net
Include BeepBeep
myapplication.html myapplication.js
<html>
<head> // Initializations
<title>My Application ...
</title>
<script type="text/javascript" req = new XMLHttpRequest();
href="myapplication.js"/>
<script type="text/javascript" ...
href="beepbeep.js"/>
</head> function abc()
<body> {
... ...
</body> req.send(some_message);
</html> }
Sylvain Hallé
41. Adding BeepBeep to a real application
Œ Copy BeepBeep to application folder
http://beepbeep.sourceforge.net
Include BeepBeep
myapplication.html myapplication.js
<html>
<head> // Initializations
<title>My Application ...
</title>
<script type="text/javascript" req = new XMLHttpRequestBB();
href="myapplication.js"/>
<script type="text/javascript" ...
href="beepbeep.js"/>
</head> function abc()
<body> {
... ...
</body> req.send(some_message);
</html> }
Sylvain Hallé
42. Adding BeepBeep to a real application
Ž Obtain (or create) a contract file with LTL-FO+ formulae
# ---------------------------------------------------------------
# BeepBeep contract file for the Amazon ECS
# ---------------------------------------------------------------
% To create a cart, you must put at least one item
; G ([x1 /CartCreate/Operation] (((x1) = ({CartCreate})) ->
(<x2 /CartCreate/Items/Item/ASIN> ({TRUE}))))
% You can only create a cart once
; G ([x1 /CartCreate/Operation] (((x1) = ({CartCreate})) ->
(X (G (!(<x2 /CartCreate/Operation> ((x2) = ({CartCreate}))))))))
% No CartAdd can occur before a CartCreate
; (!(<x1 /CartAdd/Operation> ((x1) = ({CartAdd})))) U
(<x2 /CartCreate/Operation> ((x2) = ({CartCreate})))
% You cannot add the same item twice to the shopping cart
; G ([i /CartCreate/Items/Item/ASIN] (X (G
([j /CartAdd/Items/Item/ASIN] (!((i) = (j)))))))
Sylvain Hallé
44. Experimental results
Sample property: "each car entering in a parking lot must exit
before entering again"
< 5 ms/msg.
Time per message (ms)
Trace length
Hallé & Villemaire, EDOC 2008
Sylvain Hallé
48. Take-home points
1. Constraints involving temporal operators and quantification
on message contents arise naturally in real web applications
Sylvain Hallé
49. Take-home points
1. Constraints involving temporal operators and quantification
on message contents arise naturally in real web applications
2. An extension of LTL can formalize them: LTL-FO+
Sylvain Hallé
50. Take-home points
1. Constraints involving temporal operators and quantification
on message contents arise naturally in real web applications
2. An extension of LTL can formalize them: LTL-FO+
3. Runtime monitoring of these constraints can be done
efficiently, even with quantification
Sylvain Hallé
51. Take-home points
1. Constraints involving temporal operators and quantification
on message contents arise naturally in real web applications
2. An extension of LTL can formalize them: LTL-FO+
3. Runtime monitoring of these constraints can be done
efficiently, even with quantification
4. BeepBeep is a tool that allows it with
minimal modifications on real applications
http://beepbeep.sourceforge.net/
Sylvain Hallé