Search

Οι ροές επεξεργασίας δεδομένων είναι και πάλι στο προσκήνιο: ευρέως-διαδεδομένες βιβλιοθήκες για επεξεργασία ροών υπάρχουν σε κάθε μοντέρνα γλώσσα προγραμματισμού και οικοσύστημα, από την Java στην C# και από την Scala και OCaml στη Haskell. Ωστόσο, καίρια χαρακτηριστικά τους όπως η εκφραστικότητα και οι επιδόσεις έχουν σημαντικά περιθώρια βελτίωσης. Στην παρούσα διατριβή, εξακριβώνουμε το ποια είναι ακριβώς τα ποιοτικά χαρακτηριστικά κάθε βιβλιοθήκης και παρατηρούμε ότι παρούσες αλλά και μελλοντικές χρήσεις τους, είναι άρρηκτα συνδεδεμένες (και δεσμευτικές) με την εκάστοτε υλοποίηση. Απλοί μηχανισμοί αφαίρεσης δεν είναι επαρκείς. Είναι εφικτό να διαμορφώσουμε την υλοποίηση των βιβλιοθηκών ροών και να τις κάνουμε πιο επεκτάσιμες και με μεγαλύτερες επιδόσεις; Παρουσιάζουμε δυο λύσεις προς την επίτευξη της επεκτασιμότητάς τους. Κατά την πρώτη, διαχωρίζουμε τους ορισμούς του συντακτικού και της σημασιολογίας των βιβλιοθηκών και κατά τη δεύτερη λύση απελευθερώνουμε τις εν λόγω βιβλιοθήκες από την επιτακτική ανάγκη ύπαρξης ενός ικανού και έξυπνου μεταγλωττιστή. Ο στόχος της διατριβής είναι να δημιουργήσει επεκτάσιμες βιβλιοθήκες ροών, υψηλών επιδόσεων, διατηρώντας όμως την υψηλού επιπέδου δομή τους. Η παρουσίαση των ερευνητικών μας αποτελεσμάτων έπεται αξιολόγησης επιδόσεων σε σύγχρονες βιβλιοθήκες που διεξήγαμε για διάφορες σύγχρονες γλώσσες προγραμματισμού. Στη συνέχεια προτείνουμε έναν μηχανισμό για την ενίσχυση της συντήρησης βιβλιοθηκών ροών διατηρώντας ενός υψηλού επιπέδου επεκτασιμότητα. Για να το επιτύχουμε αυτό, θεωρούμε τις εν λόγω βιβλιοθήκες ως γλώσσες προγραμματισμού ειδικού σκοπού, σχεδιάζοντας και υλοποίώντας την βιβλιοθήκη StreamAlg, μία βιβλιοθήκη που προσφέρει την δυνατότητα να δεχθεί επεκτάσεις με νέες μεθόδους και συμπεριφορά κατ' επιλογή. Στη συνέχεια, παρουσιάζουμε την εφαρμογή της προαναφερθείσας τεχνικής σε μία γλώσσα προγραμματισμού, την Java, για να επιτύχουμε την ίδια γενικότητα κατά την επέκταση της, με το εργαλείο που ονομάζουμε Recaf. Δείχνουμε πώς δημιουργούμε διαλέκτους στην Java για να υποστηρίξουμε νέο συντακτικό και νέα σημασιολογικά στοιχεία στην ίδια τη γλώσσα. Ως αποτέλεσμα, δημιουργήσαμε επεκτάσεις της Java, μία εκ των οποίων μας έδωσε τη δυνατότητα να δημιουργήσουμε βιβλιοθήκη ροών στη Java, όπως ακριβώς γίνεται και στην C#. Τέλος παρουσιάζουμε την πρότασή μας για βιβλιοθήκες ροών υψηλών επιδόσεων που υλοποιήσαμε σε δύο γλώσσες προγραμματισμού με τον ενιαίο όρο-ομπρέλα Strymonas. Η βιβλιοθήκη που παρέχουμε, χωρίς να βασίζεται σε απροσπέλαστους βελτιστοποιητές ή ``ικανοποιητικά-ικανούς'' μεταγλωττιστές, παρέχει, υψηλού επιπέδου, εγγυημένη και φορητή ταχύτητα ως προς την επεξεργασία δεδομένων. Η προσέγγισή μας βασίζεται σε έννοιες υψηλού επιπέδου οι οποίες στη συνέχεια υλοποιούνται. Stream processing is mainstream (again): Widely-used stream libraries are now available for virtually all modern OO and functional languages, from Java to C# to Scala to OCaml to Haskell. Yet expressivity and performance are still lacking. This dissertation identifies the key high-level differences between various implementations, observes that future use cases are tied with past design decisions, and shows that simple abstraction mechanisms are not sufficient. Is it possible to modularize the implementation of streams to enhance such libraries in terms of extensibility and performance? We present a twofold modularization of streams. To begin with, we untangle streams from the definition of their syntax and semantics and afterwards we liberate them from the need of a ``sufficiently-smart'' compiler. The utmost goal of this dissertation is to make streams extensible and performant, while maintaining their high level structure. Our contributions are preceded by a performance assessment of the current state-of-the-art of streaming libraries. Subsequently, we first propose a mechanism to enhance the maintainability of streams, supporting a high-level of extensibility. We treat streams as a domain-specific language and we design and implement StreamAlg, a library that has the ability to accept new operators and semantics à la carte. Next, we port the library design we used for streams to Java itself, with a lightweight tool named Recaf. We show how to create dialects in Java, override its semantics, support new syntactic elements and much more. Among many examples and case studies we build an extension of Java with a keyword that enables us to construct streams similar to C#. The culmination of our work is a library design, Strymonas, for very efficient streams while preserving their high-level nature.It explicitly avoids the reliance on black-box optimizers and ``sufficiently-smart'' compilers, offering highest, guaranteed and portable performance. Our approach relies on high-level concepts that are then readily mapped into an implementation.

