Apache Spark is a popular batch processing framework that is integrated into the ASML data analytics platform. However, having multiple users share the same resources creates fairness and efficiency problems in the scheduler, where some users may receive more resources than others, or the scheduler slows down all jobs equally. Apache Spark provides a built-in fair scheduler that attempts to mitigate these issues, but cannot account for changing user environments and has been shown to slow down overall job execution. Previous literature has already proposed improvements to the Spark fair scheduler, however, it does not account for user contexts to ensure fair resource distribution among users, and does not account for task skews that are present in the Spark ecosystem.


In this work, we present User Weighted Fair Queuing (UWFQ) scheduler that can minimize the response time of jobs in Apache Spark, while ensuring that users are allocated a fair share of resources that they equally distribute among their jobs. This is done by simulating a virtual fair scheduler, and assigning the highest priority to jobs that complete the earliest in the virtual scheduler. The algorithm is an extension to Cluster Fair Queuing designed by C. Chen et al., with an added fairness layer to ensure that each user is entitled to a fair share of resources. To address the problem of task skew present in Spark, we introduce runtime partitioning that can more effectively avoid task skew by splitting them into more partitions. We implement our scheduler in the Apache Spark framework and show that UWFQ with runtime partitioning can decrease the average response time of small jobs by up to 70% in certain workloads, while still providing fair resource allocation in critical scenarios.

Organisations are increasingly adopting Microservice and Service-Oriented Architectures, moving from monolithic applications to (service-oriented) distributed systems. By their nature, distributed systems are prone to partial failures, where a subset of processes fail while others continue to operate. To assess the behaviour of the system when subjected to partial failures, we can inject faults that mimic partial failures. By automatically injecting all relevant combinations of faults, we can verify the system’s resilience or uncover resilience bugs. However, the search space consisting of all combinations of faults grows exponentially. Moreover, it requires significant engineering effort to adjust systems to work with existing state-of-the-art tools. This work investigates a practical approach to automated fault injection for service-oriented distributed systems while remaining efficient. We design a novel automated fault injection tool that uses network-level instrumentation to inject faults. By using an abstraction to model the system’s behaviour, we can dynamically infer information available to service-level instrumentation. Furthermore, we efficiently represent the search space as a search tree and prune it using multiple pruning policies. To evaluate our design, we developed an implementation of this design called Reynard. Compared to the current state-of-the-art, we show that Reynard is efficient, requiring equal or fewer states in the search space, has minimal overhead, and can be integrated into various existing benchmark systems with a feasible engineering effort. Furthermore, we demonstrate the applicability of Reynard by integrating it into an industry system, highlighting that it can run practical experiments and can identify real bugs. In conclusion, Reynard can provide a starting point for lowering the engineering effort required to perform automated fault injection testing, while increasing the confidence in the resiliency of systems.

Blockchain technologies enable the decentralized storage and verification of records, such as financial transactions.
Systems like Bitcoin and Ethereum see a considerable usage and have market values in the order of 10s of billions of dollars.
A recent evolution of blockchain consensus systems, which have traditionally been maintaining a chain of blocks of transactions, is the introduction of Directed Acyclic Graph (DAG)-based algorithms.
In these new systems, popularized by companies such as Sui and IOTA, transactions are positioned in rows of blocks that are connected in a DAG.
The participants of these systems add blocks to the DAG in parallel, which has been shown to result in higher throughput, lower latency and higher decentralization.

Some blockchains, including DAG-based ones, support smart contracts, which enable the execution of (almost) arbitrary code with correctness, verifiability, and consistency guarantees.
A natural usage of smart contracts is Decentralized Finance (DeFi).
DeFi implements services that are offered in traditional centralized finance, such as loans and currency exchanges, in a decentralized fashion.
For example, instead of a central authority possessing different currencies and fixing their exchange rates through supply and demand of their clients, a decentralized exchange (DeX) can match buyers and sellers and update the exchange rate on the fly based on the supply of the two tokens.

The promise of safely removing the need for a central authority and regulations is however undermined by current blockchain implementations.
Intuitively, the decentralized nature of DeFi should prevent malicious behavior, but in practice validators (i.e., the entities that maintain the blockchain) have the possibility to do so.
For example, in Ethereum, miners have full control over the content of blocks.
This means that they have the power to reorder and inject transactions.
The profit that is obtained this way is called Miner Extractable Value (MEV).
% Indeed, the output of arbitrary code, in particular of DeFi code, can heavily depend on the transaction execution order.
% For example, in a DeX, if the exchange rate between two tokens is computed on the fly, an adversary can manipulate the transaction order to extract a profit.

MEV is not desirable because it introduces hidden costs for correct users: higher fees, worse exchange rates and network congestion.
Different mitigation techniques have been proposed over the years.
The most commonly used in practice are systems that allow the re-distribution or an easier extraction of MEV.
These have significant ethical concerns, as they increase resource consumption while still maintaining the negative side effects of MEV on the average consumer.

It is also possible to anonymize the content of transactions until after their execution, making it more difficult for attackers to exploit their contents for profit.
While anonymizing transactions makes an attacker's task more difficult, it requires the use of expensive cryptographic primitives or the presence of a trusted third-party, and transaction metadata might still be exploited to enable MEV.

The most interesting concept from the academic community against MEV is Order Fairness, which promises that transactions will be executed in an order that accurately represents the actual order in which the transactions were made public.
These systems have been mainly studied as an extension of existing linear consensus systems, but have been scarcely applied to DAGs.
Indeed, DAGs have been thought to have some inherent resistance to MEV extraction, but recent work by Zhang et al. has shown otherwise.

To the best of our knowledge, the only system that combines DAG-based consensus and Order Fairness is FairDAG.
While this protocol provides strong theoretical guarantees, we will show that it lacks real-world applicability and contains some suboptimal design decisions.

In this work we propose Tilikum, the first DAG-based consensus protocol that upholds Order Fairness through Ordering linearizability without sacrificing usability and improving average throughput by about 15 times.

Following the design of more efficient blockchain consensus algorithms, the execution layer has emerged as the new performance bottleneck of blockchains, especially under high contention. Current parallel execution frameworks either rely on optimistic concurrency control (OCC) or on pessimistic concurrency control (PCC), both of which see their performance decrease when workloads are highly contended, albeit for different reasons. In this work, we present NEMO, a new blockchain execution engine that combines OCC with the object data model to address this challenge. NEMO introduces four core innovations: (i) a greedy commit rule for transactions using only owned objects; (ii) refined handling of dependencies to reduce re-executions; (iii) the use of incomplete but statically derivable read/write hints to guide execution; and (iv) a priority-based scheduler that favors transactions that unblock others. Through simulated execution experiments, we demonstrate that NEMO significantly reduces redundant computation and achieves higher throughput than representative approaches. For example, with 16 workers when running on the Delft High Performance Center (DHPC) supercomputer, NEMO's throughput is up to 42% higher than the one of Block-STM, the state-of-the-art OCC approach, and 61% higher than the PCC baseline used.

Reliable communication algorithms have existed for a while that assumed either a global authentication model backed by public key infrastructure or peer-to-peer authentication using shared session keys between pairs of neighboring nodes. Real-life networks, however, do not settle for only one or the other. Instead, they are dynamic, heterogeneous, and often composed of a mix of authentication capabilities across different nodes.

Recent work has introduced hybrid models that combine both authenticated links and authenticated processes to better reflect these real-world conditions. These models aim to preserve the strong correctness guarantees of Byzantine-resilient protocols while reducing their communication overhead and improving practical deployability.

This thesis builds on these ideas by introducing DualRC, a reliable broadcast protocol that explicitly supports hybrid authentication environments. It also presents a novel routed version of the protocol designed to shift complexity away from intermediate nodes and toward the sender and receiver, thereby improving scalability and efficiency. Alongside the theoretical contribution, this work includes the first implementation of both variants of DualRC and evaluates their performance across a range of network conditions, trust assumptions, and deployment scenarios.

