# papers

title: Oblivious Routing of Highly Variable Traffic in Service Overlays and IP Backbones
venue: IEEE/ACM Transactions on Networking
directory: distributed_systems/
created: 2017-09-06T19:06:04.512895996
modified: 2017-09-06T19:06:04.512895996
abstract:
The emergence of new applications on the Internet like voice-over-IP, peer-to-peer, and video-on-demand has created highly dynamic and changing traffic patterns. In order to route such traffic with quality-of-service (QoS) guarantees without requiring detection of traffic changes in real-time or reconfiguring the network in response to it, a routing and bandwidth allocation scheme has been recently proposed that allows preconfiguration of the network such that all traffic patterns permissible within the network's natural ingress-egress capacity constraints can be handled in a capacity efficient manner. The scheme routes traffic in two phases. In the first phase, incoming traffic is sent from the source to a set of intermediate nodes and then, in the second phase, from the intermediate nodes to the final destination. The traffic in the first phase is distributed to the intermediate nodes in predetermined proportions that depend on the intermediate nodes. In this paper, we develop linear programming formulations and a fast combinatorial algorithm for routing under the scheme so as to maximize throughput (or, minimize maximum link utilization). We compare the throughput performance of the scheme with that of the optimal scheme among the class of all schemes that are allowed to even make the routing dependent on the traffic matrix. For our evaluations, we use actual Internet Service Provider topologies collected for the Rocketfuel project. We also bring out the versatility of the scheme in not only handling widely fluctuating traffic but also accommodating applicability to several widely differing networking scenarios, including i) economical Virtual Private Networks (VPNs); ii) supporting indirection in specialized service overlay models like Internet Indirection Infrastructure (i3); iii) adding QoS guarantees to services that require routing through a network-based middlebox; and iv) reducing IP layer transit traffic and handling extreme traffic variability in IP-over-optical networks without dynamic reconfiguration of the optical layer. The two desirable properties of supporting indirection in specialized service overlay models and static optical layer provisioning in IP-over-optical networks are not present in other approaches for routing variable traffic, such as direct source-destination routing along fixed paths.


title: How the Hidden Hand Shapes the Market for Software Reliability
directory: distributed_systems/
created: 2017-09-06T19:06:05.356531982
modified: 2017-09-06T19:06:05.356531982
abstract:
— Since the 18th century, economists have recognized that absent government intervention, market forces determine the pricing and ultimate fate of technologies. Our contention is that the " hidden hand " explains a series of market failures impacting products in the field of software reliability. If reliability solutions are to reach mainstream developers, greater attention must be paid to market economics and drivers.


title: Efficient Selectivity and Backup Operators in Monte-Carlo Tree Search
venue: Computers and Games
directory: artificial_intelligence/
created: 2017-09-06T19:06:06.132245117
modified: 2017-09-06T19:06:06.132245117
abstract:
Monte-Carlo evaluation consists in estimating a position by averaging the outcome of several random continuations, and can serve as an evaluation function at the leaves of a min-max tree. This paper presents a new framework to combine tree search with Monte-Carlo evaluation , that does not separate between a min-max phase and a Monte-Carlo phase. Instead of backing-up the min-max value close to the root, and the average value at some depth, a more general backup operator is defined that progressively changes from averaging to min-max as the number of simulations grows. This approach provides a fine-grained control of the tree growth, at the level of individual simulations, and allows efficient selectivity methods. This algorithm was implemented in a 9 × 9 Go-playing program, Crazy Stone, that won the 10th KGS computer-Go tournament.


title: Dapper, a Large-Scale Distributed Systems Tracing Infrastructure
directory: distributed_systems/
created: 2017-09-06T19:06:06.757719971
modified: 2017-09-06T19:06:06.757719971
abstract:
Modern Internet services are often implemented as complex , large-scale distributed systems. These applications are constructed from collections of software modules that may be developed by different teams, perhaps in different programming languages, and could span many thousands of machines across multiple physical facilities. Tools that aid in understanding system behavior and reasoning about performance issues are invaluable in such an environment. Here we introduce the design of Dapper, Google's production distributed systems tracing infrastructure, and describe how our design goals of low overhead, application-level transparency, and ubiquitous deployment on a very large scale system were met. Dapper shares conceptual similarities with other tracing systems, particularly Magpie [3] and X-Trace [12], but certain design choices were made that have been key to its success in our environment, such as the use of sampling and restricting the instrumentation to a rather small number of common libraries. The main goal of this paper is to report on our experience building, deploying and using the system for over two years, since Dapper's foremost measure of success has been its usefulness to developer and operations teams. Dapper began as a self-contained tracing tool but evolved into a monitoring platform which has enabled the creation of many different tools, some of which were not anticipated by its designers. We describe a few of the analysis tools that have been built using Dapper, share statistics about its usage within Google, present some example use cases, and discuss lessons learned so far.


title: Functional Reactive Animation
venue: ICFP
directory: paradigms/functional_reactive_programming/
created: 2017-09-06T19:06:07.594613037
modified: 2017-09-06T19:06:07.594613037
abstract:
<i>Fran</i> (Functional Reactive Animation) is a collection of data types and functions for composing richly interactive, multimedia animations. The key ideas in Fran are its notions of <i>behaviors</i> and <i>events</i>. Behaviors are time-varying, reactive values, while events are sets of arbitrarily complex conditions, carrying possibly rich information. Most traditional values can be treated as behaviors, and when images are thus treated, they become animations. Although these notions are captured as data types rather than a programming language, we provide them with a denotational semantics, including a proper treatment of real time, to guide reasoning and implementation. A method to effectively and efficiently perform <i>event detection</i> using <i>interval analysis</i> is also described, which relies on the partial information structure on the domain of event times. Fran has been implemented in Hugs, yielding surprisingly good performance for an interpreter-based system. Several examples are given, including the ability to describe physical phenomena involving gravity, springs, velocity, acceleration, etc. using ordinary differential equations.


title: A survey on reactive programming
venue: ACM Comput. Surv.
directory: paradigms/functional_reactive_programming/
created: 2017-09-06T19:06:08.168893066
modified: 2017-09-06T19:06:08.168893066
abstract:
Reactive programming has recently gained popularity as a paradigm that is well-suited for developing event-driven and interactive applications. It facilitates the development of such applications by providing abstractions to express time-varying values and automatically managing dependencies between such values. A number of approaches have been recently proposed embedded in various languages such as Haskell, Scheme, JavaScript, Java, .NET, etc. This survey describes and provides a taxonomy of existing reactive programming approaches along six axes: representation of time-varying values, evaluation model, lifting operations, multidirectionality, glitch avoidance, and support for distribution. From this taxonomy, we observe that there are still open challenges in the field of reactive programming. For instance, multidirectionality is supported only by a small number of languages, which do not automatically track dependencies between time-varying values. Similarly, glitch avoidance, which is subtle in reactive programs, cannot be ensured in distributed reactive programs using the current techniques.


title: Meta algorithms for hierarchical Web caches
venue: IPCCC
directory: caching/
created: 2017-09-06T19:06:08.844947998
modified: 2017-09-06T19:06:08.844947998
abstract:
— Large scale hierarchical caches for web content have been deployed widely in an attempt to reduce delivery delays and bandwidth consumption and also to improve the scalability of content dissemination through the world wide web. Irrespectively of the specific replacement algorithm employed in each cache, a de facto characteristic of contemporary hierarchical caches is that a hit for a document at an ¢-level cache leads to the caching of the document in all intermediate caches (levels ¢ ¤ £ ¦ ¥ ¨ § © © © § ¥) on the path towards the leaf cache that received the initial request. This paper presents various algorithms that revise this standard behavior and attempt to be more selective in choosing the caches that get to store a local copy of the requested document. As these algorithms operate independently of the actual replacement algorithm running in each individual cache, they are referred to as meta algorithms. Three new meta algorithms are proposed and compared against the de facto one and a recently proposed one1] by means of synthetic and trace-driven simulations. The best of the new meta algorithms appears to be able to lead to improved performance under most simulated scenarios, especially under a low availability of storage. The latter observation makes the presented meta algorithms particularly favorable for the handling of large data objects such as stored music files or short video clips. Additionally, a simple load balancing algorithm that is based on the concept of meta algorithms is proposed and evaluated. The algorithm is shown to be able to provide for an effective balancing of load thus possibly addressing the recently discovered " filtering-effect " in hierarchical web caches (C. Williamson [2]).


title: Tor: The Second-Generation Onion Router
venue: USENIX Security Symposium
directory: distributed_systems/
created: 2017-09-06T19:06:09.787862061
modified: 2017-09-06T19:06:09.787862061
abstract:
We present Tor, a circuit-based low-latency anonymous communication service. This second-generation Onion Routing system addresses limitations in the original design. Tor adds perfect forward secrecy, congestion control, directory servers, integrity checking, configurable exit policies, and a practical design for rendezvous points. Tor works on the real-world Internet, requires no special privileges or kernel modifications, requires little synchronization or coordination between nodes, and provides a reasonable trade-off between anonymity, usability, and efficiency. We briefly describe our experiences with an international network of more than a dozen hosts. We close with a list of open problems in anonymous communication. Onion Routing is a distributed overlay network designed to anonymize TCP-based applications like web browsing, secure shell, and instant messaging. Clients choose a path through the network and build a circuit, in which each node (or " onion router " or " OR ") in the path knows its predecessor and successor, but no other nodes in the circuit. Traffic flows down the circuit in fixed-size cells, which are unwrapped by a symmetric key at each node (like the layers of an onion) and relayed downstream. The Onion Routing project published several design and analysis papers [27, 41, 48, 49]. While a wide area Onion Routing network was deployed briefly, the only long-running public implementation was a fragile proof-of-concept that ran on a single machine. Even this simple deployment processed connections from over sixty thousand distinct IP addresses from all over the world at a rate of about fifty thousand per day. But many critical design and deployment issues were never resolved, and the design has not been updated in several years. Here we describe Tor, a protocol for asynchronous, loosely federated onion routers that provides the following improvements over the old Onion Routing design: Perfect forward secrecy: Onion Routing was originally vulnerable to a single hostile node recording traffic and later compromising successive nodes in the circuit and forcing them to decrypt it. Rather than using a single multiply en-crypted data structure (an onion) to lay each circuit, Tor now uses an incremental or telescoping path-building design , where the initiator negotiates session keys with each successive hop in the circuit. Once these keys are deleted, subsequently compromised nodes cannot decrypt old traffic. As a side benefit, onion replay detection is no longer necessary, and the process of building circuits is more reliable , since the initiator knows when a hop fails …


title: Why Functional Programming Matters
venue: Comput. J.
directory: paradigms/functional_programming/
created: 2017-09-06T19:06:10.776664062
modified: 2017-09-06T19:06:10.776664062
abstract:
As software becomes more and more complex, it is more and more important to structure it well. Well-structured software is easy to write, easy to debug, and provides a collection of modules that can be re-used to reduce future programming costs. Conventional languages place conceptual limits on the way problems can be modularised. Functional languages push those limits back. In this paper we show that two features of functional languages in particular, higher-order functions and lazy evaluation, can contribute greatly to modularity. As examples, we manipulate lists and trees, program several numerical algorithms, and implement the alpha-beta heuristic an algorithm from Artiicial Intelligence used in game-playing programs. Since modularity is the key to successful programming, functional languages are vitally important to the real world.


title: A Versatile Scheme for Routing Highly Variable Traffic in Service Overlays and IP Backbones
venue: Proceedings IEEE INFOCOM 2006. 25TH IEEE International Conference on Computer Communications
directory: distributed_systems/
created: 2017-09-06T19:06:12.033961914
modified: 2017-09-06T19:06:12.033961914
abstract:
— The emergence of new applications on the Internet like voice-over-IP, peer-to-peer, and video-on-demand has created highly dynamic and changing traffic patterns. In order to route such traffic with Quality-of-Service (QoS) guarantees without requiring detection of traffic changes in real-time or reconfiguring the network in response to it, a routing and bandwidth allocation scheme has been recently proposed [9], [20] that allows preconfiguration of the network such that all traffic patterns permissible within the network's natural ingress-egress capacity constraints can be handled in a capacity efficient manner. The scheme routes traffic in two phases. In the first phase, incoming traffic is sent from the source to a set of intermediate nodes and then, in the second phase, from the intermediate nodes to the final destination. The traffic in the first phase is distributed to the intermediate nodes in predetermined proportions that depend on the intermediate nodes. In this paper, we develop linear programming formulations and a fast combinatorial algorithm for routing under the scheme so as to maximize throughput (or, minimize maximum link utilization). We compare the throughput performance of the scheme with that of the optimal scheme among the class of all schemes that are allowed to even make the routing dependent on the traffic matrix. For our evaluations, we use actual Internet Service Provider topologies collected for the Rocketfuel project. We also bring out the versatility of the scheme in not only handling widely fluctuating traffic but also accommodating applicability to several widely differing networking scenarios, including (i) economical Virtual Private Networks (VPNs), (ii) supporting indirection in specialized service overlay models like Internet Indirection Infrastructure (i3) [18], (iii) adding QoS guarantees to services that require routing through a network-based middlebox, and (iv) reducing IP layer transit traffic and handling extreme traffic variability in IP-over-Optical networks without dynamic reconfiguration of the optical layer. The two desirable properties of supporting indirection in specialized service overlay models and static optical layer provisioning in IP-over-Optical networks are not present in other approaches for routing variable traffic, such as direct source-destination routing along fixed paths, considered in [6], [11], [2]. I. INTRODUCTION As the Internet continues to grow in size and complexity , it becomes increasingly difficult to predict future traffic patterns. Many emerging applications for the Internet are characterized by highly variable traffic behavior over time. Classical approaches to network design and planning rely on a model in which a single traffic …


title: Herbivore: A Scalable and Efficient Protocol for Anonymous Communication
directory: distributed_systems/
created: 2017-09-06T19:06:12.76850708
modified: 2017-09-06T19:06:12.76850708
abstract:
Anonymity is increasingly important for networked applications amidst concerns over censorship and privacy. In this paper, we describe Herbivore, a peer-to-peer, scalable, tamper-resilient communication system that provides provable anonymity and privacy. Building on dining cryptographer networks, Herbivore scales by partitioning the network into anonymizing cliques. Adversaries able to monitor all network traffic cannot deduce the identity of a sender or receiver beyond an anonymiz-ing clique. In addition to strong anonymity, Herbivore simultaneously provides high efficiency and scalability, distinguishing it from other anonymous communication protocols. Performance measurements from a prototype implementation show that the system can achieve high bandwidths and low latencies when deployed over the Internet.


title: Beehive: O(1) Lookup Performance for Power-Law Query Distributions in Peer-to-Peer Overlays
venue: NSDI
directory: distributed_systems/
created: 2017-09-06T19:06:13.427961914
modified: 2017-09-06T19:06:13.427961914
abstract:
Structured peer-to-peer hash tables provide decentralization , self-organization, failure-resilience, and good worst-case lookup performance for applications, but suffer from high latencies (O(logN)) in the average case. Such high latencies prohibit them from being used in many relevant, demanding applications such as DNS. In this paper, we present a proactive replication framework that can provide constant lookup performance for common Zipf-like query distributions. This framework is based around a closed-form optimal solution that achieves O(1) lookup performance with low storage requirements , bandwidth overhead and network load. Simulations show that this replication framework can realistically achieve good latencies, outperform passive caching, and adapt efficiently to sudden changes in object popularity, also known as flash crowds. This framework provides a feasible substrate for high-performance, low-latency applications, such as peer-to-peer domain name service.


title: Life beyond Distributed Transactions: an Apostate's Opinion
venue: CIDR
directory: distributed_systems/
created: 2017-09-06T19:06:14.067424072
modified: 2017-09-06T19:06:14.067424072
abstract:
The positions expressed in this paper are personal opinions and do not in any way reflect the positions of my employer Amazon.com. ABSTRACT Many decades of work have been invested in the area of distributed transactions including protocols such as 2PC, Paxos, and various approaches to quorum. These protocols provide the application programmer a façade of global serializability. Personally, I have invested a non-trivial portion of my career as a strong advocate for the implementation and use of platforms providing guarantees of global serializability. My experience over the last decade has led me to liken these platforms to the Maginot Line 1. In general, application developers simply do not implement large scalable applications assuming distributed transactions. When they attempt to use distributed transactions, the projects founder because the performance costs and fragility make them impractical. Natural selection kicks in… 1 The Maginot Line was a huge fortress that ran the length of the Franco-German border and was constructed at great expense between World War I and World War II. It successfully kept the German army from directly crossing the border between France and Germany. It was quickly bypassed by the Germans in 1940 who invaded through Belgium. Instead, applications are built using different techniques which do not provide the same transactional guarantees but still meet the needs of their businesses. This paper explores and names some of the practical approaches used in the implementations of large-scale mission-critical applications in a world which rejects distributed transactions. We discuss the management of fine-grained pieces of application data which may be repartitioned over time as the application grows. We also discuss the design patterns used in sending messages between these repartitionable pieces of data. The reason for starting this discussion is to raise awareness of new patterns for two reasons. First, it is my belief that this awareness can ease the challenges of people hand-crafting very large scalable applications. Second, by observing the patterns, hopefully the industry can work towards the creation of platforms that make it easier to build these very large applications.


title: Megastore: Providing Scalable, Highly Available Storage for Interactive Services
venue: CIDR
directory: datastores/
created: 2017-09-06T19:06:14.710675049
modified: 2017-09-06T19:06:14.710675049
abstract:
Megastore is a storage system developed to meet the requirements of today's interactive online services. Megas-tore blends the scalability of a NoSQL datastore with the convenience of a traditional RDBMS in a novel way, and provides both strong consistency guarantees and high availability. We provide fully serializable ACID semantics within fine-grained partitions of data. This partitioning allows us to synchronously replicate each write across a wide area network with reasonable latency and support seamless failover between datacenters. This paper describes Megastore's semantics and replication algorithm. It also describes our experience supporting a wide range of Google production services built with Megastore.


title: An implementation and semantics for transactional memory introspection in Haskell
venue: PLAS
directory: languages/haskell/
created: 2017-09-06T19:06:17.519659912
modified: 2017-09-06T19:06:17.519659912
abstract:
Transactional Memory Introspection (TMI) is a novel reference monitor architecture that provides complete mediation, freedom from <i>time of check to time of use</i> bugs and improved failure handling for authorization. TMI builds on and integrates with implementations of the Software Transactional Memory (STM) architecture [Harris and Fraser 2003]. In this paper we present a formal definition of TMI and a concrete implementation over the Haskell STM. We find that this specification and reference implementation establishes clear semantics for the TMI architecture. In particular, they help identify and resolve ambiguities that apply to implementations such in our prior work [Birgisson et al. 2008].


title: On Proof and Progress in Mathematics
directory: distributed_systems/
created: 2017-09-06T19:06:20.546394043
modified: 2017-09-06T19:06:20.546394043
abstract:
This essay on the nature of proof and progress in mathematics was stimulated by the article of Jaffe and Quinn, "Theoretical Mathematics: Toward a cultural synthesis of mathematics and theoretical physics". Their article raises interesting issues that mathematicians should pay more attention to, but it also perpetuates some widely held beliefs and attitudes that need to be questioned and examined. The article had one paragraph portraying some of my work in a way that diverges from my experience, and it also diverges from the observations of people in the field whom I've discussed it with as a reality check. After some reflection, it seemed to me that what Jaffe and Quinn wrote was an example of the phenomenon that people see what they are tuned to see. Their portrayal of my work resulted from projecting the sociology of mathematics onto a one-dimensional scale (speculation versus rigor) that ignores many basic phenomena. Responses to the Jaffe-Quinn article have been invited from a number of mathematicians, and I expect it to receive plenty of specific analysis and criticism from others. Therefore, I will concentrate in this essay on the positive rather than on the contranegative. I will describe my view of the process of mathematics, referring only occasionally to Jaffe and Quinn by way of comparison. In attempting to peel back layers of assumptions, it is important to try to begin with the right questions: 1. What is it that mathematicians accomplish? There are many issues buried in this question, which I have tried to phrase in a way that does not presuppose the nature of the answer. It would not be good to start, for example, with the question How do mathematicians prove theorems? This question introduces an interesting topic, but to start with it would be to project two hidden assumptions: (1) that there is uniform, objective and firmly established theory and practice of mathematical proof, and (2) that progress made by mathematicians consists of proving theorems. It is worthwhile to examine these hypotheses, rather than to accept them as obvious and proceed from there.


