uu.seUppsala University Publications
Change search
Refine search result
1 - 49 of 49
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association
  • 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.
    Blessing, Sebastian
    et al.
    Imperial College London, UK.
    Fernandez-Reyes, Kiko
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Yang, Albert Mingkun
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Drossopoulou, Sophia
    Imperial College London, UK.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Run, Actor, Run: Towards Cross-Actor Language Benchmarking2019In: AGERE 2019 Proceedings of the 9th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control, 2019, p. 41-50Conference paper (Refereed)
    Abstract [en]

    The actor paradigm supports the natural expression of concurrency. It has inspired the development of several actor-based languages, whose adoption depends, to a large extent, on the runtime characteristics ( the performance and scaling behaviour) of programs written in these languages.

    This paper investigates the relative runtime characteristics of Akka, CAF and Pony, based on the Savina benchmarks. We observe that the scaling of many of the Savina benchmarks does not reflect their categorization (into essentially sequential, concurrent and parallel), that many programs have similar runtime characteristics, and that their runtime behaviour may drastically change nature ( go from essentially sequential to parallel) by tweaking some parameters.

    These observations lead to our proposal of a single benchmark program which we designed so that through tweaking of some knobs (we hope) we can simulate most of the programs of the Savina suite.

  • 2.
    Brandauer, Stephan
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Castegren, Elias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Clarke, Dave
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Fernandez-Reyes, Kiko
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Johnsen, Einar Broch
    Univ Oslo, Dept Informat, N-0316 Oslo, Norway..
    Pun, Ka I.
    Univ Oslo, Dept Informat, N-0316 Oslo, Norway..
    Tarifa, S. Lizeth Tapia
    Univ Oslo, Dept Informat, N-0316 Oslo, Norway..
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Yang, Albert Mingkun
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Parallel Objects for Multicores: A Glimpse at the Parallel Language ENCORE2015In: Formal Methods for Multicore Programming, 2015, p. 1-56Conference paper (Refereed)
    Abstract [en]

    The age of multi-core computers is upon us, yet current programming languages, typically designed for single-core computers and adapted post hoc for multi-cores, remain tied to the constraints of a sequential mindset and are thus in many ways inadequate. New programming language designs are required that break away from this old-fashioned mindset. To address this need, we have been developing a new programming language called Encore, in the context of the European Project UpScale. The paper presents a motivation for the Encore language, examples of its main constructs, several larger programs, a formalisation of its core, and a discussion of some future directions our work will take. The work is ongoing and we started more or less from scratch. That means that a lot of work has to be done, but also that we need not be tied to decisions made for sequential language designs. Any design decision can be made in favour of good performance and scalability. For this reason, Encore offers an interesting platform for future exploration into object-oriented parallel programming.

  • 3.
    Brandauer, Stephan
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Castegren, Elias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    C♭: A New Modular Approach to Implementing Efficient and Tunable Collections2018In: Proceedings of the 2018 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (Onward! 2018), ACM , 2018, p. 57-71Conference paper (Refereed)
  • 4.
    Brandauer, Stephan
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Clarke, Dave
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Disjointness Domains for Fine-Grained Aliasing2015Conference paper (Refereed)
    Abstract [en]

    Aliasing is crucial for supporting useful implementation patterns, but it makes reasoning about programs difficult. To deal with this problem, numerous type-based aliasing control mechanisms have been proposed, expressing properties such as uniqueness. Uniqueness, however, is black-and-white: either a reference is unique or it can be arbitrarily aliased; and global: excluding aliases throughout the entire system, making code brittle to changing requirements. Disjointness domains, a new approach to alias control, address this problem by enabling more graduations between uniqueness and arbitrary reference sharing. They allow expressing aliasing constraints local to a certain set of variables (either stack variables or fields) for instance that no aliasing occurs between variables within some set of variables but between such sets or the opposite, that aliasing occurs within that set but not between different sets. A hierarchy of disjointness domains controls the flow of references through a program, helping the programmer reason about disjointness and enforce local alias invariants. The resulting system supports fine-grained control of aliasing between both variables and objects, making aliasing explicit to programmers, compilers, and tooling. This paper presents a formal account of disjointness domains along with examples. Disjointness domains provide novel means of expressing may-alias kinds of constraints, which may prove useful in compiler optimisation and verification.

  • 5.
    Brandauer, Stephan
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Mining for Safety using Interactive Trace Analysis2017In: Pre-Proceedings - Fifteenth International Workshop on Quantitative Aspects of Programming Languages and Systems, 2017, no 15, article id 14Conference paper (Refereed)
  • 6.
    Brandauer, Stephan
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Spencer: Interactive Heap Analysis for the Masses2017In: 2017 IEEE/ACM 14th International Conference on Mining Software Repositories (MSR 2017), IEEE, 2017, no 14, p. 113-123Conference paper (Refereed)
    Abstract [en]

    Programming language-design and run-time-implementation require detailed knowledge about the programs that users want to implement. Acquiring this knowledge is hard, and there is little tool support to effectively estimate whether a proposed tradeoff actually makes sense in the context of real world applications. Ideally, knowledge about behaviour of "typical" programs is 1) easily obtainable, 2) easily reproducible, and 3) easily sharable. We present Spencer, an open source web service and API framework for dynamic analysis of a continuously growing set of traces of standard program corpora. Users do not obtain traces on their own, but can instead send queries to the web service that will be executed on a set of program traces. Queries are built in terms of a set of query combinators that present a high level interface for working with trace data. Since the framework is high level, and there is a hosted collection of recorded traces, queries are easy to implement. Since the data sets are shared by the research community, results are reproducible. Since the actual queries run on one (or many) servers that provide analysis as a service, obtaining results is possible on commodity hardware. Data in Spencer is meant to be obtained once, and analysed often, making the overhead of data collection mostly irrelevant. This allows Spencer to collect more data than traditional tracing tools can afford within their performance budget. Results in Spencer are cached, making complicated analyses that build on cached primitive queries speedy.

  • 7.
    Cameron, Nicholas
    et al.
    Victoria University of Wellington, Wellington, New Zealand.
    Noble, James
    Victoria University of Wellington, Wellington, New Zealand.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Tribal ownership2010In: Proc. 1st International Conference on Systems, Programming, Languages, and Applications: Software for Humanity, New York: ACM Press , 2010, p. 618-633Conference paper (Refereed)
  • 8.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science. KTH Royal Institute of Technology.
    Clarke, Dave
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Fernandez-Reyes, Kiko
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Yang, Albert Mingkun
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Attached and Detached Closures in Actors2018In: Proceedings of the 8th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control, ACM Digital Library, 2018, p. 54-61Conference paper (Refereed)
    Abstract [en]

    Expressive actor models combine aspects of functional programming into the pure actor model enriched with futures. Such functional features include first-class closures which can be passed between actors and chained on futures. Combined with mutable objects, this opens the door to race conditions. In some situations, closures may not be evaluated by the actor that created them yet may access fields or objects owned by that actor. In other situations, closures may be safely fired off to run as a separate task.

    This paper discusses the problem of who can safely evaluate a closure to avoid race conditions, and presents the current solution to the problem adopted by the Encore language. The solution integrates with Encore's capability type system, which influences whether a closure is attached and must be evaluated by the creating actor, or whether it can be detached and evaluated independently of its creator.

    Encore's current solution to this problem is not final or optimal. We conclude by discussing a number of open problems related to dealing with closures in the actor model.

  • 9.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wallin, Joel
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Bestow and Atomic: Concurrent programming using isolation, delegation and grouping2018In: The Journal of logical and algebraic methods in programming, ISSN 2352-2208, E-ISSN 2352-2216, Vol. 100, p. 130-151Article in journal (Refereed)
    Abstract [en]

    Any non-trivial concurrent system warrants synchronisation, regardless of the concurrency model. Actor-based concurrency serialises all computations in an actor through asynchronous message passing. In contrast, lock-based concurrency serialises some computations by following a lock-unlock protocol for accessing certain data. Both systems require sound reasoning about pointers and aliasing to exclude data-races. If actor isolation is broken, so is the single-thread-of-control abstraction. Similarly for locks, if a datum is accessible outside of the scope of the lock, the datum is not governed by the lock. In this paper we discuss how to balance aliasing and synchronisation. In previous work, we defined a type system that guarantees data-race freedom of actor-based concurrency and lock-based concurrency. This paper extends this work by the introduction of two programming constructs; one for decoupling isolation and synchronisation and one for constructing higher-level atomicity guarantees from lower-level synchronisation. We focus predominantly on actors, and in particular the Encore programming language, but our ultimate goal is to define our constructs in such a way that they can be used both with locks and actors, given that combinations of both models occur frequently in actual systems. We discuss the design space, provide several formalisations of different semantics and discuss their properties, and connect them to case studies showing how our proposed constructs can be useful. We also report on an on-going implementation of our proposed constructs in Encore. 

  • 10.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Actors without Borders: Amnesty for Imprisoned State2017Conference paper (Refereed)
    Abstract [en]

    In concurrent systems, some form of synchronisation is typically needed to achieve data-race freedom, which is important for correctness and safety. In actor-based systems, messages are exchanged concurrently but executed sequentially by the receiving actor. By relying on isolation and non-sharing, an actor can access its own state without fear of data-races, and the internal behavior of an actor can be reasoned about sequentially. However, actor isolation is sometimes too strong to express useful patterns. For example, letting the iterator of a data-collection alias the internal structure of the collection allows a more efficient implementation than if each access requires going through the interface of the collection. With full isolation, in order to maintain sequential reasoning the iterator must be made part of the collection, which bloats the interface of the collection and means that a client must have access to the whole data-collection in order to use the iterator. In this paper, we propose a programming language construct that enables a relaxation of isolation but without sacrificing sequential reasoning. We formalise the mechanism in a simple lambda calculus with actors and passive objects, and show how an actor may leak parts of its internal state while ensuring that any interaction with this data is still synchronised.

  • 11.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Kappa: Insights, Current Status and Future Work2016Conference paper (Refereed)
    Abstract [en]

    KAPPA is a type system for safe concurrent object-oriented program- ming using reference capabilities. It uses a combination of static and dynamic techniques to guarantee data-race freedom, and, for a certain subset of the system, non-interference (and thereby determin- istic parallelism). It combines many features from previous work on alias management, such as substructural types, regions, ownership types, and fractional permissions, and brings them together using a unified set of primitives.

    In this extended abstract we show how KAPPA’s capabilities express variations of the aforementioned concepts, discuss the main insights from working with KAPPA, present the current status of the implementation of KAPPA in the context of the actor language Encore, and discuss ongoing and future work. 

  • 12.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    LOLCAT: Relaxed Linear References for Lock-free Programming2016Report (Other academic)
    Abstract [en]

    A linear reference is a reference guaranteed to be unaliased. Thisis a powerful property that simplifies reasoning about programs,but is also a property that is too strong for certainapplications. For example, lock-free algorithms, which implementprotocols to ensure safe concurrent access to data structures, aregenerally not typable with linear references as they involvesharing of mutable state.

    This paper presents a type system with a relaxed notion oflinearity that allows an unbounded number of aliases to an objectas long as at most one alias at a time owns the right to accessthe contents of the object. This ownership can be transferredbetween aliases, but can never be duplicated. The resultinglanguage is flexible enough to express several lock-freealgorithms and at the same time powerful enough to guarantee theabsence of data-races when accessing owned data. The language isformalised and proven sound, and is also available as a prototype implementation.

  • 13.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    OOlong: An Extensible Concurrent Object Calculus2018In: Proceedings of SAC 2018: Symposium on Applied Computing, 2018, p. 1022-1029Conference paper (Refereed)
    Abstract [en]

    We present OOlong, an object calculus with interface inheritance, structured concurrency and locks. The goal of the calculus is extensibility and reuse. The semantics are therefore available in a version for LaTeX typesetting (written in Ott), and a mechanised version for doing rigorous proofs in Coq.

  • 14.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Reference Capabilities for Concurrency & Scalability: an Experience Report2017Conference paper (Refereed)
  • 15.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Reference Capabilities for Concurrency Control2016In: ECOOP 2016 — Object-Oriented Programming, 2016Conference paper (Refereed)
    Abstract [en]

    The proliferation of shared mutable state in object-oriented programming complicates software development as two seemingly unrelated operations may interact via an alias and produce unexpected results. In concurrent programming this manifests itself as data-races.

    Concurrent object-oriented programming suffers from the fact that code that warrants synchronisation cannot easily be distinguished from code that does not. The burden is placed solely on the programmer to reason about alias freedom, sharing across threads and side-effects to deduce where and when to apply concurrency control, without inadvertently blocking parallelism.

    This paper presents a reference capability approach to concurrent and parallel object-oriented programming where all uses of aliases are guaranteed to be data-race free. Locations' static types describe their possible sharing. Type information can express non-interfering deterministic parallelism without dynamic concurrency control, thread-locality, lock-based schemes, and guarded-by relations giving multi-object atomicity to nested data structures. Unification of capabilities and traits allows trait-reuse across multiple concurrency scenarios with minimal code duplication. The resulting system brings together features from a wide range of prior work in a unified way.

  • 16.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Reference Capabilities for Trait Based Reuse and Concurrency Control2016Report (Other academic)
    Abstract [en]

    The proliferation of shared mutable state in object-orientedprogramming complicates software development as two seeminglyunrelated operations may interact via an alias and produceunexpected results. In concurrent programming this manifestsitself as data-races.

    Concurrent object-oriented programming further suffers from thefact that code that warrants synchronisation cannot easily bedistinguished from code that does not. The burden is placed solelyon the programmer to reason about alias freedom, sharing acrossthreads and side-effects to deduce where and when to applyconcurrency control, without inadvertently blocking parallelism.

    This paper presents a reference capability approach to concurrentand parallel object-oriented programming where all uses of aliasesare guaranteed to be data-race free. The static type of an aliasdescribes its possible sharing without using explicit ownership oreffect annotations. Type information can express non-interferingdeterministic parallelism without dynamic concurrency control,thread-locality, lock-based schemes, and guarded-by relationsgiving multi-object atomicity to nested data structures.Unification of capabilities and traits allows trait-based reuseacross multiple concurrency scenarios with minimal codeduplication. The resulting system brings together features from awide range of prior work in a unified way.

  • 17.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Relaxed Linear References for Lock-free Data Structures2017In: / [ed] Peter Müller, 2017, p. 47:1-47:31, article id 47Conference paper (Refereed)
    Abstract [en]

    Linear references are guaranteed to be free from aliases. This is a strong property that simplifies reasoning about programs and enables powerful optimisations, but it is also a property that is too strong for many applications. Notably, lock-free algorithms, which implement protocols that ensure safe, non-blocking concurrent access to data structures, are generally not typable with linear references because they rely on aliasing to achieve lock-freedom.

    This paper presents LOLCAT, a type system with a relaxed notion of linearity that allows an unbounded number of aliases to an object as long as at most one alias at a time owns the right to access the contents of the object. This ownership can be transferred between aliases, but can never be duplicated. LOLCAT types are powerful enough to type several lock-free data structures and give a compile-time guarantee of absence of data-races when accessing owned data. In particular, LOLCAT is able to assign types to the CAS (compare and swap) primitive that precisely describe how ownership is transferred across aliases, possibly across different threads. The paper introduces LOLCAT through a sound core procedural calculus, and shows how LOLCAT can be applied to three fundamental lock-free data structures. It also discusses a prototype implementation which integrates LOLCAT with an object-oriented programming language.

  • 18.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Types for CAS: Relaxed Linearity with Ownership Transfer2016Conference paper (Refereed)
    Abstract [en]

    This extended abstract overviews work on a type system for lock-free programming based on compare-and-swap. The type system prevents atomicity violations in lock-free programs, where insertion and removal of objects from a linked structure would be subject to data-races breaking linearity of ownership. The type system has successfully been applied to a small number of lock-free data structures.

  • 19.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Types for CAS: Relaxed Linearity with Ownership Transfer2017In: Article in journal (Other academic)
    Abstract [en]

    Linear references are guaranteed to be free from aliases. This is a strong property that simplifies reasoning about programs and enables powerful optimisations, but it is also a property that is too strong for many applications. Notably, lock-free algorithms, which implement protocols that ensure safe, non-blocking concurrent access to data structures, are generally not typable with linear references because they rely on aliasing to achieve lock-freedom.

    This paper presents LOLCAT, a type system with a relaxed notion of linearity that allows an unbounded number of aliases to an object as long as at most one alias at a time owns the right to access the contents of the object. This ownership can be transferred between aliases, but can never be duplicated. LOLCAT types are powerful enough to type several lock-free data structures and give a compile-time guarantee of absence of data-races when accessing owned data. In particular, LOLCAT is able to assign types to the CAS (compare and swap) primitive that precisely describe how ownership is transferred across aliases, possibly across different threads.

    The paper introduces LOLCAT through a sound core procedural calculus, and shows how LOLCAT can be applied to three fundamental lock-free data structures. It also shows how LOLCAT can be used to implement synchronisation primitives like locks, and discusses a prototype implementation which integrates LOLCAT with an object-oriented programming language.

  • 20.
    Castegren, Elias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Östlund, Johan
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Refined Ownership: Fine-grained controlled internal sharing2015In: Formal Methods for Multicore Programming, 2015, Vol. 9104, p. 179-210Conference paper (Refereed)
    Abstract [en]

    Ownership type systems give a strong notion of separation between aggregates. Objects belonging to different owners cannot be aliased, and thus a mutating operation internal to one object is guaranteed to be invisible to another. This naturally facilitates reasoning about correctness on a local scale, but also proves beneficial for coarse-grained parallelism as noninterference between statements touching different objects is easily established. For fine-grained parallelism, ownership types fall short as owner-based disjointness only allows separation of the innards of different aggregates, which is very coarse-grained. Concretely: ownership types can reason about the disjointness of two different data structures, but cannot reason about the internal structure or disjointness within the data structure, without resorting to static and overly constraining measures. For similar reasons, ownership fails to determine internal disjointness of external pointers to objects that share a common owner. In this paper, we introduce the novel notion of refined ownership which overcomes these limitations by allowing precise local reasoning about a group of objects even though they belong to the same external owner. Using refined ownership, we can statically check determinism of parallel operations on tree-shaped substructures of a data structure, including operations on values external to the structure, without imposing any non-local alias restrictions.

  • 21.
    Clarke, Dave
    et al.
    KU Leuven.
    Noble, James
    Victoria University of Wellington.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Beyond the Geneva Convention on the Treatment of Object Aliasing2013In: Aliasing in Object-Oriented Programming: Types, Analysis, and Verification / [ed] Dave Clarke, James Noble, Tobias Wrigstad, Springer Berlin/Heidelberg, 2013, p. 1-6Chapter in book (Other academic)
  • 22.
    Clarke, Dave
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Vats: A safe, reactive storage abstraction2016In: Theory and Practice of Formal Methods: Essays Dedicated to Frank de Boer on the Occasion of His 60th Birthday / [ed] Ábrahám, Erika; Bonsangue, Marcello; Broch Johnsen, Einar, Springer, 2016, p. 140-154Chapter in book (Refereed)
  • 23.
    Clarke, Dave
    et al.
    CWI.
    Wrigstad, Tobias
    Purdue University.
    Östlund, Johan
    Purdue University.
    Broch Johnsen, Einar
    University of Olso.
    Minimal Ownership for Active Objects2008In: Lecture Notes in Computer Science, ISSN 0302-9743, E-ISSN 1611-3349Article in journal (Refereed)
    Abstract [en]

    Active objects offer a structured approach to concurrency, encapsulating both unshared state and a thread of control. For efficient data transfer, data should be passed by reference whenever possible, but this introduces aliasing and undermines the validity of the active objects. This paper proposes a minimal variant of ownership types that preserves the required race freedom invariant yet enables data transfer by reference between active objects (that is, without copying) in many cases, and a cheap clone operation where copying is necessary. Our approach is general and should be adaptable to several existing active object systems.

  • 24.
    Clarke, Dave
    et al.
    KU Leuven.
    Östlund, Johan
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Sergey, Ilya
    KU Leuven.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Ownership Types: A Survey2013In: Aliasing in Object-Oriented Programming: Types, Analysis, and Verification / [ed] Dave Clarke, James Noble, Tobias Wrigstad, Springer Berlin/Heidelberg, 2013, p. 15-58Chapter in book (Refereed)
  • 25.
    Clebsch, Sylvan
    et al.
    Microsoft Research, UK.
    Franco, Juliana
    Imperial College London, UK.
    Drossopoulou, Sophia
    Imperial College London, UK.
    Yang, Albert Mingkun
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Vitek, Jan
    Northeastern University, USA.
    Orca: GC and Type System Co-design for Actor Languages2017In: Proceedings of the ACM on Programming Languages, ISSN 2475-1421, Vol. 1, no OOPSLA, p. 1-28, article id 72Article in journal (Refereed)
    Abstract [en]

    ORCA is a concurrent and parallel garbage collector for actor programs, which does not require any STW steps, or synchronization mechanisms, and that has been designed to support zero-copy message passing and sharing of mutable data. ORCA is part of a runtime for actor-based languages, which was co-designed with the Pony programming language, and in particular, with its data race free type system. By co-designing an actor language with its runtime, it was possible to exploit certain language properties in order to optimize performance of garbage collection. Namely, ORCA relies on the guarantees of absence of race conditions in order to avoid read/write barriers, and it leverages the actor message passing, for synchronization among actors.

    In this paper we briefly describe Pony and its type system. We use pseudo-code in order to introduce how ORCA allocates and deallocates objects, how it shares mutable data without requiring barriers upon data mutation, and how can immutability be used to further optimize garbage collection. Moreover, we discuss the advantages of co-designing an actor language with its runtime, and we demonstrate that ORCA can be implemented in a performant and scalable way through a set of micro-benchmarks, including a comparison with other well-known collectors.

  • 26. de Boer, Frank
    et al.
    Broch Johnsen, Einar
    Olso University.
    Clarke, Dave
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Drossopoulou, Sophia
    Imperial College London.
    Yoshida, Nobuko
    Imperial College London.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Scaling Future Software: The Manycore Challenge2014Other (Other (popular science, discussion, etc.))
    Abstract [en]

    Existing software cannot benefit from the revolutionary potential increases in computational power provided by manycore chips unless their design and code are polluted by an unprecedented amount of low-level, fine-grained concurrency detail. As a consequence, the advent of manycore chips threatens to make current main-stream programming approaches obsolete, and thereby, jeopardizes the benefits gained from the last 20 years of development in industrial software engineering. In this article we put forward an argument for a fundamental breakthrough in how parallelism and concurrency are integrated into the software of the future.

  • 27.
    Fernandez-Reyes, Kiko
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Clarke, Dave
    Storytel, Stockholm, Sweden.
    Henrio, Ludovic
    Univ Lyon, EnsL, UCBL, CNRS, Inria, LIP, France.
    Johnsen, Einar Broch
    University of Oslo, Norway.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Godot: All the Benefits of Implicit and Explicit Futures2019In: 33rd European Conference on Object-Oriented Programming (ECOOP 2019), 2019Conference paper (Refereed)
    Abstract [en]

    Concurrent programs often make use of futures, handles to the results of asynchronous operations. Futures provide means to communicate not yet computed results, and simplify the implementation of operations that synchronise on the result of such asynchronous operations. Futures can be characterised as implicit or explicit, depending on the typing discipline used to type them. Current future implementations suffer from "future proliferation", either at the type-level or at run-time. The former adds future type wrappers, which hinders subtype polymorphism and exposes the client to the internal asynchronous communication architecture. The latter increases latency, by traversing nested future structures at run-time. Many languages suffer both kinds. Previous work offer partial solutions to the future proliferation problems; in this paper we show how these solutions can be integrated in an elegant and coherent way, which is more expressive than either system in isolation. We describe our proposal formally, and state and prove its key properties, in two related calculi, based on the two possible families of future constructs (data-flow futures and control-flow futures). The former relies on static type information to avoid unwanted future creation, and the latter uses an algebraic data type with dynamic checks. We also discuss how to implement our new system efficiently.

  • 28.
    Fjällstrom, Eva
    et al.
    Lulea Univ Technol, Dept Arts Commun & Educ, Lulea, Sweden.
    Forsberg, Christoffer
    Lulea Univ Technol, Dept Comp Sci Elect & Space Engn, Lulea, Sweden.
    Trulsson, Felix
    Lulea Univ Technol, Dept Comp Sci Elect & Space Engn, Lulea, Sweden.
    Knorn, Steffi
    Uppsala University, Disciplinary Domain of Science and Technology, Technology, Department of Engineering Sciences, Signals and Systems Group.
    Staffas, Kjell
    Uppsala University, Disciplinary Domain of Science and Technology, Technology, Department of Engineering Sciences, Signals and Systems Group.
    Varagnolo, Damiano
    Norwegian Univ Sci & Technol, Dept Engn Cybernet, Trondheim, Norway.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Courses-Concepts-Graphs as a Tool to Measure the Importance of Concepts in University Programmes2019In: 2019 18th European Control Conference (ECC), IEEE, 2019, p. 3076-3083Conference paper (Refereed)
    Abstract [en]

    This paper investigates methods for quantitatively assessing the importance and relative importance of concepts taught in a university program. This assessment has many uses, e.g., to aid program design and inventory, and for communicating what concepts a course may rely on at a given point in the program. We propose to perform this quantitative assessment in two steps: first, representing the university program as an opportune graph with courses and concepts as nodes and connections between courses and concepts as edges; second, by quantitatively defining each concept's importance as its centrality as a node within the network. We thus perform two investigations, both leveraging a practical case - data collected from two engineering programs at two Swedish university: a) how to represent university programs in terms of graphs (here called Courses-Concepts Graph (CCG)), and b) how to reinterpret the most classical graph-theoretical node centrality indexes in the pedagogical term of concept centrality index.

  • 29. Franco, Juliana
    et al.
    Clebsch, Sylvan
    Drossopoulou, Sophia
    Vitek, Jan
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Correctness of a concurrent object collector for actor languages2018In: Programming Languages and Systems, Springer, 2018, p. 885-911Conference paper (Refereed)
  • 30. Franco, Juliana
    et al.
    Hagelin, Martin
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Drossopoulou, Sophia
    Eisenbach, Susan
    You can have it all: abstraction and good cache performance2017Conference paper (Refereed)
  • 31.
    Franco, Juliana
    et al.
    Microsoft Research Cambridge.
    Tasos, Alexandros
    Imperial College London.
    Drossopoulou, Sophia
    Imperial College London.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Eisenbach, Susan
    Imperial College London.
    Safely Abstracting Memory Layouts2018In: 20th Workshop on Formal Techniques for Java-like Programs, 2018Conference paper (Refereed)
    Abstract [en]

    Modern architectures require applications to make effective use of caches to achieve high performance and hide memory latency. This in turn requires careful consideration of placement of data in memory to exploit spatial locality, leverage hardware prefetching and conserve memory bandwidth. In unmanaged languages like C++, memory optimisations are common, but at the cost of losing object abstraction and memory safety. In managed languages like Java and C#, the abstract view of memory and proliferation of moving compacting garbage collection does not provide enough control over placement and layout. We have proposed SHAPES, a type-driven abstract placement specification that can be integrated with object-oriented languages to enable memory optimisations. SHAPES preserves both memory and object abstraction. In this paper, we formally specify the SHAPES semantics and describe its memory safety model.

  • 32.
    Franco, Juliana
    et al.
    Imperial College London.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Drossopoulou, Sophia
    Imperial College London.
    Towards Enabling Low-Level Memory Optimisations at the High-Level with Ownership Annotations2016Conference paper (Refereed)
    Abstract [en]

    In modern architectures, due to the huge gap between CPU performance and memory bandwidth, an application’s performance highly depends on the speed at which the system is able to deliver data to operate on. The placement of data in memory affects the number of cache misses, and thus the overall speed of the application. To address this, pooling and splitting are two techniques that allow to group or split data in memory, according to whether they are usually accessed together or separately. However, theseare either low-level optimisations, or outside the control of the programmer. We propose OHMM, an object-oriented programming language that uses ownership-like annotations to express high-level constraintson how objects should be placed in memory. These annotations will allow the runtime to allocate objects using pooling andsplitting, and thus lead to efficient data accesses. In this short paper, we explain OHMM through an example, show how the objects will be laid out, and informally argue the benefits in terms of cache performance.

  • 33.
    Knorn, Steffi
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Technology, Department of Engineering Sciences, Signals and Systems Group.
    Varagnolo, Damiano
    Norwegian Univ Sci & Technol, Dept Engn Cybernet, Trondheim, Norway.
    Staffas, Kjell
    Uppsala University, Disciplinary Domain of Science and Technology, Technology, Department of Engineering Sciences, Signals and Systems Group.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Fjällstrom, Eva
    Lulea Univ Technol, Dept Arts Commun & Educ, Lulea, Sweden.
    Quantitative analysis of curricula coherence using directed graphs2019In: IFAC-PapersOnLine, E-ISSN 2405-8963, Vol. 52, no 9, p. 318-323Article in journal (Refereed)
    Abstract [en]

    This paper investigates methods for quantitatively examining the connectivity and knowledge flow in a university program considering courses and concepts included in the program. The proposed method is expected to be useful to aid program design and inventory, and for communicating what concepts a course may rely on at a given point in the program. As a first step, we represent the university program as a directed graph with courses and concepts as nodes and connections between courses and concepts as directed edges. Then, we investigate the connectivity and the flow through the graph in order to gain insights into the structure of the program. We thus perform two investigations based on data collected from an engineering program at a Swedish university: a) how to represent (parts of) the university program as a graph (here called Directed Courses-Concepts Graph (DCCG)), and b) how to use graph theory tools to analyse the coherence and structure of the program.

  • 34.
    Källén, Malin
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Division of Scientific Computing. Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computational Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Performance of an OO compute kernel on the JVM: Revisiting Java as a language for scientific computing applications2019In: Proc. 16th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes, New York: ACM Press, 2019, p. 144-156Conference paper (Refereed)
  • 35.
    Källén, Malin
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Division of Scientific Computing. Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computational Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Performance of an OO compute kernel on the JVM: Revisiting Java as a language for scientific computing applications (extended version)2019Report (Other academic)
  • 36.
    Tasos, Alexandros
    et al.
    Imperial College London.
    Franco, Juliana
    Microsoft Research Cambridge.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Drossopoulou, Sophia
    Imperial College London.
    Eisenbach, Susan
    Imperial College London.
    Extending SHAPES for SIMD Architectures –: An approach to native support for Struct of Arrays in languages2018In: 13th Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems Workshop, 2018Conference paper (Refereed)
  • 37. Varagnolo, Damiano
    et al.
    Knorn, Steffi
    Staffas, Kjell
    Fjällström, Eva
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Graph-theoretic approaches and tools for quantitatively assessing curricula coherence2020In: European Journal of Engineering Education, ISSN 0304-3797, E-ISSN 1469-5898Article in journal (Refereed)
  • 38.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Structured Aliasing2013In: Aliasing in Object-Oriented Programming: Types, Analysis, and Verification / [ed] Dave Clarke, James Noble, Tobias Wrigstad, Springer Berlin/Heidelberg, 2013, p. 512-513Chapter in book (Refereed)
  • 39.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Structured Aliasing2012In: ECOOP 2012 – Object-Oriented Programming, Springer Berlin/Heidelberg, 2012, Vol. 7313, p. 232-232Conference paper (Refereed)
  • 40.
    Wrigstad, Tobias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Castegren, Elias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Mastery Learning-Like Teaching with Achievements2017Conference paper (Refereed)
  • 41.
    Wrigstad, Tobias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Clarke, Dave
    Is the World Ready for Ownership Types? Is Ownership Types Ready for the World?2011Conference paper (Refereed)
  • 42.
    Wrigstad, Tobias
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Östlund, Johan
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Owners as Ombudsmen: Multiple Aggregate Entry Points for Ownership Types2011Conference paper (Refereed)
  • 43.
    Yang, Albert Mingkun
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Type-assisted automatic garbage collection for lock-free data structures2017In: SIGPLAN notices, ISSN 0362-1340, E-ISSN 1558-1160, Vol. 52, no 9, p. 14-24Article in journal (Refereed)
    Abstract [en]

    We introduce Isolde, an automatic garbage collection scheme designed specifically for managing memory in lock-free data structures, such as stacks, lists, maps and queues. Isolde exists as a plug-in memory manager, designed to sit on-top of another memory manager, and use it's allocator and reclaimer (if exists). Isolde treats a lock-free data structure as a logical heap, isolated from the rest of the program. This allows garbage collection outside of Isolde to take place without affecting the lock-free data structure. Isolde further manages objects allocated on a Isolde heap in a fully concurrent manner, allowing garbage collection to incrementally remove garbage without stopping other threads doing work.

  • 44.
    Åkerblom, Beatrice
    et al.
    Stockholm University.
    Castegren, Elias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Parallel Programming With Arrays in Kappa2018In: 5th ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, 2018Conference paper (Refereed)
  • 45.
    Åkerblom, Beatrice
    et al.
    Stockholm Univ, Stockholm, Sweden..
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Measuring Polymorphism in Python Programs2015In: DLS 2015: Proceedings of the 11th Symposium on Dynamic Languages, New York: ACM Press, 2015, p. 114-128Conference paper (Refereed)
    Abstract [en]

    Following the increased popularity of dynamic languages and their increased use in critical software, there have been many proposals to retrofit static type system to these languages to improve possibilities to catch bugs and improve performance. A key question for any type system is whether the types should be structural, for more expressiveness, or nominal, to carry more meaning for the programmer. For retrofitted type systems, it seems the current trend is using structural types. This paper attempts to answer the question to what extent this extra expressiveness is needed, and how the possible polymorphism in dynamic code is used in practise. We study polymorphism in 36 real-world open source Python programs and approximate to what extent nominal and structural types could be used to type these programs. The study is based on collecting traces from multiple runs of the programs and analysing the polymorphic degrees of targets at more than 7 million call-sites. Our results show that while polymorphism is used in all programs, the programs are to a great extent monomorphic. The polymorphism found is evenly distributed across libraries and program-specific code and occur both during program start-up and normal execution. Most programs contain a few ``megamorphic'' call-sites where receiver types vary widely. The non-monomorphic parts of the programs can to some extent be typed with nominal or structural types, but none of the approaches can type entire programs.

  • 46.
    Östlund, Johan
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Brandauer, Stephan
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    The Joelle Programming Language: Evolving Java Programs Along Two Axes of Parallel Eval2012Conference paper (Other academic)
  • 47.
    Östlund, Johan
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Multiple Aggregate Entry Points for Ownership Types2012In: ECOOP 2012 – Object-Oriented Programming, Springer Berlin/Heidelberg, 2012, p. 156-180Conference paper (Refereed)
  • 48.
    Östlund, Johan
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Regions as Owners: A Discussion on Ownership-based Effects in Practice2011Conference paper (Refereed)
  • 49.
    Östlund, Johan
    et al.
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Wrigstad, Tobias
    Uppsala University, Disciplinary Domain of Science and Technology, Mathematics and Computer Science, Department of Information Technology, Computing Science.
    Welterweight Java2010In: Objects, Models, Components, Patterns / [ed] Vitek, Jan, Berlin: Springer-Verlag , 2010, p. 97-116Conference paper (Refereed)
1 - 49 of 49
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association
  • 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