Federated Space Public Key Infrastructure (PKI) can offer a scalable foundation for secure and interoperable communications in collaborative space missions. Yet, its deployment faces challenges stemming from resource-constrained assets, architectural complexity, and the transition to post-quantum (PQ) cryptography. Current CCSDS space guidelines rely on the Internet X.509 profile, whose extensive feature set—if left unrestricted—can increase implementation complexity, certificate size (especially under PQ algorithms), and the risk of interoperability issues. In parallel, the IETF C509 Certificates draft emerges as a streamlined subset of X.509 with a compact encoding specifically tailored for constrained environments. This paper provides an empirical comparison between X.509 and C509 to inform space mission designers about the associated advantages and costs of each, specifically when PQ cryptography is incorporated into space PKIs. To help pave the way for interoperability in federated space missions, a minimal certificate profile for space PKI is proposed.

In addition, the work introduces the first open-source native C509 toolkit that supports PQ algorithms and evaluates open-source and proprietary certificate parsers. While the IETF C509 draft proposal reports a size reduction of over 50%, our evaluation confirms approximately 40% savings for classical certificates generated according to our proposed minimal certificate profile. For PQ certificates, the savings plateau at around 200 bytes, rendering the size gains negligible. However, revocation lists consistently achieve a 60% reduction for 30,000 entries, independent of the cryptographic scheme (PQ or traditional). To quantify and compare the software implementation complexity of X.509 and C509, we conduct software complexity analysis using well-established heuristic metrics (e.g., cyclomatic complexity, Halstead metrics, logical lines of code). The findings further highlight the relative simplicity of the C509 parser implementation in software. Defining a standardised certificate profile for federated space would advance interoperability; however, adopting C509 requires carefully balancing modest PQ size savings against software simplification and the uncertainties associated with a draft standard.

Modern software depends heavily on third-party open-source libraries, with the vast majority of applications incorporating external components. While this dependency-driven development accelerates innovation, it creates significant security risks through complex, deeply nested dependency graphs where vulnerabilities can propagate across thousands of downstream systems.

While Software Composition Analysis (SCA) tools effectively identify known vulnerabilities, they generate overwhelming alert volumes in large organizations. Our analysis shows that over 8% of dependencies have known vulnerabilities, with each vulnerable version appearing multiple times across projects. This results in dozens of alerts per project, making manual triage infeasible.

This thesis presents a data-driven approach to prioritizing dependency risk, addressing the challenge of identifying the most critical security threats within the overwhelming volumes of alerts generated by SCA tools. The methodology integrates multiple risk indicators, including severity scores, exploit prediction metrics, known exploitation evidence, dependency freshness measures, and license compliance risks into a unified feature set. To capture transitive risk propagation while maintaining focus on actionable components, the framework applies a depth-weighted aggregation technique that assigns exponentially decreasing weights to deeper dependencies. Prioritization is performed using an autoencoder-based model, which leverages reconstruction error to rank dependencies by risk.

The framework was evaluated on thousands of real-world dependencies and showed promise in ranking components based on complex, multi-dimensional risk signals. It prioritized not only dependencies with extreme values in individual indicators but also those with unusual combinations across dimensions, including risks buried in transitive relationships. In a preliminary validation study, expert reviewers agreed with the model’s prioritizations in 96.7% of cases, highlighting its practical relevance and alignment with expert opinion.

By integrating diverse risk indicators, modeling transitive influence, and leveraging autoencoders, this work provides a practical framework for identifying high-risk dependencies in complex software ecosystems. It reduces noise in vulnerability alerts, highlights truly critical components, and supports more focused remediation. While not a replacement for expert judgment, the framework complements existing practices, representing a step toward more adaptive and risk-aware approaches within modern software ecosystems.

Stateful Functions-as-a-Service (SFaaS) platforms, such as Styx, are emerging as powerful abstractions for building distributed, serverless cloud applications. By combining the abilities of FaaS with strong transactional guarantees, they enable complex, stateful workflows without requiring developers to manage infrastructure. However, they lack built-in support for analytical queries across distributed function state. This thesis addresses that gap by proposing H-Styx, whose hybrid architecture extends Styx with a snapshot-based Query Engine, enabling near-real-time OLAP queries over global state while maintaining performance isolation for transactions. The Query Engine integrates seamlessly into the Styx architecture, leveraging periodic snapshots transmitted via a loosely-coupled, asynchronous interface. It ingests partitioned state from object store MinIO into columnar database DuckDB, supports incremental delta loads, and delivers results over a Kafka-based interface to achieve scalable, low-latency analytical querying while employing robust fault tolerance.