title: Building global and scalable systems with atomic multicast
venue: Middleware
directory: datastores/
created: 2017-09-06T19:06:26.128658936
modified: 2017-09-06T19:06:26.128658936
abstract:
The rise of worldwide Internet-scale services demands large distributed systems. Indeed, when handling several millions of users, it is common to operate thousands of servers spread across the globe. Here, replication plays a central role, as it contributes to improve the user experience by hiding failures and by providing acceptable latency. In this work, we claim that atomic multicast, with strong and well-defined properties, is the appropriate abstraction to efficiently design and implement globally scalable distributed systems. We substantiate our claim with the design of two modern online services atop atomic multicast, a strongly consistent key-value store and a distributed log.


title: Symbolic Representation and Natural Language
directory: comp_sci_fundamentals_and_history/
created: 2017-09-06T19:06:26.75486792
modified: 2017-09-06T19:06:26.75486792
abstract:
The n o t ion of s y m bolizability is taken as the second requisite of comp u t a tion (the first being 'a l g o r i t h m i z a b i l i t y '), and it is shown that symbols, qua symbols, are not symbolizable. This has farreaching consequences for the computational study of language and for Al-research in language understanding. The representation hypothesis is formulated, and its various assumptions and goals are examined. A research strategy for the computational study of natural language u n d erstanding is outlined.


title: Buridan’s Principle
directory: physics/
created: 2017-09-06T19:06:28.2806521
modified: 2017-09-06T19:06:28.2806521
abstract:
The problem of Buridan's Ass, named after the fourteenth century French philosopher Jean Buridan, states that an ass placed equidistant between two bales of hay must starve to death because it has no reason to choose one bale over the other. With the benefit of modern mathematics, the argument can be expressed as follows. Assume that, at time 0, the ass is placed at position x along the line joining the bales of hay, where one bale is at position 0 and the other at position 1, so 0 < x < 1. The position of the ass at time t > 0 is a function of two arguments: the time t and the starting position x. Let A t (x) denote that position. For simplicity, assume that when the ass reaches a bale of hay it stays there forever, so for all t ≥ 0: A t (0) = 0, A t (1) = 1, and 0 ≤ A t (x) ≤ 1 for any x with 0 < x < 1. The ass is a physical mechanism subject to the laws of physics. Any such mechanism is continuous, so A t (x) is a continuous function of x. Since A t (0) = 0 and A t (1) = 1, by continuity there must be a finite range of values of x for which 0 < A t (x) < 1. These values represent initial positions of the ass for which it does not reach either bale of hay within t seconds. Such a range of values of x exists for any time t, including times large enough to insure that the ass has starved to death by then. Thus, there exists a finite range of starting positions for which the ass starves to death. The key assumption in this argument is continuity: the ass's position at a later time is a continuous function of its initial position. Continuity has been a guiding principle in the development of modern physics. Phenomena that appear discontinuous, such as discrete atomic spectral lines, are explained in terms of continuous physical laws, such as Schroedinger's equation. The assumption of continuity is discussed at length in Section 6. For now, let us accept it and investigate its consequences. The general principle underlying the starvation of Buridan's ass can be stated as follows: Buridan's Principle. A discrete decision based upon an input having a …


title: Flat Datacenter Storage
venue: OSDI
directory: datastores/
created: 2017-09-06T19:06:28.973719971
modified: 2017-09-06T19:06:28.973719971
abstract:
Flat Datacenter Storage (FDS) is a high-performance, fault-tolerant, large-scale, locality-oblivious blob store. Using a novel combination of full bisection bandwidth networks, data and metadata striping, and flow control, FDS multiplexes an application's large-scale I/O across the available throughput and latency budget of every disk in a cluster. FDS therefore makes many optimizations around data locality unnecessary. Disks also communicate with each other at their full bandwidth, making recovery from disk failures extremely fast. FDS is designed for datacenter scale, fully distributing metadata operations that might otherwise become a bottleneck. FDS applications achieve single-process read and write performance of more than 2 GB/s. We measure recovery of 92 GB data lost to disk failure in 6.2 s and recovery from a total machine failure with 655 GB of data in 33.7 s. Application performance is also high: we describe our FDS-based sort application which set the 2012 world record for disk-to-disk sorting.


title: Copysets: Reducing the Frequency of Data Loss in Cloud Storage
venue: USENIX Annual Technical Conference
directory: distributed_systems/
created: 2017-09-06T19:06:29.685522949
modified: 2017-09-06T19:06:29.685522949
abstract:
Random replication is widely used in data center storage systems to prevent data loss. However, random replica-tion is almost guaranteed to lose data in the common scenario of simultaneous node failures due to cluster-wide power outages. Due to the high fixed cost of each incident of data loss, many data center operators prefer to minimize the frequency of such events at the expense of losing more data in each event. We present Copyset Replication, a novel general-purpose replication technique that significantly reduces the frequency of data loss events. We implemented and evaluated Copyset Replication on two open source data center storage systems, HDFS and RAMCloud, and show it incurs a low overhead on all operations. Such systems require that each node's data be scattered across several nodes for parallel data recovery and access. Copyset Replication presents a near optimal trade-off between the number of nodes on which the data is scattered and the probability of data loss. For example, in a 5000-node RAMCloud cluster under a power outage, Copyset Replication reduces the probability of data loss from 99.99% to 0.15%. For Facebook's HDFS cluster, it reduces the probability from 22.8% to 0.78%.


title: Tiered Replication: A Cost-effective Alternative to Full Cluster Geo-replication
venue: USENIX Annual Technical Conference
directory: distributed_systems/
created: 2017-09-06T19:06:30.379120117
modified: 2017-09-06T19:06:30.379120117
abstract:
Cloud storage systems typically use three-way random replication to guard against data loss within the cluster, and utilize cluster geo-replication to protect against correlated failures. This paper presents a much lower cost alternative to full cluster geo-replication. We demonstrate that in practical settings, using two replicas is sufficient for protecting against independent node failures, while using three random replicas is inadequate for protecting against correlated node failures. We present Tiered Replication, a replication scheme that splits the cluster into a primary and backup tier. The first two replicas are stored on the primary tier and are used to recover data in the case of independent node failures , while the third replica is stored on the backup tier and is used to protect against correlated failures. The key insight of our paper is that, since the third replicas are rarely read, we can place the backup tier on separate physical infrastructure or a remote location without affecting performance. This separation significantly increases the resilience of the storage system to correlated failures and presents a low cost alternative to geo-replication of an entire cluster. In addition, the Tiered Replication algorithm optimally minimizes the probability of data loss under correlated failures. Tiered Repli-cation can be executed incrementally for each cluster change, which allows it to supports dynamic environments in which nodes join and leave the cluster, and it facilitates additional data placement constraints required by the storage designer, such as network and rack awareness. We have implemented Tiered Replication on HyperDex, an open-source cloud storage system, and demonstrate that it incurs a small performance overhead. Tiered Replication improves the cluster-wide MTTF by a factor of 20,000 compared to random replication and by a factor of 20 compared to previous non-random replica-tion schemes, without increasing the amount of storage.


title: Design Principles Behind Smalltalk
directory: languages/smalltalk/
created: 2017-09-06T19:06:31.505039062
modified: 2017-09-06T19:06:31.505039062
abstract:
The purpose of the Smalltalk project is to provide computer support for the creative spirit in everyone. Our work flows from a vision that includes a creative individual and the best computing hardware available. We have chosen to concentrate on two principle areas of research: a language of description (programming language) that serves as an interface between the models in the human mind and those in computing hardware, and a language of interaction (user interface) that matches the human communication system to that of the computer. Our work has followed a two-to four-year cycle that can be seen to parallel the scientific method: Build an application program within the current system (make an observation) Based on that experience, redesign the language (formulate a theory) Build a new system based on the new design (make a prediction that can be tested) The Smalltalk-80 system marks our fifth time through this cycle. In this article, I present some of the general principles we have observed in the course of our work. While the presentation frequently touches on Smalltalk "motherhood", the principles themselves are more general and should prove useful in evaluating other systems and in guiding future work. Just to get warmed up, I'll start with a principle that is more social than technical and that is largely responsible for the particular bias of the Smalltalk project: Personal Mastery: If a system is to serve the creative spirit, it must be entirely comprehensible to a single individual. The point here is that the human potential manifests itself in individuals. To realize this potential, we must provide a medium that can be mastered by a single individual. Any barrier that exists between the user and some part of the system will eventually be a barrier to creative expression. Any part of the system that cannot be changed or that is not sufficiently general is a likely source of impediment. If one part of the system works differently from all the rest, that part will require additional effort to control. Such an added burden may detract from the final result and will inhibit future endeavors in that area. We can thus infer a general principle of design: Good Design: A system should be built with a minimum set of unchangeable parts; those parts should be as general as possible; and all parts of the system should be held in a uniform framework. Language In …


title: ZooKeeper: Wait-free Coordination for Internet-scale Systems
venue: USENIX Annual Technical Conference
directory: distributed_systems/
created: 2017-09-06T19:06:32.836990967
modified: 2017-09-06T19:06:32.836990967
abstract:
In this paper, we describe ZooKeeper, a service for coordinating processes of distributed applications. Since ZooKeeper is part of critical infrastructure, ZooKeeper aims to provide a simple and high performance kernel for building more complex coordination primitives at the client. It incorporates elements from group messaging, shared registers, and distributed lock services in a repli-cated, centralized service. The interface exposed by Zoo-Keeper has the wait-free aspects of shared registers with an event-driven mechanism similar to cache invalidations of distributed file systems to provide a simple, yet powerful coordination service. The ZooKeeper interface enables a high-performance service implementation. In addition to the wait-free property, ZooKeeper provides a per client guarantee of FIFO execution of requests and linearizability for all requests that change the ZooKeeper state. These design decisions enable the implementation of a high performance processing pipeline with read requests being satisfied by local servers. We show for the target workloads, 2:1 to 100:1 read to write ratio, that ZooKeeper can handle tens to hundreds of thousands of transactions per second. This performance allows ZooKeeper to be used extensively by client applications.