To maximize run-time performance, programmers often specialize their code by hand, replacing library collections and containers by custom objects in which data is restructured for efficient access. However, changing the data representation is a tedious and error-prone process that makes it hard to test, maintain and evolve the source code. We present an automated and composable mechanism that allows programmers to safely change the data representation in delimited scopes containing anything from expressions to entire class definitions. To achieve this, programmers define a transformation and our mechanism automatically and transparently applies it during compilation, eliminating the need to manually change the source code. Our technique leverages the type system in order to offer correctness guarantees on the transformation and its interaction with object-oriented language features, such as dynamic dispatch, inheritance and generics. We have embedded this technique in a Scala compiler plugin and used it in four very different transformations, ranging from improving the data layout and encoding, to retrofitting specialization and value class status, and all the way to collection deforestation. On our benchmarks, the technique obtained speedups between 1.8x and 24.5x.

Streaming libraries have become ubiquitous in object-oriented languages, with recent offerings in Java, C#, and Scala. All such libraries, however, suffer in terms of extensibility: there is no way to change the semantics of a streaming pipeline (e.g., to fuse filter operators, to perform computations lazily, to log operations) without changes to the library code. Furthermore, in some languages it is not even possible to add new operators (e.g., a zip operator, in addition to the standard map, filter, etc.) without changing the library. We address such extensibility shortcomings with a new design for streaming libraries. The architecture underlying this design borrows heavily from Oliveira and Cook's object algebra solution to the expression problem, extended with a design that exposes the push/pull character of the iteration, and an encoding of higher-kinded polymorphism. We apply our design to Java and show that the addition of full extensibility is accompanied by high performance, matching or exceeding that of the original, highly-optimized Java streams library.

