DOCSLIB.ORG

A Distributed Logic Reactive Programming Model and Its Application to Monitoring Security

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
A Distributed Logic Reactive Programming Model and Its Application to Monitoring Security A Distributed Logic Reactive Programming Model and its Application to Monitoring Security Thierry Renaux Dissertation submitted in fulfillment of the requirement for the degree of Doctor of Sciences March 28, 2019 Jury: Prof. Dr. Wolfgang De Meuter, Vrije Universiteit Brussel, Belgium (promotor) Prof. Dr. Joeri De Koster, Vrije Universiteit Brussel, Belgium (promotor) Prof. Dr. Viviane Jonckers, Vrije Universiteit Brussel, Belgium (chair) Prof. Dr. Katrien Beuls, Vrije Universiteit Brussel, Belgium (secretary) Prof. Dr. Tias Guns, Vrije Universiteit Brussel, Belgium Prof. Dr. Coen De Roover, Vrije Universiteit Brussel, Belgium Prof. Dr. Sebastian Erdweg, TU Delft, The Netherlands Prof. Dr. Robert Hirschfeld, Hasso Plattner Institute, Germany Vrije Universiteit Brussel Faculty of Sciences and Bio-engineering Sciences Department of Computer Science Software Languages Lab © 2019 Thierry Renaux Printed by Crazy Copy Center Productions VUB Pleinlaan 2, 1050 Brussel Tel / fax : +32 2 629 33 44 [email protected] www.crazycopy.be ISBN 9789493079205 NUR 989 All rights reserved. No part of this publication may be produced in any form by print, photoprint, microfilm, electronic or any other means without permission from the author. Abstract Processes in the world are increasingly managed by software systems that are centered around the notion of events. For instance, banking software responds to the occurrence of financial transaction events and parcel services respond to the arrival event of a package at a depot. To, e.g., identify fraud in a series of financial transactions, multiple transaction events must be correlated. How to efficiently extract patterns from a stream of events — in an online fashion — is an active research topic. The state of the art enables extracting complex patterns from large streams, or performing simple processing with predictable latency. There are, however, no techniques which combine expres- sive event correlation mechanisms with guaranteed upper bounds on resource usage. Lacking such guarantees, event monitoring systems risk falling behind on the live data, or even crashing due to memory exhaustion. Preventing this is of utmost importance for modern systems that are online 24/7. In this dissertation, we propose a novel programming paradigm for large-scale online event correlation: Logic Reactive Programming. LRP overcomes the issues in the state of the art by imposing maximum lifetimes on stored event data. Through temporal reasoning, LRP then guarantees that a fixed upper limit exists on the number of events whose data needs to be retained. Stale data is automatically discarded, thus enabling LRP systems to operate in a fixed resource budget. We introduce PARTElang, the first Logic Reactive Programming language. Its formal foundations are defined by means of an event algebra. We define Featherweight PARTE, an operational semantics for PARTElang, which guarantees that every operation evaluates in constant time, using constant space. We prove correctness of Featherweight PARTE, i.e., that steps defined by the formal model ensure that a PARTElang program is translated to a number of concurrent units of computation which jointly arrive at the results prescribed by the event algebra. We further validate PARTE- lang by building a security monitoring application on top of a prototypical implementation of the Featherweight PARTE model. i Samenvatting Steeds vaker worden activiteiten in de buitenwereld beheerd door softwaresys- temen die werken op basis van events. Zo reageren banksystemen bijvoorbeeld op het plaatsvinden van een transactie-event. De systemen van pakjesdiensten voeren acties uit wanneer een aankomst-event van een pakje zich bij een depot voordoet. Dergelijke events bevatten op zich reeds nuttige informatie, maar er kan nog meer informatie onttrokken worden uit een correlatie van meerdere events, bv. door fraude te detecteren in een reeks financiële transacties. Dit alles zorgt ervoor dat er nood is aan middelen om grote stromen van events te monitoren op het voorkomen van patronen van events. Omdat het vaak nuttig is om snel te reageren, vindt deze monitoring best live plaats — terwijl de events plaatsvinden. De ontwikkeling van technieken om grootschalige eventstromen live te analyseren, is de focus van meerdere onderzoeksdomei- nen. Er ontbreekt echter een oplossing die kan garanderen dat de grootschalige live analyse uitgevoerd kan worden met een op voorhand bepaalde hoeveel- heid middelen. Zonder die garantie riskeren eventmonitoringsystemen om achterop te geraken ten opzichte van de live data, of zelfs om hun taak te moeten staken bij gebrek aan werkgeheugen. Voor systemen die continu beschikbaar moeten blijven, is dit onaanvaardbaar. In deze doctoraatsverhandeling stellen we een nieuw programmeerparadigma voor voor grootschalige live eventcorrelatie: Logisch-Reactief Programmeren. LRP overkomt de problemen in huidige oplossingen door een garandeerbare bovengrens te vereisen op de levensduur van eventdata. Aan de hand van temporal reasoning garandeert LRP dat een vaste bovengrens bestaat op het aantal events dat bijgehouden moet worden. Oude events worden automatisch verwijderd. Dit laat LRP systemen toe om binnen een eindig tijds- en geheugenbudget te werken. We introduceren PARTElang, de eerste LRP taal. De formele onderbouwing van LRP berust op een event algebra. We definiëren een operationele semantiek voor PARTElang. Deze garandeert dat iedere operatie in constante tijd uitgevoerd wordt, gebruikmakend van een constante hoeveelheid geheugen. We bewijzen dat het evaluatiemodel het correcte gedrag voorschrijft, en demonstreren dit aan de hand van een prototype. iii Acknowledgments First of all, I would like to thank the members of my jury (Viviane Jonckers, Katrien Beuls, Tias Guns, Coen De Roover, Sebastian Erdweg, and Robert Hirschfeld) for their insightful comments and feedback. I would like to thank my promotors, Wolf and Joeri, for their guidance and feedback. Their advice, encouragement, and occasional constructive criticism were essential throughout my PhD. Of course, the rest of the Software Languages Lab was also a great bonus. Thank you all, both for offering a good environment to do work in, and for being great colleagues. I won’t list you all, but know that I am thankful for the work environment you helped create. So, thanks to the Rete-and-event-based- things people: Kennedy, Humberto, Sam, etc. Thanks to those of you who arrived at SOFT around the same time as me, and therefore were often going through the same thing at the same time as me: Janwillem, Nathalie, Simon, etc. Thanks to those who at some point were doing the day-to-day guidance for the part of SOFT I was in at that time: Stefan, Lode, Yves, etc. Outside of SOFT, I’d also like to thank my family and friends. Thanks Ansje, for being there for me through all these years. Thanks, mom and Evelyne too, for all the support you provided. Thanks, Raf, for your friendship and for proofreading this entire dissertation, even though you had no obligation to do so at all. Finally, thanks, reader, for reading this. Why are you reading this? Are you waiting for my public defense to start? (Hello! Wave!) Or are you reading it during the presentation? Aww, I spent all that effort making it interesting... Or are you looking for inspiration while writing your own Acknowledgments section? Did you pass your private defense yet? Congratulations! Or are you just that well-prepared that you’re writing it proactively? Wow, keep up the good work! In any case, thanks, and I hope the work described in this dissertation is useful to some of you. This work is partially funded by a PhD scholarship of the Agency for Innovation by Science and Technology in Flanders (IWT). v Contents 1 Introduction 1 1.1 Problem Statement . .4 1.2 Research Goal . .4 1.3 Approach . .5 1.4 Contributions . .8 1.5 Supporting publications . .8 1.6 Outline of the Dissertation . 10 2 State of the Art in Distributed Big Data and Stream Processing 11 2.1 Driver Scenarios . 12 2.1.1 Setting . 12 2.1.2 Scenarios . 13 2.1.3 Conclusion . 14 2.2 History of Big Data Stream Processing . 14 2.2.1 Origins . 14 2.2.2 Early Stream Processing: Tribeca . 16 2.2.3 Later Stream Processing Systems . 17 2.2.4 Early Big Data Processing: MapReduce . 19 2.2.5 Data-Parallel Pipelines . 20 2.2.6 Towards Streaming Big Data Processing . 21 2.2.7 Summary . 23 2.3 Research Trends . 23 2.3.1 Restricting Selections by Time: Windowing . 23 2.3.2 Distribution and Fault-Tolerance . 27 2.3.3 Expressivity and Language Paradigm . 29 2.3.4 Summary . 31 2.4 Discussion: Shortcomings in the State of the Art . 31 2.4.1 Event Correlation in Big Data Stream Processing Frameworks . 32 2.4.2 Data Processing Guarantees of Data in Streaming Databases . 33 2.5 Conclusion . 34 vii 3 State of the Art in Event Handling 35 3.1 Traditional Approaches to Event Handling . 35 3.2 Averting the Callback Hell: Reactive Programming . 37 3.2.1 The Functional Reactive Programming Paradigm . 37 3.2.2 Beyond Functional Reactive Programming . 38 3.2.3 Active Research in Reactive Programming . 38 3.3 Detecting Event Patterns: Complex Event Processing . 38 3.3.1 Differentiating CEP from Streaming Databases . 39 3.3.2 A Baseline for Modern CEP: SASE . 41 3.3.3 Aggregation and Monitoring Multiple Streams: Cayuga . 42 3.3.4 Expressive and Efficient CEP with Distributed Event Sources: TESLA 44 3.3.5 A Formal Foundation for Modern CEP: EVA . 46 3.3.6 Complex Event Patterns and Reaction Logic as Declarative Rules . 46 3.4 A Taxonomy of Event Handling . 47 3.4.1 Event Consumption Policies . 47 3.4.2 Semantics of “followed by” . 48 3.4.3 Support for Temporal Constraints in Event Handling Languages . 50 3.4.4 Event Detection Models . 51 3.4.5 Summary . 56 3.5 Discussion: Shortcomings in the State of the Art . 56 3.5.1 Shortcomings of Functional Reactive Programming .
Load more