title: A Hundred Impossibility Proofs for Distributed Computing
venue: PODC
directory: distributed_systems/
created: 2017-09-06T19:06:34.453427002
modified: 2017-09-06T19:06:34.453427002
abstract:
1 Introduction This talk is about impossibility results in the area of distributed computing. In this category, I include not just results that, say that a particular task cannot be accomplished, but also lower bound results, which say that a task cannot be accomplished within a certain bound on cost. I started out with a simple plan for preparing this talk: I would spend a couple of weeks reading all the impossibility proofs in our field, and would categs rize them according to the ideas used. Then I would make wise and general observations, and try to predict where the future of this area is headed. That turned out to be a bit too ambitious; there are many more such results than I thought. Although it is often hard to say what constitutes a " different result " , I managed to count over 100 such impossibility proofs! And my search wasn't even very systematic or exhaustive. It's not quite as hopeless to understand this area as it might seem from the number of papers. Although there are 100 different results, there aren't 100 different ideas. I thought I could contribute something by identifying some of the commonality among the different results. So what I will do in this talk will be an incomplete version of what I originally intended. I will give you Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific permission. a tour of the impossibility results that I was able to collect. I apologize for not being comprehensive, and in particular for placing perhaps undue emphasis on results I have been involved in (but those are the ones I know best!). I will describe the techniques used, as well as giving some historical perspective. I'll intersperse this with my opinions and observations, and I'll try to collect what I consider to be the most important of these at the end. Then I'll make some suggestions for future work. 2 The Results I classified the impossibility results I found into the following categories: shared memory resource allocation , distributed consensus, …


title: Pastry: Scalable, distributed object location and routing for large-scale peer-to-peer systems
directory: distributed_systems/
created: 2017-09-06T19:06:36.022144043
modified: 2017-09-06T19:06:36.022144043
abstract:
This paper presents the design and evaluation of Pastry, a scalable, distributed object location and routing scheme for wide-area peer-to-peer applications. Pastry performs application-level routing and object location in a potentially very large overlay network of nodes connected via the Internet. It can be used to support a wide range of peer-to-peer applications like global data storage, global data sharing, and naming. An insert operation in Pastry stores an object at a user-defined number of diverse nodes within the Pastry network. A lookup operation reliably retrieves a copy of the requested object if one exists. Moreover, a lookup is usually routed to the node nearest the client issuing the lookup (by some measure of proximity), among the nodes storing the requested object. Pastry is completely decentralized, scalable, and self-configuring; it automatically adapts to the arrival, departure and failure of nodes. Experimental results obtained with a prototype implementation on a simulated network of up to 100,000 nodes confirm Pastry's scalability, its ability to self-configure and adapt to node failures, and its good network locality properties.


title: RADOS: a scalable, reliable storage service for petabyte-scale storage clusters
venue: PDSW
directory: datastores/
created: 2017-09-06T19:06:36.640909912
modified: 2017-09-06T19:06:36.640909912
abstract:
Brick and object-based storage architectures have emerged as a means of improving the scalability of storage clusters. However, existing systems continue to treat storage nodes as passive devices, despite their ability to exhibit significant intelligence and autonomy. We present the design and implementation of RADOS, a reliable object storage service that can scales to many thousands of devices by leveraging the intelligence present in individual storage nodes. RADOS preserves consistent data access and strong safety semantics while allowing nodes to act semi-autonomously to self-manage replication, failure detection, and failure recovery through the use of a small cluster map. Our implementation offers excellent performance, reliability, and scalability while providing clients with the illusion of a single logical object store.


title: Mesos: A Platform for Fine-Grained Resource Sharing in the Data Center
venue: NSDI
directory: distributed_systems/
created: 2017-09-06T19:06:37.218272949
modified: 2017-09-06T19:06:37.218272949
abstract:
Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission. Abstract We present Mesos, a platform for sharing commodity clusters between multiple diverse cluster computing frameworks, such as Hadoop and MPI 1. Sharing improves cluster utilization and avoids per-framework data replication. Mesos shares resources in a fine-grained manner, allowing frameworks to achieve data locality by taking turns reading data stored on each machine. To support the sophisticated schedulers of today's frameworks , Mesos introduces a distributed two-level scheduling mechanism called resource offers. Mesos decides how many resources to offer each framework, while frameworks decide which resources to accept and which computations to run on them. Our experimental results show that Mesos can achieve near-optimal locality when sharing the cluster among diverse frameworks, can scale up to 50,000 nodes, and is resilient to node failures.


title: Particle gibbs with ancestor sampling
venue: Journal of Machine Learning Research
directory: data_structures/
created: 2017-09-06T19:06:38.152174072
modified: 2017-09-06T19:06:38.152174072
abstract:
Particle Markov chain Monte Carlo (PMCMC) is a systematic way of combining the two main tools used for Monte Carlo statistical inference: sequential Monte Carlo (SMC) and Markov chain Monte Carlo (MCMC). We present a new PMCMC algorithm that we refer to as particle Gibbs with ancestor sampling (PGAS). PGAS provides the data analyst with an off-the-shelf class of Markov kernels that can be used to simulate, for instance, the typically high-dimensional and highly autocorrelated state trajectory in a state-space model. The ancestor sampling procedure enables fast mixing of the PGAS kernel even when using seemingly few particles in the underlying SMC sampler. This is important as it can significantly reduce the computational burden that is typically associated with using SMC. PGAS is conceptually similar to the existing PG with backward simulation (PGBS) procedure. Instead of using separate forward and backward sweeps as in PGBS, however, we achieve the same effect in a single forward sweep. This makes PGAS well suited for addressing inference problems not only in state-space models, but also in models with more complex dependencies, such as non-Markovian, Bayesian nonparametric, and general probabilistic graphical models.


title: Quantum vacuum pressure on a conducting slab
directory: physics/
created: 2017-09-06T19:06:38.850137939
modified: 2017-09-06T19:06:38.850137939
abstract:
The casimir pressure on a non ideal conducting slab is calculated. Using a simple model for the conductivity according to which the slab is perfectly conducting at frequencies below plasma frequency ω p and perfectly transparent above such frequency, it is found that the vacuum pressure on each surface of the slab is ¯ hω 4 p 24π 2 c 3 which is finite without removal of any divergence.


title: How to design a good API and why it matters
venue: OOPSLA Companion
directory: api_design/
created: 2017-09-06T19:06:40.661684082
modified: 2017-09-06T19:06:40.661684082
abstract:
In lieu of a traditional , I've tried to distill the essence of the talk into a collection of maxims:<ul><li><b>All programmers are API designers.</b> Good programs are modular, and intermodular boundaries define APIs. Good modules get reused.</li><li><b>APIs can be among your greatest assets or liabilities.</b> Good APIs create long-term customers; bad ones create long-term support nightmares.</li><li><b>Public APIs, like diamonds, are forever.</b> You have one chance to get it right so give it your best.</li><li><b>APIs should be easy to use and hard to misuse.</b> It should be easy to do simple things; possible to do complex things; and impossible, or at least difficult, to do wrong things.</li><li><b>APIs should be self-documenting:</b> It should rarely require documentation to read code written to a good API. In fact, it should rarely require documentation to write it.</li><li><b>When designing an API, first gather requirements - with a healthy degree of skepticism.</b> People often provide solutions; it's your job to ferret out the underlying problems and find the best solutions.</li><li><b>Structure requirements as use-cases:</b> they are the yardstick against which you'll measure your API.</li><li><b>Early drafts of APIs should be short,</b> typically one page with class and method signatures and one-line descriptions. This makes it easy to restructure the API when you don't get it right the first time.</li><li><b>Code the use-cases against your API before you implement it</b>, even before you specify it properly. This will save you from implementing, or even specifying, a fundamentally broken API.</li><li><b>Maintain the code for uses-cases as the API evolves.</b> Not only will this protect you from rude surprises, but the resulting code will become the examples for the API, the basis for tutorials and tests.</li><li><b>Example code should be exemplary.</b> If an API is used widely, its examples will be the archetypes for thousands of programs. Any mistakes will come back to haunt you a thousand fold.</li><li><b>You can't please everyone so aim to displease everyone equally.</b> Most APIs are overconstrained.</li><li><b>Expect API-design mistakes due to failures of imagination.</b> You can't reasonably hope to imagine everything that everyone will do with an API, or how it will interact with every other part of a system.</li><li><b>API design is not a solitary activity.</b> Show your design to as many people as you can, and take their feedback seriously. Possibilities that elude your imagination may be clear to others.</li><li><b>Avoid fixed limits on input sizes.</b> They limit usefulness and hasten obsolescence.</li><li><b>If it's hard to find good names, go back to the drawing board.</b> Don't be afraid to split or merge an API, or embed it in a more general setting. If names start falling into place, you're on the right track.</li><li><b>Names matter.</b> Strive for intelligibility, consistency, and symmetry. Every API is a little language, and people must learn to read and write it. If you get an API right, code will read like prose.</li><li><b>When in doubt, leave it out.</b> If there is a fundamental theorem of API design, this is it. It applies equally to functionality, classes, methods, and parameters. Every facet of an API should be as small as possible, but no smaller. You can always add things later, but you can't take them away.</li><li><b>Minimizing <i>conceptual weight</i> is more important than class- or method-count.</b></li><li><b>Keep APIs free of implementations details.</b> They confuse users and inhibit the flexibility to evolve. It isn't always obvious what's an implementation detail: Be wary of overspecification.</li><li><b>Minimize mutability.</b> Immutable objects are simple, thread-safe, and freely sharable.</li><li><b>Documentation matters.</b> No matter how good an API, it won't get used without good documentation. Document every exported API element: every class, method, field, and parameter.</li><li><b>Consider the performance consequences of API design decisions,</b> but don't warp an API to achieve performance gains. Luckily, good APIs typically lend themselves to fast implementations.</li><li><b>APIs must coexist peacefully with the platform, so do what is customary.</b> It is almost always wrong to "transliterate" an API from one platform to another.</li><li><b>Minimize accessibility; when in doubt, make it private.</b> This simplifies APIs and reduces coupling.</li><li><b>Subclass only if you can say with a straight face that every instance of the subclass is an instance of the superclass.</b> Exposed classes should never subclass just to reuse implementation code.</li><li><b>Design and document for inheritance or else prohibit it.</b> This documentation takes the form of self-use patterns: how methods in a class use one another. Without it, safe subclassing is impossible.</li><li><b>Don't make the client do anything the library could do.</b> Violating this rule leads to boilerplate code in the client, which is annoying and error-prone.</li><li><b>Obey the principle of least astonishment.</b> Every method should do the least surprising thing it could, given its name. If a method doesn't do what users think it will, bugs will result.</li><li><b>Fail fast.</b> The sooner you report a bug, the less damage it will do. Compile-time is best. If you must fail at run-time, do it as soon as possible.</li><li><b>Provide programmatic access to all data available in string form.</b> Otherwise, programmers will be forced to parse strings, which is painful. Worse, the string forms will turn into de facto APIs.</li><li><b>Overload with care.</b> If the behaviors of two methods differ, it's better to give them different names.</li><li><b>Use the right data type for the job.</b> For example, don't use string if there is a more appropriate type.</li><li><b>Use consistent parameter ordering across methods.</b> Otherwise, programmers will get it backwards.</li><li><b>Avoid long parameter lists,</b> especially those with multiple consecutive parameters of the same type.</li><li><b>Avoid return values that demand exceptional processing.</b> Clients will forget to write the special-case code, leading to bugs. For example, return zero-length arrays or collections rather than nulls.</li><li><b>Throw exceptions only to indicate exceptional conditions</b>. Otherwise, clients will be forced to use exceptions for normal flow control, leading to programs that are hard to read, buggy, or slow.</li><li><b>Throw unchecked exceptions unless clients can realistically recover from the failure.</b></li><li><b>API design is an art, not a science.</b> Strive for beauty, and trust your gut. Do not adhere slavishly to the above heuristics, but violate them only infrequently and with good reason.</li></ul>.


