Search

In order to remain competitive, more and more industries are embracing the concept of industry 4.0 and trying to improve their manufacturing systems. A modern manufacturing system is the one which provides the industry with flexibility to adopt to the constantly changing market demands. In order to be flexible, the manufacturing system should be able to make better use of the shop floor data. Data from the shop floor level should be available in real time to facilitate the decision making process. The process of implementation of an event driven architecture along with services in a real time production environment will be discussed in this paper. For this purpose, pedal car line at Scania Sodertalje is analyzed for the implementation of event driven architecture. The old hand held tools and controllers at the assembly stations were replaced with modern wireless power tools and the latest power focus 6000 controller. The data generated by the power tools was converted into a standard format so that it can easily be interpreted by a message broker. The messages were published on Kafka message bus where other systems were able to subscribe and consume the data. A couple of endpoints were created, one was a REST API that subscribed to the message bus and consumed the data from power tools and visualized key parameters for the operator at the shop floor in real time. Second service created was to calculate certain KPIs and visualize them in graphs form for the maintenance and production engineers. This implementation demonstrated that an event driven architecture such as LISA can be implemented on a real shop floor making real time data available to different systems.

Obravnavan je potek razvoja sodobne aplikacije v oblaku, ki je namenjena piscem spletnih zgodb. Seznanimo se s tehnologijami in arhitekturami, o katerih se dandanes pogosto sliˇsi, ko je govora o računalništvu v oblaku – različni tipi podatkovnih baz (baze SQL, NoSQL, ipd.), programski jeziki (Java, JavaScript – Node.JS, Go), arhitekture aplikacij (monolitna, mikro-storitvena, funkcijska, dogodkovno-vodena). Razvoj zaobjema analizo funkcionalnih in nefunkcionalnih zahtev aplikacije, pripravo načrta arhitekture aplikacije in podatkovnih modelov, izbor ustreznih tehnologij, vzpostavitve razvojnega okolja, pripravo osnovne strukture projekta, razvoj uporabniškega vmesnika in zalednega sistema. Uporabljen izbor je evalviran na podlagi kompleksnosti razvoja, ustreznosti definiranim zahtevnostim in stroškom obratovanja aplikacije. Aplikacija je razvita za platformo oblačnih storitev Google Cloud Platform, uporabniški vmesnik z uporabo ogrodja Angular. Addressed is the course of developing a modern cloud computing application, meant for web-novels writers. We are introduced to modern-day technologies and architectures for cloud computing–different types of databases (traditional SQL, modern NoSQL, etc.), programming languages (Java, JavaScript–Node.JS, Go), application architectures (monolithic, microservices, functional, event-driven). The development comprises of analyzing functional and non-functional requirements, preparing architectural design and data models, selecting appropriate technologies, establishing the development environment, preparing a basic project structure, developing user interface and back-end system. Selection is evaluated based on development complexity, compliance with defined requirements, and application deployment costs. Application is developed for Google Cloud Platform, user interface using Angular framework.

IoT devices usually operate in random-sparse-event scenarios (Fig. 20.2.1). To avoid missing events, traditionally a periodic-wake-up frequency [1] must be orders of magnitude higher than the average event rate, wasting huge power. An emerging event-driven approach seeks to trigger a power-hungry highperformance system (HPS) using an ultra-low-power wake-up circuit. State-of-the-art wake-up chips with DSP-based and neural-network-based feature extraction consume 12nW [2], 1µW [3], and 142nW [4]. However, they can only respond to dedicated voice/acoustic signal of low bandwidth. Another wake-up chip with 2.2µW power [5] shows potential for general purpose use, however, the pattern recognition technology is complicated and power hungry for many IoT devices. Considering the cost, the versatile and continuously emerging IoT applications, and time-to-market, a general-purpose wake-up chip defined by software with ultra-low power is highly desired, but not yet reported.

Autonomous driving is inducing a paradigm shift in the automotive electrical system industry towards higher process transparency and reliability. In manufacturing, this requires the implementation of a traceability system, which allows comprehending the product’s configuration and batch structure as well as its process history, including quality tests, resource data, and machine parameters. In this research, we specify the traceability scheme for automotive electrical systems with regard to the newly arising requirements in the context of autonomous driving. We further derive an aligned traceability information system architecture based on manufacturing data events, in which relevant traceability functionalities are provided through microservices. Our research, therefore, overcomes the shortcomings of state-of-the-art monolithic traceability solutions, contributing a scalable and configurable manufacturing data design, which leverages data utilization in distributed and complex manufacturing flows.

View references (37)[Context] Data-intensive systems, a.k.a. big data systems (BDS), are software systems that handle a large volume of data in the presence of performance quality attributes, such as scalability and availability. Before the advent of big data management systems (e.g. Cassandra) and frameworks (e.g. Spark), organizations had to cope with large data volumes with custom-tailored solutions. In particular, a decade ago, Tecgraf/PUC-Rio developed a system to monitor truck fleet in real-time and proactively detect events from the positioning data received. Over the years, the system evolved into a complex and large obsolescent code base involving a costly maintenance process. [Goal] We report our experience on replacing a legacy BDS with a microservice-based event-driven system. [Method] We applied action research, investigating the reasons that motivate the adoption of a microservice-based event-driven architecture, intervening to define the new architecture, and documenting the challenges and lessons learned. [Results] We perceived that the resulting architecture enabled easier maintenance and faultisolation. However, the myriad of technologies and the complex data flow were perceived as drawbacks. Based on the challenges faced, we highlight opportunities to improve the design of big data reactive systems. [Conclusions] We believe that our experience provides helpful takeaways for practitioners modernizing systems with data-intensive requirements. © 2020 IEEE.

Microservices is one of the most commonly used buzzword of the systems architecture industry and is being adopted by several of the world’s largest technology companies such as Netflix, Uber and Amazon. The architecture which embraces splitting up your system in smaller independent units is an extension of the service-oriented architecture and an opponent of the monolithic architecture. Being a top buzzword and promises of extreme scalability has spiked the interest for microservices, but unlike the relatively simple monolithic architecture the complexity of microservices creates a new set of obstacles. This work sheds a light on these issues and implements solutions for some of the most frequent problems using a case study. The study shows that while microservices can help reduce the inner complexity of a system, it greatly increases the outer complexity and creates the need for a variety of tools aimed at distributed systems. It also concludes that communication and data storage are two of the most frequently occurring issues when developing microservices with the most difficult one being how you reason with and structure your data, especially for efficient queries across microservices. Microservices eller så kallade mikrotjänster är ett ofta förekommande buzzword inom systemarkitektur och nyttjas av flera teknikjättar som exempelvis Netflix, Uber och Amazon. Arkitekturen som bygger på att dela upp sina system i mindre oberoende delar är en utbyggnad av den tjänstorienterade arkitekturen och numera motståndare till den klassiska monolitiska arkitekturen. En plats högt upp på trendlistan och lovord om extrem skalbarhet har gjort att intresset för mikrotjänster är enormt, men till skillnad från den relativt simpla monolitiska arkitekturen skapar komplexiteten hos mikrostjänster en rad nya hinder. Det här arbetet belyser dessa hinder och implementerar även lösningar för de vanligaste förekommande problemen med hjälp av en fallstudie. Resultatet visar att även fast en mikrotjänstarkitektur kan minska systemets interna komplexitet så leder det till en markant ökning av systemets yttre komplexitet och det skapas ytterligare behov av en mängd olika verktyg och tjänster designade för distribuerade system. Studien visar också att de två mest förekommande problemen vid utveckling av en mikrotjänstarkitektur är kommunikation och datalagring där hantering och struktur av data är den mest komplicerade och kräver mycket kunskap, speciellt för att skapa effektiva datasökningar som sträcker sig över flera mikrotjänster.

Seit der Entstehung von High-Level-Programmiersprachen in den 1940er Jahren wurde fast die gesamte Softwareentwicklung auf ähnliche „literarische“ Weise durchgeführt. Während einige visuelle Programmiermethoden für hochspezifische Aufgaben entwickelt wurden (z.B. grundlegende Webseiten, modulare Logistiksoftware, usw.), werden die meisten der heutigen „ernsthaften“ Entwicklungsaufgaben immer noch über Textprogrammierung umgesetzt. Diese Arbeit stellt einen generischen Ansatz für die Softwareentwicklung vor, der nicht auf Textdarstellung, Syntax oder Semantik basiert, sondern auf visueller Komposition. Im Kern ist dieser Ansatz höchst nebenläufig (nur asynchrone Rückgaben, leicht austauschbare, lose gekoppelte Komponenten) und im Gegensatz zu bestehenden visuellen Programmiersystemen (z.B. DRAKON oder Scratch), welche funktionale Grundelemente (if, else, for, usw.) mittels grafischer Blöcke abbilden, ist das vorgestellte Entwicklungskonzept nicht nur unabhängig, sondern sogar stark agnostisch gegenüber einem potenziellen zugrunde liegenden (objektorientierten oder funktionalen) System. Darüber hinaus werden Software-Design-Prinzipien nicht vorgeschlagen oder angedeutet, sondern als grundlegender Teil des Entwicklungsprozesses inhärent durchgesetzt. Als solches wird der Entwicklungsfluss von oben nach unten vorgegeben, wobei Elemente durch Komposition aus anderen Elementen zusammengesetzt werden, die möglicherweise noch nicht existieren. Diese zugrunde liegenden Eigenschaften ermöglichen die Entwicklung von zukunftssichere Software, die eine variable Anzahl von Rechenkernen verwendet, leicht skalierbar, sezierbar (bei jeder Komponentenverbindung) und wiederverwendbar ist und gleichzeitig einheitliche komponentenbasierte Entwicklungsmethoden selbst auf Mikroebene bietet. Der Weg als auch die Suche nach einer solchen Entwicklungsmethode ist dabei das Kernstück dieser Arbeit. Since the genesis of high-level languages in the 1940s, almost all of software development has been conducted in a similar “literary” way. While some visual programming methods emerged for highly specific tasks (e.g. basic web pages, modular logistics software, etc.), most of today’s “serious” software development tasks are still carried out via textual programming. This thesis presents a generic approach to software development, which is not based upon textual representation, syntax, or semantics, but visual composition. At its core this approach is highly nonsequential (only asynchronous returns, easily exchangeable loosely coupled components) and in contrast to existing prized visual programming systems (e.g. DRAKON or Scratch), which may map functional primitives (if, else, for, etc.) to graphical blocks, the presented development concept is not only independent of, but even strongly agnostic towards a potential underlying (object-oriented or functional) system. Over and above that, software design principles are not suggested or hinted at but, as a fundamental part of the development process, intrinsically enforced. As such, the flow of development is purposefully constrained from top to bottom, whereby elements are created via composition from other elements, which may not yet exist. These properties could potentially allow for future-proof software which utilizes varying numbers of computing cores, is easily scalable, dissectible (at every component conjunction) and reusable, as well as easy to master and comprehend, while offering unified homogeneous component-based development methods, even on the micro scale. The way to, as well as search for, such an approach to software development is the centerpiece of this thesis.

