Cities today have become highly dense, dynamic living areas for the majority of planet's population and also focal points of innovation, commerce, and growth in a highly modernized world. Due to its intensifying importance, cities need to transform into sustainable, smarter and credible places to enable a tenantable and comfortable life for their citizens. City data, which is the source of our digitized knowledge about the cities, is a highly important element to achive this goal as it is the main input to build complex city ecosystems and to solve particular problems that are encountered in the cities today. In this respect, this workshop will provide a major forum to identify the challenges and opportunities in terms of better managing city data and to reveal its discriminating importance in various applications in a city ecosystem. As city data becomes more widespread and prevailing, it poses novel research problems which importantly are open to the investigation of a broad community of researchers in various fields.

There is a growing need for systems that react automatically to events. While some events are generated externally and deliver data across distributed systems, others need to be derived by the system itself based on available information. Event derivation is hampered by uncertainty attributed to causes such as unreliable data sources or the inability to determine with certainty whether an event has actually occurred, given available information. Two main challenges exist when designing a solution for event derivation under uncertainty. First, event derivation should scale under heavy loads of incoming events. Second, the associated probabilities must be correctly captured and represented. We present a solution to both problems by introducing a novel generic and formal mechanism and framework for managing event derivation under uncertainty. We also provide empirical evidence demonstrating the scalability and accuracy of our approach.

Analysts have marked Event Processing as the most growing segment in enterprise computing during years 2008 and 2009, furthermore, this trend is expected to continue. Many of the large and medium software companies (IBM, Oracle, Microsoft, Sybase, Progress Software, Software AG and TIBCO) are now offering event processing products as well as a collection of smaller companies. Other indications for the emerging nature of this area are: extensive coverage by analysts as a separate area, the establishment of a dedicated research community with an annual conference (DEBS), and the establishment of a consortium that includes vendors and academic people as EPTS (Event Processing Technical Society) http://www.ep-ts.com/. The early event processing commercial products were mostly descendents of research projects rooted in multiple disciplines, some of them are data management disciplines (active databases, data stream management, temporal databases) and some are rooted in other areas (discrete event simulation, distributed computing, formal verification). The tutorial is intended for a technical audience that is interested in deep dive into understanding event processing. The audience will gain insights about event processing: What it really means? Where does it come from? How does it relate to research concepts (e.g. stream computing) as well as enterprise computing terms (e.g. Business Rules Management Systems)? The audience will also gain insights into the current state of the art, the leading architectures, the basic building blocks of event processing, and the various programming styles exemplified by code examples. Last but not least, the audience will gain insights about the current trends, and the research challenges that exist, this part will be based on the discussions in the Event Processing Dagstuhl seminar that was held in May 2010 http://www.dagstuhl.de/de/programm/kalender/semhp/?semnr=10201. The tutorial slides are available for public viewing on slideshare http://www.slideshare.net/search/slideshow?q=opher+etzion+%2B+vldb2010+tutorial The current generation of event processing products [14] has been preceded by several research projects in the 1990-ies: Rapide in Stanford [15], Infospheres in Cal Tech [2], Apama in Cambridge University [6] and Amit in IBM Haifa Research Lab [1]. In later phase there were some research project that have taken the stream oriented approach such as the Stanford Stream project [3] and Aurora [5]. A collection of start-up companies, many of them descendents of these projects have emerged, some survived, and some did not. From those who survived some were acquired by bigger companies. Event processing as a research discipline has multiple ancestors. In the database area it is a descendent of work done in active databases [19], temporal databases [12], and data stream management systems [9]. Other ancestors are inference rules, discrete event simulation, and distributed computing (pub/sub).

In many security-related contexts, a quick recognition of security hazards is required. Such recognition is challenging, since available information sources are often insufficient to infer the occurrence of hazards with certainty. This requires that the recognition of security hazard is carried out using inference based on patterns of occurrences distributed over space and time. The two main existing approaches to the inference of security hazards are a) custom-coded solutions, which are tailored to specific patterns, and cannot respond quickly to changes in the patterns of occurrences used for inference, and b) approaches based on direct statistical inferencing techniques, such as regression, which do not enable combining various kinds of evidence regarding the same hazard. In this work, we introduce a more generic formal framework which overcomes the aforementioned deficiencies, together with a case study illustrating the detection of DoS attacks.