title: A Universal Modular ACTOR Formalism for Artificial Intelligence
venue: IJCAI
directory: distributed_systems/
created: 2017-09-06T19:06:41.3347771
modified: 2017-09-06T19:06:41.3347771
abstract:
This paper proposes a modular ACTOR architecture and definitional method for artificial intelligence that is conceptually based on a single kind of object: actors [or, if you will, virtual processors, activation frames, or streams]. The formalism makes no presuppositions about the representation of primitive data structures and control structures. Such structures can be programmed, micro-coded, or hard wired 1n a uniform modular fashion. In fact it is impossible to determine whether a given object is "really" represented as a list, a vector, a hash table, a function, or a process. The architecture will efficiently run the coming generation of PLANNER-like artificial intelligence languages including those requiring a high degree of parallelism. The efficiency is gained without loss of programming generality because it only makes certain actors more efficient; it does not change their behavioral characteristics. The architecture is general with respect to control structure and does not have or need goto, interrupt, or semaphore primitives. The formalism achieves the goals that the disallowed constructs are intended to achieve by other more structured methods. PLANNER Progress "Programs should not only work, but they should appear to work as well." PDP-1X Dogma The PLANNER project is continuing research in natural and effective means for embedding knowledge in procedures. In the course of this work we have succeeded in unifying the formalism around one fundamental concept: the ACTOR. Intuitively, an ACTOR is an active agent which plays a role on cue according to a script" we" use the ACTOR metaphor to emphasize the inseparability of control and data flow in our model. data bases can all be shown to be special cases of actors. All of the above are objects with certain useful modes of behavior. Our formalism shows how all of the modes of behavior can be defined in terms of one kind of behavior: sending messages to actors. An actor is always invoked uniformly in exactly the same way regardless of whether 1t behaves as a recursive function, data structure, or process. "It is vain to multiply Entities beyond need." William of Occam "Monotheism is the Answer." The unification and simplification of the formalisms for the procedural embedding of knowledge has a great many benefits for us: FOUNDATIONS: The concept puts procedural semantics [the theory of how things operate] on a firmer basis. It will now be possible to do cleaner theoretical studies of the relation between procedural semantics and set-theoretic …


title: The LCA Problem Revisited
venue: LATIN
directory: data_structures/
created: 2017-09-06T19:06:42.037481934
modified: 2017-09-06T19:06:42.037481934
abstract:
We present a very simple algorithm for the Least Common Ancestor problem. We thus dispel the frequently held notion that an optimal LCA computation is unwieldy and unimplementable. Interestingly, this algorithm is a sequentialization of a previously known PRAM algorithm of Berkman, Breslauer,


title: Stasis: Flexible Transactional Storage
venue: OSDI
directory: datastores/
created: 2017-09-06T19:06:43.354815918
modified: 2017-09-06T19:06:43.354815918
abstract:
An increasing range of applications requires robust support for atomic, durable and concurrent transactions. Databases provide the default solution, but force applications to interact via SQL and to forfeit control over data layout and access mechanisms. We argue there is a gap between DBMSs and file systems that limits designers of data-oriented applications.
 Stasis is a storage framework that incorporates ideas from traditional write-ahead logging algorithms and file systems. It provides applications with flexible control over data structures, data layout, robustness, and performance. Stasis enables the development of unforeseen variants on transactional storage by generalizing write-ahead logging algorithms. Our partial implementation of these ideas already provides specialized (and cleaner) semantics to applications.
 We evaluate the performance of a traditional transactional storage system based on Stasis, and show that it performs favorably relative to existing systems. We present examples that make use of custom access methods, modified buffer manager semantics, direct log file manipulation, and LSN-free pages. These examples facilitate sophisticated performance optimizations such as zero-copy I/O. These extensions are composable, easy to implement and significantly improve performance.


title: Eluding carnivores: file sharing with strong anonymity
venue: ACM SIGOPS European Workshop
directory: distributed_systems/
created: 2017-09-06T19:06:43.985160889
modified: 2017-09-06T19:06:43.985160889
abstract:
Anonymity is increasingly important for networked applications amidst concerns over censorship and privacy. This paper outlines the design of HerbivoreFS, a scalable and efficient file sharing system that provides strong anonymity. HerbivoreFS provides computational guarantees that even adversaries able to monitor all network traffic cannot deduce the identity of a sender or receiver beyond an anonymizing clique of <i>k</i> peers. HerbivoreFS achieves scalability by partitioning the global network into smaller anonymizing cliques. Measurements on PlanetLab indicate that the system achieves high anonymous bandwidth when deployed on the Internet.


title: The UNIX Time-Sharing System
venue: Commun. ACM
directory: operating_systems/
created: 2017-09-06T19:06:45.61564209
modified: 2017-09-06T19:06:45.61564209
abstract:
UNIX is a general-purpose, multi-user, interactive operating system for the Digital Equipment Corporation PDP-11/40 and 11/45 computers. It offers a number of features seldom found even in larger operating systems, including: (1) a hierarchical file system incorporating demountable volumes; (2) compatible file, device, and inter-process I/O; (3) the ability to initiate asynchronous processes; (4) system command language selectable on a per-user basis; and (5) over 100 subsystems including a dozen languages. This paper discusses the nature and implementation of the file system and of the user command interface.


title: The Pagerank Citation Ranking: Bringing Order to the Web
directory: information_retrieval/
created: 2017-09-06T19:06:46.375980957
modified: 2017-09-06T19:06:46.375980957
abstract:
The importance of a Web page is an inherently subjective matter, which depends on the readers interests, knowledge and attitudes. But there is still much that can be said objectively about the relative importance of Web pages. This paper describes PageRank, a method for rating Web pages objectively and mechanically, eeectively measuring the human interest and attention devoted to them. We compare PageRank to an idealized random Web surfer. We show how to eeciently compute PageRank for large numbers of pages. And, we show how to apply PageRank to search and to user navigation.


title: A Data-driven Method for the Detection of Close Submitters in Online Learning Environments
venue: WWW
directory: gamification/
created: 2017-09-06T19:06:47.276063965
modified: 2017-09-06T19:06:47.276063965
abstract:
Online learning has become very popular over the last decade. However , there are still many details that remain unknown about the strategies that students follow while studying online. In this study, we focus on the direction of detecting 'invisible' collaboration ties between students in online learning environments. Specifically, the paper presents a method developed to detect student ties based on temporal proximity of their assignment submissions. The paper reports on findings of a study that made use of the proposed method to investigate the presence of close submitters in two different massive open online courses. The results show that most of the students (i.e., student user accounts) were grouped as couples, though some bigger communities were also detected. The study also compared the population detected by the algorithm with the rest of user accounts and found that close submitters needed a statistically significant lower amount of activity with the platform to achieve a certificate of completion in a MOOC. These results confirm that the detected close submitters were performing some collaboration or even engaged in unethical behaviors, which facilitates their way into a certificate. However, more work is required in the future to specify various strategies adopted by close submitters and possible associations between the user accounts.


title: Secure network provenance
venue: SOSP
directory: distributed_systems/
created: 2017-09-06T19:06:47.911821045
modified: 2017-09-06T19:06:47.911821045
abstract:
This paper introduces <i>secure network provenance (SNP)</i>, a novel technique that enables networked systems to explain to their operators <i>why</i> they are in a certain state -- e.g., why a suspicious routing table entry is present on a certain router, or where a given cache entry originated. SNP provides network forensics capabilities by permitting operators to track down faulty or misbehaving nodes, and to assess the damage such nodes may have caused to the rest of the system. SNP is designed for adversarial settings and is robust to manipulation; its tamper-evident properties ensure that operators can detect when compromised nodes lie or falsely implicate correct nodes.
 We also present the design of SNooPy, a general-purpose SNP system. To demonstrate that SNooPy is practical, we apply it to three example applications: the Quagga BGP daemon, a declarative implementation of Chord, and Hadoop MapReduce. Our results indicate that SNooPy can efficiently explain state in an adversarial setting, that it can be applied with minimal effort, and that its costs are low enough to be practical.


title: A Response to Cheriton and Skeen's Criticism of Causal and Totally Ordered Communication
venue: Operating Systems Review
directory: distributed_systems/
created: 2017-09-06T19:06:48.537523926
modified: 2017-09-06T19:06:48.537523926
abstract:
In a paper to be presented at the 1993 ACM Symposium on Operating Systems Principles, Cheriton and Skeen offer their understanding of causal and total ordering as a communication property. In this brief rebuttal. I present some responses to their criticism, and also explain why I find their discussion of causal and total communication ordering to be narrow and incomplete.


title: Commodifying Replicated State Machines with OpenReplica
directory: distributed_systems/
created: 2017-09-06T19:06:49.056123047
modified: 2017-09-06T19:06:49.056123047
abstract:
This paper describes OpenReplica, an open service that provides replication and synchronization support for large-scale distributed systems. OpenReplica is designed to commodify Paxos replicated state machines by providing infrastructure for their construction, deployment and maintenance. OpenReplica is based on a novel Paxos replicated state machine implementation that employs an object-oriented approach in which the system actively creates and maintains live replicas for user-provided objects. Clients access these replicated objects transparently as if they are local objects. OpenReplica supports complex distributed synchronization constructs through a multi-return mechanism that enables the replicated objects to control the execution flow of their clients, in essence providing blocking and non-blocking method in-vocations that can be used to implement richer synchronization constructs. Further, it supports elasticity requirements of cloud deployments by enabling any number of servers to be replaced dynamically. A rack-aware placement manager places replicas on nodes that are unlikely to fail together. Experiments with the system show that the latencies associated with replication are comparable to ZooKeeper, and that the system scales well.


title: Cognitive Computing: A Brief Survey and Open Research Challenges
directory: paradigms/new_paradigms/
created: 2017-09-06T19:06:49.73623999
modified: 2017-09-06T19:06:49.73623999
abstract:
Cognitive computing is a multidisciplinary field of research aiming at devising computational models and decision making mechanisms based on the neurobiological processes of the brain, cognitive sciences, and psychology. The objective of cognitive computational models is to endow computer systems with the faculties of knowing, thinking, and feeling. The major contributions of this survey include (i) giving insights into cognitive computing by listing and describing its definitions, related fields, and terms, (ii) classifying current research on cognitive computing according to its objectives, (iii) presenting a concise review of cognitive computing approaches, and (iv) identifying the open research issues in the area of cognitive computing.

venue:
2015 3rd International Conference on Applied Computing and Information Technology/2nd International Conference on Computational Science and Intelligence


title: On the Electrodynamics of Moving Bodies
directory: physics/
created: 2017-09-06T19:06:50.622789062
modified: 2017-09-06T19:06:50.622789062
abstract:
It is known that Maxwell's electrodynamics—as usually understood at the present time—when applied to moving bodies, leads to asymmetries which do not appear to be inherent in the phenomena. Take, for example, the reciprocal electrodynamic action of a magnet and a conductor. The observable phenomenon here depends only on the relative motion of the conductor and the magnet, whereas the customary view draws a sharp distinction between the two cases in which either the one or the other of these bodies is in motion. For if the magnet is in motion and the conductor at rest, there arises in the neighbourhood of the magnet an electric field with a certain definite energy, producing a current at the places where parts of the conductor are situated. But if the magnet is stationary and the conductor in motion, no electric field arises in the neighbourhood of the magnet. In the conductor, however, we find an electro-motive force, to which in itself there is no corresponding energy, but which gives rise—assuming equality of relative motion in the two cases discussed—to electric currents of the same path and intensity as those produced by the electric forces in the former case. Examples of this sort, together with the unsuccessful attempts to discover any motion of the earth relatively to the " light medium, " suggest that the phenomena of electrodynamics as well as of mechanics possess no properties corresponding to the idea of absolute rest. They suggest rather that, as has already been shown to the first order of small quantities, the same laws of electrodynamics and optics will be valid for all frames of reference for which the equations of mechanics hold good. 1 We will raise this conjecture (the purport of which will hereafter be called the " Principle of Relativity ") to the status of a postulate, and also introduce another postulate, which is only apparently irreconcilable with the former, namely, that light is always propagated in empty space with a definite velocity c which is independent of the state of motion of the emitting body. These two postulates suffice for the attainment of a simple and consistent theory of the electrodynamics of moving bodies based on Maxwell's theory for stationary bodies. The introduction of a " luminiferous ether " will prove to be superfluous inasmuch as the view here to be developed will not require an " absolutely stationary space " …


title: In Search of an Understandable Consensus Algorithm
venue: USENIX Annual Technical Conference
directory: distributed_systems/
created: 2017-09-06T19:06:51.851302979
modified: 2017-09-06T19:06:51.851302979
abstract:
Raft is a consensus algorithm for managing a replicated log. It produces a result equivalent to (multi-)Paxos, and it is as efficient as Paxos, but its structure is different from Paxos; this makes Raft more understandable than Paxos and also provides a better foundation for building practical systems. In order to enhance understandabil-ity, Raft separates the key elements of consensus, such as leader election, log replication, and safety, and it enforces a stronger degree of coherency to reduce the number of states that must be considered. Results from a user study demonstrate that Raft is easier for students to learn than Paxos. Raft also includes a new mechanism for changing the cluster membership, which uses overlapping majorities to guarantee safety.


title: Distributed Snapshots: Determining Global States of Distributed Systems
venue: ACM Trans. Comput. Syst.
directory: distributed_systems/
created: 2017-09-06T19:06:52.618040039
modified: 2017-09-06T19:06:52.618040039
abstract:
This paper presents an algorithm by which a process in a distributed system determines a global state of the system during a computation. Many problems in distributed systems can be cast in terms of the problem of detecting global states. For instance, the global state detection algorithm helps to solve an important class of problems: stable property detection. A stable property is one that persists: once a stable property becomes true it remains true thereafter. Examples of stable properties are &#8220;computation has terminated,&#8221; &#8220; the system is deadlocked&#8221; and &#8220;all tokens in a token ring have disappeared.&#8221; The stable property detection problem is that of devising algorithms to detect a given stable property. Global state detection can also be used for checkpointing.


title: Why Do Some Men Use Violence Against Women and How Can We Prevent It?
directory: distributed_systems/
created: 2017-09-06T19:06:56.841433105
modified: 2017-09-06T19:06:56.841433105
abstract:
The views expressed in this publication are those of the authors and do not necessarily represent those of the United Nations, including UNDP, UNFPA, UN Women, UNV or UN Member States. UNDP partners with people at all levels of society to help build nations that can withstand crisis and drive and sustain the kind of growth that improves the quality of life for everyone. On the ground in 177 countries and territories, we offer a global perspective and local insight to help empower lives and build resilient nations. The United Nations Population Fund (UNFPA) is an international development agency that works with countries to protect and promote the sexual and reproductive health of women, men and young people. The United Nations Entity for Gender Equality and the Empowerment of Women (UN Women) is a global champion for women and girls; UN Women was established to accelerate progress on meeting their rights worldwide. The United Nations Volunteers (UNV) programme, is the UN organization that contributes to peace and development through volunteerism worldwide. Partners for Prevention is a UNDP, UNFPA, UN Women and UNV regional joint programme for gender-based violence prevention in Asia and the Pacific. foreword Violence against women constrains the enjoyment of women's human rights everywhere. We know that it is a manifestation of power and control and a tool to maintain gender inequalities, disrupting the health, survival, safety and freedom of women and their families around the world. We know that to end violence against women and girls, we must ensure their full empowerment, promote and protect their rights, including access to justice and support services, and end the discrimination they face in all aspects of their lives. Changing cultures towards zero tolerance for violence against women, therefore, must be a priority for States, communities and families. Over the past few decades, much has been done in legal and policy reform and the extension of services to support and protect women and their families from domestic and sexual violence, while prevention efforts have focused on campaigns and advocacy that have brought the issue into public consciousness. Preventing violence requires the sustained involvement of socializing institutions at the community and state levels, including schools, faith-based organizations, media and popular culture. This is recognized in the Declaration on the Elimination of Violence against Women, which calls for States to modify the social and cultural patterns of conduct of men and women …


title: High-Level Specifications: Lessons from Industry
venue: FMCO
directory: distributed_systems/
created: 2017-09-06T19:06:57.786835938
modified: 2017-09-06T19:06:57.786835938
abstract:
We explain the rationale behind the design of the TLA + specification language , and we describe our experience using it and the TLC model checker in industrial applications—including the verification of multiprocessor memory designs at Intel. Based on this experience, we challenge some conventional wisdom about high-level specifications.


title: Consistency and fault tolerance for erasure-coded distributed storage systems
venue: DICT@HPDC
directory: datastores/
created: 2017-09-06T19:06:59.006271973
modified: 2017-09-06T19:06:59.006271973
abstract:
One challenge in applying erasure codes (or error-correcting codes) to distributed storage systems is to maintain consistency between data and redundancy blocks in the face of crashing servers. We present two access protocols that provide sequential consistency and maximum distance separable fault tolerance at the same time. The protocols use sequence numbers to recover a consistent version in the presence of failures or partial writes. The first (pessimistic) PSW protocol uses a master per stripe to execute updates in sequence. The second (optimistic) OCW protocol allows concurrent writes to blocks in the same stripe to happen in parallel at the cost of additional buffer space.
 We present empirical performance results for PSW and OCW and compare them to other protocols. Our results show that OCW is as fast as simple replication while providing better fault tolerance and/or reduced storage overhead. This demonstrates that erasure coding can be used as a space-efficient alternative to replication in distributed storage systems.


title: Reducing Garbage Collector Cache Misses
venue: ISMM
directory: garbage_collection/
created: 2017-09-06T19:07:00.376624023
modified: 2017-09-06T19:07:00.376624023
abstract:
Cache misses are currently a major factor in the cost of garbage collection, and we expect them to dominate in the future. Traditional garbage collection algorithms exhibit relatively little temporal locality; each live object in the heap is likely to be touched exactly once during each garbage collection. We measure two techniques for dealing with this issue: prefetch-on-grey, and lazy sweeping. The first of these is new in this context. Lazy sweeping has been in common use for a decade. It was introduced as a mechanism for reducing paging and pause times; we argue that it is also crucial for eliminating cache misses during the sweep phase.
Our measurements are obtained in the context of a non-moving garbage collector. Fully copying garbage collection inherently requires more traffic through the cache, and thus probably also stands to benefit substantially from something like the prefetch-on-grey technique. Generational garbage collection may reduce the benefit of these techniques for some applications, but experiments with a non-moving generational collector suggest that they remain quite useful.


title: Towards Equal Rights for Higher-kinded Types
directory: paradigms/functional_programming/
created: 2017-09-06T19:07:01.276646973
modified: 2017-09-06T19:07:01.276646973
abstract:
Generics are a very popular feature of contemporary OO languages, such as Java, C# or Scala. Their support for genericity is lacking, however. The problem is that they only support abstracting over proper types, and not over generic types. This limitation makes it impossible to, e.g., define a precise interface for Iterable, a core abstraction in Scala's collection API. We implemented " type constructor polymorphism " in Scala 2.5, which solves this problem at the root, thus greatly reducing the duplication of type signatures and code.