During the discussions with different internal stakeholders and from market review, Telecommunications operator’s architecture team of IT department has concluded that there is a need to focus on old paradigm. Some of the operator’s systems are coupled with each other that causes issues during system development and during normal operations. If a system is malfunctioning or has a planned service break, it might have impacts to other systems and cause loss of sales since customers cannot be served. There was a wish to view the issue through event-driven architecture. An event is a significant change of state and the event can be viewed from system design point of view or computer science point of view among others. In this thesis, the events are limited to system and business events. A system event occurs inside of the software component, for instance, an internal log event. A business event reflects to real life events such as customer’s order to eCommerce platform where the order is the event of the interest. Event-driven architecture is a way to create systems or software that are highly decoupled thus enabling parallel development cycles. In addition, it enables a system where malfunctioning piece of system does not affect to other systems. Event-driven architecture enables also faster data transfer and a way to create new information by combining events. The goals of this thesis were to find out what is event-driven architecture, how to design and implement event-driven architecture through business cases and what kind of obstacles and possibilities a company may have. Literature review was used to define the meaning of the event-driven architecture. For design and implementing the event-driven architecture, both literature review and capability-based framework were used. The framework helps to create a roadmap for event-driven architecture for the company. The obstacles and possibilities are charted via expert interviews on the company’s personnel. The results of the interviews are applied to the capability-based and a tailored roadmap for the company was created. As summary, the result of the thesis is a roadmap for event-driven architecture. The roadmap was achieved by using expert interviews and capability-based framework that IT organization can use while engaging in development activities.

International audience; An effective crisis response requires up-to-date information. The crisis cell must reach for new, external, data sources. However, new data lead to new issues: their volume, veracity, variety or velocity cannot be managed by humans only, especially under high stress and time pressure. This paper proposes (i) a framework to enhance situation awareness while managing the 5Vs of Big Data, (ii) general principles to be followed and (iii) a new architecture implementing the proposed framework. The latter merges event-driven and model-driven architectures. It has been tested on a realistic flood scenario set up by official French services.

Node.js has been widely-used as an event-driven server-side architecture. To improve performance, a task in a Node.js application is usually divided into a group of events, which are non-deterministically scheduled by Node.js. Developers may assume that the group of events (named atomic event group) should be atomically processed, without interruption. However, the atomicity of an atomic event group is not guaranteed by Node.js, and thus other events may interrupt the execution of the atomic event group, break down the atomicity and cause unexpected results. Existing approaches mainly focus on event race among two events, and cannot detect high-level atomicity violations among a group of events. In this paper, we propose NodeAV, which can predictively detect atomicity violations in Node.js applications based on an execution trace. Based on happens-before relations among events in an execution trace, we automatically identify a pair of events that should be atomically processed, and use predefined atomicity violation patterns to detect atomicity violations. We have evaluated NodeAV on real-world Node.js applications. The experimental results show that NodeAV can effectively detect atomicity violations in these Node.js applications.

In the Internet-of-Things (IoT) things of the physical world communicate with humans and other objects by means of the Internet. The concept extends the traditional Internet of Computers (IoC) that uses computers such as desktop PC, notebooks or smartphones as access points to the Internet by a multitude of end points represented by physical objects. Since things, human beings but also events in the physical world possess various spatial properties, their actions, observations or happenings inhere geospatial information. Hence, the exchange of digital geospatial information in the IoT leads to the Geospatial IoT. The Geospatial IoT is fundamentally different from established geoinformation technologies. Things in the Geospatial IoT provide geodata with a much higher frequency and quantity. Its integration is foreseen as the most revolutionary change in the history of geoinformation technologies. The ubiquitous geodata collection and provisioning through the Geospatial IoT as an all-encompassing infrastructure holds huge potential for better spatially understanding, modeling and visualizing of our natural and artificial ecosystems. However, a lot of challenges occur in integrating spatial and spatiotemporal data from IoT devices into new or already established systems. Novel requirements concerning architectures, messaging mechanisms and technologies such as scalability or efficiency appear, which must be analyzed and considered when implementing an appropriate infrastructure. This thesis addresses different research questions regarding an infrastructure for the Geospatial IoT and its integration into established geoinformation technologies. Approaching these issues, typical concepts, architectures and buildings blocks of the IoT are investigated first. This holds especially for recent developments in the field of IoT communications on different layers. Based on these typical structures, a concept for a Geospatial IoT architecture is designed. The conceptual architecture uses GeoEvents as a base data type for exchanging spatiotemporal messages between actors in the Geospatial IoT. The data type is derived from real-world geospatial events and states, which represent occurrences and states of continuants. Basically, a GeoEvent is a four tuple with a name, a spatial component, a temporal component and a message payload. With that event type defined, a GeoEvent-driven architecture for the Geospatial IoT can be specified. It follows an event-driven pattern, so that GeoEvents are send to interested consumers when they occur. Thereby, consumers may specify their interest in GeoEvents by GeoSubscriptions. In the architecture, GeoEvents are distributed by a GeoEvent processing engine, which evaluates the meta information of the GeoEvents against filters of the GeoSubscriptions. The IoT communication protocol Message Queuing Telemetry Transport (MQTT) is chosen to implement the GeoEvent-driven architecture for the Geospatial IoT. It meets requirements for resource-constraint devices such as small message size and efficiency, but has also beneficial architectural properties such as the messaging paradigm or the scalability of the server. In the thesis, the topic-based publish/subscribe protocol MQTT is extended by a GeoEvent and a GeoSubscription data type. In the developed extension called GeoMQTT, new messages are introduced to encode these data types. A GeoMQTT broker distributes the GeoEvents between the clients based on the GeoSubscriptions. To achieve this, filtering capabilities on temporal and spatial components are integrated, so that GeoMQTT can be used as a content-based publish/subscribe protocol. Several clients in different programming languages are implemented, as well as a GeoMQTT-SN extension for unreliable networks. The latter one focuses especially on small message sizes. GeoMQTT is evaluated with respect to multiple requirements for IoT environments. The expressiveness of the message types as well as the efficiency of the subscribe mechanisms meet the requirements for the Geospatial IoT. Further, scalability is ensured by the GeoMQTT broker and, thus, prepared for a dynamically increasing number of things in the Geospatial IoT. Finally, the spatiotemporal messaging protocol GeoMQTT is integrated in established geoinformation technologies. For instance, a GeoMQTT plug-in for QGIS is implemented to receive GeoEvents in a desktop GIS in real-time. The WPS for executing geoprocesses is extended by new input and output data types, namely GeoPipes, so that processes on geospatial data streams can be invoked. Additionally, bridges to Sensor Web services and to REST servers provide end users or software agents access to historical or new GeoEvents by means of the WWW.The thesis approaches and solves some of the challenges and tasks occurring in building an infrastructure for the Geospatial IoT. The prototypical implementation of the GeoEvent-based architecture and its related services show that things in the Geospatial IoT can be interconnected efficiently by a spatiotemporal messaging mechanism. Real-time access is realizable by services and established geoinformation technologies may also participate. Nevertheless, there are still many ongoing issues to solve, which are addressed in the end of the thesis.

Choosing the appropriate architecture for a big data project is not a straightforward task. The architect needs to have knowledge in the problem domain, future application requirements, big data technology landscape and architectural patterns. Today’s dynamic business environment enforces constantly evolving big data applications, which often need to process thousands of messages per second. Solutions implementing microservices and Event Driven Architecture (EDA) could provide scalability and extensibility to the required application. The article will outline microservices and EDA challenges, advantages and potential problems concerning big data stream processing.

Sensor data offers a massive potential for the logistics sector. To achieve an optimal, effective and productive supply chain, operators and manufacturers are challenged to use this information and extract value from it. They have to comply with the main task of efficiently managing logistics processes as well as fulfilling requirements and guidelines. To do so, it is necessary to monitor all processes and understand exceptions and anomalies. Sensor and Internet of Things (IoT) data is the key for these tasks. Currently, the data is available but not (sufficiently) used. The heterogeneity of sensor data is a major obstacle for the usage. Therefore, we present an architecture, which addresses these challenges by integrating heterogenic data in well-formed data sets.

State changes over time are inherent characteristics of stateful applications. So far, there are almost no attempts to make the past application history programmatically accessible or even modifiable. This is primarily due to the complexity of temporal changes and a difficult alignment with prevalent programming primitives and persistence strategies. Retroactive computing enables powerful capabilities though, including computations and predictions of alternate application timelines, post-hoc bug fixes, or retroactive state explorations. We propose an event-driven programming model that is oriented towards serverless computing and applies retroaction to the event sourcing paradigm. Our model is deliberately restrictive, but therefore keeps the complexity of retroactive operations in check. We introduce retro-λ, a runtime platform that implements the model and provides retroactive capabilites to its applications. While retro-λ only shows negligible performance overheads compared to similar solutions for running regular applications, it enables its users to execute retroactive computations on the application histories as part of its programming model.

