@article{christie_chopra_singh_2022, title={Mandrake: multiagent systems as a basis for programming fault-tolerant decentralized applications}, volume={36}, ISSN={["1573-7454"]}, url={https://doi.org/10.1007/s10458-021-09540-8}, DOI={10.1007/s10458-021-09540-8}, abstractNote={Abstract We conceptualize a decentralized software application as one constituted from autonomous agents that communicate via asynchronous messaging. Modern software paradigms such as microservices and settings such as the Internet of Things evidence a growing interest in decentralized applications. Constructing a decentralized application involves designing agents as independent local computations that coordinate successfully to realize the application’s requirements. Moreover, a decentralized application is susceptible to faults manifested as message loss, delay, and reordering. We contribute Mandrake , a programming model for decentralized applications that tackles these challenges without relying on infrastructure guarantees. Specifically, we adopt the construct of an information protocol that specifies messaging between agents purely in causal terms and can be correctly enacted by agents in a shared-nothing environment over nothing more than unreliable, unordered transport. Mandrake facilitates (1) implementing protocol-compliant agents by introducing a programming model; (2) transforming protocols into fault-tolerant ones with simple annotations; and (3) a declarative policy language that makes it easy to implement fault-tolerance in agents based on the capabilities in protocols. Mandrake’s significance lies in demonstrating a straightforward approach for constructing decentralized applications without relying on coordination mechanisms in the infrastructure, thus achieving some of the goals of the founders of networked computing from the 1970s.}, number={1}, journal={AUTONOMOUS AGENTS AND MULTI-AGENT SYSTEMS}, publisher={Springer Science and Business Media LLC}, author={Christie, Samuel H. and Chopra, Amit K. and Singh, Munindar P.}, year={2022}, month={Apr} }
 @article{chopra_christie_singh_2022, title={Multiagent Foundations for Distributed Systems: A Vision}, volume={13190}, ISBN={["978-3-030-97456-5"]}, ISSN={["1611-3349"]}, url={https://doi.org/10.1007/978-3-030-97457-2_4}, DOI={10.1007/978-3-030-97457-2_4}, abstractNote={Early works and retrospectives by the researchers who founded the network protocols underlying current distributed systems indicate they were aware of the importance of capturing application meaning but didn’t know how to handle it programmatically. Therefore, those researchers introduced simplifications in the protocols that violated their own principle of the end-to-end argument in systems design. The thesis of this vision paper is the following. First, the above-mentioned simplifications, especially the reliance on reliable, ordered communication protocols such as TCP have run their course. Modern applications demand flexibility that can only be achieved through modeling application meaning, and many applications (such as those based on the Internet of Things) cannot pay TCP’s overhead. Second, the multiagent systems community has developed alternative meaning-based approaches that can provide a new foundation for distributed computing at large.}, journal={ENGINEERING MULTI-AGENT SYSTEMS}, author={Chopra, Amit K. and Christie, Samuel H. and Singh, Munindar P.}, year={2022}, pages={62–71} }
 @article{christie_chopra_singh_2021, title={Bungie: Improving Fault Tolerance via Extensible Application-Level Protocols}, volume={54}, ISSN={["1558-0814"]}, url={https://doi.org/10.1109/MC.2021.3052147}, DOI={10.1109/MC.2021.3052147}, abstractNote={We present Bungie, an approach based on applicationlevel protocols that precisely capture the causality inherent to the interactions among agents. We show through patterns and examples how Bungie provides abstractions for achieving fault tolerance.}, number={5}, journal={COMPUTER}, publisher={Institute of Electrical and Electronics Engineers (IEEE)}, author={Christie, Samuel H. and Chopra, Amit Khushwant and Singh, Munindar P.}, year={2021}, month={May}, pages={44–53} }
 @article{christie_chopra_singh_2021, title={Deserv: Decentralized Serverless Computing}, url={https://doi.org/10.1109/ICWS53863.2021.00020}, DOI={10.1109/ICWS53863.2021.00020}, abstractNote={A decentralized application involves multiple autonomous principals, e.g., humans and organizations. Autonomy motivates (i) specifying a decentralized application via a protocol that captures the interactions between the principals, and (ii) a programming model that enables each principal to independently (from other principals) construct its own protocol-compliant agent. An agent encodes its principal's decision making and represents it in the application. We contribute Deserv, the first protocol-based programming model for decentralized applications that is suited to the cloud. Specifically, Deserv demonstrates how to leverage function-as-a-service (FaaS), a popular serverless programming model, to implement agents. A notable feature of Deserv is the use declarative protocols to specify interactions. Declarative protocols support implementing stateful agents in a manner that naturally exploits the concurrency and autoscaling benefits offered by serverless computing.}, journal={2021 IEEE INTERNATIONAL CONFERENCE ON WEB SERVICES, ICWS 2021}, publisher={IEEE}, author={Christie, Samuel H. and Chopra, Amit K. and Singh, Munindar P.}, year={2021}, pages={51–60} }
 @article{christie_singh_chopra_2021, title={Hercule: Representing and Reasoning About Norms as a Foundation for Declarative Contracts Over Blockchain}, volume={25}, ISSN={["1941-0131"]}, url={https://doi.org/10.1109/MIC.2021.3080982}, DOI={10.1109/MIC.2021.3080982}, abstractNote={Current blockchain approaches for business contracts are based on smart contracts, namely, software programs placed on a blockchain that are automatically executed to realize a contract. However, smart contracts lack flexibility and interfere with the autonomy of the parties concerned. We propose Hercule, an approach for declaratively specifying blockchain applications in a manner that reflects business contracts. Hercule represents a contract via regulatory norms that capture the involved parties’ expectations of one another. It computes the states of norms (hence, of contracts) from events in the blockchain. Hercule’s novelty and significance lie in that it operationalizes declarative contracts over semistructured databases, the underlying representation for practical blockchain such as Hyperledger Fabric and Ethereum. Specifically, it exploits the map–reduce capabilities of such stores to compute norm states. We demonstrate that our implementation over Hyperledger Fabric can process thousands of events per second, sufficient for many applications.}, number={4}, journal={IEEE INTERNET COMPUTING}, publisher={Institute of Electrical and Electronics Engineers (IEEE)}, author={Christie, Samuel H. and Singh, Munindar P. and Chopra, Amit K.}, year={2021}, pages={67–75} }
 @article{chopra_christie_singh_2021, title={Interaction-Oriented Programming: An Application Semantics Approach for Engineering Decentralized Applications}, DOI={10.1145/3465084.3467486}, abstractNote={Interaction-Oriented Programming (IOP) refers to multiagent concepts, languages, and programming models for engineering applications that are characterized by interactions between autonomous parties. Such applications arise in domains such as e-commerce, health care, and finance. Owing to the autonomy of the principals involved, such applications are conceptually decentralized. We demonstrate how to specify a decentralized application flexibly and how to engineer correct, fault-tolerant endpoints (agents) for the principals in a straightforward manner. Notably, the entire application is realized as agents communicating over an unordered, unreliable messaging infrastructure (our implementations in fact use UDP). IOP departs from traditional distributed systems approaches that rely on guarantees in the application's communication infrastructure, e.g., for ordering and fault tolerance. Notably, IOP shows how to address application semantics, the holy grail of distributed systems.}, journal={PROCEEDINGS OF THE 2021 ACM SYMPOSIUM ON PRINCIPLES OF DISTRIBUTED COMPUTING (PODC '21)}, author={Chopra, Amit K. and Christie, Samuel H. and Singh, Munindar P.}, year={2021}, pages={575–576} }
 @inbook{v_chopra_2020, title={Fault Tolerance in Multiagent Systems}, url={https://doi.org/10.1007/978-3-030-66534-0_5}, DOI={10.1007/978-3-030-66534-0_5}, abstractNote={A decentralized multiagent systems (MAS) is comprised of autonomous agents who interact with each other via asynchronous messaging. A protocol specifies a MAS by specifying the constraints on messaging between agents. Agents enact protocols by applying their own internal decision making. Various kinds of faults may occur when enacting a protocol. For example, messages may be lost, duplicates may be delivered, and agents may crash during the processing of a message. Our contribution in this paper is demonstrating how information protocols support rich fault tolerance mechanisms, and in a manner that is unanticipated by alternative approaches for engineering decentralized MAS.}, booktitle={Engineering Multi-Agent Systems}, publisher={Springer International Publishing}, author={V, Samuel H. Christie and Chopra, Amit K.}, year={2020}, pages={78–86} }
 @article{v_smirnova_chopra_singh_2020, title={Protocols Over Things: A Decentralized Programming Model for the Internet of Things}, volume={53}, url={https://doi.org/10.1109/MC.2020.3023887}, DOI={10.1109/MC.2020.3023887}, abstractNote={Current programming models for developing Internet of Things (IoT) applications are logically centralized and ill-suited for most IoT applications. We contribute Protocols over Things, a decentralized programming model that represents an IoT application via a protocol between the parties involved and provides improved performance over network-level delivery guarantees.}, number={12}, journal={Computer}, publisher={Institute of Electrical and Electronics Engineers (IEEE)}, author={V, Samuel H. Christie and Smirnova, Daria and Chopra, Amit K. and Singh, Munindar P.}, year={2020}, month={Dec}, pages={60–68} }
 @article{barik_lubick_christie_murphy-hill_2014, title={How Developers Visualize Compiler Messages: A Foundational Approach to Notification Construction}, DOI={10.1109/vissoft.2014.24}, abstractNote={Self-explanation is one cognitive strategy through which developers comprehend error notifications. Self-explanation, when left solely to developers, can result in a significant loss of productivity because humans are imperfect and bounded in their cognitive abilities. We argue that modern IDEs offer limited visual affordances for aiding developers with self-explanation, because compilers do not reveal their reasoning about the causes of errors to the developer. The contribution of our paper is a foundational set of visual annotations that aid developers in better comprehending error messages when compilers expose their internal reasoning. We demonstrate through a user study of 28 undergraduate Software Engineering students that our annotations align with the way in which developers self-explain error notifications. We show that these annotations allow developers to give significantly better self-explanations when compared against today's dominant visualization paradigm, and that better self-explanations yield better mental models of notifications. The results of our work suggest that the diagrammatic techniques developers use to explain problems can serve as an effective foundation for how IDEs should visually communicate to developers.}, journal={2014 SECOND IEEE WORKING CONFERENCE ON SOFTWARE VISUALIZATION (VISSOFT)}, author={Barik, Titus and Lubick, Kevin and Christie, Samuel and Murphy-Hill, Emerson}, year={2014}, pages={87–96} }