Single-cell RNA sequencing data clustering is a valuable technique for demonstrating cell-to-cell heterogeneity and revealing cell dynamics within and amongst groups. Large up-scaling of scRNA-seq datasets in recent years pose computational challenges for existing state-of-the-art clustering techniques. A possible solution to tackle these challenges is to binarize the scRNA-seq data and perform clustering using optimized binary methods. Using a binary clustering pipeline we demonstrate that binary clustering solutions resemble conventional clustering solutions for large clusters, but show less resemblance for smaller clusters. We also show that the Leiden community detection algorithm can achieve higher cluster quality compared to the Louvain algorithm for the binarized data.

Analysing single-cell RNA sequencing data is becoming an increasingly tedious task as the size of data sets grows. As a proposed solution, recent discoveries suggest that these data sets can be binarized without losing much information. This in turn should allow for memory and time efficient methods of storage and computation. Numerous analyses techniques require cell clustering as a preliminary procedure, which suggests the need to evaluate binary representation performance under that context. In this work we present a comparison between binary clustering results and the state-of-the-art, with a focus on similarity metric choice and the impact on intermediate steps of the procedure (i.e. similarity matrices and kNN graphs). The method was evaluated on single-cell transcriptomic data sets, utilizing a combination of R and C++ as an evaluation framework. Through these means we found that some of the similarity metrics operating on continuous input can possibly be reproduced with similarity metrics operating on binary input.

The rapid increase in the size of single-cell RNAseq datasets presents significant performance challenges when conducting evaluations and extracting information. We research an alternative input data format that utilizes binarization. Our main focus is an analysis of peak memory usage. An in-depth exploration of the solution’s design and implementation is provided, specifically emphasizing the strategies used to minimize memory usage. We analyzed and validated memory usage patterns and asymptotes using memory profiling tools. However, our findings suggest that gains in reducing memory usage on big modern datasets are attributable only to binarized data format rather than workflow interaction with the new format, which we found to be independent of the input format.

As single-cell RNA sequencing techniques improve and more cells are measured in individual experiments, cell clustering procedures become increasingly more computationally intensive. This paper studies the runtime performance impact of a specialized clustering algorithm for data converted to a binary format, in order to reduce computational burden. We experimentally show that our specialized algorithm runs faster than the Seurat library on small datasets, and that with proper dimensionality reduction and approximation techniques, the algorithm could be more scalable than current methods. Optimizations for cluster quality and memory efficiency are not considered in this paper.

AI-assisted development tools use Machine Learning models to help developers achieve tasks such as Method Name Generation, Code Captioning, Smart Bug Finding and others. A common practice among data scientists training these models is to omit inline code comments from training data. We hypothesize that including inline comments in the training code will provide more information to the model and improve the model's performance for natural-language related tasks, specifically Code Captioning. We adjust one of these models, code2seq, to include inline comments in its data processing, then train and compare it to a commentless version. We find that including inline comments tends to increase the performance of the model by making it faster and producing more verbose results, and then reflect on the results of this work to formulate suggestions on how to improve upon this body of research.

Machine learning (ML) algorithms have been used frequently in the past years for Software Engineering tasks.
One of the popular tasks researchers use is method name prediction, which helps them generate an identifier for methods with ML models such as Code2Seq.
This model represents code snippets as Abstract Syntax Trees (AST) and includes all code elements except comments.
This paper introduces a novel approach to incorporating comments in Code2Seq.
The reimplemented models integrate comments into the AST when preprocessing the data.
We filtered comments to reduce the noise introduced in the model and improve the predictions using techniques such as TF-IDF and stopword removal.
We implement several models for each filtering technique and one for raw comments.
These models are trained and evaluated using the dataset java-small, provided by Code2Seq, with 700K examples and the following metrics: precision, recall, and F1.
The results obtained from the evaluation of our model with raw comments show an improvement of 3.62% and 2.36% in precision and F1, respectively, on method name prediction compared to the original model.
Furthermore, the model with stopword removal has a 6% and 3.52% gain in recall and F1. These improvements suggest that adding comments to Code2Seq is valuable for better method name predictions since they contain additional information about the methods.