Recommended publications
  • The Implementation of Metagraph Agents Based on Functional Reactive Programming
    ______________________________________________________PROCEEDING OF THE 26TH CONFERENCE OF FRUCT ASSOCIATION The Implementation of Metagraph Agents Based on Functional Reactive Programming Valeriy Chernenkiy, Yuriy Gapanyuk, Anatoly Nardid, Nikita Todosiev Bauman Moscow State Technical University, Moscow, Russia [email protected], [email protected], [email protected], [email protected] Abstract—The main ideas of the metagraph data model and there is no doubt that it is the functional approach in the metagraph agent model are discussed. The metagraph programming that makes it possible to make such approach for semantic complex event processing is presented. implementation effectively. Therefore, the work is devoted to The metagraph agent implementation based on Functional the implementation of a multi-agent paradigm using functional Reactive Programming is proposed. reactive programming. The advantage of this implementation is that agents can work in parallel, supporting a functional I. INTRODUCTION reactive paradigm. Currently, models based on complex networks are The article is organized as follows. The section II discusses increasingly used in various fields of science, from the main ideas of the metagraph model. The section III mathematics and computer science to biology and sociology. discusses the metagraph agent model. The section IV discusses According to [1]: “a complex network is a graph (network) the Semantic Complex Event Processing approach and its’ with non-trivial topological features – features that do not occur correspondence to the metagraph model. The section V (which in simple networks such as lattices or random graphs but often is the novel result presented in the article) discusses the occur in graphs modeling of real systems.” The terms “complex metagraph agent implementation based on Functional Reactive network” and “complex graph” are often used synonymously.
    [Show full text]
  • Functional Reactive Programming, Refactored
    Functional Reactive Programming, Refactored Ivan Perez Manuel Barenz¨ Henrik Nilsson University of Nottingham University of Bamberg University of Nottingham [email protected] [email protected] [email protected] Abstract 18] and Reactive Values [21]. Through composition of standard Functional Reactive Programming (FRP) has come to mean many monads like reader, exception, and state, any desirable combination things. Yet, scratch the surface of the multitude of realisations, and of time domain, dynamic system structure,flexible handling of I/O there is great commonality between them. This paper investigates and more can be obtained in an open-ended manner. this commonality, turning it into a mathematically coherent and Specifically, the contributions of this paper are: practical FRP realisation that allows us to express the functionality We define a minimal Domain-Specific Language of causal • of many existing FRP systems and beyond by providing a minimal Monadic Stream Functions (MSFs), give them precise mean- FRP core parametrised on a monad. We give proofs for our theoreti- ing and analyse the properties they fulfill. cal claims and we have verified the practical side by benchmarking We explore the use of different monads in MSFs, how they nat- a set of existing, non-trivial Yampa applications running on top of • our new system with very good results. urally give rise to known reactive constructs, like termination, switching, higher-order, parallelism and sinks, and how to com- Categories and Subject Descriptors D.3.3 [Programming Lan- pose effects at a stream level using monad transformers [15]. guages]: Language Constructs and Features – Control Structures We implement three different FRP variants on top of our frame- • Keywords functional reactive programming, reactive program- work: 1) Arrowized FRP, 2) Classic FRP and 3) Signal/Sink- ming, stream programming, monadic streams, Haskell based reactivity.
    [Show full text]
  • Flapjax: Functional Reactive Web Programming
    Flapjax: Functional Reactive Web Programming Leo Meyerovich Department of Computer Science Brown University [email protected] 1 People whose names should be before mine. Thank you to Shriram Krishnamurthi and Gregory Cooper for ensuring this project’s success. I’m not sure what would have happened if not for the late nights with Michael Greenberg, Aleks Bromfield, and Arjun Guha. Peter Hopkins, Jay McCarthy, Josh Gan, An- drey Skylar, Jacob Baskin, Kimberly Burchett, Noel Welsh, and Lee Butterman provided invaluable input. While not directly involved with this particular project, Kathi Fisler and Michael Tschantz have pushed me along. 1 Contents 4.6. Objects and Collections . 32 4.6.1 Delta Propagation . 32 1. Introduction 3 4.6.2 Shallow vs Deep Binding . 33 1.1 Document Approach . 3 4.6.3 DOM Binding . 33 2. Background 4 4.6.4 Server Binding . 33 2.1. Web Programming . 4 4.6.5 Disconnected Nodes and 2.2. Functional Reactive Programming . 5 Garbage Collection . 33 2.2.1 Events . 6 2.2.2 Behaviours . 7 4.7. Evaluations . 34 2.2.3 Automatic Lifting: Transparent 4.7.1 Demos . 34 Reactivity . 8 4.7.2 Applications . 34 2.2.4 Records and Transparent Reac- 4.8 Errors . 34 tivity . 10 2.2.5 Behaviours and Events: Conver- 4.9 Library vs Language . 34 sions and Event-Based Derivation 10 4.9.1 Dynamic Typing . 34 4.9.2 Optimization . 35 3. Implementation 11 3.1. Topological Evaluation and Glitches . 13 4.9.3 Components . 35 3.1.1 Time Steps . 15 4.9.4 Compilation .
    [Show full text]
  • Computer Science 1
    Computer Science 1 Computer Science Department Website: https://www.cs.uchicago.edu Program of Study The computer science program offers BA and BS degrees, as well as combined BA/MS and BS/MS degrees. Students who earn the BA are prepared either for graduate study in computer science or a career in industry. Students who earn the BS degree build strength in an additional field by following an approved course of study in a related area. The department also offers a minor. Where to Start The Department of Computer Science offers several different introductory pathways into the program. In consultation with their College adviser and the Computer Science Department advisers, students should choose their introductory courses carefully. Some guidelines follow. For students intending to pursue further study in computer science, we recommend CMSC 15100 Introduction to Computer Science I or CMSC 16100 Honors Introduction to Computer Science I as the first course. CMSC 15100 does not assume prior experience or unusually strong preparation in mathematics. Students with programming experience and strong preparation in mathematics should consider CMSC 16100 Honors Introduction to Computer Science I. First-year students considering a computer science major are strongly advised to register for an introductory sequence in the Winter or Spring Quarter of their first year, and it is all but essential that they start the introductory sequence no later than the second quarter of their second year. Students who are not intending to major in computer science, but are interested in getting a rigorous introduction to computational thinking with a focus on applications are encouraged to start with CMSC 12100 Computer Science with Applications I.
    [Show full text]
  • Compiling Real Time Functional Reactive Programming
    Compiling Real Time Functional Reactive Programming Dana N. Xu and Siau-Cheng Khoo Department of Computer Science School of Computing National University of Singapore {xun,khoosc}@comp.nus.edu.sg ABSTRACT 1. INTRODUCTION Most of the past languages for reactive systems are based Reactive systems are required to react in a timely man- on synchronous dataflow. Recently, a new reactive lan- ner to external events. Their use can be found in a broad guage, called Real-Time Functional Reactive Programming range of applications, ranging from high-end consumer prod- (RT-FRP) [18] , has been proposed based on the functional ucts (digital radio, intelligent cookers) to systems used in paradigm. The unique feature of this language is the high- mission-critical applications (such as air-craft and nuclear- level abstraction provided in the form of behaviors for conti- power stations). nuous-time signals, and events for discrete-time signals. RT- Programming these systems poses a great challenge, and FRP also features some performance guarantees in the form a number of programming languages have been proposed of bounded runtime and space usage for each reactive com- over the last two decades. Two main concerns are typically putation step. addressed in these languages. Firstly, some features must In this paper, we propose a new compilation scheme for be available to express signals and events, and how they are RT-FRP. Our compilation scheme is based on two key stages. transformed by the intended reactive systems. Secondly, we In the first stage, we translate RT-FRP program to an in- must be able to show that each reaction could be carried termediate functional code.
    [Show full text]
  • Haskell-Like S-Expression-Based Language Designed for an IDE
    Department of Computing Imperial College London MEng Individual Project Haskell-Like S-Expression-Based Language Designed for an IDE Author: Supervisor: Michal Srb Prof. Susan Eisenbach June 2015 Abstract The state of the programmers’ toolbox is abysmal. Although substantial effort is put into the development of powerful integrated development environments (IDEs), their features often lack capabilities desired by programmers and target primarily classical object oriented languages. This report documents the results of designing a modern programming language with its IDE in mind. We introduce a new statically typed functional language with strong metaprogramming capabilities, targeting JavaScript, the most popular runtime of today; and its accompanying browser-based IDE. We demonstrate the advantages resulting from designing both the language and its IDE at the same time and evaluate the resulting environment by employing it to solve a variety of nontrivial programming tasks. Our results demonstrate that programmers can greatly benefit from the combined application of modern approaches to programming tools. I would like to express my sincere gratitude to Susan, Sophia and Tristan for their invaluable feedback on this project, my family, my parents Michal and Jana and my grandmothers Hana and Jaroslava for supporting me throughout my studies, and to all my friends, especially to Harry whom I met at the interview day and seem to not be able to get rid of ever since. ii Contents Abstract i Contents iii 1 Introduction 1 1.1 Objectives ........................................ 2 1.2 Challenges ........................................ 3 1.3 Contributions ...................................... 4 2 State of the Art 6 2.1 Languages ........................................ 6 2.1.1 Haskell ....................................
    [Show full text]
  • A Deterministic Model of Concurrent Computation for Reactive Systems by Hendrik Marten Frank Lohstroh a Dissertation S
    Reactors: A Deterministic Model of Concurrent Computation for Reactive Systems by Hendrik Marten Frank Lohstroh A dissertation submitted in partial satisfaction of the requirements for the degree of Doctor of Philosophy in Computer Science in the Graduate Division of the University of California, Berkeley Committee in charge: Professor Edward A. Lee, Chair Professor Gul A. Agha Professor Alberto L. Sangiovanni-Vincentelli Professor Sanjit A. Seshia Fall 2020 Reactors: A Deterministic Model of Concurrent Computation for Reactive Systems Copyright 2020 by Hendrik Marten Frank Lohstroh i Abstract Reactors: A Deterministic Model of Concurrent Computation for Reactive Systems by Hendrik Marten Frank Lohstroh Doctor of Philosophy in Computer Science University of California, Berkeley Professor Edward A. Lee, Chair Actors have become widespread in programming languages and programming frameworks focused on parallel and distributed computing. While actors provide a more disciplined model for concurrency than threads, their interactions, if not constrained, admit nondeter- minism. As a consequence, actor programs may exhibit unintended behaviors and are less amenable to rigorous testing. The same problem exists in other dominant concurrency mod- els, such as threads, shared-memory models, publish-subscribe systems, and service-oriented architectures. We propose \reactors," a new model of concurrent computation that combines synchronous- reactive principles with a sophisticated model of time to enable determinism while preserving much of the style and performance of actors. Reactors promote modularity and allow for dis- tributed execution. The relationship that reactors establish between events across timelines allows for: 1. the construction of programs that react predictably to unpredictable external events; 2. the formulation of deadlines that grant control over timing; and 3.
    [Show full text]
  • How I Teach Functional Programming
    How I Teach Functional Programming Johannes Waldmann Fakult¨atIMN, HTWK Leipzig, D-04275 Leipzig Abstract. I teach a course Advanced Programming for 4th semester bachelor students of computer science. In this note, I will explain my reasons for choosing the topics to teach, as well as their order, and pre- sentation. In particular, I will show how I include automated exercises, using the Leipzig autotool system. 1 Motivation In my course Advanced Programming, I aim to show mathematical models (say, the lambda calculus) as well as their concrete realization first in its \pure" form in a functional programming language (Haskell [Mar10]), then also in some of today's multi-paradigm languages (imperative and object-oriented, actually mostly class-based) that students already known from their programming courses in their first and second semester. My course is named \advanced" because it introduces functional programming (but it's not advanced functional program- ming). I will explain this in some detail now. Motivation (this section) and discussion will be somewhat opinionated, starting with the following paragraph. I still think it will be clear on what facts my opinion is based, and I hope that at least the facts (examples and exercises) are re-usable by other academic teachers of func- tional programming. The slides for the most recent instance of this lecture are at https://www.imn.htwk-leipzig.de/~waldmann/edu/ss17/fop/folien/, and online exercises can be tried here: https://autotool.imn.htwk-leipzig.de/ cgi-bin/Trial.cgi?lecture=238 When teaching programming, the focus should really be on how to solve the task at hand (given an algorithm, produce executable code) using available tools (programming languages, libraries), and to understand the fundamentals that these tools are based on.
    [Show full text]
  • Reactive Probabilistic Programming
    Reactive Probabilistic Programming Pedro Zuidberg Dos Martires Sebastijan Dumančić KU Leuven KU Leuven [email protected] [email protected] Abstract event might be the delay, and the actor has to reason about Reactive programming allows a user to model the flow of a the possibility of conflicting train routes. program for event-driven streams of data without explicitly stating its control flow. However, many domains are inher- 2 Reactive Probabilistic Programming ently uncertain and observations (the data) might ooze with Reactive programming [1], which falls itself under the declar- noise. Probabilistic programming has emerged as the go-to ative programming paradigm, has recently gained traction as technique to handle such uncertain domains. Therefore, we a paradigm for event-driven applications. A common trait of introduce the concept of reactive probabilistic programming, event driven-applications is that external events at discrete which allows to unify the methods of reactive programming points in time, such as a mouse click from a user on a web and probabilistic programming. Herewith, we broaden the page, drive the execution of a program. The increased inter- scope of probabilistic programming to event-driven data. est has resulted in various implementations, for instance, in Haskell [3] and Scala [5]. Recently also the ReactiveX 2 library Keywords probabilistic programming, reactive program- emerged, with bindings to various different languages. The ming, declarative programming, event-driven data two distinguishing features of reactive programming are: 1 Introduction & Motivation • Behaviors change continuously over time and are com- posable first-class citizens in the reactive programming The declarative programming paradigm allows the user to paradigm.
    [Show full text]
  • Reactive Programming and Clean Architecture in Android Development
    Tung Bui Duy Reactive Programming and Clean Architecture in Android Development Helsinki Metropolia University of Applied Sciences Bachelor of Engineering Information Technology Thesis 27 April 2017 Abstract Author(s) Tung Bui Duy Title Reactive programming and clean architecture in Android de- veloment Number of Pages 47 pages Date 12-04-2017 Degree Bachelor of Engineering Degree Programme Information Technology Specialisation option Software Engineering Instructor(s) Peter Hjort, Principal Lecturer Software application becomes more and more complex nowadays. To provide a good software application that is easy to scale, developers need to design a good software ar- chitecture. The purpose of the project was to find a good Android architecture that can be used in later projects of the team C63-Studio. The project was implemented by refactoring a lega- cy Android application of team C63-Studio using clean architecture, dependency injection and reactive programming. From the refactoring experience, the team realized advantages and disadvantages of ap- plying clean architecture and reactive programming. While there are some disadvantages when applying this architecture for small applications, the advantages for applications that require scalability easily overwhelm the disadvantages. Based on the analysis, the C63 studio development team decided to use this architecture for later Android projects. Keywords Android, Reactive Programming, Clean Architecture, MVP, RxJava, Dagger2, Retrofit Contents 1 Introduction 1 2 Sunshine Application 2
    [Show full text]
  • And/Or Hierarchies and Round Abstraction
    And/Or Hierarchies and Round Abstraction Radu Grosu Department of Computer and Information Science University of Pennsylvania Email: [email protected] URL: www.cis.upenn.edu/~grosu Abstract. Sequential and parallel composition are the most fundamen- tal operators for incremental construction of complex concurrent sys- tems. They reflect the temporal and respectively the spatial properties of these systems. Hidingtemporal detail like internal computation steps supports temporal scalability and may turn an asynchronous system to a synchronous one. Hidingspatial detail like internal variables sup- ports spatial scalability and may turn a synchronous system to an asyn- chronous one. In this paper we show on hand of several examples that a language explicitly supporting both sequential and parallel composition operators is a natural settingfor designingheterogeneous synchronous and asynchronous systems. The language we use is Shrm,avisuallan- guage that backs up the popular and/or hierarchies of statecharts with a well defined compositional semantics. 1 Introduction With the advent of very large scale integration technology (VLSI), digital circuits became too complex to be designed and tested on a breadboard.The hardware community introduced therefore languages like Verilog and VHDL [Ver,Vhdl] that allow to describe the architectural and the behavioral structure of a complex circuit in a very abstract and modular way.Architectural modularity means that a system is composed of subsystems using the operations of parallel composition and hiding of variables.Behavioral hierarchy means that a system is composed of subsystems using the operations of sequential composition and hiding of internal computation steps.Verilog allows the arbitrary nesting of the architecture and behavior hierarchies.
    [Show full text]
  • Reactive Relational Database Connectivity for Java and JVM
    R2DBC Revealed Reactive Relational Database Connectivity for Java and JVM Programmers — Robert Hedgpeth R2DBC Revealed Reactive Relational Database Connectivity for Java and JVM Programmers Robert Hedgpeth R2DBC Revealed: Reactive Relational Database Connectivity for Java and JVM Programmers Robert Hedgpeth Chicago, IL, USA ISBN-13 (pbk): 978-1-4842-6988-6 ISBN-13 (electronic): 978-1-4842-6989-3 https://doi.org/10.1007/978-1-4842-6989-3 Copyright © 2021 by Robert Hedgpeth This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made.
    [Show full text]