title: Back to the future: the story of Squeak, a practical Smalltalk written in itself
directory: comp_sci_fundamentals_and_history/
created: 2017-09-06T19:07:01.89023999
modified: 2017-09-06T19:07:01.89023999
abstract:
Squeak is an open, highly-portable Smalltalk implementation whose virtual machine is written entirely in Smalltalk, making it easy to debug, analyze, and change. To achieve practical performance, a translator produces an equivalent C program whose performance is comparable to commercial Smalltalks. Other noteworthy aspects of Squeak include: a compact object format that typically requires only a single word of overhead per object; a simple yet efficient incremental garbage collector for 32-bit direct pointers; efficient bulk-mutation of objects; extensions of BitBlt to handle color of any depth and anti-aliased image rotation and scaling; and real-time sound and music synthesis written entirely in Smalltalk. It includes platform-independent support for color, sound, and image processing. Originally developed on the Macintosh, members of its user community have since ported it to numerous platforms including Windows 95 and NT, Windows CE, all common flavors of UNIX, and the Acorn. Squeak stands alone as a practical Smalltalk in which a researcher, professor, or motivated student can examine source code for every part of the system, including graphics primitives and the virtual machine itself, and make changes immediately and without needing to see or deal with any language other than Smalltalk. It also runs bit-identical images across its wide portability base. Three strands weave through this paper:. 1 the design of the Squeak virtual machine, which differs in several interesting ways from the implementation presented in the Smalltalk "Blue Book" [Gold83] and explored in the "Green Book" [Kras83];. 2 an implementation strategy based on writing the Squeak virtual machine in Smalltalk and translating it into C, using an existing Smalltalk for bootstrapping until Squeak was able to debug and generate its own virtual machine; and. 3 the incremental development process through which Squeak was created and evolved over the course of a year.


title: Dining Cryptographers are Practical
directory: distributed_systems/
created: 2017-09-06T19:07:02.64151001
modified: 2017-09-06T19:07:02.64151001
abstract:
The dining cryptographers protocol provides information-theoretically secure sender and recipient untraceability. However, the protocol is considered to be impractical because a malicious participant may disrupt the communication. We propose an implementation which provides information-theoretical security for senders and recipients, and in which a disruptor with limited computational capabilites can easily be detected.


title: SoK: Eternal War in Memory
venue: 2013 IEEE Symposium on Security and Privacy
directory: security/
created: 2017-09-06T19:07:03.987009033
modified: 2017-09-06T19:07:03.987009033
abstract:
Memory corruption bugs in software written in low-level languages like C or C++ are one of the oldest problems in computer security. The lack of safety in these languages allows attackers to alter the program's behavior or take full control over it by hijacking its control flow. This problem has existed for more than 30 years and a vast number of potential solutions have been proposed, yet memory corruption attacks continue to pose a serious threat. Real world exploits show that all currently deployed protections can be defeated. This paper sheds light on the primary reasons for this by describing attacks that succeed on today's systems. We systematize the current knowledge about various protection techniques by setting up a general model for memory corruption attacks. Using this model we show what policies can stop which attacks. The model identifies weaknesses of currently deployed techniques, as well as other proposed protections enforcing stricter policies. We analyze the reasons why protection mechanisms implementing stricter polices are not deployed. To achieve wide adoption, protection mechanisms must support a multitude of features and must satisfy a host of requirements. Especially important is performance, as experience shows that only solutions whose overhead is in reasonable bounds get deployed. A comparison of different enforceable policies helps designers of new protection mechanisms in finding the balance between effectiveness (security) and efficiency. We identify some open research problems, and provide suggestions on improving the adoption of newer techniques.


title: RAY: Integrating Rx and Async for Direct-Style Reactive Streams
directory: paradigms/functional_reactive_programming/
created: 2017-09-06T19:07:06.59047998
modified: 2017-09-06T19:07:06.59047998
abstract:
Languages like F#, C#, and recently also Scala, provide “async” extensions which aim to make asynchronous programming easier by avoiding an inversion of control that is inherent in traditional callback-based programming models (for the purpose of this paper called the “Async” model). This paper outlines a novel approach to integrate the Async model with observable streams of the Reactive Extensions model which is best-known from the .NET platform, and of which popular implementations exist for Java, Ruby, and other widespread languages. We outline the translation of “Reactive Async” programs to efficient state machines, in a way that generalizes the state machine translation of regular Async programs. Finally, we sketch a formalization of the Reactive Async model in terms of a small-step operational semantics.


title: Warp: Lightweight Multi-Key Transactions for Key-Value Stores
venue: ArXiv
directory: datastores/
created: 2017-09-06T19:07:07.199143066
modified: 2017-09-06T19:07:07.199143066
abstract:
Traditional NoSQL systems scale by sharding data across multiple servers and by performing each operation on a small number of servers. Because transactions on multiple keys necessarily require coordination across multiple servers, NoSQL systems often explicitly avoid making transactional guarantees in order to avoid such coordination. Past work on transactional systems control this coordination by either increasing the granularity at which transactions are ordered, sacrificing serializability, or by making clock synchronicity assumptions. This paper presents a novel protocol for providing serializable transactions on top of a sharded data store. Called acyclic transactions, this protocol allows multiple transactions to prepare and commit simultaneously, improving concurrency in the system, while ensuring that no cycles form between concurrently-committing transactions. We have fully implemented acyclic transactions in a document store called Warp. Experiments show that Warp achieves 4× higher throughput than Sinfo-nia's mini-transactions on the standard TPC-C benchmark with no aborts. Further, the system achieves 75% of the throughput of the non-transactional key-value store it builds upon.


title: Part I: Transcendence of Values of Some Special Functions
directory: mathematics/
created: 2017-09-06T19:07:07.846612061
modified: 2017-09-06T19:07:07.846612061
abstract:
This paper is a transcript of the Inaugural Monroe H. Martin Lecture and Seminar given at Johns Hopkins University on February 23rd and 24th, 2009. In Part I, we present classical and recent results on the transcendence of values of certain special functions of one variable at algebraic points. In Part II, we describe some new results, joint with Marvin D. Tretkoff, on the transcendence of values at algebraic points of hypergeometric functions of several variables. Note that the author's maiden name is Paula B. Cohen. In this part of our paper, we present some results on the transcendence of values of certain special functions of one variable at algebraic points. Recall that the algebraic numbers are the complex numbers satisfying a non-trivial polynomial relation with rational coefficients. We denote the field of rational numbers by Q, and the field of algebraic numbers by Q. A transcendental number, α, is a complex number which is not algebraic. Therefore P (α) = 0 for every polynomial P ∈ Q[x] with at least one non-zero coefficient. The first examples of explicit transcendental numbers are due to Liouville in 1844 [Lio1], but their construction is rather artificial. Liouville showed that an irrational algebraic number cannot be too well approximated by rational numbers with denominators of relatively small size. He then constructed numbers that are so well approximated by rational numbers that they must be transcendental. An example is the number ξ = ∞ n=1 10 −n!. In 1874, Cantor gave another proof of the existence of transcendental numbers. He showed that the set of all algebraic numbers is countable, while the set of real numbers is uncountable. It follows that the set of transcendental numbers is uncountable. Somewhat paradoxically, it is usually very difficult to show that any given number is transcendental.


title: Bouvier's Conjecture
directory: distributed_systems/
created: 2017-09-06T19:07:08.428653076
modified: 2017-09-06T19:07:08.428653076
abstract:
This paper deals with Bouvier's conjecture which sustains that finite-dimensional non-Noetherian Krull domains need not be Jaf-fard.


title: kvm: the Linux Virtual Machine Monitor
directory: operating_systems/
created: 2017-09-06T19:07:09.745834961
modified: 2017-09-06T19:07:09.745834961
abstract:
Virtualization is a hot topic in operating systems these days. It is useful in many scenarios: server consolidation , virtual test environments, and for Linux enthusiasts who still can not decide which distribution is best. Recently , hardware vendors of commodity x86 processors have added virtualization extensions to the instruction set that can be utilized to write relatively simple virtual machine monitors. The Kernel-based Virtual Machine, or kvm, is a new Linux subsystem which leverages these virtualization extensions to add a virtual machine monitor (or hyper-visor) capability to Linux. Using kvm, one can create and run multiple virtual machines. These virtual machines appear as normal Linux processes and integrate seamlessly with the rest of the system. Virtualization has been around almost as long as computers. The idea of using a computer system to emulate another, similar, computer system was early recognized as useful for testing and resource utilization purposes. As with many computer technologies, IBM led the way with their VM system. In the last decade, VMware's software-only virtual machine monitor has been quite successful. More recently, the Xen [xen] open-source hypervisor brought virtualization to the open source world, first with a variant termed paravirtualization and as hardware became available, full virtualization. 2 x86 Hardware Virtualization Extensions x86 hardware is notoriously difficult to virtualize. Some instructions that expose privileged state do not trap when executed in user mode, e.g. popf. Some privileged state is difficult to hide, e.g. the current privilege level, or cpl. Recognizing the importance of virtualization, hardware vendors [Intel][AMD] have added extensions to the x86 architecture that make virtualization much easier. While these extensions are incompatible with each other, they are essentially similar, consisting of: • A new guest operating mode – the processor can switch into a guest mode, which has all the regular privilege levels of the normal operating modes, except that system software can selectively request that certain instructions, or certain register accesses, be trapped. • Hardware state switch – when switching to guest mode and back, the hardware switches the control registers that affect processor operation modes, as well as the segment registers that are difficult to switch, and the instruction pointer so that a control transfer can take effect. • Exit reason reporting – when a switch from guest mode back to host mode occurs, the hardware reports the reason for the switch so that software can take the appropriate action. Under …


