Workshop REBLS 2017 – Author Index

A C D I M N P R S V

	Aotani, Tomoyuki	REBLS '17: "A DSL for Compensable and ..." A DSL for Compensable and Interruptible Executions Hiroaki Inoue, Tomoyuki Aotani, and Atsushi Igarashi (Kyoto University, Japan; Tokyo Institute of Technology, Japan) Context-awareness is getting more and more important in software applications. Such an application runs depending on the time-varying status of the surrounding environment such as network connection, battery/energy charge and heat. Interruptions, or asynchronous exceptions, are useful to achieve con­text-awareness: if the environment changes, the execution of the application is interrupted reactively to stop and/or recover the internal state for adapting to the new environment. It is, however, difficult to program with interruptions modularly in most programming languages because their support is too basic and is based on synchronous exception handling mechanism such as try–catch. We propose a domain-specific language Context­Workflow for modular interruptible programs as a solution to the problem. An interruptible program is basically a workflow, i.e., a sequence of atomic computations with compensations. The uniqueness of Context­Workflow is that, during its execution, a workflow watches the context, which is represented as a reactive value in functional reactive programming and instructs how the execution reflects the status of the surrounding environment. @InProceedings{REBLS17p8, author = {Hiroaki Inoue and Tomoyuki Aotani and Atsushi Igarashi}, title = {A DSL for Compensable and Interruptible Executions}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {8--14}, doi = {10.1145/3141858.3141860}, year = {2017}, } Publisher's Version
	Calus, Ben	REBLS '17: "FRP IoT Modules as a Scala ..." FRP IoT Modules as a Scala DSL Ben Calus, Bob Reynders, Dominique Devriese, Job Noorman, and Frank Piessens (KU Leuven, Belgium) With Internet of Things applications growing in size and popularity, physical sensor networks are more often running multiple complex applications. It becomes increasingly important to maintain these event-driven programs on embedded systems. Traditionally, event-driven applications such as sensor network applications are written using an imperative style of programming where different callback routines are registered to handle events. As the application complexity grows, the inverted control flow and reliance on shared global state makes this style of programming hard to maintain. Furthermore, sensor network applications are inherently distributed and are written by manually managing code-bases of sub-applications that go on all nodes separately. If security is important, the programmer needs to manually interface with low-level security primitives because there is no built-in notion of components. We propose a more maintainable approach where the developer essentially writes a first-order FRP program, containing code fragments in an embedded subset of C. From this FRP program, we generate efficient C code to be run on every node. Every module of the FRP program is compiled to a separate C module, making it easy to deploy modules to different nodes, and to enhance the security of the application by isolating modules from other software running on the nodes. Our implementation is based on a Scala EDSL that we use to let the user conveniently embed fragments of C code. The annotated C code gets compiled to Sancus, a security architecture for IoT nodes that supports the secure and distributed execution of the generated modules. @InProceedings{REBLS17p15, author = {Ben Calus and Bob Reynders and Dominique Devriese and Job Noorman and Frank Piessens}, title = {FRP IoT Modules as a Scala DSL}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {15--20}, doi = {10.1145/3141858.3141861}, year = {2017}, } Publisher's Version
	De Koster, Joeri	REBLS '17: "Tackling the Awkward Squad ..." Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model Sam Van den Vonder, Joeri De Koster, Florian Myter, and Wolfgang De Meuter (Vrije Universiteit Brussel, Belgium) In his famous paper entitled "Tackling the Awkward Squad", Peyton Jones studies how features that traditionally did not fit in the functional programming paradigm can be added to a functional language via careful language design (e.g. using monads), instead of allowing programmers to sprinkle around impure expressions and ad-hoc library calls, thereby turning the entire program into a non-functional program. Similarly, in this paper, we identify a number of code characteristics that do not map onto the reactive programming paradigm but that are present in many real life reactive programs. We propose a novel Actor-Reactor model that can serve as the basis for future language designs that allow a programmer to use the awkward squad without making the reactive parts of the program accidentally non-reactive. @InProceedings{REBLS17p27, author = {Sam Van den Vonder and Joeri De Koster and Florian Myter and Wolfgang De Meuter}, title = {Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {27--33}, doi = {10.1145/3141858.3141863}, year = {2017}, } Publisher's Version
	De Meuter, Wolfgang	REBLS '17: "Handling Partial Failures ..." Handling Partial Failures in Distributed Reactive Programming Florian Myter, Christophe Scholliers, and Wolfgang De Meuter (Vrije Universiteit Brussel, Belgium; Ghent University, Belgium) Distributed reactive programming enables programmers to reuse the abstractions provided by reactive programming to elegantly implement distributed systems. However, distributed reactive approaches have thus far neglected to address an inherent property of distributed systems: partial failures. This forces programmers to either disregard failures and write poor distributed code or try to detect failures manually (e.g. through time-outs and heartbeats). Moreover, this prohibits distributed reactive runtimes to garbage collect remote references to failed parts of the reactive network. In this paper we present a first attempt at failure handling for distributed reactive applications. To this end we introduce the novel concept of leased signals which allow both programmer and runtime to react to partial failures in distributed reactive applications. We implement leased signals in a distributed reactive TypeScript framework for the development of microservice applications. @InProceedings{REBLS17p1, author = {Florian Myter and Christophe Scholliers and Wolfgang De Meuter}, title = {Handling Partial Failures in Distributed Reactive Programming}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {1--7}, doi = {10.1145/3141858.3141859}, year = {2017}, } Publisher's Version REBLS '17: "First-Class Reactive Programs ..." First-Class Reactive Programs for CPS Christophe De Troyer, Jens Nicolay, and Wolfgang De Meuter (Vrije Universiteit Brussel, Belgium) Cyber-Physical Systems (CPS) are comprised of a network of devices that vary widely in complexity, ranging from simple sensors to autonomous robots. Traditionally, controlling and sensing these devices happens through API communication, in either push or pull-based fashion. We argue that the computational power of these devices is converging to the point where they can do autonomous computations. This allows application programmers to run programs locally on the sensors, thereby reducing the communication and workload of more central command and control entities. This work introduces the Potato framework that aims to make programming CPS systems intuitively easy and fast. Potato is based on three essential mechanisms: failure handling by means of leasing, distribution by means of first-class reactive programs, and intentional retroactive designation of the network by means of capabilities and dynamic properties. In this paper we focus on the reactive capabilities of our framework. Potato enables programmers to create and deploy first-class reactive programs on CPS devices at run time, abstracting away from the API approach. Each node in the network is equipped with a minimal actor-based middleware that can execute first-class reactive programs. We have implemented Potato as a library in Elixir and have used it to implement several small examples. @InProceedings{REBLS17p21, author = {Christophe De Troyer and Jens Nicolay and Wolfgang De Meuter}, title = {First-Class Reactive Programs for CPS}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {21--26}, doi = {10.1145/3141858.3141862}, year = {2017}, } Publisher's Version REBLS '17: "Tackling the Awkward Squad ..." Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model Sam Van den Vonder, Joeri De Koster, Florian Myter, and Wolfgang De Meuter (Vrije Universiteit Brussel, Belgium) In his famous paper entitled "Tackling the Awkward Squad", Peyton Jones studies how features that traditionally did not fit in the functional programming paradigm can be added to a functional language via careful language design (e.g. using monads), instead of allowing programmers to sprinkle around impure expressions and ad-hoc library calls, thereby turning the entire program into a non-functional program. Similarly, in this paper, we identify a number of code characteristics that do not map onto the reactive programming paradigm but that are present in many real life reactive programs. We propose a novel Actor-Reactor model that can serve as the basis for future language designs that allow a programmer to use the awkward squad without making the reactive parts of the program accidentally non-reactive. @InProceedings{REBLS17p27, author = {Sam Van den Vonder and Joeri De Koster and Florian Myter and Wolfgang De Meuter}, title = {Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {27--33}, doi = {10.1145/3141858.3141863}, year = {2017}, } Publisher's Version
	De Troyer, Christophe	REBLS '17: "First-Class Reactive Programs ..." First-Class Reactive Programs for CPS Christophe De Troyer, Jens Nicolay, and Wolfgang De Meuter (Vrije Universiteit Brussel, Belgium) Cyber-Physical Systems (CPS) are comprised of a network of devices that vary widely in complexity, ranging from simple sensors to autonomous robots. Traditionally, controlling and sensing these devices happens through API communication, in either push or pull-based fashion. We argue that the computational power of these devices is converging to the point where they can do autonomous computations. This allows application programmers to run programs locally on the sensors, thereby reducing the communication and workload of more central command and control entities. This work introduces the Potato framework that aims to make programming CPS systems intuitively easy and fast. Potato is based on three essential mechanisms: failure handling by means of leasing, distribution by means of first-class reactive programs, and intentional retroactive designation of the network by means of capabilities and dynamic properties. In this paper we focus on the reactive capabilities of our framework. Potato enables programmers to create and deploy first-class reactive programs on CPS devices at run time, abstracting away from the API approach. Each node in the network is equipped with a minimal actor-based middleware that can execute first-class reactive programs. We have implemented Potato as a library in Elixir and have used it to implement several small examples. @InProceedings{REBLS17p21, author = {Christophe De Troyer and Jens Nicolay and Wolfgang De Meuter}, title = {First-Class Reactive Programs for CPS}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {21--26}, doi = {10.1145/3141858.3141862}, year = {2017}, } Publisher's Version
	Devriese, Dominique	REBLS '17: "FRP IoT Modules as a Scala ..." FRP IoT Modules as a Scala DSL Ben Calus, Bob Reynders, Dominique Devriese, Job Noorman, and Frank Piessens (KU Leuven, Belgium) With Internet of Things applications growing in size and popularity, physical sensor networks are more often running multiple complex applications. It becomes increasingly important to maintain these event-driven programs on embedded systems. Traditionally, event-driven applications such as sensor network applications are written using an imperative style of programming where different callback routines are registered to handle events. As the application complexity grows, the inverted control flow and reliance on shared global state makes this style of programming hard to maintain. Furthermore, sensor network applications are inherently distributed and are written by manually managing code-bases of sub-applications that go on all nodes separately. If security is important, the programmer needs to manually interface with low-level security primitives because there is no built-in notion of components. We propose a more maintainable approach where the developer essentially writes a first-order FRP program, containing code fragments in an embedded subset of C. From this FRP program, we generate efficient C code to be run on every node. Every module of the FRP program is compiled to a separate C module, making it easy to deploy modules to different nodes, and to enhance the security of the application by isolating modules from other software running on the nodes. Our implementation is based on a Scala EDSL that we use to let the user conveniently embed fragments of C code. The annotated C code gets compiled to Sancus, a security architecture for IoT nodes that supports the secure and distributed execution of the generated modules. @InProceedings{REBLS17p15, author = {Ben Calus and Bob Reynders and Dominique Devriese and Job Noorman and Frank Piessens}, title = {FRP IoT Modules as a Scala DSL}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {15--20}, doi = {10.1145/3141858.3141861}, year = {2017}, } Publisher's Version
	Igarashi, Atsushi	REBLS '17: "A DSL for Compensable and ..." A DSL for Compensable and Interruptible Executions Hiroaki Inoue, Tomoyuki Aotani, and Atsushi Igarashi (Kyoto University, Japan; Tokyo Institute of Technology, Japan) Context-awareness is getting more and more important in software applications. Such an application runs depending on the time-varying status of the surrounding environment such as network connection, battery/energy charge and heat. Interruptions, or asynchronous exceptions, are useful to achieve con­text-awareness: if the environment changes, the execution of the application is interrupted reactively to stop and/or recover the internal state for adapting to the new environment. It is, however, difficult to program with interruptions modularly in most programming languages because their support is too basic and is based on synchronous exception handling mechanism such as try–catch. We propose a domain-specific language Context­Workflow for modular interruptible programs as a solution to the problem. An interruptible program is basically a workflow, i.e., a sequence of atomic computations with compensations. The uniqueness of Context­Workflow is that, during its execution, a workflow watches the context, which is represented as a reactive value in functional reactive programming and instructs how the execution reflects the status of the surrounding environment. @InProceedings{REBLS17p8, author = {Hiroaki Inoue and Tomoyuki Aotani and Atsushi Igarashi}, title = {A DSL for Compensable and Interruptible Executions}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {8--14}, doi = {10.1145/3141858.3141860}, year = {2017}, } Publisher's Version
	Inoue, Hiroaki	REBLS '17: "A DSL for Compensable and ..." A DSL for Compensable and Interruptible Executions Hiroaki Inoue, Tomoyuki Aotani, and Atsushi Igarashi (Kyoto University, Japan; Tokyo Institute of Technology, Japan) Context-awareness is getting more and more important in software applications. Such an application runs depending on the time-varying status of the surrounding environment such as network connection, battery/energy charge and heat. Interruptions, or asynchronous exceptions, are useful to achieve con­text-awareness: if the environment changes, the execution of the application is interrupted reactively to stop and/or recover the internal state for adapting to the new environment. It is, however, difficult to program with interruptions modularly in most programming languages because their support is too basic and is based on synchronous exception handling mechanism such as try–catch. We propose a domain-specific language Context­Workflow for modular interruptible programs as a solution to the problem. An interruptible program is basically a workflow, i.e., a sequence of atomic computations with compensations. The uniqueness of Context­Workflow is that, during its execution, a workflow watches the context, which is represented as a reactive value in functional reactive programming and instructs how the execution reflects the status of the surrounding environment. @InProceedings{REBLS17p8, author = {Hiroaki Inoue and Tomoyuki Aotani and Atsushi Igarashi}, title = {A DSL for Compensable and Interruptible Executions}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {8--14}, doi = {10.1145/3141858.3141860}, year = {2017}, } Publisher's Version
	Myter, Florian	REBLS '17: "Handling Partial Failures ..." Handling Partial Failures in Distributed Reactive Programming Florian Myter, Christophe Scholliers, and Wolfgang De Meuter (Vrije Universiteit Brussel, Belgium; Ghent University, Belgium) Distributed reactive programming enables programmers to reuse the abstractions provided by reactive programming to elegantly implement distributed systems. However, distributed reactive approaches have thus far neglected to address an inherent property of distributed systems: partial failures. This forces programmers to either disregard failures and write poor distributed code or try to detect failures manually (e.g. through time-outs and heartbeats). Moreover, this prohibits distributed reactive runtimes to garbage collect remote references to failed parts of the reactive network. In this paper we present a first attempt at failure handling for distributed reactive applications. To this end we introduce the novel concept of leased signals which allow both programmer and runtime to react to partial failures in distributed reactive applications. We implement leased signals in a distributed reactive TypeScript framework for the development of microservice applications. @InProceedings{REBLS17p1, author = {Florian Myter and Christophe Scholliers and Wolfgang De Meuter}, title = {Handling Partial Failures in Distributed Reactive Programming}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {1--7}, doi = {10.1145/3141858.3141859}, year = {2017}, } Publisher's Version REBLS '17: "Tackling the Awkward Squad ..." Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model Sam Van den Vonder, Joeri De Koster, Florian Myter, and Wolfgang De Meuter (Vrije Universiteit Brussel, Belgium) In his famous paper entitled "Tackling the Awkward Squad", Peyton Jones studies how features that traditionally did not fit in the functional programming paradigm can be added to a functional language via careful language design (e.g. using monads), instead of allowing programmers to sprinkle around impure expressions and ad-hoc library calls, thereby turning the entire program into a non-functional program. Similarly, in this paper, we identify a number of code characteristics that do not map onto the reactive programming paradigm but that are present in many real life reactive programs. We propose a novel Actor-Reactor model that can serve as the basis for future language designs that allow a programmer to use the awkward squad without making the reactive parts of the program accidentally non-reactive. @InProceedings{REBLS17p27, author = {Sam Van den Vonder and Joeri De Koster and Florian Myter and Wolfgang De Meuter}, title = {Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {27--33}, doi = {10.1145/3141858.3141863}, year = {2017}, } Publisher's Version
	Nicolay, Jens	REBLS '17: "First-Class Reactive Programs ..." First-Class Reactive Programs for CPS Christophe De Troyer, Jens Nicolay, and Wolfgang De Meuter (Vrije Universiteit Brussel, Belgium) Cyber-Physical Systems (CPS) are comprised of a network of devices that vary widely in complexity, ranging from simple sensors to autonomous robots. Traditionally, controlling and sensing these devices happens through API communication, in either push or pull-based fashion. We argue that the computational power of these devices is converging to the point where they can do autonomous computations. This allows application programmers to run programs locally on the sensors, thereby reducing the communication and workload of more central command and control entities. This work introduces the Potato framework that aims to make programming CPS systems intuitively easy and fast. Potato is based on three essential mechanisms: failure handling by means of leasing, distribution by means of first-class reactive programs, and intentional retroactive designation of the network by means of capabilities and dynamic properties. In this paper we focus on the reactive capabilities of our framework. Potato enables programmers to create and deploy first-class reactive programs on CPS devices at run time, abstracting away from the API approach. Each node in the network is equipped with a minimal actor-based middleware that can execute first-class reactive programs. We have implemented Potato as a library in Elixir and have used it to implement several small examples. @InProceedings{REBLS17p21, author = {Christophe De Troyer and Jens Nicolay and Wolfgang De Meuter}, title = {First-Class Reactive Programs for CPS}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {21--26}, doi = {10.1145/3141858.3141862}, year = {2017}, } Publisher's Version
	Noorman, Job	REBLS '17: "FRP IoT Modules as a Scala ..." FRP IoT Modules as a Scala DSL Ben Calus, Bob Reynders, Dominique Devriese, Job Noorman, and Frank Piessens (KU Leuven, Belgium) With Internet of Things applications growing in size and popularity, physical sensor networks are more often running multiple complex applications. It becomes increasingly important to maintain these event-driven programs on embedded systems. Traditionally, event-driven applications such as sensor network applications are written using an imperative style of programming where different callback routines are registered to handle events. As the application complexity grows, the inverted control flow and reliance on shared global state makes this style of programming hard to maintain. Furthermore, sensor network applications are inherently distributed and are written by manually managing code-bases of sub-applications that go on all nodes separately. If security is important, the programmer needs to manually interface with low-level security primitives because there is no built-in notion of components. We propose a more maintainable approach where the developer essentially writes a first-order FRP program, containing code fragments in an embedded subset of C. From this FRP program, we generate efficient C code to be run on every node. Every module of the FRP program is compiled to a separate C module, making it easy to deploy modules to different nodes, and to enhance the security of the application by isolating modules from other software running on the nodes. Our implementation is based on a Scala EDSL that we use to let the user conveniently embed fragments of C code. The annotated C code gets compiled to Sancus, a security architecture for IoT nodes that supports the secure and distributed execution of the generated modules. @InProceedings{REBLS17p15, author = {Ben Calus and Bob Reynders and Dominique Devriese and Job Noorman and Frank Piessens}, title = {FRP IoT Modules as a Scala DSL}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {15--20}, doi = {10.1145/3141858.3141861}, year = {2017}, } Publisher's Version
	Piessens, Frank	REBLS '17: "FRP IoT Modules as a Scala ..." FRP IoT Modules as a Scala DSL Ben Calus, Bob Reynders, Dominique Devriese, Job Noorman, and Frank Piessens (KU Leuven, Belgium) With Internet of Things applications growing in size and popularity, physical sensor networks are more often running multiple complex applications. It becomes increasingly important to maintain these event-driven programs on embedded systems. Traditionally, event-driven applications such as sensor network applications are written using an imperative style of programming where different callback routines are registered to handle events. As the application complexity grows, the inverted control flow and reliance on shared global state makes this style of programming hard to maintain. Furthermore, sensor network applications are inherently distributed and are written by manually managing code-bases of sub-applications that go on all nodes separately. If security is important, the programmer needs to manually interface with low-level security primitives because there is no built-in notion of components. We propose a more maintainable approach where the developer essentially writes a first-order FRP program, containing code fragments in an embedded subset of C. From this FRP program, we generate efficient C code to be run on every node. Every module of the FRP program is compiled to a separate C module, making it easy to deploy modules to different nodes, and to enhance the security of the application by isolating modules from other software running on the nodes. Our implementation is based on a Scala EDSL that we use to let the user conveniently embed fragments of C code. The annotated C code gets compiled to Sancus, a security architecture for IoT nodes that supports the secure and distributed execution of the generated modules. @InProceedings{REBLS17p15, author = {Ben Calus and Bob Reynders and Dominique Devriese and Job Noorman and Frank Piessens}, title = {FRP IoT Modules as a Scala DSL}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {15--20}, doi = {10.1145/3141858.3141861}, year = {2017}, } Publisher's Version
	Reynders, Bob	REBLS '17: "FRP IoT Modules as a Scala ..." FRP IoT Modules as a Scala DSL Ben Calus, Bob Reynders, Dominique Devriese, Job Noorman, and Frank Piessens (KU Leuven, Belgium) With Internet of Things applications growing in size and popularity, physical sensor networks are more often running multiple complex applications. It becomes increasingly important to maintain these event-driven programs on embedded systems. Traditionally, event-driven applications such as sensor network applications are written using an imperative style of programming where different callback routines are registered to handle events. As the application complexity grows, the inverted control flow and reliance on shared global state makes this style of programming hard to maintain. Furthermore, sensor network applications are inherently distributed and are written by manually managing code-bases of sub-applications that go on all nodes separately. If security is important, the programmer needs to manually interface with low-level security primitives because there is no built-in notion of components. We propose a more maintainable approach where the developer essentially writes a first-order FRP program, containing code fragments in an embedded subset of C. From this FRP program, we generate efficient C code to be run on every node. Every module of the FRP program is compiled to a separate C module, making it easy to deploy modules to different nodes, and to enhance the security of the application by isolating modules from other software running on the nodes. Our implementation is based on a Scala EDSL that we use to let the user conveniently embed fragments of C code. The annotated C code gets compiled to Sancus, a security architecture for IoT nodes that supports the secure and distributed execution of the generated modules. @InProceedings{REBLS17p15, author = {Ben Calus and Bob Reynders and Dominique Devriese and Job Noorman and Frank Piessens}, title = {FRP IoT Modules as a Scala DSL}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {15--20}, doi = {10.1145/3141858.3141861}, year = {2017}, } Publisher's Version
	Scholliers, Christophe	REBLS '17: "Handling Partial Failures ..." Handling Partial Failures in Distributed Reactive Programming Florian Myter, Christophe Scholliers, and Wolfgang De Meuter (Vrije Universiteit Brussel, Belgium; Ghent University, Belgium) Distributed reactive programming enables programmers to reuse the abstractions provided by reactive programming to elegantly implement distributed systems. However, distributed reactive approaches have thus far neglected to address an inherent property of distributed systems: partial failures. This forces programmers to either disregard failures and write poor distributed code or try to detect failures manually (e.g. through time-outs and heartbeats). Moreover, this prohibits distributed reactive runtimes to garbage collect remote references to failed parts of the reactive network. In this paper we present a first attempt at failure handling for distributed reactive applications. To this end we introduce the novel concept of leased signals which allow both programmer and runtime to react to partial failures in distributed reactive applications. We implement leased signals in a distributed reactive TypeScript framework for the development of microservice applications. @InProceedings{REBLS17p1, author = {Florian Myter and Christophe Scholliers and Wolfgang De Meuter}, title = {Handling Partial Failures in Distributed Reactive Programming}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {1--7}, doi = {10.1145/3141858.3141859}, year = {2017}, } Publisher's Version
	Van den Vonder, Sam	REBLS '17: "Tackling the Awkward Squad ..." Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model Sam Van den Vonder, Joeri De Koster, Florian Myter, and Wolfgang De Meuter (Vrije Universiteit Brussel, Belgium) In his famous paper entitled "Tackling the Awkward Squad", Peyton Jones studies how features that traditionally did not fit in the functional programming paradigm can be added to a functional language via careful language design (e.g. using monads), instead of allowing programmers to sprinkle around impure expressions and ad-hoc library calls, thereby turning the entire program into a non-functional program. Similarly, in this paper, we identify a number of code characteristics that do not map onto the reactive programming paradigm but that are present in many real life reactive programs. We propose a novel Actor-Reactor model that can serve as the basis for future language designs that allow a programmer to use the awkward squad without making the reactive parts of the program accidentally non-reactive. @InProceedings{REBLS17p27, author = {Sam Van den Vonder and Joeri De Koster and Florian Myter and Wolfgang De Meuter}, title = {Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model}, booktitle = {Proc.\ REBLS}, publisher = {ACM}, pages = {27--33}, doi = {10.1145/3141858.3141863}, year = {2017}, } Publisher's Version

15 authors

proc time: 2.71