A number of Machine Learning models utilize source code as training data for automating software development tasks. A common trend is to omit inline comments from source code in order to unify and standardize the examples, even though the additional information can capture important aspects and better explain algorithms. We claim that models, utilizing the supplementary data, are able to produce more fluent translations for Automatic Documentation Generation task. We test this by creating two datasets and measuring the performance difference. The results show that there is a slight improvement in translation accuracy when a dataset contains inline comments, with stop words removed. Further research needs to be done to optimize the preprocessing of data and to more accurately detect the scope of inline comments.

Maven Central Repository hosts over 9 million repositories which ease software reuse. Since its appearance, Maven has been studied and character- ized using different popularity and quality metrics, in order to identify defining patterns and possible improvements. This study aims to analyze extent of use of packages released in the Maven Central Repository. Extent of use is a metric that quanti- fies how much of a package is used. The findings of this study show that on average 73.2% of avail- able methods and 77.1% modules in a package are used by dependents of the package. The study also shows that extent of use at method level is highly correlated with extent of use at module level (Pear- son correlation coefficient r = 0.829).

In this paper, we investigate whether developers of artifacts on Maven Central adhere to semantic versioning. We also investigate whether there is a link between violations in semantic versioning and the popularity of the violating method. Developers can violate semantic versioning by removing or altering methods in their API, which we refer to as breaking changes. They can also violate semantic versioning by extending the API in a patch version, referred to as an illegal API extension. APIs that do not keep their promise of adhering to semantic versioning, will unexpectedly break their dependents during upgrading of dependencies.

We have found that these two types of violations do occur in practice. We find that 24% of analyzed artifacts contain breaking changes and 24% of artifacts contain illegal API extensions. Finally, we show that popularity of a method does not have an impact on breaking changes.

We conclude that semantic versioning can not always guarantee that upgrading dependencies will not lead to incompatibility. This indicates a need for developers to be more aware of the impact that violating semantic versioning has.

Even though previous studies have studied software artefacts on a package level, little research has been done on a method level. In this work, we perform a method-level analysis to determine how popularity disperses among methods within software libraries of Maven Central. We analyse 384 software artefacts with three different metrics: eigenvector centrality, degree centrality and dependent usage percentage. Using callgraphs of the interactions of a software artefact with its dependents, we can determine the relative popularity score of any method. We observe that popularity is inverse logarithmically distributed among the most frequently used methods within a library. Furthermore, 80% of calls to a library are to 26% of all methods, following the Pareto Principle. Likewise, the number of dependents per artefacts also follows a power-law distribution. We also find that no significant correlation exists between any of the analysed metrics, allowing opportunities for future research to determine a more accurate popularity metric. All of our results show that method popularity is logarithmically distributed within software artefacts of Maven Central.

We look at the Maven eco-system and how popularity of packages and its methods change. We want to know if there are any trends that can help developers more efficiently use their time. To look at the popularity we do package analysis and method analysis. We find that there is no correlation between time and popularity on both the package and the method level. We do seem to find that developers are slow to adopt newer versions. We also found that library maintainers tend to re-release older versions, these versions often have low usage.

There has been a lot of research focused on the next generation of the internet, the so-called quantum networks. This analysis has been so far limited to mostly symmetrical architectures, but any near-term realisations of quantum networks using existing fibre topologies will contain asymmetry. In this thesis, we investigate how midpoint asymmetry affects quantum repeater protocols implemented with atomic ensembles. We extend the existing simulation framework to allow for midpoint asymmetry. By simulating asymmetry in elementary links, we show that the performance of an elementary link executing quantum key distribution decreases with an increasing degree of asymmetry. This effect can be mitigated by individual optimisation of photon sources at both ends of the elementary link. We present a way how to reduce the search space of such optimisations by developing a heuristic. The contributions of this thesis provide a crucial starting point for investigations of asymmetry in quantum repeater chains.