D63 the intelligent manufacturing process, the status fluctuation of the product quality could be reflected the stability of the manufacturing process to a certain extent. Aiming at the multi-dimensional heterogeneous information of the equipment operating and the product quality information, a new kind of two-level event-driven service BESPES architecture would be proposed. The hierarchical structure of events and services for multi-dimensional heterogeneous status information (MDHSIS) based on the status fluctuation would be analyzed, the flow would be established which would be used during the monitoring, responding and servicing process of the product quality information and the running status information in the intelligent manufacturing process. The virtualized mapping between the information resources and the event-driven services would be completed under the event-driven service system (SOA-EDA) and the fusion, status' associating analysis and decision of the multi-dimensional heterogeneous information of the intelligent manufacturing process would be realized. Through these above methods, the problems of manufacturing process monitoring and product quality controlling would be solved and a technical approach would be provided in order to monitor the reliably operating and the health level of the intelligent manufacturing process.

Today's exible demands and short product life cycles have lead to a modular thinking for machinery and plant engineering. A hidden challenge for this sector is the maintenance of plant documentation throughout the entire operating time of the machine components. This paper introduces an architecture for updating plant documentation. The concept is based on a exible masterslave hierarchy for IT-integrated machine components and aims at detecting physical changes in them. The standard data exchange format AutomationML functions as a decentralized and up-to-date virtual representation of each component carrying all types and contents of both construction and documentation disciplines.

Smart factory requires 4 Zero factors including Zero Waiting-time, Zero Inventory, Zero Defect, Zero Down-time) that needs IT convergence for production resources of 4M1E(Man, Machine, Material, Method, Energy) in real time and event processing in all type of manufacturing enterprises. This paper will be explaining about core emerging production IT convergence technologies including cyber device security, 4M1E integration, real time event driven architecture, common platform of manufacturing standard applications, smart factory to-be model for small and medium manufacturing enterprises.

In the near future, Internet of Things (IoT) will realize that sensors and processors embedded in every device and communicate with each other. In order to realize smart home, it is desirable for home appliances to autonomously communicate with each other, and do actions. To this end, we propose distributed autonomous control framework of home appliances based on event driven architecture where each home appliance works autonomously in accordance with Event-Condition-Action rules stored within each home appliance. We also design and implement the proposed framework and evaluate its effectiveness and practicality.

Part 1: Smart Manufacturing System Characterization; International audience; In order to meet the ever-changing customer demands, smart manufacturing needs to intelligently integrate and coordinate the entire manufacturing supply chain. Event-driven architecture has been considered as a promising enabler for smart manufacturing. However, in the primitive event-driven architecture all components work in parallel, and there are few frameworks or standards that deal with organizing and managing the components. This paper proposes an ontology based holonic event-driven architecture for smart manufacturing systems. Powered by the developed ontology model and Semantic Web technology, the ontology based architecture enables the distributed components in a smart manufacturing system to be configured autonomously and collaborate with each other even when they don’t know much about their counterpart.

Highly dynamic distributed applications often require flexible coordination among several autonomous components. Space-based middleware provides a suitable, data-driven coordination paradigm for such scenarios, where distributed peers exchange data and commands in a scalable and decoupled way using shared tuple spaces. In its basic form, such a middleware supports access to a data storage and (blocking) queries on the stored tuples. However, in many cases the injection of additional server-side logic would ease the development of complex applications, as the semantics of the tuple space can be adapted to domain-specific requirements.This paper introduces reactive programming features for XVSM, a space-based middleware that enhances the tuple space concept with powerful coordination mechanisms. We present a comprehensive extension mechanism that supports the execution of application logic in reaction to composite and time-based events. As an example for the feasibility of the approach, we provide a bootstrapped solution for a leasing mechanism that manages the lifetime of data in the space.

