Change search
Refine search result
1 - 39 of 39
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
Rows per page
  • 5
  • 10
  • 20
  • 50
  • 100
  • 250
Sort
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
Select
The maximal number of hits you can export is 250. When you want to export more records please use the Create feeds function.
  • 1. Boix, E. G.
    et al.
    Haller, Philipp
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Ricci, A.
    Varela, C.
    Message from the Chairs2015In: AGERE 2015 - Proceedings of the 5th International Workshop on Programming Based on Actors, Agents,and Decentralized Control, Association for Computing Machinery (ACM), 2015Conference paper (Refereed)
  • 2. Boix, E. G.
    et al.
    Haller, Philipp
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Ricci, A.
    Varela, C.
    Workshop preview of the 2015 workshop on programming based on actors, agents, and decentralized control (AGERE! 2015)2015In: SPLASH Companion 2015 - Companion Proceedings of the 2015 ACM SIGPLAN International Conference on Systems, Programming, Languages and Applications: Software for Humanity, 2015, p. 99-100Conference paper (Refereed)
    Abstract [en]

    The AGERE! workshop focuses on programming systems, languages and applications based on actors, active/concurrent objects, agents and - more generally - high-level programming paradigms promoting a mindset of decentralized control in solving problems and developing software. The workshop is designed to cover both the theory and the practice of design and programming, bringing together researchers working on models, languages and technologies, and practitioners developing real-world systems and applications.

  • 3.
    Glassey, Richard
    et al.
    KTH, School of Electrical Engineering and Computer Science (EECS), Theoretical Computer Science, TCS.
    Haller, Philipp
    KTH, School of Electrical Engineering and Computer Science (EECS), Theoretical Computer Science, TCS.
    Wiggberg, Mattias
    KTH, School of Industrial Engineering and Management (ITM), Industrial Economics and Management (Dept.), Industrial Management.
    Agile and adaptive learning via the ECK-model in the software development academy2018In: CEUR Workshop Proceedings, CEUR-WS , 2018, Vol. 2193Conference paper (Refereed)
    Abstract [en]

    This paper reports the learning management experiences within an intensive three-month education that helps newly arrived in Sweden find work as IT professionals. The creation of the Software Development Academy was motivated by the migration crisis and the wider need to help integrate newcomers into the social and professional landscape. Despite having relevant skills and training, many have had their studies and careers disrupted either by conflict, or simply by lacking the profile and networks needed to restart their careers in a new country. With limited resources and time, combined with the intensive pace and diverse student backgrounds, the program faces many challenges that threaten its success. To mitigate these challenges, an agile and adaptive approach was adopted that employs TEL techniques and pedagogical concepts to ensure the program is continuously improving via short iterations and tight feedback loops. The program has just finished its third offering and has continuously improved through weekly collection of knowledge, confidence, and experience data that guide interventions and reactions as they are needed. The experience, process, and model presented here may inspire and benefit other courses with similar profiles and challenges.

  • 4.
    Gonzalez Boix, Elisa
    et al.
    Vrije Universiteit Brussel, Belgium.
    Haller, PhilippTypesafe, Switzerland.Ricci, AlessandroUniversity of Bologna, Italy.Varela, CarlosRensselaer Polytechnic Institute, USA.
    Proceedings of the 4th International Workshop on Programming based on Actors Agents & Decentralized Control2014Conference proceedings (editor) (Refereed)
  • 5. Gonzalez Boix, Elisa
    et al.
    Haller, PhilippKTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.Ricci, AlessandroVarela, Carlos
    Proceedings of the 5th International Workshop on Programming Based on Actors, Agents, and Decentralized Control2015Conference proceedings (editor) (Refereed)
  • 6.
    Haller, Philipp
    Typesafe, Switzerland.
    On the integration of the actor model in mainstream technologies: The Scala perspective2012In: AGERE!@SPLASH 2012: Proceedings of the 2nd International Workshop on Programming systems, languages and applications based on actors, agents, and decentralized control abstractions, 2012, p. 1-5Conference paper (Other academic)
    Abstract [en]

    Integrating the actor model into mainstream software platforms is challenging because typical runtime environments, such as the Java Virtual Machine, have been designed for very different concurrency models. Moreover, to enable integration with existing infrastructures, execution modes and constructs foreign to the pure actor model have to be supported. This paper provides an overview of past and current efforts to address these challenges in the context of the Scala programming language.

  • 7.
    Haller, Philipp
    et al.
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Geries, Simon
    KTH.
    Eichberg, Michael
    Salvaneschi, Guido
    Reactive Async: Expressive Deterministic Concurrency2016In: Proceedings of the 2016 7th ACM SIGPLAN Symposium on Scala, Association for Computing Machinery (ACM), 2016, p. 11-20Conference paper (Refereed)
    Abstract [en]

    Concurrent programming is infamous for its difficulty. An important source of difficulty is non-determinism, stemming from unpredictable interleavings of concurrent activities. Futures and promises are widely-used abstractions that help designing deterministic concurrent programs, although this property cannot be guaranteed statically in mainstream programming languages. Deterministic-by-construction concurrent programming models avoid this issue, but they typically restrict expressiveness in important ways.

    This paper introduces a concurrent programming model, Reactive Async, which decouples concurrent computations using so-called cells, shared locations which generalize futures as well as recent deterministic abstractions such as LVars. Compared to previously proposed programming models Reactive Async provides (a) a fallback mechanism for the case where no computation ever computes the value of a given cell, and (b) explicit and optimized handling of cyclic dependencies. We present a complete implementation of the Reactive Async programming model as a library in Scala. Finally, the paper reports on a case study applying Reactive Async to static analyses of JVM bytecode based on the Opal framework.

  • 8.
    Haller, Philipp
    et al.
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Gonzalez Boix, E.
    Special issue on the 3rd and 4th ACM SIGPLAN workshops on programming based on actors, agents, and decentralized control (AGERE! 2013/2014)2016In: Computer languages, systems & structures, ISSN 1477-8424, E-ISSN 1873-6866, p. 161-162Article in journal (Other academic)
  • 9.
    Haller, Philipp
    et al.
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Loiko, Alex
    LACASA: Lightweight Affinity and Object Capabilities in Scala2016In: SIGPLAN notices, ISSN 0362-1340, E-ISSN 1558-1160, Vol. 51, no 10, p. 272-291Article in journal (Refereed)
    Abstract [en]

    Aliasing is a known source of challenges in the context of imperative object-oriented languages, which have led to important advances in type systems for aliasing control. However, their large-scale adoption has turned out to be a surprisingly difficult challenge. While new language designs show promise, they do not address the need of aliasing control in existing languages. This paper presents a new approach to isolation and uniqueness in an existing, widely-used language, Scala. The approach is unique in the way it addresses some of the most important obstacles to the adoption of type system extensions for aliasing control. First, adaptation of existing code requires only a minimal set of annotations. Only a single bit of information is required per class. Surprisingly, the paper shows that this information can be provided by the object-capability discipline, widely-used in program security. We formalize our approach as a type system and prove key soundness theorems. The type system is implemented for the full Scala language, providing, for the first time, a sound integration with Scala's local type inference. Finally, we empirically evaluate the conformity of existing Scala open-source code on a corpus of over 75,000 LOC.

  • 10.
    Haller, Philipp
    et al.
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Loiko, Alex
    LaCasa: Lightweight Affinity and Object Capabilities in Scala2016In: Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications, Association for Computing Machinery (ACM), 2016, p. 272-291Conference paper (Refereed)
    Abstract [en]

    Aliasing is a known source of challenges in the context of imperative object-oriented languages, which have led to important advances in type systems for aliasing control. However, their large-scale adoption has turned out to be a surprisingly difficult challenge. While new language designs show promise, they do not address the need of aliasing control in existing languages.

    This paper presents a new approach to isolation and uniqueness in an existing, widely-used language, Scala. The approach is unique in the way it addresses some of the most important obstacles to the adoption of type system extensions for aliasing control. First, adaptation of existing code requires only a minimal set of annotations. Only a single bit of information is required per class. Surprisingly, the paper shows that this information can be provided by the object-capability discipline, widely-used in program security. We formalize our approach as a type system and prove key soundness theorems. The type system is implemented for the full Scala language, providing, for the first time, a sound integration with Scala's local type inference. Finally, we empirically evaluate the conformity of existing Scala open-source code on a corpus of over 75,000 LOC.

  • 11.
    Haller, Philipp
    et al.
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Miller, H.
    Chairs' welcome2015Conference paper (Refereed)
  • 12.
    Haller, Philipp
    et al.
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Miller, H.
    Distributed programming via safe closure passing2016In: Electronic Proceedings in Theoretical Computer Science, EPTCS, Open Publishing Association , 2016, p. 99-107Conference paper (Refereed)
    Abstract [en]

    Programming systems incorporating aspects of functional programming, e.g., higher-order functions, are becoming increasingly popular for large-scale distributed programming. New frameworks such as Apache Spark leverage functional techniques to provide high-level, declarative APIs for in-memory data analytics, often outperforming traditional "big data" frameworks like Hadoop MapReduce. However, widely-used programming models remain rather ad-hoc; aspects such as implementation trade-offs, static typing, and semantics are not yet well-understood. We present a new asynchronous programming model that has at its core several principles facilitating functional processing of distributed data. The emphasis of our model is on simplicity, performance, and expressiveness. The primary means of communication is by passing functions (closures) to distributed, immutable data. To ensure safe and efficient distribution of closures, our model leverages both syntactic and type-based restrictions. We report on a prototype implementation in Scala. Finally, we present preliminary experimental results evaluating the performance impact of a static, type-based optimization of serialization.

  • 13.
    Haller, Philipp
    et al.
    KTH, School of Electrical Engineering and Computer Science (EECS).
    Miller, Heather
    Carnegie Mellon Univ, Pittsburgh, PA 15213 USA..
    A reduction semantics for direct-style asynchronous observables2019In: The Journal of logical and algebraic methods in programming, ISSN 2352-2208, E-ISSN 2352-2216, Vol. 105, p. 75-111Article in journal (Refereed)
    Abstract [en]

    Asynchronous programming has gained in importance, not only due to hardware developments like multi-core processors, but also due to pervasive asynchronicity in client-side Web programming and large-scale Web applications. However, asynchronous programming is challenging. For example, control-flow management and error handling are much more complex in an asynchronous than a synchronous context. Programming with asynchronous event streams is especially difficult: expressing asynchronous stream producers and consumers requires explicit state machines in continuation-passing style when using widely-used languages like Java. In order to address this challenge, recent language designs like Google's Dart introduce asynchronous generators which allow expressing complex asynchronous programs in a familiar blocking style while using efficient non-blocking concurrency control under the hood. However, several issues remain unresolved, including the integration of analogous constructs into statically-typed languages, and the formalization and proof of important correctness properties. This paper presents a design for asynchronous stream generators for Scala, thereby extending previous facilities for asynchronous programming in Scala from tasks/futures to asynchronous streams. We present a complete formalization of the programming model based on a reduction semantics and a static type system. Building on the formal model, we contribute a complete type soundness proof, as well as the proof of a subject reduction theorem which establishes that the programming model enforces an important state transition protocol for asynchronous streams. (C) 2019 Elsevier Inc. All rights reserved.

  • 14.
    Haller, Philipp
    et al.
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Miller, Heather
    Proceedings of the 6th ACM SIGPLAN Symposium on Scala2015Conference proceedings (editor) (Refereed)
  • 15.
    Haller, Philipp
    et al.
    KTH, School of Electrical Engineering and Computer Science (EECS).
    Miller, Heather
    Mueller, Normen
    A programming model and foundation for lineage-based distributed computation2018In: Journal of functional programming (Print), ISSN 0956-7968, E-ISSN 1469-7653, Vol. 28, article id e7Article in journal (Refereed)
    Abstract [en]

    The most successful systems for "big data" processing have all adopted functional APIs. We present a new programming model, we call function passing, designed to provide a more principled substrate, or middleware, upon which to build data-centric distributed systems like Spark. A key idea is to build up a persistent functional data structure representing transformations on distributed immutable data by passing well-typed serializable functions over the wire and applying them to this distributed data. Thus, the function passing model can be thought of as a persistent functional data structure that is distributed, where transformations performed on distributed data are stored in its nodes rather than the distributed data itself. One advantage of this model is that failure recovery is simplified by design - data can be recovered by replaying function applications atop immutable data loaded from stable storage. Deferred evaluation is also central to our model; by incorporating deferred evaluation into our design only at the point of initiating network communication, the function passing model remains easy to reason about while remaining efficient in time and memory. Moreover, we provide a complete formalization of the programming model in order to study the foundations of lineage-based distributed computation. In particular, we develop a theory of safe, mobile lineages based on a subject reduction theorem for a typed core language. Furthermore, we formalize a progress theorem that guarantees the finite materialization of remote, lineage-based data. Thus, the formal model may serve as a basis for further developments of the theory of data-centric distributed programming, including aspects such as fault tolerance. We provide an open-source implementation of our model in and for the Scala programming language, along with a case study of several example frameworks and end-user programs written atop this model.

  • 16.
    Haller, Philipp
    et al.
    EPFL, Switzerland.
    Odersky, Martin
    EPFL, Switzerland.
    Actors That Unify Threads and Events2007In: Coordination Models and Languages, 2007, p. 171-190Conference paper (Refereed)
    Abstract [en]

    There is an impedance mismatch between message-passing concurrency and virtual machines, such as the JVM. VMs usually map their threads to heavyweight OS processes. Without a lightweight process abstraction, users are often forced to write parts of concurrent applications in an event-driven style which obscures control flow, and increases the burden on the programmer.

    In this paper we show how thread-based and event-based programming can be unified under a single actor abstraction. Using advanced abstraction mechanisms of the Scala programming language, we implemented our approach on unmodified JVMs. Our programming model integrates well with the threading model of the underlying VM.

  • 17.
    Haller, Philipp
    et al.
    EPFL, Switzerland.
    Odersky, Martin
    EPFL, Switzerland.
    Capabilities for Uniqueness and Borrowing2010In: ECOOP 2010: Proceedings of the 24th European Conference on Object-Oriented Programming, 2010, p. 354-378Conference paper (Refereed)
    Abstract [en]

    An important application of unique object references is safe and efficient message passing in concurrent object-oriented programming. However, to prevent the ill effects of aliasing, practical systems often severely restrict the shape of messages passed by reference. Moreover, the problematic interplay between destructive reads often used to implement unique references and temporary aliasing through "borrowed" references is exacerbated in a concurrent setting, increasing the potential for unpredictable run-time errors.

    This paper introduces a new approach to uniqueness. The idea is to use capabilities for enforcing both at-most-once consumption of unique references, and a flexible notion of uniqueness. The main novelty of our approach is a model of uniqueness and borrowing based on simple, unstructured capabilities. The advantages are: first, it provides simple foundations for uniqueness and borrowing. Second, it can be formalized using a relatively simple type system, for which we provide a complete soundness proof. Third, it avoids common problems involving borrowing and destructive reads, since unique references subsume borrowed references.

    We have implemented our type system as an extension to Scala. Practical experience suggests that our system allows type checking real-world actor-based concurrent programs with only a small number of additional type annotations.

  • 18.
    Haller, Philipp
    et al.
    Ecole Polytechnique F´ed´erale de Lausanne (EPFL).
    Odersky, Martin
    Ecole Polytechnique F´ed´erale de Lausanne (EPFL).
    Event-Based Programming Without Inversion of Control2006In: Modular Programming Languages: 7th Joint Modular Languages Conference, JMLC 2006 Oxford, UK, September 13-15, 2006 Proceedings, Springer, 2006, Vol. 4228, p. 4-22Conference paper (Refereed)
    Abstract [en]

    Concurrent programming is indispensable. On the one hand, distributed and mobile environments naturally involve concurrency. On the other hand, there is a general trend towards multi-core processors that are capable of running multiple threads in parallel.

  • 19.
    Haller, Philipp
    et al.
    EPFL, Switzerland.
    Odersky, Martin
    EPFL, Switzerland.
    Scala Actors: Unifying thread-based and event-based programming2009In: Theoretical Computer Science, ISSN 0304-3975, E-ISSN 1879-2294, Vol. 410, no 2-3, p. 202-220Article in journal (Refereed)
    Abstract [en]

    There is an impedance mismatch between message-passing concurrency and virtual machines, such as the JVM. VMs usually map their threads to heavyweight OS processes. Without a lightweight process abstraction, users are often forced to write parts of concurrent applications in an event-driven style which obscures control flow, and increases the burden on the programmer. In this paper we show how thread-based and event-based programming can be unified under a single actor abstraction. Using advanced abstraction mechanisms of the Scala programming language, we implement our approach on unmodified JVMs. Our programming model integrates well with the threading model of the underlying VM.

  • 20.
    Haller, Philipp
    et al.
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Sommar, Fredrik
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Towards an Empirical Study of Affine Types for Isolated Actors in Scala2017In: Electronic Proceedings in Theoretical Computer Science, ISSN 2075-2180, E-ISSN 2075-2180, no 246, p. 3-9Article in journal (Refereed)
    Abstract [en]

    LaCasa is a type system and programming model to enforce the object capability discipline in Scala, and to provide affine types. One important application of LaCasa's type system is software isolation of concurrent processes. Isolation is important for several reasons including security and data-race freedom. Moreover, LaCasa's affine references enable efficient, by-reference message passing while guaranteeing a "deep-copy" semantics. This deep-copy semantics enables programmers to seamlessly port concurrent programs running on a single machine to distributed programs running on large-scale clusters of machines. This paper presents an integration of LaCasa with actors in Scala, specifically, the Akka actor-based middleware, one of the most widely-used actor systems in industry. The goal of this integration is to statically ensure the isolation of Akka actors. Importantly, we present the results of an empirical study investigating the effort required to use LaCasa's type system in existing open-source Akka-based systems and applications.

  • 21.
    Haller, Philipp
    et al.
    EPFL, Switzerland.
    Van Cutsem, Tom
    Vrije Universiteit Brussel, Belgium.
    Implementing Joins Using Extensible Pattern Matching2008In: COORDINATION 2008: Proceedings of the 10th International Conference on Coordination Models and Languages, 2008, p. 135-152Conference paper (Refereed)
    Abstract [en]

    Join patterns are an attractive declarative way to synchronize both threads and asynchronous distributed computations. We explore joins in the context of extensible pattern matching that recently appeared in languages such as F# and Scala. Our implementation supports join patterns with multiple synchronous events, and guards. Furthermore, we integrated joins into an existing actor-based concurrency framework. It enables join patterns to be used in the context of more advanced synchronization modes, such as future-type message sending and token-passing continuations.

  • 22.
    Haller, Philipp
    et al.
    KTH, School of Electrical Engineering and Computer Science (EECS), Theoretical Computer Science, TCS.
    Vasconcelos, Vasco Thudichum
    Univ Lisbon, Lisbon, Portugal..
    Special issue on the tenth Workshop on Programming Language Approaches to Concurrency- and Communication-cEntric Software2019In: The Journal of logical and algebraic methods in programming, ISSN 2352-2208, E-ISSN 2352-2216, Vol. 106, p. 196-197Article in journal (Refereed)
  • 23. Karlsson, Olof
    et al.
    Haller, Philipp
    KTH, School of Electrical Engineering and Computer Science (EECS), Theoretical Computer Science, TCS.
    Extending Scala with records: Design, implementation, and evaluation2018In: Scala 2018 Proceedings of the 9th ACM SIGPLAN International Symposium on Scala, Association for Computing Machinery (ACM), 2018, p. 72-82Conference paper (Refereed)
  • 24. Miller, Heather
    et al.
    Haller, Philipp
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    A Type-Based Foundation for Closure-Passing in the Age of Concurrency and Distribution2015In: Software Engineering & Management 2015, 2015, p. 41-42Conference paper (Refereed)
  • 25.
    Miller, Heather
    et al.
    EPFL, Switzerland.
    Haller, Philipp
    Typesafe, Switzerland.
    Burmako, Eugene
    EPFL, Switzerland.
    Odersky, Martin
    EPFL, Switzerland.
    Instant pickles: generating object-oriented pickler combinators for fast and extensible serialization2013In: OOPSLA 2013: Proceedings of the 2013 ACM SIGPLAN International Conference on Object Oriented Programming Systems Languages & Applications, Association for Computing Machinery (ACM), 2013, p. 183-202Conference paper (Refereed)
    Abstract [en]

    As more applications migrate to the cloud, and as "big data" edges into even more production environments, the performance and simplicity of exchanging data between compute nodes/devices is increasing in importance. An issue central to distributed programming, yet often under-considered, is serialization or pickling, i.e., persisting runtime objects by converting them into a binary or text representation. Pickler combinators are a popular approach from functional programming; their composability alleviates some of the tedium of writing pickling code by hand, but they don't translate well to object-oriented programming due to qualities like open class hierarchies and subtyping polymorphism. Furthermore, both functional pickler combinators and popular, Java-based serialization frameworks tend to be tied to a specific pickle format, leaving programmers with no choice of how their data is persisted. In this paper, we present object-oriented pickler combinators and a framework for generating them at compile-time, called scala/pickling, designed to be the default serialization mechanism of the Scala programming language. The static generation of OO picklers enables significant performance improvements, outperforming Java and Kryo in most of our benchmarks. In addition to high performance and the need for little to no boilerplate, our framework is extensible: using the type class pattern, users can provide both (1) custom, easily interchangeable pickle formats and (2) custom picklers, to override the default behavior of the pickling framework. In benchmarks, we compare scala/pickling with other popular industrial frameworks, and present results on time, memory usage, and size when pickling/ unpickling a number of data types used in real-world, large-scale distributed applications and frameworks.

  • 26. Miller, Heather
    et al.
    Haller, PhilippKTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.Lhoták, Ondrej
    Proceedings of the 8th ACM SIGPLAN International Symposium on Scala2017Conference proceedings (editor) (Refereed)
  • 27.
    Miller, Heather
    et al.
    EPFL, Switzerland.
    Haller, Philipp
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Müller, Normen
    Trivadis GmbH, Germany.
    Boullier, Jocelyn
    EPFL, Switzerland.
    Function Passing: A Model for Typed, Distributed Functional Programming2016Conference paper (Refereed)
  • 28.
    Miller, Heather
    et al.
    EPFL, Switzerland.
    Haller, Philipp
    Typesafe, Switzerland.
    Odersky, Martin
    EPFL, Switzerland.
    Spores: A Type-Based Foundation for Closures in the Age of Concurrency and Distribution2014In: ECOOP 2014: Proceedings of the 28th European Conference on Object-Oriented Programming, 2014, Vol. 8586, p. 308-333Conference paper (Refereed)
    Abstract [en]

    Functional programming (FP) is regularly touted as the way forward for bringing parallel, concurrent, and distributed programming to the mainstream. The popularity of the rationale behind this viewpoint has even led to a number of object-oriented (OO) programming languages outside the Smalltalk tradition adopting functional features such as lambdas and thereby function closures. However, despite this established viewpoint of FP as an enabler, reliably distributing function closures over a network, or using them in concurrent environments nonetheless remains a challenge across FP and OO languages. This paper takes a step towards more principled distributed and concurrent programming by introducing a new closure-like abstraction and type system, called spores, that can guarantee closures to be serializable, thread-safe, or even have custom user-defined properties. Crucially, our system is based on the principle of encoding type information corresponding to captured variables in the type of a spore. We prove our type system sound, implement our approach for Scala, evaluate its practicality through a small empirical study, and show the power of these guarantees through a case analysis of real-world distributed and concurrent frameworks that this safe foundation for closures facilitates.

  • 29.
    Miller, Heather
    et al.
    EPFL, Switzerland.
    Haller, Philipp
    Typesafe, Switzerland.
    Rytz, Lukas
    EPFL, Switzerland.
    Odersky, Martin
    EPFL, Switzerland.
    Functional programming for all!: Scaling a MOOC for students and professionals alike2014In: ICSE 2014: Companion Proceedings of the 36th International Conference on Software Engineering, 2014, p. 256-263Conference paper (Refereed)
    Abstract [en]

    Massive open online courses (MOOCs) have launched a scale shift in higher education, with several individual MOOCs now boasting tens or hundreds of thousands of participants worldwide. Our MOOC on the principles of functional pro-gramming has more than 100,000 registered students to date, and boasts one of the highest rates of completion (19.2%) for its size. In this paper, we describe our experience organiz-ing this popular MOOC, and demonstrate how providing in-novative supporting tools (IDE plugins, testing frameworks, interactive build tools, automated cloud-based graders, style checkers) and considering key human-computer interaction factors potentially contributed to this markedly high com-pletion rate. We collect an unprecedented volume of course statistics and survey results and have made them available, along with scripts for generating interactive web-based vi-sualizations, as an open-source project.

  • 30.
    Moors, Adriaan
    et al.
    EPFL, Switzerland.
    Rompf, Tiark
    EPFL, Switzerland.
    Haller, Philipp
    Stanford University, USA.
    Odersky, Martin
    EPFL, Switzerland.
    Scala-virtualized2012Conference paper (Refereed)
    Abstract [en]

    Scala-Virtualized extends the Scala language to better support hosting embedded DSLs. Embedding a DSL in Scala-Virtualized comes with all the benefits of a shallow embedding thanks to Scala's flexible syntax, without giving up analyzing and manipulating the domain program - typically exclusive to deep embeddings. Through lightweight modular staging, implemented in standard Scala, the benefits of a deep embedding are recovered with little overhead. Scala-Virtualized lifts more of the language's built-in constructs and static information to complete this support and make it more convenient. We illustrate how Scala-Virtualized makes Scala an even better host for embedded DSLs along three axes of customizing the language: syntax, run-time behavior and static semantics.

  • 31.
    Prokopec, Aleksandar
    et al.
    Oracle Labs, Switzerland.
    Haller, Philipp
    Typesafe, Switzerland.
    Odersky, Martin
    EPFL, Switzerland.
    Containers and aggregates, mutators and isolates for reactive programming2014In: SCALA 2014 - Proceedings of the 5th Annual Scala Workshop, Co-located with ECOOP 2014, ACM Digital Library, 2014, p. 51-61Conference paper (Refereed)
    Abstract [en]

    Many programs have an inherently reactive nature imposed by the functional dependencies between their data and external events. Classically, these dependencies are dealt with using callbacks. Reactive programming with first-class reactive values is a paradigm that aims to encode callback logic in declarative statements. Reactive values concisely define dependencies between singular data elements, but cannot efficiently express dependencies in larger datasets. Orthogonally, embedding reactive values in a shared-memory concurrency model convolutes their semantics and requires synchronization. This paper presents a generic framework for reactive programming that extends first-class reactive values with the concept of lazy reactive containers, backed by several concrete implementations. Our framework addresses concurrency by introducing reactive isolates. We show examples that our programming model is efficient and convenient to use.

  • 32.
    Prokopec, Aleksandar
    et al.
    EPFL, Switzerland.
    Miller, Heather
    EPFL, Switzerland.
    Schlatter, Tobias
    EPFL, Switzerland.
    Haller, Philipp
    EPFL, Switzerland.
    Odersky, Martin
    EPFL, Switzerland.
    FlowPools: A Lock-Free Deterministic Concurrent Dataflow Abstraction2012In: Languages and Compilers for Parallel Computing: 25th International Workshop, LCPC 2012, Tokyo, Japan, September 11-13, 2012, Revised Selected Papers, Springer Berlin/Heidelberg, 2012, Vol. 7760, p. 158-173Conference paper (Refereed)
    Abstract [en]

    Implementing correct and deterministic parallel programs is challenging. Even though concurrency constructs exist in popular programming languages to facilitate the task of deterministic parallel programming, they are often too low level, or do not compose well due to underlying blocking mechanisms. In this paper, we present the design and implementation of a fundamental data structure for composable deterministic parallel dataflow computation through the use of functional programming abstractions. Additionally, we provide a correctness proof, showing that the implementation is linearizable, lock-free, and deterministic. Finally, we show experimental results which compare our FlowPool against corresponding operations on other concurrent data structures, and show that in addition to offering new capabilities, FlowPools reduce insertion time by 49 - 54% on a 4-core i7 machine with respect to comparable concurrent queue data structures in the Java standard library.

  • 33.
    Ricci, Alessandro
    et al.
    University of Bologna, Italy.
    Haller, PhilippKTH, School of Electrical Engineering and Computer Science (EECS), Theoretical Computer Science, TCS.
    Programming with Actors: State-of-the-Art and Research Perspectives2018Collection (editor) (Refereed)
  • 34.
    Rompf, Tiark
    et al.
    EPFL, Switzerland.
    Amin, Nada
    EPFL, Switzerland.
    Moors, Adriaan
    EPFL, Switzerland.
    Haller, Philipp
    EPFL, Switzerland.
    Odersky, Martin
    EPFL, Switzerland.
    Scala-Virtualized: linguistic reuse for deep embeddings2012In: Higher-Order and Symbolic Computation, ISSN 1388-3690, E-ISSN 2212-0793, Vol. 25, no 1, p. 165-207Article in journal (Refereed)
    Abstract [en]

    Scala-Virtualized extends the Scala language to better support hosting embedded DSLs. Scala is an expressive language that provides a flexible syntax, type-level computation using implicits, and other features that facilitate the development of embedded DSLs. However, many of these features work well only for shallow embeddings, i.e. DSLs which are implemented as plain libraries. Shallow embeddings automatically profit from features of the host language through linguistic reuse: any DSL expression is just as a regular Scala expression. But in many cases, directly executing DSL programs within the host language is not enough and deep embeddings are needed, which reify DSL programs into a data structure representation that can be analyzed, optimized, or further translated. For deep embeddings, linguistic reuse is no longer automatic.

    Scala-Virtualized defines many of the language’s built-in constructs as method calls, which enables DSLs to redefine the built-in semantics using familiar language mechanisms like overloading and overriding. This in turn enables an easier progression from shallow to deep embeddings, as core language constructs such as conditionals or pattern matching can be redefined to build a reified representation of the operation itself.

    While this facility brings shallow, syntactic, reuse to deep embeddings, we also present examples of what we call deep linguistic reuse: combining shallow and deep components in a single DSL in such a way that certain features are fully implemented in the shallow embedding part and do not need to be reified at the deep embedding level.

  • 35.
    Rytz, Lukas
    et al.
    EPFL, Switzerland.
    Odersky, Martin
    EPFL, Switzerland.
    Haller, Philipp
    EPFL, Switzerland.
    Lightweight Polymorphic Effects2012In: ECOOP 2012 – Object-Oriented Programming: 26th European Conference, Beijing, China, June 11-16, 2012. Proceedings, Springer Berlin/Heidelberg, 2012, Vol. 7313, p. 258-282Conference paper (Refereed)
    Abstract [en]

    Type-and-effect systems are a well-studied approach for reasoning about the computational behavior of programs. Nevertheless, there is only one example of an effect system that has been adopted in a wide-spread industrial language: Java’s checked exceptions. We believe that the main obstacle to using effect systems in day-to-day programming is their verbosity, especially when writing functions that are polymorphic in the effect of their argument. To overcome this issue, we propose a new syntactically lightweight technique for writing effect-polymorphic functions. We show its independence from a specific kind of side-effect by embedding it into a generic and extensible framework for checking effects of multiple domains. Finally, we verify the expressiveness and practicality of the system by implementing it for the Scala programming language.

  • 36. Stivan, Gianluca
    et al.
    Peruffo, Andrea
    Haller, Philipp
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Akka.js: towards a portable actor runtime environment2015In: Proceedings of the 5th International Workshop on Programming Based on Actors, Agents, and Decentralized Control, New York, NY, USA: Association for Computing Machinery (ACM), 2015, p. 57-64Conference paper (Refereed)
    Abstract [en]

    Multiple mature implementations of the actor model of concurrency exist. Besides several ones available for the Java Virtual Machine, there are others, for example, written in SmallTalk or in C++, targeting native platforms or other virtual machines. Recently, runtime environments for platforms such as GPUs have also appeared. However, so far, no full-featured, distributed actor runtime environment has allowed actor programs to run, unchanged, on both Java and JavaScript virtual machines. This paper describes our ongoing effort in providing a portable implementation of the widely-used Akka actor framework.

  • 37. Vasconcelos, V. T.
    et al.
    Haller, Philipp
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Preface2017In: Electronic Proceedings in Theoretical Computer Science, ISSN 2075-2180, E-ISSN 2075-2180, Vol. 246Article in journal (Refereed)
  • 38. Wiener, L.
    et al.
    Ekholm, Tomas
    KTH, School of Engineering Sciences (SCI), Mathematics (Dept.), Mathematics (Div.).
    Haller, Philipp
    KTH, School of Computer Science and Communication (CSC), Theoretical Computer Science, TCS.
    Modular responsive web design: An experience report2017In: Companion to the first International Conference on the Art, Science and Engineering of Programming, Association for Computing Machinery (ACM), 2017, Vol. F129681, article id a22Conference paper (Refereed)
    Abstract [en]

    Responsive Web Design (RWD) enables web applications to adapt to the characteristics of different devices such as screen size which is important for mobile browsing. Today, the only W3C standard to support this adaptability is CSS media queries. However, using media queries it is impossible to create applications in a modular way, because responsive elements then always depend on the global context. Hence, responsive elements can only be reused if the global context is exactly the same. This makes it extremely challenging to develop large responsive applications, because the lack of true modularity makes certain requirement changes either impossible or expensive to realize. In this paper we extend RWD to also include responsive modules, i.e., modules that adapt their design based on their local context, independently of the global context. We present the ELQ project that includes an approach to enabling modular responsivity, and a novel implementation of resize detection of DOM elements. ELQ provides an implementation of element queries which generalize CSS media queries. Importantly, our design conforms to existing web specifications, enabling adoption on a large scale. ELQ is designed to be heavily extensible using plugins. Experimental results show speed-ups of the core algorithms of up to 37x compared to previous approaches. CCS Concepts • Software and its engineering → Domain specific languages; Reusability; Hypertext languages;.

  • 39.
    Zhao, Xin
    et al.
    KTH.
    Haller, Philipp
    KTH.
    Observable atomic consistency for CVRDTs2018In: AGERE 2018 - Proceedings of the 8th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control, co-located with SPLASH 2018, Association for Computing Machinery (ACM), 2018, p. 23-32Conference paper (Refereed)
    Abstract [en]

    The development of distributed systems requires developers to balance the need for consistency, availability, and partition tolerance. Conflict-free replicated data types (CRDTs) are widely used in eventually consistent systems to reduce concurrency control. However, CRDTs lack consistent totally-ordered operations which can make them difficult to use. In this paper, we propose a new consistency protocol, the observable atomic consistency protocol (OACP). OACP enables a principled relaxation of strong consistency to improve performance in specific scenarios. OACP combines the advantages of mergeable data types, specifically, convergent replicated data types, and reliable total order broadcast to provide on-demand strong consistency. By providing observable atomic consistency, OACP avoids the anomalies of related protocols. We provide a distributed implementation of OACP based on Akka, a widely-used actor-based middleware. Our experimental evaluation shows that OACP can reduce coordination overhead compared to other protocols providing atomic consistency. Our results also suggest that OACP increases availability through mergeable data types and provides acceptable latency for achieving strong consistency.

1 - 39 of 39
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf