Instruct: Identify the main and secondary category of Arxiv papers based on the titles and abstracts
Query: Topology-Level Reactivity in Distributed Reactive Programs: Reactive
  Acquaintance Management using Flocks   Reactive programming is a popular paradigm to program event-driven
applications, and it is often proposed as a paradigm to write distributed
applications. One such type of application is *prosumer* applications, which
are distributed applications that both produce and consume many events. We
analyse the problems that occur when using a reactive programming language or
framework to implement prosumer applications. We find that the assumption of an
open network, which means prosumers of various types spontaneously join and
leave the network, can cause a lot of code complexity or run-time inefficiency.
At the basis of these issues lies *acquaintance management*: the ability to
discover prosumers as they join and leave the network, and correctly
maintaining this state throughout the reactive program. Most existing reactive
programming languages and frameworks have limited support for managing
acquaintances, resulting in accidental complexity of the code or inefficient
computations.
  In this paper we present acquaintance management for reactive programs.
First, we design an *acquaintance discovery* mechanism to create a *flock* that
automatically discovers prosumers on the network. An important aspect of flocks
is their integration with reactive programs, such that a reactive program can
correctly and efficiently maintain its state. To this end we design an
*acquaintance maintenance* mechanism: a new type of operator for functional
reactive programming languages that we call `deploy-*`. The `deploy-*` operator
enables correct and efficient reactions to time-varying collections of
discovered prosumers. The proposed mechanisms are implemented in a reactive
programming language called Stella, which serves as a linguistic vehicle to
demonstrate the ideas of our approach. Our implementation of acquaintance
management results in computationally efficient and idiomatic reactive code.
  We evaluate our approach quantitatively via benchmarks that show that our
implementation is efficient: computations will efficiently update whenever a
new prosumer is discovered, or a connected prosumer is dropped. To evaluate the
distributed capabilities of our prototype implementation, we implement a
use-case that simulates the bike-sharing infrastructure of Brussels, and we run
it on a Raspberry Pi cluster computer. We consider our work to be an important
step to use functional reactive programming to build distributed systems for
open networks, in other words, distributed reactive programs that involve many
prosumer devices and sensors that spontaneously join and leave the network.

25
The categories of this paper are: patt-sol
33
The categories of this paper are: plasm-ph
17
The categories of this paper are: q-fin
35
The categories of this paper are: mtrl-th
19
The categories of this paper are: eess
9
The categories of this paper are: nlin
27
The categories of this paper are: comp-gas
10
The categories of this paper are: q-bio
34
The categories of this paper are: chem-ph
20
The categories of this paper are: acc-phys
26
The categories of this paper are: bayes-an
36
The categories of this paper are: cmp-lg
0
The categories of this paper are: hep-ph
11
The categories of this paper are: hep-lat
21
The categories of this paper are: adap-org
6
The categories of this paper are: astro-ph