Elements of Multiparadigm Programming in Scala

Abstract

The dissertation contains novel research results on four aspects of software development: type systems, managing complexity related to error handling, levels of component coupling and concurrent programming at high abstraction levels. The first thesis represents my research on approaches where we can compute the return types of simple recursive functions without a fixed-point search and how the compilation performance is affected by implicit resolution and how this can be improved. Analyzing and managing the complexity of software systems is a core question of every software project. Error handling has been almost completely neglected in this research area, despite the fact that it is an essential part of programs. The advancements in the error handling approaches promise reduced complexity while providing an increase in usability and feature set. I analyze how different error handling methods compare to each other with a scientific rigour. I also investigate these error handling methods in paradigm-agnostic and multiparadigm settings to gain an understanding of their usefulness in different programming methodologies (Thesis II). Software complexity can be of course observed at higher abstraction levels as well. A widely accepted metric of complexity is the coupling between components. It is generally accepted that lower coupling helps reduce complexity and overall software development costs. In the dissertation I investigate what properties coupling metrics present in multiparadigm languages and if there are special attributes we can observe. Furthermore I try to find an answer if there is a natural limit to reducing coupling (Thesis III). As we are reaching the physical limits of single-threaded performance of CPUs, the focus shifts towards concurrent and parallel computing. Parallel computing increases the complexity of programs in a completely new aspect: most programmers find it extremely hard to argue about correctness of their code if it can run on multiple threads. This is the motivation behind finding high-level abstractions for parallel computing problems. A fairly new abstraction is called Read-Copy-Update, but its implementations so far have been only available in lower-level languages.I examine if this can be changed and if RCU can be implemented in a high-level language efficiently. I test the performance of different approaches by implementing a common data structure, a concurrent hash map and evaluate it in a wide range of use cases (Thesis IV).