Active database systems are systems that detect events and trigger actions as a result of this detection. Active capabilities are provided by a set of rules, such that each rule consists of three components (event, condition, and action). A major performance issue in active databases is the issue of relationships among rule components. Current implementations of triggers do not allow flexibility in the selection of transaction policies (partition of rules to transactions); the intertransaction timing policies of rules' components, the intratransaction policies of commit and abort dependencies, and synchronization issues. While these decisions have a substantial impact on the application performance, they are not provided as design primitives; one of the reasons for that is that it is very difficult to manually tune these decisions. In some research prototypes of active databases, these relationships are encapsulated into a set of coupling modes. Each coupling mode represents a combination of decisions about the partition of rule components to transactions, the relative timing within a transaction, and the interrelationships among these transactions. We describe a self-tuning model that operates on a general active database. The optimization model strives to minimize a programmable goal function that reflects the system designer's preferences and the system behavior and the applications' semantics through constraint definitions. The tuning model strives to optimize the mutual relationships among the system rules' components.

Mobile agents is an important enabling technology for certain types of real world applications such as e-commerce and workflows. While the potential benefits are appealing, this technology is not being used by many applications. This is largely attributed to the lack of components such as transactions and their integration with de-facto technologies. This work focuses on bridging this gap and devising an extended transactional model for mobile agents. The nature of mobile agents for autonomous processing and mobility introduces numerous challenges with respect to transactions which are originally, addressed in our work. First, given that, unstructured, execution scripts for agents, it is necessary to isolate side-effects that occur between two successive migrations to later be able to commit or abort them locally according to transaction semantics maintained across multiple hosts. Second, intra-transaction parallelism requires synchronization among multiple autonomous agents to join their processing and to rollback a transaction. Third, recovery from failures at a specific host, may necessitate maintaining a global state of a transaction across all the agent's destinations to determine how to proceed (e.g., repeat activities upon recovery). This paper presents a comprehensive transaction model for mobile agents and its deployment in the context of Java-based mobile agents. The overall complexity of transaction management is handled using a division of labor between an object-oriented programming model, protocols and a concurrency control mechanism. Specifically, the programming model maintains separation of concerns between mobility, transactions and application logic in order to cope with the aforementioned challenges.

Events are at the core of reactive and proactive applications, which have become popular in many domains.

Temporal data dependencies are high-level linguistic constructs that define relationships among values of data-elements in temporal databases. These constructs enable the support of schema versioning as well as the definition of consistency requirements for a single time-point and among values in different time-points. In this paper, we present a multiagent update process in a database with temporal data dependencies and schema versioning. The update process supports the evolution of dependencies over time and the use of temporal operators within temporal data dependencies. The temporal dependency language is presented, along with the temporal dependency graph-which serves as the executable data structure. A thorough discussion of the feasibility, performance, and consistency of the presented model is provided.

The research in materialization of derived data elements has dealt so far with the if issue of whether to physically store derived data elements. In the active database area, there has been some research on the how issue. We deal with the when issue, devising an optimization model to determine the optimal materialization strategy. The decision problem confronted by the optimization model deals with devising the materialization strategy that consists of a set of interdependent decisions about each derived data element. Each decision relates to two issues: Should the value of a derived data element be persistent? What is the required level of consistency of a derived value with respect to its derivers? For each derived data element, the decision is based on both its local properties and its interdependencies with other derived values. The optimization model is based on a heuristic algorithm that finds a local optimum in O(N/sup 2/) and a monitor that obtains feedback about the actual database performance. This optimization model is general and is not specific to any data model. Our experimental results show that a predictor for the optimal solution cannot be obtained in any intuitive or analytic way, due to the complexity of the involved considerations; thus, there is no obvious way to achieve these results without using the optimization model. This fact is a strong motivation for applying such an optimization model.

This paper presents an alternative to the E-C-A approach adopted by most active database models, in which, whenever a given event occurs the database triggers some actions. A reflective paradigm is implemented in a dependency-oriented fashion. According to this paradigm, data driven rules are specified as invariants. The invariants are translated to a dependency graph and the execution logic is being self-determined at run-time using this dependency graph. This architecture is presented and discussed as a solution for data-driven rules with an extension to support event-driven rules.