The goal of this thesis is to demonstrate that reliable communication in partially trusted networks is not only possible but can be efficient, practical, and scalable—provided that protocol design embraces the diversity and complexity of modern distributed systems.

Decentralized learning (DL) enables a set of nodes to train a model collaboratively without central coordination, offering benefits for privacy and scalability. However, DL struggles to train a high accuracy model when the data distribution is non-independent and identically distributed (non-IID) and when the communication topology is static. To address these issues, we propose DissDL, a fully decentralized topology optimization algorithm for DL where nodes select the peers they exchange models with based on local model dissimilarity. DissDL maintains a fixed in-degree while dynamically adapting the communication graph via gossip-based peer discovery and diversity-driven neighbor selection, improving robustness to data heterogeneity. Experiments on CIFAR-10 and FEMNIST show that DissDL achieves faster convergence, more stable learning, as quantified by lower inter-node variance across nodes, and higher final accuracy than with static topologies and state-of-the-art baselines. For example, on CIFAR-10, DissDL reaches the best accuracy achieved by its most competitive baseline using 1.34 × fewer communication rounds and 1.34 × less communication cost, while maintaining comparable overhead.

Decentralized Learning (DL) is a key tool for training machine learning models on sensitive, distributed data. However, peer-to-peer model exchange in DL systems exposes participants to privacy attacks. Existing defenses often degrade model utility, introduce communication overhead, or are not applicable to a DL system. Model chunking (splitting a model into parts before sharing them individually) has been proposed as an alternative, but its standalone privacy implications have not been investigated. This work implements and evaluates three distinct model chunking methods (static, cyclic, and random) against two privacy attacks: membership inference and linkability. Our work introduces a Hungarian matching-based enhancement to the linkability attack, and relaxes prior assumptions by evaluating attack success under limited access to neighbor datasets. Our results show that chunking increases vulnerability to membership inference. However, static and random chunking are effective against linkability attacks under specific conditions, particularly when full epochs are used during training.

Decentralized Learning is becoming increasingly popular due to its ability to protect user privacy and scale across large distributed systems. However, when clients leave the network, either by choice or due to failure, their past contributions remain in the model. This raises privacy concerns and may violate the right to be forgotten. In some applications, it is also undesirable to retain the outdated influence of clients that no longer reflect the current state of the system. While Machine Unlearning has seen significant progress in Federated Learning, similar solutions for Decentralized Learning are limited because there is no central server to orchestrate these operations. This work adapts and extends a state-of-the-art Federated Unlearning algorithm, QuickDrop, to operate in a decentralized setting. Our method uses synthetic data to reverse the influence of dropped clients and efficiently restore the model’s generalization performance. It also supports unannounced client crashes and performs reliably in sparse network topologies. We evaluate the algorithm on MNIST and CIFAR-10 using different graph structures and show that it remains competitive with oracle baselines that require access to sensitive data. Finally, we discuss the limitations of our approach and suggest directions for future work in Decentralized Unlearning.

Decentralized learning (DL) enables collaborative model training in a distributed fashion without a central server, increasing resilience but still remaining vulnerable to the same adversarial model attacks, that Federated Learning is vulnerable to. In this paper, we test two defense mechanisms, specifically designed to protect fully decentralized learning, in the scenario of chunked models and introduce one new defense. We clearly define the threat model, where malicious peers either try to perform a backdoor attack or an untargeted label flipping. The defenses are Norm Clipping, Sentinel and we propose Adaptive Norm Clipping. We evaluate the effectiveness of these defenses on the CIFAR-10 dataset. Our results indicate that the model attacks (backdoor attack and untargeted label flipping) significantly harm model accuracy on vanilla DL with chunking. While static defenses like Norm Clipping and Adaptive Norm Clipping reduce the impact of the attack, they lower the final test average accuracy in the chunked scenario. Also, robust aggregators like Sentinel fail at mitigating the attack, but do not lower the average test accuracy.

