Satisfiability solvers have been shown to be a powerful tool for solving constraint problems. These problems often contain pseudo-boolean and cardinality constraints. These constraints can either be encoded into SAT or handled by extending the solver with special propagators. Which method will perform better is often not known in advance. It has been shown that adding the encoding during the search can be beneficial. This thesis extends those methods by incrementally constructing the encoding during the search. This work proposes several methods that only encode the active parts of the constraint. In contrast to previous work the full encoding of the constraint is not determined beforehand but instead is determined during the search. The results show that during the search the same subset of variables is active and therefore not all variables are needed for the encoding. Furthermore, this work shows that the order of the literals in the encoding has effect on the performance. However, this mostly affects the first part of the solve process, and therefore the effect on optimization problems is limited. Finally, it shows that an incremental encoding can lead to a smaller encoding while having similar results as adding the full encoding during the search.

There has been an increasing interest in moving computation closer to storage in recent years due to significant improvements in memory technology. FPGAs were proven to be an exciting candidate for accelerating database workloads since they provide an energy-efficient, reconfigurable and high-performance computation platform. Therefore, FPGAs are widely used as attached accelerators on data-centric applications.

Database operations usually run on large volumes of data, which creates an I/O bottleneck when processing them on CPUs. Therefore, recently, researchers have been investigating query pushdown techniques during a database load operation. A well-known columnar storage format, Apache Parquet, provides an efficient way to store a database. In addition, current big data processing engines provide functionalities for pushing filter operation down to the parquet reading stage.

This study explores the boundaries of pushing down analytic queries to the parquet reader stage by using FPGAs. An extended roofline analysis is performed on a proof-of-concept hardware design. The analysis shows that peak performance is achieved via a storage-attached accelerator once a high bandwidth interface is introduced. Furthermore, using multiple FPGAs with flash storage while interfacing them with OpenCAPI or PCI switch enables higher performance for aggregation since aggregation is shown to be I/O bound.

The thesis introduces Apache Spark integration of the proof-of-concept query pushdown for parquet reading operations. Apache Spark implements several layers of parallelism to achieve higher speed-ups. However, the concurrency and parallelism for a single FPGA instance for multi-threaded Apache Spark applications requires synchronization on a constrained resource represented by a single FPGA. Therefore, this work suggests a way to achieve synchronization with a single FPGA instance.

The present work shows that for a single Spark thread, a maximum end-to-end application speed-up of 3.88x and a kernel speed-up of 7.24x are achieved. As a result, the throughput of TPC-H Query 6 can be increased up to 3.8 GB/s. Furthermore, FPGA can perform better than CPU until Spark is configured to run on 7 CPU threads. Then, for the scaled-up multi-threaded Spark application with six CPU threads, the FPGA can achieve 1.13x end-to-end application speed-up and a kernel speed-up of 13.19x.

Cross Browser Inconsistencies (XBI) were created when different browser vendors implemented their products without deciding upon common protocols for interoperability. It is hard to pinpoint these inconsistencies with precision because of a lack of a good tool. Here we show how to use a web-based event logger (LogUI) to find XBI at a granular level. LogUI attaches itself to the DOM of a webpage and makes a log file based on how the browser re- sponds to user interactions. A test suite is made by simulating user interactions (Selenium WebDriver) to test different browsers and interaction events (individually and in sequences) to generate log files which are then analyzed to spot differences in the actions performed and entries logged. It is found that XBI are few and hard to find, the two XBI found are that browsers load differently and sometimes change the order of actions being performed.

Web-based interaction logging is an important concept for understanding user behavior on web-pages. LogUI is a powerful modern framework for logging a user's interactions. Integrating such a framework in web-pages requires the construction of configuration objects to define selectors that indicate which elements on a web-page should be under observation. Writing such configuration object can be a tedious task for researchers who are less experienced in programming. Therefore, this paper addresses the potential of a graphical user interface (GUI) to simplify the creation of configuration objects. An experimental GUI-based tool was devised to aid a user in the process of producing configuration objects in an interactive fashion. Results from conducting a small scale user study show that users are capable of creating configurations utilizing the GUI-based tool with an average accuracy of 70% measured in terms of selector equivalence. User experience evaluation shows that the tool is perceived as efficient.