Empirical evaluation demonstrates that H-Styx preserves transactional throughput and latency under hybrid workloads, while significantly outperforming a baseline HTAP architecture (Postgres with Streaming Replication) on analytical throughput and providing superior workload isolation. These results validate the feasibility of supporting hybrid transactional and analytical processing in SFaaS environments. Overall, H-Styx bridges a crucial capability gap in SFaaS, enabling more powerful data-driven applications in distributed, event-driven architectures.

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.

Current tools for pattern matching computer programs often operate on abstract syntax trees or other static representations of programs. These approaches, though efficient, are fundamentally limited when it comes to capturing the dynamic behavior of programs. For example, it is not always possible to express (concise) syntactic patterns that capture programs which are semantically equivalent but differ in their syntactic representation. A tool that takes into account the behavior (or dynamic semantics) of programs would be able to capture programs that are semantically equivalent in a more concise manner with a single pattern. Additionally, taking into account program behavior leads to more precise pattern matching, by excluding unreachable paths of computation. In this thesis, we explore a novel method, based on behavioral models of programs, that allows patterns to take into account the dynamic semantics of a program. We propose the Dyno pattern language, in which concrete object language syntax can be used to express intuitive semantic patterns of programs. Pattern matching is performed by translating Dyno patterns to μ-calculus formulas and model checking these formulas against models extracted from object programs. Because our method is based on dynamic models of programs, we are fundamentally limited by the halting problem. In favor of precision, our method compromises on efficiency and termination guarantees. In particular, termination is not guaranteed when the extracted model of a program has infinitely many states. To recover termination in some cases, we provide the facility to express bounds on input parameters, limiting the search space while compromising on soundness. We recognize some limitations in our work, including a lack of match evidence (e.g. the location of a match in the object program’s syntax tree), as well as holes in Dyno’s expressiveness. To address the latter issue, we suggest operators that could be added to Dyno in the future.

The rise of graph processing has led to an increase in the usage of graph databases and the availability of various frameworks. Graph databases have become more accessible and, in specific instances, can compete with relational databases. Testing an application with a relational database backend has shown limited test coverage, and current test generators cannot cover every branch condition in graph processing applications. There is a lack of test methods specifically designed for applications that utilize graph structures.
This paper presents PGFuzz, a coverage-guided, schema-aware fuzzer for graph processing applications. PGFuzz utilizes existing graph generators to generate inputs and applies graph-specific mutations to alter the graph state. These mutations are schema-aware, designed to cover the graph model search space and satisfy logical conditions from real-world applications. The mutations involve adding new graph elements, removing graph elements, modifying existing elements, altering property values, and violating graph constraints. When compared against existing graph generators and a random byte mutation approach on the nine real-world examples in our benchmark suite, PGFuzz demonstrates an increase in coverage over time and detects more logic errors than the other methods. PGFuzz can cover all previously uncovered branching.

Deep Learning models can use pretext tasks to learn representations on unlabelled datasets. Although there have been several works on representation learning and pre-training, to the best of our knowledge combining pretext tasks in a multi-task setting for relational multimodal data has not been done before. In this work, we implemented 4 pretext tasks on top of a framework for handling relational multi-modal data and evaluated them based on two datasets. We first identified the best-performing masking strategy for pretext tasks that require masking. Then, we compared different combinations of the pretext tasks based on self-supervised metrics as a proxy for the quality of the representation learned. The results reveal that masking values by replacing from the column's empirical distribution yields 4.6\% and 4\% higher accuracy on each dataset respectively than replacing them with a fixed value. We also found that different combinations of pretext tasks, even with different numbers of tasks, converge to marginally different values and MoCo further reduces this difference. Our findings imply that the number of pretext tasks can scale efficiently allowing for a more diverse representation to be learned.

While LLMs are proficient in processing textual information, integrating them with other models presents significant challenges.
This study evaluates the effectiveness of various configurations for integrating a large language model (LLM) with models capable of handling multimodal data.\\