Decentralized learning is a paradigm that enables machine learning in a distributed and decentralized manner. A common challenge in this setting is the presence of non-identically and independently distributed (non-IID) data across clients. Under such conditions, it has been shown that node churn, where clients leave and rejoin the system, leads to reduced generalization performance and slower convergence. This degradation occurs because certain data classes may exist only on a few clients. Thus, if those clients drop out, the global model may lose access to important parts of the data distribution. This setting poses an important question: How can we mitigate the impact of node churn in decentralized learning systems to maintain some persistence of member contributions? To address this challenge, we empirically study the effectiveness of data augmentation, specifically extending local datasets with small synthetic datasets received from neighbors and generated using their local data. We further enhance this approach with supervised contrastive loss applied to synthetic and local data together, to which we refer to as synthetic anchors. Through experiments on the MNIST and CIFAR10 datasets, we demonstrate that data augmentation and synthetic anchors effectively mitigate the effects of churn and help preserve member contribution in decentralized learning.

Federated learning (FL) allows the collaborative training of a model while keeping data decentralized. However, FL has been shown to be vulnerable to poisoning attacks. Model poisoning, in particular, enables adversaries to manipulate their local updates, leading to a significant degradation of the global model accuracy. Most state-of-the-art attacks rely on prior knowledge of the server's aggregation rules (AGRs), so-called AGR-tailored attacks, making them more effective than AGR-agnostic attacks that lack such information. In this paper, we propose AIDA (Adaptive Inference-Driven Attack), the first adaptive AGR-agnostic attack. This attack begins with an AGR-agnostic approach where it analyzes the training process to identify the aggregation rule that the server is using, and it then transitions to a more powerful AGR-tailored attack. Extensive experiments reveal that AIDA substantially outperforms other state-of-the-art AGR-agnostic attacks, achieving additional model degradation of up to 3.01% on Krum, 13.96% on MKrum, and 2.85% on FLAME. These results demonstrate the effectiveness of AIDA and its ability to significantly degrade the global model performance, making it a more generic and powerful attack than existing AGR-agnostic approaches.

Federated Learning (FL) is a distributed machine learning approach that enhances data privacy by training models across multiple devices or servers without centralizing raw data. Traditional FL frameworks, which rely on synchronous updates and homogeneous resources, face significant performance challenges in real-world deployments. These challenges include handling heterogeneous data distributions (non-IID) and varying computational resources across clients, leading to performance degradation. To address these issues, asynchronous FL frameworks have been proposed, but they introduce new complexities such as communication latency and workload management across geo-distributed servers.

This paper focuses on the impact of network latency and non-IID data distributions on asynchronous multi-server FL systems. We propose and evaluate three methods to mitigate the adverse effects of data heterogeneity on model accuracy: (1) transferring clients between servers; (2) sharing clients among servers so that they alternatively train their models; and (3) sharing clients among servers with model averaging. Our contributions include a reproducible experimental framework for multi-server FL, strategies for optimizing client-server interactions, and an analysis of the effectiveness of these strategies in reducing the impact of non-IID data distributions. Experimental results demonstrate that our methods can reduce training time by up to 85.67%, decrease the number of updates required by 85.82%, and improve accuracy by 4.815% in heterogeneous environments, compared to Spyker, a state-of-the-art multi-server FL algorithm.

This thesis explores the application of a modular execution environment, specifically utilizing the Move Virtual Machine (MoveVM), within a blockchain-agnostic framework. The study aims to demonstrate how this modular approach can enhance the execution capability of existing blockchain systems. The case study focuses on the IOTA Distributed Ledger Technology (DLT), known for its unique Tangle architecture, which differentiates it from traditional blockchain technologies.

The research begins by detailing the current limitations in existing blockchain platforms, such as their dependence on specific consensus algorithms and rigid execution environments. It then introduces the MoveVM, developed firstly by the Libra (Diem) project and now by the projects Sui and Aptos, highlighting its advantages in terms of security, programmability, and modularity.