Spiking neural networks (SNNs) represent the third generation of neural networks and are expected to enable new classes of machine learning applications. However, evaluating large-scale SNNs (e.g., of the scale of the visual cortex) on power-constrained systems requires significant improvements in computing efficiency. A unique attribute of SNNs is their event-driven nature—information is encoded as a series of spikes, and work is dynamically generated as spikes propagate through the network. Therefore, parallel implementations of SNNs on multi-cores and GPGPUs are severely limited by communication and synchronization overheads. Recent years have seen great interest in deep learning accelerators for non-spiking neural networks, however, these architectures are not well suited to the dynamic, irregular parallelism in SNNs. Prior efforts on specialized SNN hardware utilize spatial architectures, wherein each neuron is allocated a dedicated processing element, and large networks are realized by connecting multiple chips into a system. While suitable for large-scale systems, this approach is not a good match to size or cost constrained mobile devices. We propose PEASE, a Programmable Event-driven processor Architecture for SNN Evaluation. PEASE comprises of Spike Processing Units (SPUs) that are dynamically scheduled to execute computations triggered by a spike. Instructions to the SPUs are dynamically generated by Spike Schedulers (SSs) that utilize event queues to track unprocessed spikes and identify neurons that need to be evaluated. The memory hierarchy in PEASE is fully software managed, and the processing elements are interconnected using a two-tiered bus-ring topology matching the communication characteristics of SNNs. We propose a method to map any given SNN to PEASE such that the workload is balanced across SPUs and SPU clusters, while pipelining across layers of the network to improve performance. We implemented PEASE at the RTL level and synthesized it to IBM 45 technology. Across 6 SNN benchmarks, our 64-SPU configuration of PEASE achieves 7.1×−17.5× and 2.6×−5.8× speedups, respectively, over software implementations on an Intel Xeon E5-2680 CPU and NVIDIA Tesla K40C GPU. The energy reductions over the CPU and GPU are 71×−179× and 198×−467×, respectively.

International audience; Recent advances in Web 3D technology have opened a wide area for Collaborative Virtual Environments (CVE). While CVE are often viewed in a concurrency context, they need to provide a satisfying experience in terms of consistency latency and recovery. Because (i) Event-Driven architectures (EDA) are well-suited for distributed application and (ii) traditional communication architecture (client-server) can be limited in such situations, this paper presents a loosely-coupled approach combining event sourcing with a hybrid communication architecture. This model aims to ensure a strong versioning system and resource availability for collaborative 3D object manipulation in a web browser. To evaluate acceptance of our system, we conducted a user study on groups of users working simultaneously on 3D cooperative assembly tasks. The results detail the users' involvement evolution, qualitative appreciations of the system's usability and the collaborative features.

Recent advances in Web 3D technology have opened a wide area for Collaborative Virtual Environments (CVE). While CVE are often viewed in a concurrency context, they need to provide a satisfying experience in terms of consistency latency and recovery. Because (i) Event-Driven architectures (EDA) are well-suited for distributed application and (ii) traditional communication architecture (client-server) can be limited in such situations, this paper presents a loosely-coupled approach combining event sourcing with a hybrid communication architecture. This model aims to ensure a strong versioning system and resource availability for collaborative 3D object manipulation in a web browser. To evaluate acceptance of our system, we conducted a user study on groups of users working simultaneously on 3D cooperative assembly tasks. The results detail the users' involvement evolution, qualitative appreciations of the system's usability and the collaborative features.

The importance of the Event-Driven Architecture (EDA) has never been greater. Web servers and the IoT alike have begun to adopt the EDA, and the popular server-side EDA framework, Node.js, boasts the world's largest package ecosystem. While multi-threaded programming has been well studied in the literature, concurrency bug characteristics and useful development tools remain largely unexplored for server-side EDA-based applications.We present the first (to the best of our knowledge) concurrency bug characteristic study of real world open-source event-driven applications, based in Node.js. Like multithreaded programs, event-driven programs are prone to concurrency bugs like atomicity violations and order violations. Our study shows the forms that atomicity violations and ordering violations take in the EDA context, and points out the limitations of existing concurrency error detection tools developed for client-side EDA applications.Based on our bug study, we propose Node.fz, a novel testing aid for server-side event-driven programs. Node.fz is a schedule fuzzing test tool for event-driven programs, embodied for server-side Node.js programs. Node.fz randomly perturbs the execution of a Node.js program, allowing Node.js developers to explore a variety of possible schedules. Thanks to its low overhead, Node.fz enables a developer to explore a broader "schedule space" with the same test time budget, ensuring that applications will be stable in a wide variety of deployment conditions. We show that Node.fz can expose known bugs much more frequently than vanilla Node.js, and that it can uncover new bugs.

Node.js has seen rapid adoption in industry and the open-source community. Unfortunately, its event-driven architecture exposes Node.js applications to Event Handler-Poisoning denial of service attacks. Our evaluation of the state of practice in Node.js--- combining a study of 353 publicly reported security vulnerabilities and a survey of 151 representative npm modules --- demonstrates that the community is not equipped to combat this class of attack. We recommend several changes to the state of practice and propose both programming language and runtime approaches to defend against Event Handler-Poisoning attacks.

This paper discusses a new programming method - event driven programming. This method is compared with other popular ways of implementing web services to find its weak points and discover in which areas of modern web applications it could be implemented.

Integration of heterogeneous and distributed systems is a challenging task, because they might be running on different platforms and written with different implementation languages by multiple organizations. Data-centricity and event-driven architecture (EDA) are concepts that help to implement versatile and well-scaling distributed systems. This paper focuses on the implementation of inter-subsystem communication in a prototype distributed remote handling control system developed at Divertor Test Platform 2 (DTP2). The control system consists of a variety of heterogeneous subsystems, including a client–server web application and hard real-time controllers. A standardized middleware solution (Data Distribution Services (DDS)) that supports a data-centric EDA approach is used to integrate the system. One of the greatest challenges in integrating a system with a data-centric EDA approach is in defining the global data space model. The selected middleware is currently only used for non-deterministic communication. For future application, we evaluated the performance of point-to-point communication with and without the presence of additional network load to ensure applicability to real-time systems. We found that, under certain limitations, the middleware can be used for soft real-time communication. Hard real-time use will require more validation with a more suitable environment.

