Large-Scale Microtask Programming

To make microtask programming more efficient and reduce the potential for conflicts between contributors, I developed a new behavior-driven approach to microtasking programming. In our approach, each microtask asks developers to identify a behavior behavior from a high-level description of a function, implement a unit test for it, implement the behavior, and debug it. It enables developers to work on functions in isolation through high-level function descriptions and stubs. In addition, I developed the first approach for building microservices through microtasks. Building microservices through microtasks is a good match because our approach requires a client to first specify the functionality the crowd will create through an API. This API can then take the form of a microservice description. A traditional project may ask a crowd to implement a new microservice by simply describing the desired behavior in a API and recruiting a crowd. We implemented our approach in a web-based IDE, \textit{Crowd Microservices}. It includes an editor for clients to describe the system requirements through endpoint descriptions as well as a web-based programming environment where crowd workers can identify, test, implement, and debug behaviors. The system automatically creates, manages, assigns microtasks. After the crowd finishes, the system automatically deploys the microservice to a hosting site.Comment: 2 page, 1 figure, GC VL/HCC 2020, Graduate Consortiu

Hierarchical agent supervision

Agent supervision is a form of control/customization where a supervisor restricts the behavior of an agent to enforce certain requirements, while leaving the agent as much autonomy as possible. To facilitate supervision, it is often of interest to consider hierarchical models where a high level abstracts over low-level behavior details. We study hierarchical agent supervision in the context of the situation calculus and the ConGolog agent programming language, where we have a rich first-order representation of the agent state. We define the constraints that ensure that the controllability of in-dividual actions at the high level in fact captures the controllability of their implementation at the low level. On the basis of this, we show that we can obtain the maximally permissive supervisor by first considering only the high-level model and obtaining a high- level supervisor and then refining its actions locally, thus greatly simplifying the supervisor synthesis task

A Fast Compiler for NetKAT

High-level programming languages play a key role in a growing number of networking platforms, streamlining application development and enabling precise formal reasoning about network behavior. Unfortunately, current compilers only handle "local" programs that specify behavior in terms of hop-by-hop forwarding behavior, or modest extensions such as simple paths. To encode richer "global" behaviors, programmers must add extra state -- something that is tricky to get right and makes programs harder to write and maintain. Making matters worse, existing compilers can take tens of minutes to generate the forwarding state for the network, even on relatively small inputs. This forces programmers to waste time working around performance issues or even revert to using hardware-level APIs. This paper presents a new compiler for the NetKAT language that handles rich features including regular paths and virtual networks, and yet is several orders of magnitude faster than previous compilers. The compiler uses symbolic automata to calculate the extra state needed to implement "global" programs, and an intermediate representation based on binary decision diagrams to dramatically improve performance. We describe the design and implementation of three essential compiler stages: from virtual programs (which specify behavior in terms of virtual topologies) to global programs (which specify network-wide behavior in terms of physical topologies), from global programs to local programs (which specify behavior in terms of single-switch behavior), and from local programs to hardware-level forwarding tables. We present results from experiments on real-world benchmarks that quantify performance in terms of compilation time and forwarding table size

Realtime system control by means of path expressions

A high-level, algebraic programming method for the online control of actions in a real-time, parallel processing environment is described. The method is based on the interaction of path expressions. On the basis of a set of path expressions, evocation of actions can be controlled in real-time in a fully automated way. It is shown how intelligent system behavior can be obtained by a combination of rules given as path expressions. Each of these rules specifies some partial behavior to which the system must comply. The control system operates as a rule-based action planning system that works online in an asynchronous environment. The development of the prototype system PBOS (Path Based Operating System) has demonstrated that path expression specification naturally integrates with a real-time, multitasking control syste

Teaching agents to learn: from user study to implementation

Graphical user interfaces have helped center computer use on viewing and editing, rather than on programming. Yet the need for end-user programming continues to grow. Software developers have responded to the demand with a barrage of customizable applications and operating systems. But the learning curve associated with a high level of customizability-even in GUI-based operating systems-often prevents users from easily modifying their software. Ironically, the question has become, "What is the easiest way for end users to program?" Perhaps the best way to customize a program, given current interface and software design, is for users to annotate tasks-verbally or via the keyboard-as they are executing them. Experiments have shown that users can "teach" a computer most easily by demonstrating a desired behavior. But the teaching approach raises new questions about how the system, as a learning machine, will correlate, generalize, and disambiguate a user's instructions. To understand how best to create a system that can learn, the authors conducted an experiment in which users attempt to train an intelligent agent to edit a bibliography. Armed with the results of these experiments, the authors implemented an interactive machine learning system, which they call Configurable Instructible Machine Architecture. Designed to acquire behavior concepts from few examples, Cima keeps users informed and allows them to influence the course of learning. Programming by demonstration reduces boring, repetitive work. Perhaps the most important lesson the authors learned is the value of involving users in the design process. By testing and critiquing their design ideas, users keep the designers focused on their objective: agents that make computer-based work more productive and more enjoyable

A Compilation Framework for Macroprogramming Networked Sensors

Abstract. Macroprogramming—the technique of specifying the behavior of the system, as opposed to the constituent nodes—provides application developers with high level abstractions that alleviate the programming burden in develop- ing wireless sensor network (WSN) applications. However, as the semantic gap between macroprogramming abstractions and node-level code is considerably wider than in traditional programming, converting the high level specification to running code is a daunting process, and a major hurdle to the acceptance of macroprogramming. In this paper, we propose a general compilation framework for a data-driven macroprogramming language that allows for plugging in different modules implementing various stages of compilation. We also demonstrate an actual instantiation of our framework by showing an end-to-end solution for compiling macro- programs. Our compiler provides the final code to be deployed on real nodes as well as an estimate of the costs the running system will incur, e.g., in terms of messages exchanged. We compared the auto-generated code against a hand- coded version for the same application behavior to verify the outcome of our compiler

SOTER: A Runtime Assurance Framework for Programming Safe Robotics Systems

The recent drive towards achieving greater autonomy and intelligence in robotics has led to high levels of complexity. Autonomous robots increasingly depend on third party off-the-shelf components and complex machine-learning techniques. This trend makes it challenging to provide strong design-time certification of correct operation. To address these challenges, we present SOTER, a robotics programming framework with two key components: (1) a programming language for implementing and testing high-level reactive robotics software and (2) an integrated runtime assurance (RTA) system that helps enable the use of uncertified components, while still providing safety guarantees. SOTER provides language primitives to declaratively construct a RTA module consisting of an advanced, high-performance controller (uncertified), a safe, lower-performance controller (certified), and the desired safety specification. The framework provides a formal guarantee that a well-formed RTA module always satisfies the safety specification, without completely sacrificing performance by using higher performance uncertified components whenever safe. SOTER allows the complex robotics software stack to be constructed as a composition of RTA modules, where each uncertified component is protected using a RTA module. To demonstrate the efficacy of our framework, we consider a real-world case-study of building a safe drone surveillance system. Our experiments both in simulation and on actual drones show that the SOTER-enabled RTA ensures the safety of the system, including when untrusted third-party components have bugs or deviate from the desired behavior