By integrating an object-flavored MoveVM into the IOTA framework, the study examines how the modular smart contract execution environment can operate almost independently of the underlying ledger. The work for this thesis was conducted in two main parts. In the first part, a prototype was created by integrating a modified version of the existing IOTA node software with an object-flavored Move execution environment. In the second part, a Move Swap smart contract was developed at the application layer to showcase the system's ability to support an advanced intent-based architecture. This approach, which executes based on user intents rather than declarative smart contract commands, offers significant economic benefits and reduces unnecessary costs for users.

To validate the effectiveness of this approach, the thesis presents empirical data and performance metrics gathered from various test scenarios. The results demonstrate the successful integration of the Move smart contract execution into the IOTA node software, but also significant improvements resource efficiency thanks to the intent-based architecture.

In conclusion, this thesis contributes to the growing body of knowledge on blockchain technology by showcasing the potential of MoveVM in enhancing the functionality and performance of blockchain-agnostic networks. Moreover, the findings suggest that the intent-based approach not only simplifies user interactions but also enables advanced functionalities and custom on-chain VMs, paving the way for innovative applications in DLTs.

Federated Learning (FL) systems often suffer from high variability in the final model due to inconsistent training across distributed clients. This paper identifies the problem of high variance in models trained through FL and proposes a novel approach to mitigate this issue through scheduling simulations subject to precedence constraints. By effectively scheduling the execution of client tasks and parameter server updates, we aim to reduce the variance in the final aggregated model. Through a series of experiments, we demonstrate that our proposed scheduling method significantly reduces model variance, while not impacting the time of simulation drastically. Additionally, we propose 2 algorithms to solve the problem of scheduling under precedence constraints - Ant Colony Optimisation, and an Evolutionary Algorithm - to minimize the makespan of simulations.

Federated Learning has gained prominence in recent years, in no small part due to its ability to train Machine Learning models with data from users' devices whilst keeping this data private. Decentralized Federated Learning (DFL) is a branch of Federated Learning (FL) that deals with clients directly communicating with each other as opposed to using a central server. Client mobility describes how users' devices move in the real world, and its effects on the learning performance of Hierarchical Federated Learning (HFL) systems have been found to be significant. However, the effects of client mobility on DFL systems have not been explored. In this work, we fill this research gap. First, we develop a model that can describe client mobility in a DFL system. Then, using synthetic datasets, we show that client mobility has a positive impact on learning performance, which we quantify. Moreover, we show that there is a disparity in learning performance between high-mobility and low-mobility clients when using a baseline model aggregation algorithm. To address this disparity, we propose a new mobility-aware model aggregation algorithm. Our experimental results on synthetic datasets show that our solution reduces the disparity in learning performance between high- and low-mobility clients in the scenarios where this disparity is greatest, with no appreciable downsides in global learning performance.

Distributed consensus algorithms are essential for maintaining data reliability and consistency across computer networks, ensuring that all nodes agree to a single state despite failures or malicious disruptions. Despite the critical role of Byzantine Fault Tolerant State Machine Replication (BFT SMR) protocols in securing such systems, existing protocols like Practical Byzantine Fault Tolerance (PBFT) and HotStuff still struggle with scalability, particularly in large applications where latency and throughput are crucial. A notable tradeoff is that, for example, PBFT is able to utilize network resources very well, but has significant communication complexity for reaching consensus, especially in scenarios where leaders are faulty. HotStuff manages to reduce the communication complexity by streamlining the leader-change mechanism, but by doing so is unable to fully utilise network resources in most cases.

This thesis introduces Para-HotStuff, a new BFT SMR protocol designed to improve the performance of streamlined leader-based consensus protocols by enabling parallel processing of blocks. Para-HotStuff builds on the core functionality of HotStuff, maintaining its linear communication complexity while incorporating parallel voting features from PBFT to optimize resource utilization and network bandwidth. The performance of Para-HotStuff was evaluated and compared to HotStuff under various conditions and protocol configurations, showing improved throughput and latency, particularly in scenarios with high transaction loads. Further research could explore implementing further mechanisms to improve \name{} as well as doing more comprehensive evaluations on how it behaves in real-world settings.