We explore the advantages of using pre-trained LLMs for generating text embeddings and the benefits of fine-tuning LLMs for specific tasks. Our investigation includes various fine-tuning strategies, such as Low-Rank Adaptation (LoRA), prompt tuning, and full fine-tuning, applied to both smaller and larger language models. Additionally, we analyze different training setups, including sequential and cascaded training of LLMs and downstream architectures. Our comparative analysis evaluates the performance and cost-effectiveness of these methods. The findings indicate that while full fine-tuning achieves the best results, LoRA offers a practical balance between computational efficiency and model performance. We also highlight the correlation between increased LLM size and corresponding increases in cost and performance.

The substantial amount of tabular data can be attributed to its storage convenience. There is a high demand for learning useful information from the data. To achieve that, machine learning models, called transformers, have been created. They can find patterns in the data, learn from them, and improve their predictive abilities based on that learning experience. There are also tabular transformers for tabular data. In order to attempt to increase the predictive performance of the transformers, we have combined them with graph neural networks (GNNs), which are again machine learning models, which work on graph data by learning information from the nodes and the edges. A graph representation of the dataset is created and input into the graph neural network. The architecture that fuses these two machine learning models is a more complex machine learning model that combines the transformer and the GNN. The aim is to increase the predictive ability of the model for values from the table or to predict whether an edge in the graph exists, which represents whether a transaction between two users exists. We have built the architecture using certain types of a tabular transformer and a graph neural network, FT-Transformer and GINe respectively, and the next step is to try modifying this architecture by using different models, and different ways of using these layers, for example how many copies we are creating of it. This has the potential to be a versatile model than can be used for different kinds of datasets. We have seen notable improvement in performance when using a different GNN, PNA. The transformer ResNet also shows to be on a similar or slightly better performing level than FT-Transformer when not combined with a GNN. GraphSage in the fused model underperforms significantly due to its weakness to capture simple graph structures.

The rapid advancement of automated vehicles (AVs) can potentially improve transportation. However, ensuring the safety and reliability of Automated Driving Systems (ADS) remains a critical challenge, particularly when facing the expansion of Operational Design Domains (ODDs) and the continuous emergence of unknown hazardous scenarios. This thesis aims to address these challenges by developing a framework for monitoring the safety of multi-channel ADS and identifying hazardous scenarios using Safety Performance Indicators (SPIs) and Hazardous Scenario Identification (HSI) techniques.

The proposed SPI framework, based on the principles outlined in the UL 4600 standard, encompasses a comprehensive set of metrics for assessing the safety and performance of ADS. These metrics cover various critical functionalities, such as ego localization, object detection, trajectory planning, and overall ADS behaviour. By defining appropriate thresholds for each SPI, the framework enables the identification of potential safety issues and supports the continuous monitoring and improvement of ADS.

The HSI module, developed as part of this thesis, leverages the SPI framework and the NXP Daruma cross-channel analysis to detect hazardous scenarios. The HSI module's performance is evaluated using the CARLA simulator and advanced ADS software stacks (LAV and TFUSE) across diverse driving scenarios. The results demonstrate the HSI module's effectiveness in identifying hazardous scenarios such as ego vehicle tailgating, inconsistent ego localization, and ego vehicle being tailgated. However, our analysis also reveals challenges in terms of false positives and negatives, highlighting the need for further improvements in the ADS's perception and localization functionalities and in tuning the SPI thresholds appropriately based on testing as well as the characteristics of the ADS.

This thesis contributes to advancing ADS safety by developing a comprehensive SPI framework and implementing a proof of concept HSI module. We propose an architecture that integrates these components in a closed-loop process involving vehicle fleet data collection, cloud-based analysis, and targeted software updates. This framework enables the identification of areas for improvement and supports generating OpenSCENARIO files for reproducing and analyzing hazardous scenarios ad hoc. The findings from the experimental evaluation provide valuable insights into the performance and limitations of the SPI safety monitoring and HSI techniques, guiding the safe deployment and continuous improvement of ADS. This research ultimately paves the way for the widespread adoption of automated vehicles (AVs) in driving environments.

With the increase of machine learning applications in our every-day life, high-quality datasets are becoming necessary to train accurate and reliable models. This research delves into the factors that contribute to a high quality dataset and examines how different dataset metrics affect the performance of machine learning models particularly focusing on Graph Neural Networks (GNNs) Tabular Transformers and Large Language Models (LLMs). The metrics, under scrutiny include graph sparsity, missing data cells, modularity and text length. Various datasets are adjusted to assess how these metrics impact model performance.