Internet of Things (IoT) seamlessly integrates the user domain, cyberspace and physical space domains, and realizes the dynamic human-machine-thing collaborations. In general, IoT applications often comprise the interactions of human activities, software services and physical entities spanning multiple service domains or organizations. An IoT application system often involves the aggregation of several distributed enterprise application systems. It builds a larger, composite system to collaboratively achieve a specific business goal. Most previous work only focuses on the interconnection and interoperability problems among different entities and enterprise application systems in a dynamic interaction environment. However, the problems of how to efficiently disseminate the sensing information among the information providers and consumers on-demand and how to dynamically coordinate the relevant enterprise services or business processes based on the occurred events from the real world still have not been comprehensively explored. To resolve these problems, we propose an EDSOAbased (Event-driven Service-oriented Architecture) IoT service provisioning approach which well integrates the advantages of EDA (Event-driven Architecture) and SOA (Service-oriented Architecture) in this paper. The combination of SOA and EDA can easily support the on-demand dissemination of sensing information and realize the event-driven dynamic service coordination cross domain. This proposed approach enhances the flexibility and responsiveness of IoT service systems, which allows these systems to respond dynamically, in real time, as events occur. Finally, we demonstrate its practicability by a deployed District Heating Control and Information Service System (DHCISS) application.

Recently, event processing EP has gained considerable attention as an individual discipline in computer science. From a software engineering perspective, EP systems still lack the maturity of well-established software architectures. For the development of industrial EP systems, generally accepted software architectures based on proven design patterns and principles are still missing. In this article, we introduce a catalog of design patterns that supports the development of event-driven architectures EDAs and complex EP systems. The design principles originate from experiences reported in publications as well as from our own experiences in building EP systems with industrial and academic partners. We present several patterns on different layers of abstractions that define the overall structure as well as the building blocks for EP systems. Architectural patterns that determine the top-level structure of an EDA can be distinguished from design patterns that specify the basic mechanisms of EP. The practical application of the catalog of patterns is described by the pattern-based design of a sample EDA for a sensor-based energy control system. Finally, we propose a coherent and general reference architecture for EP derived from the proposed patterns.Copyright ©2013 John Wiley & Sons, Ltd.

Evolving software systems includes data schema changes, and because of those schema changes data has to be converted. Converting data between two different schemas while continuing the operation of the system is a challenge when that system is expected to be available always. Data conversion in event sourced systems introduces new challenges, because of the relative novelty of the event sourcing architectural pattern, because of the lack of standardized tools for data conversion, and because of the large amount of data that is stored in typical event stores. This paper addresses the challenge of schema evolution and the resulting data conversion for event sourced systems. First of all a set of event store upgrade operations is proposed that can be used to convert data between two versions of a data schema. Second, a set of techniques and strategies that execute the data conversion while continuing the operation of the system is discussed. The final contribution is an event store upgrade framework that identifies which techniques and strategies can be combined to execute the event store upgrade operations while continuing operation of the system. Two utilizations of the framework are given, the first being as decision support in upfront design of an upgrade system for event sourced systems. The framework can also be utilized as the description of an automated upgrade system that can be used for continuous deployment. The event store upgrade framework is evaluated in interviews with three renowned experts in the domain and has been found to be a comprehensive overview that can be utilized in the design and implementation of an upgrade system. The automated upgrade system has been implemented partially and applied in experiments.

Complex Event Processing (CEP) is a powerful technology used in complex and real-time environments. CEP is an Event Driven Architecture (EDA) style consists of processing different events within the distributed enterprise system attempting to discover interesting information from multiple streams of events in timely manner. In real world, the streams of events are uncertain, which means that is not guaranteed that an event has actually occurred, this uncertainty is due mainly to imprecise content from the event sources (Sensors, RFID,...). As a result, probabilistic CEP has become an important issue in complex environments that require a real-time reaction given streams of probabilistic events.

Part 7: EIS-Practices; International audience; Event-driven architecture (EDA) is an architectural approach for enabling communication between distributed enterprise information systems. EDA enables organisations to be adaptable, flexible and robust in the management of business processes and ultimately achieving agility. This paper reviews definitions, concepts and adoption criteria for an EDA and a case study investigates the adoption of the EDA in a micro lending organisation exploring the technological, organisational and environmental adoption factors.