Racket game variants like Frescobol, Matkot, etc. are quite popular in many countries with beaches all over the world. In Greece the name of this newly born sport is Beach-Racket and it was recognized as an official sport in 2014. Key steps in its evolution were the introduction of a high-tech score measuring system, mobiXeyes, developed by Mobics S.A., a spin-off company of University of Athens. In this work we describe the basic rules of Beach-Racket and the technology adopted for fulfilling the requirements imposed by the sport. The system is based on two high frame rate cameras and implements a stereoscopic method to calculate the speed of a ball in every hit. Apart from this, it offers a GUI interface for setup, player and category management, calculation of statistics etc. The system in general can calculate the 3D position and the speed of a fast moving object and could be used also in a wide range of relevant sports with none or minor modifications. (C) 2015 Published by Elsevier Ltd.

Java generics are compiled by-erasure: all clients reuse the same bytecode, with uses of the unknown type erased. C++ templates are compiled by-expansion: each type-instantiation of a template pro- duces a different code definition. The two approaches offer trade- offs on multiple axes. We propose an extension of Java generics that allows by-expansion translation relative to selected type pa- rameters only. This language design allows sophisticated users to get the best of both worlds at a fine granularity. Furthermore, our proposal is based on Java 8 Type Annotations (JSR 308) and the Checker Framework as an abstraction layer for controlling compi- lation without changes to the internals of a Java compiler.

We propose DelphJ: a Java-based OO language that eschews inheritance completely, in favor of a combination of class morphing and (deep) delegation. Compared to past delegation approaches, the novel aspect of our design is the ability to emulate the best aspects of inheritance while retaining maximum flexibility: using morphing, a class can select any of the methods of its delegatee and export them (if desired) or transform them (e.g., to add extra arguments or modify type signatures), yet without needing to name these methods explicitly and handle them one-by-one. Compared to past work on morphing, our approach adopts and adapts advanced delegation mechanisms, in order to add late binding capabilities and, thus, provide a full substitute of inheritance. Additionally, we explore complex semantic issues in the interaction of delegation with late binding. We present our language design both informally, with numerous examples, and formally in a core calculus.

Phantom types are a well-known type-level, design pattern which is commonly used to express constraints encoded in types. We observe that in modern, multi-paradigm programming languages, these encodings are too restrictive or do not provide the guarantees that phantom types try to enforce. Furthermore, in some cases they introduce unwanted runtime overhead. We propose a new design for phantom types as a language feature that: (a) solves the aforementioned issues and (b) makes the first step towards new programming paradigms such as proof-carrying code and static capabilities. This paper presents the design of phantom types for Scala, as implemented in the Dotty compiler.

Every newly created object goes through several initialization states: starting from a state where all fields are uninitialized until all of them are assigned. Any operation on the object during its initialization process, which usually happens in the constructor via \emph{this}, has to observe the initialization states of the object for correctness, i.e.~only initialized fields may be used. Checking safe usage of \emph{this} statically, without manual annotation of initialization states in the source code, is a challenge, due to aliasing and virtual method calls on \emph{this}. Mainstream languages either do not check initialization errors, like Java, C++, Scala, or they defend against them by not supporting useful initialization patterns, such as Swift. In parallel, past research has shown that safe initialization can be achieved for varying degrees of expressiveness but by sacrificing syntactic simplicity. We approach the problem by upholding \emph{local reasoning} about initialization which avoids whole-program analysis, and we achieve \emph{typestate polymorphism} via subtyping. On this basis, we put forward a novel type-and-effect system that can effectively ensure initialization safety while allowing flexible initialization patterns. We implement an initialization checker in the Scala 3 compiler and evaluate on several real-world projects.

Implicit parameters are used pervasively in Scala and are also present in a number of other programming and theorem proving languages. This paper describes a generalization of implicit parameters as they are currently found in Scala to implicit function types. We motivate the construct by a series of examples and provide formal foundations that closely follow the semantics implemented by the Scala compiler.

Accessing uninitialized data during object initialization is a common and subtle programming error. This error is either not prevented by mainstream languages, like in Java, C++, Scala, or it is prevented by greatly restricting initialization patterns, like in Swift. In this paper, we propose a model called _Celsius_ for safe and modular initialization of objects, and prove its soundness. We extend the model and implement a prototype in Scala. The experiments on several real-world Scala projects show that the design requires few programmer annotations.