A proof-of-work blockchain adopts an incentive-driven design to encourage people to participate in the network. Miners provide computing resources and services in exchange for incentives such as static block rewards and transaction fees collected from blockchain users. However, our findings suggest that the current reward scheme may not encourage miners to process user transactions. A non-cooperative strategy that submits a block with no transaction can be more rewarded than a cooperative strategy. As a consequence, the non-cooperative strategy can prevail over the cooperative strategy, decrease the system throughput, and distort credit distribution. We particularly choose Ethereum project as a subject since it is a general-purpose smart contract platform. By investigating the past two years of its ledger history, we find network propagation and block processing delays are the most significant factors that cause miners to choose the non-cooperative strategy. From this finding, we develop a more accurate statistical model for a block discovery time, as well as a reward matrix. We then derive the condition that either strategy has no additional gain, which also helps to estimate whether the transaction fee is underpriced or not. Simulation results show that the non-cooperative strategy is no longer dominant under the revised reward scheme.

In mobile social networks, the success of resource sharing depends on a high level of cooperations. The motivation of this work is to seek conditions under which cooperation prevails without additional incentive mechanisms such as credit and reputation-based schemes. We apply the Evolutionary Game Theory framework to investigate the formation of cooperation in opportunistic resource sharing. First, we extend the existing Small World In Motion mobility model to preserve real-world localized mobility patterns. On top of the mobility model, a game theoretic model tailored for resource sharing is developed. Preliminary simulation results show that high user cooperation rate emerges when the cost of resource sharing is sufficiently small, even if the Nash Equilibrium of the resource sharing game is non-cooperation. Moreover, we discovered that heterogeneous user mobility patterns promote cooperation.

Developers use cloud computing platforms to process a large quantity of data in parallel when developing big data analytics. Debugging the massive parallel computations that run in today's data-centers is time consuming and error-prone. To address this challenge, we design a set of interactive, real-time debugging primitives for big data processing in Apache Spark, the next generation data-intensive scalable cloud computing platform. This requires re-thinking the notion of step-through debugging in a traditional debugger such as gdb, because pausing the entire computation across distributed worker nodes causes significant delay and naively inspecting millions of records using a watchpoint is too time consuming for an end user. First, BIGDEBUG's simulated breakpoints and on-demand watchpoints allow users to selectively examine distributed, intermediate data on the cloud with little overhead. Second, a user can also pinpoint a crash-inducing record and selectively resume relevant sub-computations after a quick fix. Third, a user can determine the root causes of errors (or delays) at the level of individual records through a fine-grained data provenance capability. Our evaluation shows that BIGDEBUG scales to terabytes and its record-level tracing incurs less than 25% overhead on average. It determines crash culprits orders of magnitude more accurately and provides up to 100% time saving compared to the baseline replay debugger. The results show that BIGDEBUG supports debugging at interactive speeds with minimal performance impact.

Debugging data processing logic in Data-Intensive Scalable Computing (DISC) systems is a difficult and time consuming effort. Today's DISC systems offer very little tooling for debugging programs, and as a result programmers spend countless hours collecting evidence ( e.g. , from log files) and performing trial and error debugging. To aid this effort, we built Titian , a library that enables data provenance ---tracking data through transformations---in Apache Spark. Data scientists using the Titian Spark extension will be able to quickly identify the input data at the root cause of a potential bug or outlier result. Titian is built directly into the Spark platform and offers data provenance support at interactive speeds---orders-of-magnitude faster than alternative solutions---while minimally impacting Spark job performance; observed overheads for capturing data lineage rarely exceed 30% above the baseline job execution time.