International audience; Despite recent advances, especially in web-based Collaborative Virtual Environments (CVEs) using real-time 3D content, Web technology still requires an efficient way to distribute and stream large-scale 3D data. In this paper, we present 3DEvent: an event-driven framework to collaboratively manipulate predesigned 3D content in real-time on a web-based platform. This work introduces a new approach in achieving 3D object manipulation tasks during collaborative design stages using event-sourcing. Usually, a client-server architecture supports updates to the 3D environment state. Peer-to-peer (P2P) allows direct communication between teammates reducing response times during collaboration and decreasing server load, reducing the costs of providers. 3DEvent enables P2P-assisted delivery of 3D dynamic content in a web browser via WebRTC. By combining concepts from distributed event-processing and mesh-processing, 3D independent rendering and event-based synchronization, we present 3DEvent framework and potential uses associated that support history-aware 3D applications into a unified distributed processing solution for 3D web-based CVEs.

Context Aware Systems (CAS) support mobility of users and make context reasoning efficiently to provide relevant and real-time information. CAS should be particularly adaptive and aware by managing and responding properly to occurring events. Due mainly to the presence of numerous sensors and access to several communication networks, Context-awareness has been successfully included in the mobile device applications such as mobile and tablets. According to this fact, CAS are applied in many areas such as healthcare, transportation, education and etc. However, a reference descriptive model with respect to the capability of reusability and real-time processing and delivering the efficient service has not been considered yet. In other words, it's necessary to deploy a robust and multipurpose architecture which supports all requirements of CAS such as on demand processes and real time interactions. In this paper, the main objective is to design general purpose architecture for context aware systems which covers the CAS requirements and facilitates development of context-aware applications. Context-aware processing is a natural result of such architecture which enables the integration of context reasoning in event based systems. This architecture can be used in any environment such as healthcare, transportation, education and etc. In this paper, first we describe our architecture, related components and relationships between these components. Then, the some parts of the architecture are applied and implemented for a healthcare prototype in the hospital or home domain.

The IEC 61499 Function Block architecture is considered as the next generation of programmable control technology promoting distributed control in automation. In this paper, the redesign methodologies from the PLC control to the event-driven architecture of IEC 61499 function blocks are proposed. A general set of translation steps and mapping rules for redesigning applications from IEC 61131-3 PLC to IEC 61499 Function Blocks is provided. Three different redesign approaches are proposed: object-oriented conversion approach, object-oriented reuse approach, and class-oriented approach. These approaches are to be applied for different design styles of the source PLC code. The data handling efficiency of all approaches is investigated. An airport baggage handling system is chosen as the case study for the redesign process. The rules and limitations are summarized and guidelines for the redesign process are provided.

Monitoring systems in Grid infrastructures typically collect and aggregate data originating in distributed agents and store it in global, periodically refreshed repositories. However, in some scenarios access to real-time streams of monitoring information, rather than persistent data sets, would be beneficial. In this paper, we evaluate the Complex Event Processing (CEP) approach applied to real-time Grid monitoring and argue that CEP enables us to achieve two goals, otherwise difficult to combine: real-time access to monitoring data and advanced query capabilities. Monitoring for the purpose of dynamic allocation of Grid resources serves as a case study to demonstrate powerful real-time query capabilities provided by CEP. In addition, we show how to employ CEP for data reduction. For practical verification of our solution, a CEP-based Grid monitoring infrastructure, GEMINI2, has been developed. We have measured the overhead due to CEP-based monitoring and conclude that real-time Grid monitoring is possible without excessive intrusiveness for resources and network.

That the new generation power system control centers need a paradigm shift in their architectural design to meet new challenges, is an established conclusion of many researchers. However, literature on comprehensive architectural design towards this direction is scarce. In this paper, an information architecture design is proposed for the power system control centers. Appropriate adoption of open standards such as the common information model (CIM) is endorsed. Further, initial development of an event information model for modeling high level power system events is mentioned. Proposed architecture focuses on the desired features such as openness, interoperability, flexibility, scalability, vendor independence and event orientation. The architecture comprises services arranged in layers, viz., data integration and access, event processing and plug-in services. The details of this architecture along with the intricate relationships between various layers and services depicting how the technologies could be integrated into a coherent whole are described in this paper. An illustrative example, from the Indian power sector domain has been used to demonstrate the usefulness of the proposed architecture. (C) 2011 Elsevier Ltd. All rights reserved.

Constantly changing business conditions require a high level of flexibility in business processes as well as an adaptive and fully interoperable IT infrastructure in today’s manufacturing environments. The lack of flexibility prevents manufacturing companies from improving their responsiveness and adapting their workflows to turbulent scenarios. In order to achieve highly flexible and adaptive workflows, information systems in digital factories and shop floors need to be integrated. The most challenging problem in such manufacturing environments is the high heterogeneity of the IT landscape, where the integration of legacy systems and information silos has led to chaotic architectures over the last two decades. In order to overcome this issue, the authors present a flexible integration platform that allows a loose coupling of distributed services in event-driven manufacturing environments. The proposed approach enables a flexible communication between digital factory and shop floor components by introducing a service bus architecture. This solution integrates an application-independent canonical message format for manufacturing events, content-based routing and transformation services as well as event processing workflows.