Methods for learning vector space representations of words have yielded spaces which contain semantic and syntactic regularities. These regularities mean that vector arithmetic operations in the latent space represent meaningful and interpretable relations between words. These word vectors have been so successful in capturing such relations, as well as transfer between domains almost seamlessly, that they have become central in the foundation of modern natural language processing. There have been multiple proposals for extending these methods to sentences and documents, as well as entirely new approaches based on modern sequence models. So far, none of these methods have demonstrated the same kind of widespread applicability as word vector methods, instead being constrained to a single domain. The question that emerges is then whether these document vector methods yield spaces with the same kind of regularities as are observed in the word vector models. This work focusses on whether these spaces encode a particular relation, that between a word and its definition. Since most of these methods allow only for a conversion from sentence to vector and not the reverse, the problem has been phrased as a ranking problem over a set of candidate words. In the strict case where the relation is assumed to be linear as with the word vectors this yields a model which ranks the correct vector first $26.6\%$ of the time, with a median rank of the correct answer of $19$ out of $2000$ options. Relaxing this requirement and using a 3 layer Multi Layer Perceptron yields an improvement in this metric, predicting $37.8\%$ correct, and improves the median rank to $3$. The performance of these models suggests that words and sentences can be naturally thought of as occupying a single space. The results in this work suggest that it may be possible to generate correct definitions of words in a way that comes very close to being unsupervised, needing only a mean difference between words and definitions. When this was attempted, however, the decoder ended up converging to a fixed output.

Mistakes in binary conditions are a source of error in many software systems. They happen when developers use < or > instead of <= or >=. These boundary mistakes are hard to find for developers and pose a manual labor-intensive work. While researches have been proposing solutions to identify errors in boundary conditions, the problem remains a challenge. In this thesis, we propose deep learning models to learn mistakes in boundary conditions and train our model on approximately 1.6M examples with faults in different boundary conditions. We achieve an accuracy of 85.06%, a precision of 85.23% and a recall of 84.82% on a controlled dataset. Additionally, we perform tests on 41 real-world boundary condition bugs found from GitHub and try to find bugs from the Java project of Adyen. However, the false-positive rate of the model remains an issue. We hope that this work paves the way for future developments in using deep learning models for defect prediction.

Recommender Systems assist the user by suggesting items to be consumed based on the user's history. The topic of diversity in recommendation gained momentum in recent years as additional criterion besides recommendation accuracy, to improve user satisfaction. Accuracy and diversity in recommender systems coexist in a delicate trade-off due to the complexity in capturing user tastes through a limited amount of interactions. Graphs have been employed for recommendation, given their ability to efficiently represent user-item interactions. Graph convolutions, as learning over graphs tools, have reached state-of-the-art accuracy on recommender system benchmarks. However, the potential of graph convolutions to improve the accuracy-diversity trade-off is unexplored. Here, we develop a model that learns from a nearest neighbor and a furthest neighbor graph via a joint convolutional model to establish a novel accuracy-diversity trade-off for recommender systems. In detail, the nearest neighbor graph connects entities (users or items) based on their similarities and is responsible for improving accuracy, while the furthest neighbor graph connects entities based on their dissimilarities and is responsible for diversifying recommendations. The information between the two convolutional modules is balanced already in the training phase through a regularizer inspired by multi-kernel learning. Numerical experiments on three benchmark datasets showed the joint convolutional model can improve substantially the catalog coverage or the diversity among recommended items; or boost both by a lesser amount. We compared our model against state-of-the-art accuracy-oriented algorithms, showing diversity gains up to seven times by trading as little as 1\% in accuracy. We also compared the joint model against algorithms proposing a different accuracy-diversity trade-off, evidencing our model achieves better accuracy while preserving a wide diversity range. Our findings highlight that the joint convolutional model offers a balance in each setting that is difficult to be achieved with a single model.