The results of the experiments reveal that sparse graphs can preserve relational information. However increasing density does not necessarily lead to improved performance due to noise interference. The models demonstrated accuracy and low error rates in the presence of significant missing data indicating their ability to handle incomplete information effectively and generalize well based on imputation strategies and structural design. Higher modularity was found to aid in capturing patterns. Introduced complexity that could potentially hinder performance. Notably text length emerged as a factor influencing model performance by offering contextual details.

These insights show the significance of considering attributes when designing machine learning models for intricate predictive tasks. Through experimentation and optimization of these metrics we can enhance model resilience and accuracy for applicability, in real world scenarios.

Over the past decades, Single Instruction, Multiple Data (SIMD) instructions have become common- place in conventional hardware. Lexical analysis, the first stage of compilation, can take advantage of this by splitting its workload across sub lexers that identify groups of tokens with similar structures. Each sub lexer can leverage SIMD to search for these structures across multiple characters in paral- lel and extract token positions efficiently. This pa- per presents a lexer with this architecture for the C programming language, along with implementation details for x86/x64 processors. Benchmark results show a 12x speed up in throughput compared to the lexer found in GCC, a state-of-the-art compiler.

Build systems are essential tools for compiling codebases of any complexity. In order to maximize performance, they use parallelism to complete multiple build steps simultaneously. In this thesis, we examine the effectiveness with which common build systems distribute work across available CPUs. We design an automatic process for fetching, compiling, and inspecting the build steps of common C/C++ codebases, and use it to benchmark various build systems. Based on empirical performance measurements and an analysis of the source code of these build systems, we find that the differences in task scheduling between build systems do not significantly affect performance.

In the field of software engineering, the speed of compilation plays a crucial role in enhancing development productivity. This thesis investigates the impact of optimising the memory layout of Abstract Syntax Trees (ASTs) on the performance of the type checking and code generation phases in the compilation process of strictly-typed procedural programming languages. Existing compilers often employ a traditional Object-Oriented (OO) approach to AST construction, leading to inefficiencies such as high memory overhead and suboptimal cache usage. We applied Data-Oriented Design (DOD) principles to restructure ASTs, aiming to enhance data locality and reduce memory access times.

The study investigates various AST memory layouts, including a transition from a naive OO model to a Struct-of-Arrays (SoA) model. We evaluated the effect of these memory layouts on compiler performance using a set of benchmarks based on real-world code. We executed the benchmarks on diverse hardware platforms, measuring key performance metrics such as type checking time, code generation time, and cache miss rates.

The results demonstrate that adopting an SoA model for ASTs significantly reduces the duration of the type checking and code generation phases, with improvements varying across different hardware architectures. We provide empirical evidence supporting the application of DOD principles and specifically SoA to ASTs for performance improvements. By highlighting and addressing the performance bottlenecks associated with traditional AST layouts, we contribute to the broader goal of advancing compiler design and optimisation.

This study examines the differences between two modern linkers, LLD and mold, focusing on their efficiency during software development. Although the linking process, which combines multiple object files into a single executable, typically occupies a minor fraction of the total compilation time, optimizing it can significantly enhance the overall build efficiency - particularly during the development of large-scale projects. The research aims to determine codebase-level differences between these linkers and assess their performance across various metrics, including linking time, memory usage, and the time spent on different phases of the linking process, using CMake and Bitcoin Core as benchmarks. Furthermore, the study extends to examining the executables produced by both linkers from the HDiffPatch project, comparing their execution times and sizes. The findings consistently show that mold outperforms LLD in terms of speed and efficiency, which results from its comprehensive utilization of parallel processing techniques. Nonetheless, LLD offers broader applicability by supporting a wider range of file formats and being suitable for both embedded and kernel programming. Therefore, the selection of a linker ultimately depends on the specific requirements of the project and the characteristics of the target machine.

Term-rewriting super-optimisation during compilation uses rewrite rules in order to restructure a provided code expression into the optimal form, comparing different expressions using a cost function. To reduce the compilation time taken by term-rewriting, the ruleset can be optimised by combining rules that were commonly chained during previous optimisation runs. With an any-time super-optimiser a specialised ruleset makes it possible to attain the optimal code expression, under the ruleset constraints, with a lower time requirement.

We found rule chaining methods to be effective at reducing the time necessary to obtain the canonical form. The methods performed well on synthetic benchmarks, as well as ones representative of real C projects. The frequency of the chained rule use and their uniqueness compared to the other compound rules directly dictates how great of a performance improvement its addition provides. Optimised sets demonstrated poor generality, indicating over-specialisation.