title: Improved Dynamic Dictionary Matching
venue: Inf. Comput.
directory: pattern_matching/
created: 2017-09-06T19:07:10.418604004
modified: 2017-09-06T19:07:10.418604004
abstract:
1 Introduction In the dynamic dictionary matching problem, a dictionary D contains a set of patterns that can change over time by insertion and deletion of individual patterns. The user also presents text strings and asks for all occurrences of any patterns in the text. The two main contributions of this paper are: 1) A faster algorithm for dynamic string dictionary matching with bounded alphabets, and 2) A dynamic dictionary matching algorithm for two dimensional texts and square patterns. The first contribution is based on an algorithm that solves the general problem of maintaining a sequence of well-balanced parentheses under the operations insert, delete, and find nearest enclosing parenthesis pair. The main ideas behind the second contribution are: a linearization of two dimensional square patterns along the main diagonal, and new data structures to allow efficient manipulation of failure links. The classical pattern matching paradigm is that of searching for a given pattern in a given text. For example, the classical string matching problem is defined This is one of the most studied problems in computer science [16] and has many different linear time solutions (e.g., [lo, 191 d an many others). The two dimensional version of this problem in which strings of symbols are replaced with matrices is also well studied [9, 8, 21. Another paradigm is that of multiple matching. The input is a set of patterns D and a text. The object is to find all occurrences of all patterns from D that appear in the text. A motivation for this paradigm was given by Aho and Corasick [l]. They solved a bibliographic search problem for a set of words. Aho and Corasick gave an O((t + d) loga + tocc) time algorithm (AC for short) for the multiple string matching problem, where the text is of length t, the sum of all pattern lengths is d, the total number of pattern occurrences reported is tom, and u is the number of distinct characters that occur in D. It will always be the case that d 1 u, so terms depending on 0 are sometimes omitted. Recently there has been interest in a stronger paradigm, that of (dynamic) dictionary matching. Like multiple matching, we seek all appearances of any of a set of patterns (the dictionary) in an input text. The difference between dictionary matching and multiple matching is that the dictionary matching paradigm assumes a very …


title: Programming with algebraic effects and handlers
venue: J. Log. Algebr. Meth. Program.
directory: plt/
created: 2017-09-06T19:07:14.466851074
modified: 2017-09-06T19:07:14.466851074
abstract:
Eff is a programming language based on the algebraic approach to computational effects, in which effects are viewed as algebraic operations and effect handlers as homomorphisms from free algebras. Eff supports first-class effects and handlers through which we may easily define new computational effects, seamlessly combine existing ones, and handle them in novel ways. We give a de-notational semantics of eff and discuss a prototype implementation based on it. Through examples we demonstrate how the standard effects are treated in eff , and how eff supports programming techniques that use various forms of delimited continuations , such as backtracking, breadth-first search, selection functionals, cooperative multi-threading, and others.


# files

sha1: bde7543a8b3ce071342dfaea2a14357431d94b82
directory: distributed_systems/
normalized: kelips building an efficient and stable p2p dht through increased memory and background overhead
created: 2017-09-06T19:00:44.712782959
modified: 2017-09-06T19:00:44.712782959
filename:
kelips-building-an-efficient-and-stable-p2p-dht-through-increased-memory-and-background-overhead.pdf


sha1: 9d48eb6b89a9d7aa6feab3f6b2f57c70c1d9d18f
directory: languages/haskell/
created: 2017-09-06T19:00:46.021583984
modified: 2017-09-06T19:00:46.021583984
filename:
tackling-the-awkward-squad-monadic-input-output-concurrency-exceptions-and-foreign-language-calls-in-haskell.pdf

normalized:
tackling the awkward squad monadic input output concurrency exceptions and foreign language calls in haskell


# links

url: http://www.bodden.de/pubs/far+14flowdroid.pdf
directory: android/
created: 2017-09-06T19:00:46.404493896
modified: 2017-09-06T19:00:46.404493896
title:
FlowDroid: Precise Context, Flow, Field, Object-sensitive and Lifecycle-aware Taint Analysis for Android Apps


directory: artificial_intelligence/
created: 2017-09-06T19:00:46.406383057
modified: 2017-09-06T19:00:46.406383057
url:
https://github.com/papers-we-love/papers-we-love/blob/master/artificial_intelligence/3-bayesian-network-inference-algorithm.pdf

title:
Analysis of Three Bayesian Network Inference Algorithms: Variable Elimination, Likelihood Weighting, and Gibbs Sampling


title: An O(1) algorithm for implementing the LFU cache eviction scheme
directory: caching/
created: 2017-09-06T19:00:46.407103027
modified: 2017-09-06T19:00:46.407103027
url:
https://github.com/papers-we-love/papers-we-love/blob/master/caching/a-constant-algorithm-for-implementing-the-lfu-cache-eviction-scheme.pdf


title: On the Computational Complexity of Algorithims
directory: comp_sci_fundamentals_and_history/
created: 2017-09-06T19:00:46.407785889
modified: 2017-09-06T19:00:46.407785889
url:
http://www.ams.org/journals/tran/1965-117-00/S0002-9947-1965-0170805-7/S0002-9947-1965-0170805-7.pdf


title: MEXICA: a computer model of a cognitive account of creative writing.
directory: computational_creativity/
created: 2017-09-06T19:00:46.408032959
modified: 2017-09-06T19:00:46.408032959
url:
https://www.researchgate.net/publication/220080099_MEXICA_A_computer_model_of_a_cognitive_account_of_creative_writing


title: Map-Reduce-Merge: Simplified Relational Data Processing on Large Clusters
directory: datastores/
created: 2017-09-06T19:00:46.410187988
modified: 2017-09-06T19:00:46.410187988
url:
http://www.cs.duke.edu/courses/cps399.28/current/papers/sigmod07-YangDasdanEtAl-map_reduce_merge.pdf


title: A simple totally ordered broadcast protocol
directory: distributed_systems/
created: 2017-09-06T19:00:46.41112207
modified: 2017-09-06T19:00:46.41112207
url:
http://diyhpl.us/~bryan/papers2/distributed/distributed-systems/zab.totally-ordered-broadcast-protocol.2008.pdf


title: Practical Byzantine Fault Tolerance and Proactive Recovery
directory: distributed_systems/
created: 2017-09-06T19:00:46.41112207
modified: 2017-09-06T19:00:46.41112207
url:
http://www.itu.dk/stud/speciale/bepjea/xwebtex/litt/practical-byzantine-fault-tolerance-and-proactive-recovery.pdf


url: https://www.usenix.org/system/files/conference/osdi14/osdi14-paper-yuan.pdf
directory: distributed_systems/
created: 2017-09-06T19:00:46.41112207
modified: 2017-09-06T19:00:46.41112207
title:
Simple Testing Can Prevent Most Critical Failures:
An Analysis of Production Failures in Distributed
Data-Intensive Systems


title: From Game Design Elements to Gamefulness: Defining “Gamification”
directory: gamification/
created: 2017-09-06T19:00:46.413339111
modified: 2017-09-06T19:00:46.413339111
url:
http://dl.dropboxusercontent.com/u/220532/MindTrek_Gamification_PrinterReady_110806_SDE_accepted_LEN_changes_1.pdf


title: Epidemic Algorithms for Replicated Database Maintenance
directory: gossip/
created: 2017-09-06T19:00:46.413781982
modified: 2017-09-06T19:00:46.413781982
url:
http://bitsavers.informatik.uni-stuttgart.de/pdf/xerox/parc/techReports/CSL-89-1_Epidemic_Algorithms_for_Replicated_Database_Maintenance.pdf


url: http://www.thocp.net/biographies/papers/backus_turingaward_lecture.pdf
directory: plt/
created: 2017-09-06T19:00:46.418325928
modified: 2017-09-06T19:00:46.418325928
title:
Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs


title: Fundamental Concepts in Programming Languages
directory: plt/
created: 2017-09-06T19:00:46.418325928
modified: 2017-09-06T19:00:46.418325928
url:
https://github.com/papers-we-love/papers-we-love/blob/master/plt/fundamental-concepts-in-programming-languages.pdf


title: On Understanding Types, Data Abstraction, and Polymorphism
directory: plt/
created: 2017-09-06T19:00:46.418325928
modified: 2017-09-06T19:00:46.418325928
url:
https://github.com/papers-we-love/papers-we-love/blob/master/plt/on-understanding-types-data-abstraction-polymorphism.pdf


title: Principal type-schemes for functional programs
directory: plt/
created: 2017-09-06T19:00:46.418325928
modified: 2017-09-06T19:00:46.418325928
url:
https://github.com/papers-we-love/papers-we-love/blob/master/plt/principal-type-schemes-for-functional-programs.pdf


title: Programming Languages: Application and Interpretation
directory: plt/
created: 2017-09-06T19:00:46.418325928
modified: 2017-09-06T19:00:46.418325928
url:
https://github.com/papers-we-love/papers-we-love/blob/master/plt/programming-languages-application-and-interpretation.pdf


title: The Derivative of a Regular Type is its Type of One-Hole Contexts
directory: plt/
created: 2017-09-06T19:00:46.418325928
modified: 2017-09-06T19:00:46.418325928
url:
https://github.com/papers-we-love/papers-we-love/blob/master/plt/the-derivative-of-a-regular-type-one-hole-contexts.pdf


title: Calculus of Communicating Systems
directory: processes/
created: 2017-09-06T19:00:46.418654053
modified: 2017-09-06T19:00:46.418654053
url:
https://moodle.risc.jku.at/pluginfile.php/3407/mod_resource/content/1/A%20Calculus%20of%20Communicating%20Systems%5B1980%5D.pdf


title: Probablistic Counting Algorithms for Database Applications
directory: sublinear_algorithms/
created: 2017-09-06T19:00:46.420031006
modified: 2017-09-06T19:00:46.420031006
url:
https://github.com/papers-we-love/papers-we-love/blob/master/sublinear_algorithms/1985-Flajolet-Probabilistic-counting.pdf


title: An Elementary Proof of a Theorem of Johnson and Lindenstrauss
directory: sublinear_algorithms/
created: 2017-09-06T19:00:46.420031006
modified: 2017-09-06T19:00:46.420031006
url:
https://github.com/papers-we-love/papers-we-love/blob/master/sublinear_algorithms/An-Elementary-Proof-of-a-Theorem-of-Johnson-and-Lindenstrauss.pdf


title: Systematic Review in Software Engineering
directory: systematic_review/
created: 2017-09-06T19:00:46.420174072
modified: 2017-09-06T19:00:46.420174072
url:
http://www.elizabete.com.br/site/Outros/Entradas/2012/11/19_Revisao_Sistematica_files/ConceitosRevisaoSistematica_Biolchini.pdf