Synthetic lethality (SL) arises between two genes when loss of function of both genes would lead cells to become inviable. This can be exploited for therapy, where a drug is used to selectively kill diseased cells by perturbing one gene of an SL pair where the other gene is inactive (e.g. through naturally occurring mutation). Computational prediction of SL relationships is very appealing as it can help reduce cost- and labour-intensive experimental testing to the most promising candidate pairs. Even though machine learning models have shown promising results for SL prediction compared to traditional statistical approaches, crucial questions remain. First, which sources of molecular data are most useful for SL prediction? Many approaches rely on either cell line or patient tumour data separately, and ignore data from healthy tissue. We argue these should be combined to leverage relevant data sources that are exclusively available for cancer cell models and patient tumours, and to enable the transfer of knowledge between models and actual patient tumours. Likewise, changes in the relationship of gene pairs between healthy and tumour tissue may be informative for SL prediction. We assess several machine learning techniques to best leverage molecular profiles for cancer-specific or pan-cancer SL prediction. Second, what are the effects of selection bias on SL prediction methods and which techniques are most robust? This has been insufficiently addressed, as models in the literature are often tested using data from one or two cancer types or datasets. We investigate robustness to cancer representation and gene selection biases, which are inherent to most SL datasets. We hypothesise that approaches based on matrix factorisation will be especially sensitive to the latter, as they are dependent on an a priori SL network structure, which also determines the scope of the prediction space.

Through new digital business models, the importance of big data analytics continuously grows. Initially, data analytics clusters were mainly bounded by the throughput of network links and the performance of I/O operations. With current hardware development, this has changed, and often the performance of CPUs and memory access became the new limiting factor. Heterogeneous computing systems, consisting of CPUs and other computing hardware, such as GPUs and FPGAs, try to overcome this by offloading the computational work to the best suitable hardware.

Accelerating the computation by offloading work to special computing hardware often requires specialized knowledge and extensive effort. In contrast, Apache Spark became one of the most used data analytics tools, among other reasons, because of its user-friendly API. Notably, the component Spark SQL allows defining declarative queries without having to write any code. The present work investigates to reduce this gap and elaborates on how Spark SQL's internal information can be used to offload computations without the user having to configure Spark further.

Thereby, the present work uses the Apache Arrow in-memory format to exchange data efficiently between different accelerators. It evaluates Spark SQL's extensibility for providing custom acceleration and its new columnar processing function, including the compatibility with the Apache Arrow format. Furthermore, the present work demonstrates the technical feasibility of such an acceleration by providing a Proof-of-Concept implementation, which integrates Spark with tools from the Arrow ecosystem, such as Gandiva and Fletcher. Gandiva uses modern CPUs' SIMD capabilities to accelerate computations, and Fletcher allows the execution of FPGA-accelerated computations. Finally, the present work demonstrates that already for simple computations integrating these accelerators led to significant performance improvements. With Gandiva the computation became 1.27 times faster and with Fletcher even up-to 13 times.

Because of the transfer from brick-and-mortar stores to the web, tourism companies have had an increasing need for good recommendation systems to help the users of their websites find what they want. When developing a recommendation system for tourism, we run into a couple of problems that we would not run into when developing it for e-commerce. One of these problems is the increased effect of the cold start problem. This problem entails that we do not understand what new users are interested in because we have very little information about them. The increased effect of the problem is due to the low number of bookings that are made compared to e-commerce purchases. To reduce the effect of the cold start problem, we can use additional data sources in order to understand the user's interests better.

To simplify the use of the additional data source, we explore the possibility of embedding the data or using it in conjunction with an embedding. Vakanties.nl is a company with the need for an improved recommender system. Therefore, we decided to explore these possibilities in cooperation with Vakanties.nl. We develop a recommender system that is able to make recommendations, using both the embedding and clickstream data from Vakanties.nl. We find that although the results of our system do have potential, the system requires some further improvement to compete with a conventional recommendation system.

Since the dawn of BitTorrent technology, free-riding has always been a critical
issue restricting the performance and availability of the BitTorrent network. To solve this problem, BitTorrent involves a tit-for-tat mechanism which does not function satisfactorily against free-riding. Private trackers implement credit systems to eliminate free-riders and award the good-behaving users. However, due to these factors, the community size of private trackers is limited and not even close to that of famous public trackers. Users have to put considerable efforts to maintain a good credit record, making the experience less enjoyable. Moreover, there exists a majority group of light users who do not bother, do not have the capable knowledge or are not aware of the importance of seeding for the community. Even worse, the hardcore seeders still need to manually download much content and waste considerable resources on over-seeded torrents.
In this thesis, we design, implement and evaluate an incentive and boosting
system namely Credit Mining inside Tribler, an open source Peer-to-Peer file sharing program. Credit Mining involves a private-tracker-like incentive mechanism while maintaining good accessibility for every user. Our results show that we have succeeded in creating a profitable swarm selection algorithm that works in the real world. This thesis is a piece of the puzzle towards the long-term goal of Tribler, "a trustful blockchain-based token economy to prevent bandwidth free-riding".