Streamlined Byzantine Fault Tolerance (BFT) protocols have been developed to create efficient view-changes. To improve upon their performance, trusted components have been introduced to prevent equivocation within a protocol. However, these trusted components suffer from rollback attacks. We identify clear examples of rollback attacks on Damysus, and design a novel method to mitigate the attack vector. This is done via a pacemaker protocol called Artemis, which allocates trusted components to epochs. Integrating Artemis with Damysus creates Apollo, a streamlined BFT protocol. Apollo is demonstrates to outperform existing streamlined BFT protocols such as Hotstuff, while preventing equivocation due to rollback attacks. This is all done while maintaining the reduced number of communication phases and tolerating a minority of faulty nodes.

Federated learning (FL) is a machine learning paradigm where private datasets are distributed among decentralized client devices and model updates are communicated and aggregated to train a shared global model. While providing privacy and scalability benefits, FL systems also face challenges such as client and data heterogeneity, where the training resources and different datasets are non-Independent and Identically Distributed (non-IID). When testing novel FL algorithms or configurations, simulators are used to create controlled environments without needing costly deployments. However, it is important to understand how representative FL simulators are of real-world deployments, and what steps can be taken to bridge the gap between theoretical results and practical implementations. In this paper, we investigate the effects of incorporating traces from a pseudo-real heterogeneous FL deployment in simulated environments. We compare four non-IID attributes, including batch sizes, local epochs, data volume, and data labels, to determine the most influential factors for reproducing the deployment results in simulations. We show that there is an inherent difference between deployments and simulations, despite incorporating identical non-IID conditions. Furthermore, we show that including non-IID data labels in simulations has the most significant impact on recreating the deployment outcome. We also demonstrate that incorporating the other mentioned factors has negligible impact, resulting in similar training performance compared to fully IID simulations. Our results are derived from a 20-client single-server synchronous FL configuration, and additional research is necessary to confirm our findings for larger-scale systems.

Federated Learning is a machine learning paradigm where the computational load for training the model on the server is distributed amongst a pool of clients who only exchange model parameters with the server. Simulation environments try to accurately model all the intricacies of such a system. However, current simulators do not properly impose the concept of simulation time, leading to global model inaccuracies and difficulties of replicating reruns of the simulation, which is most prominent in the asynchronous scenarios. To this purpose, we propose a discrete-event simulator for the central server asynchronous case which timestamps all the events in the system prior to execution, reducing variability in client model updates on the server. We also introduce a log-structure used to keep states of the simulation, making client inspection possible based on time. We evaluate the proposed discrete-event simulator on the baseline simulator of Flower, reducing standard deviation amongst server model updates for 31.5% and improving accuracy with heterogeneous clients in the MNIST case for 3.3% on average.

Blockchain-based payment systems typically assume a synchronous communication network and a limited workload to confirm transactions within a bounded timeframe. These assumptions make such systems less effective in scenarios where reliable network access is not guaranteed.
Offline payment systems are designed to allow users to register offline transactions and ensure their execution once network access is restored. However, these methods often rely on specialized hardware to remain secure and tamper-proof, preventing double-spending and invalid transactions.

In this work, we introduce a novel offline payment system that does not rely on trusted hardware. Our system enables users to determine transaction fees and accept offline payments based on the trustworthiness of their peers. Users can decide whether to accept offline payments from each other based on the information our system provides.

Our system employs a smart contract to manage transactions on a blockchain for its online component. We implemented the online part of our system as an Ethereum Solidity smart contract and deployed it on the Sepolia testnet. Our performance evaluation demonstrates our system’s practicality, handling 68 Transactions Per Second (TPS) with a confirmation latency of 12 seconds on the Sepolia testnet. The system’s scalability can improve with advanced layer-1 or layer-2 blockchain solutions, enhancing throughput, decreasing latency, and reducing fees.