Dependently-typed languages allow one to guarantee correctness of a program by providing formal proofs. The type checkers of such languages elaborate the user-friendly high-level surface language to a small and fully explicit core language. A lot of trust is put into this elaboration process, even though it is rarely verified. One such elaboration is elaborating dependent pattern matching to the low-level construction of eliminators. This elaboration is done in two steps. First, the function defined by dependent pattern matching is translated into a case tree, which can then be further translated to eliminators. We present a generic, well-typed implementation of this second step in Agda, without the use of metaprogramming and unsafe transformations, by providing a type-safe, correct-by construction, generic definition of case trees and an evaluation function that, given an interpretation of such a case tree and an interpretation of the telescope of function arguments, evaluates the output term of the function using only eliminators. We only allow case splits on variables from a fixed universe of data type descriptions, for which we use techniques like basic analysis and specialization by unification.

This thesis addresses the challenge of refactoring untyped actor systems into typed ones, particularly within the Scala ecosystem using Akka framework \cite{akkaTypedDocs/Online}. The actor model, with its message-passing architecture, offers a solution to concurrency and scalability issues in distributed systems, but transitioning from untyped Akka Classic to typed Akka actors is a complex and error-prone task. This work proposes a solution through the development of a communication flow graph that captures actor interactions and message exchanges, which is then used to automate the refactoring process while preserving system behavior and communication integrity.

Key contributions include the implementation of the communication flow graph and an automated refactoring tool that translates untyped actor systems to typed ones. The evaluation demonstrates that while the refactored systems maintain communication patterns and functionality, they may introduce a slight reduction in maintainability. Additionally, the resulting effectiveness of the refactored benchmarks varies depending on the complexity of the underlying system.

Lastly, this research sets the foundation for improving refactoring tooling aimed at actor systems, extending the usability of the communication flow graph for the automated documentation of actor systems, and highlights the need to revisit traditional software quality metrics to suit actor-based systems.

Effective large-scale process optimization in manufacturing industries requires close cooperation between different parties of human experts who encode their knowledge of related domains as Bayesian network models. For example, parties in the steel industry must collaboratively use their Bayesian networks on process parameters at the maker, steel properties, and application demands at the client to identify process optimizations effectively. However, business confidentiality across domains hinders collaboration, demanding alternatives to centralized inference. We propose CCBNet, the first Confidentiality-preserving Collaborative Bayesian Network inference framework. CCBNet leverages secret sharing to securely perform analysis on the combined knowledge of party models by joining two novel subprotocols: CABN, which augments probability distributions for features across modeling parties into secret shares of their normalized combination; and (ii) SAVE, which aggregate party inference result shares through distributed variable elimination. We extensively evaluate CCBNet on nine public Bayesian networks. Our results show CCBNet achieves similar predictive quality to centralized methods while preserving model confidentiality. We finally demonstrate that CCBNet scales to challenging manufacturing use cases, where involving many (16-128) parties in large networks (223-1003 features), on average, enables 45% less computation while communicating 251k values/request.

Byzantine consensus protocols are designed to build resilient systems to achieve consensus under Byzantine settings, maintaining safety guarantees under any network synchrony model and providing liveness in partially or fully synchronous networks.
However, several Byzantine consensus protocols have been shown to violate liveness properties under certain scenarios. Existing testing methods for checking the liveness of consensus protocols check for time-bounded liveness violations, which generate a large number of false positives.

In this thesis, for the first time, we check the liveness of Byzantine consensus protocols by the temperature and lasso detection methods and precisely detail ad-hoc system state abstractions that should be used to test these algorithms.
We provide a theoretical analysis of the recently-published safety and liveness attacks and whether the existing test method is able to detect them.
To investigate the issues, we focus on the streamlined blockchain consensus, particularly the HotStuff protocol family, which has been recently developed for blockchain consensus. Among these protocols, the HotStuff protocol itself is both safe and live under the partial synchrony assumption, whereas 2-Phase Hotstuff and Sync HotStuff protocols can violate liveness in subtle fault scenarios.
We implemented our liveness checking methods on top of the Twins automated unit test generator to test the HotStuff protocol family and explored the scenarios with message delay.
Our results indicate that our methods successfully detect all known liveness violations and produce fewer false positives than the bounded liveness checks.