Modern software is being built in a continuously integrated fashion, in order to overcome the challenges that come with developing large software systems from many contributors. The cornerstone of continuous integration is the testing step, since it is supposed to protect the system from changes that might disrupt correct behavior. Mutation testing is a method that checks the fault finding capability of a test suite. Current CI settings do not implement a step that checks how thorough the test suite is.

Therefore, the goal of this thesis has been to explore how mutation testing can be applied to changes under analysis in a continuous integration setting. Since there is no infrastructure to support this, in order to conduct our study we developed OPi+, a prototype tool for experimenting the infrastructure required for a continuous mutation testing approach. Using real-world systems for analysis, we give initial evidence of the continuous mutation testing usefulness in terms of costs and benefits when applied to realistic software changes. The empirical study is based on analysis performed on the entire commit history of the popular open source Java Maven systems.

Through our study we defined 5 types of outcomes together with a continuous mutation testing behavior flow and additional analysis that streamlines current mutation testing practices.
We showed not only that mutation testing in a CI environment requires significantly fewer resources but they are also within the limits required by a CI pipeline. Through our study we also identify unmutable code for which we propose appropriate unimplemented operator set. We also study the evolution of surviving mutants with regards to their impact on the systems` technical debt.

In our study, we showed initial evidence that mutation testing can successfully be made compatible with a CI environment. We therefore propose a few ideas that could possibly further streamline continuous mutation testing.

A linter is a type of static analysis tool that warns software developers about pos- sible errors in code or violations to coding standards. By using such a tool, errors can be surfaced early in the development process when they are cheaper to fix, and code can be kept more readable and maintainable. For such a tool to be successful, it is important for its creators to understand the needs and challenges of developers when using a linter. Furthermore, it needs to be made clear to developers why using such a tool can be beneficial, along with how linters can be configured to identify appropriate and relevant issues for their projects.
In this thesis, we examine developers’ perceptions of linters to increase our knowl- edge on these tools for JavaScript, the most widely used programming language in the world today. More specifically, we study why and how developers use ESLint, the most popular JavaScript linter, along with the challenges that they face while using the tool. We collect data with three different methods where we first interview 15 experts on using linters, then analyze over 9,500 ESLint configuration files and finally survey more than 300 developers from the JavaScript community. The combined results from these analyses provide developers, tool makers and researchers with valuable knowl- edge and advice on using and developing a linter for JavaScript.

Repository mining researchers have successfully applied machine learning in a variety of
scenarios.  However, the use of deep learning in repository mining tasks is still in its infancy.
In this thesis, we describe the advantages and disadvantages of using deep learning in mining software repository research and demonstrate these by doing two case studies on pull requests.
In the first, we train neural models to predict, on arrival, whether a pull request is going to be merged or not.
In the second, we train neural models to answer the question: given two pull requests, are these similar?
We show that using neural models, researchers are able to avoid feature engineering, because these models can be trained on raw data.
Furthermore, neural models have the potential to outperform
traditional supervised machine learning models, due to being able to learn relevant features by themselves.
However, the power of neural models comes at a cost: optimizing the parameters of neural models and explaining neural models is difficult and training them is costly.
We, therefore, recommend researchers to take into account well performing neural architectures in other domains, such as natural language processing, before creating novel architectures.
Furthermore, it is therefore important to include a less costly baseline when using neural models in research, to show that the power and thereby the cost of neural models is justified.

Nowadays, service-oriented architectures are more popular than ever, and more and more companies and organizations depend on services offered through Web APIs. The capabilities and complexity of Web APIs differ from service to service, and therefore the impact of API errors varies. API problem cases related to Adyen’s payment service were found to have direct considerable impact on API consumer applications. With more than 60 thousand daily API errors the potential impact is enormous. Similarly, API consumers of any API can experience errors, and depending on the application the impact can be costly.

In an effort to reduce the impact of API related problems, we analyze 2.43 million API error responses to identify the underlying faults and derive 11 generic categories that describe them. We quantify the occurrence of faults in terms of the frequency and impacted API consumers. We investigate the impact of API faults on API consumer applications and illustrate this with 3 case studies. Furthermore, an overview is given of the current practices and challenges to avoid and reduce the impact of API errors by API consumers. Using the results, we introduce 16 recommendations for API providers and API consumers to reduce the impact of API related faults.

The goal of this thesis is to explore the current possibilities for detecting breaking changes in JavaScript. For this, we propose an approach and show its accuracy by constructing a tool and evaluating it. The evaluation is carried out on 3 chosen JavaScript projects and a total of 3000 consumer packages. For each of the projects, we compute the precision and recall rates. Furthermore, an empirical study is carried out on the 3000 consumer packages to see the effects of breaking changes on developers. The results show that we are able to detect between 43% and 80% of breaking changes. The outcome of the empirical study suggests that breaking changes appear quite often between versions, and even in versions that should not contain them according to the rules for semantic versioning. Additionally, we show the current limitations of our approach and how they can be improved upon in future research.

Kitchen is becoming a hotbed for innovation in the Internet of Things (IoT) revolution. Many kitchen appliances are being connected to the Internet to facilitate `smart-cooking'. The appliances are becoming cordless too, i.e., they are being powered by the inductive power sources which are integrated into the kitchen counter-tops. The Wireless Power Consortium (WPC) has proposed standards for smart-cooking in cordless kitchens by enabling communication using the near field communication (NFC) protocol between the appliance and the power transmitter. In order to keep the appliances safe as well as reduce the cost of the appliances, it is required that the NFC channel should be exploited to enable Internet connectivity in the appliances. However, due to practical constraints, the NFC channel is time-slotted. Furthermore, this NFC channel has low data rates and high latencies. These constraints make it highly challenging to enable Internet connectivity for these resource-constrained cooking appliances for IoT applications.

This thesis explores different ways of providing Internet connectivity to the cordless kitchen appliances using the time-slotted NFC channel. Two architectures are proposed based on this method, namely the Proxy and the Bridge architectures. In the proxy architecture, the cordless appliances implement only the application layer and tunnel the application data through the NFC channel which will then be used by the power source to create TCP/IP packets for the appliance. In the bridge architecture, the appliances implement all the layers of the TCP/IP network stack. All the TCP/IP traffic is sent through the NFC channel and the power source acts as an intermediate hop. These architectures are evaluated in detail to determine the best-suited architecture. The thesis concludes that the bridge architecture, although heavy on the appliances, truly creates an IoT-enabled appliance, and therefore adopts it.

While it is proposed to send the complete TCP/IP packets to go over the NFC
channel, the impact on the performance of the protocols needs to be investigated, specifically the TCP as it is the most used protocol for IoT applications. The performance of the TCP will be affected due to several reasons: (a) the time-slotted NFC channel; (b) low data rates on the NFC; (c) delays in accessing the NFC channel, and (d) no control over the network stack of the other TCP end-point. Furthermore, the behavior of the TCP in such resource-constrained channels aggravate the problems as spurious retransmissions get triggered. This work presents important challenges that need to be solved in order to enable the TCP to work smoothly in the time-slotted NFC channels. Two major performance problems that occur in such an environment are identified, viz., spurious retransmissions and packet drops at the NFC interface. The existence of the problems are verified with an experimental setup of the cordless kitchen and solutions are presented to these challenges: (a) determine the optimal retransmission timeout and the heuristic, and (b) avoid packet drops due to small inter-packet delay on the NFC channel. Next, a detailed parametric analysis of the other TCP parameters such as contention window size and maximum segment size of the TCP packets is performed.

From the evaluation, it is found that the proposed solutions can almost completely eliminate spurious retransmissions. With these solutions up to 38% reduction in the system latency is achieved at an NFC bit rate of 11.2 kbps and up to 53% at 24 kbps in the time-slotted mode. By implementing these solutions and choosing the right parameter values for the TCP, it is possible to seamlessly adapt and use the TCP for the time-slotted and resource-constrained NFC channel, and enable a truly IoT-based cooking experience for the smart cordless kitchens.