My submitted talk to Code BEAM V was not selected; they liked it and my talk is a backup if a speaker cannot make it in the last moment.
We submitted a paper to Onwards!
Our paper was rejected from ECOOP’21.
I submitted a talk to CODE BEAM V - Europe, abstract follows:
Documentation is key for smooth communication and synchronisation between teams/clients. For some time, our team maintained the documentation by hand. This is an error prone task, e.g., it is easy to forget to add fields, examples may be broken over time when fields are deprecated, etc. This talks explains our approach towards taming our API documentation by using schema validation and the OpenAPI specification. Among the greatest benefits, we show how we get documentation type-checking, and how we validate request/responses in Erlang with Schema Validation and its integration with OpenAPI.
I successfully defended my Ph.D.
We submitted my last paper to ECOOP :)
As of December 14, I am part of the core banking team at Klarna.
My Ph.D. defense has been scheduled to Jan 18, 2021 at 16.00 PM. Martin Steffen will be the opponent. The following researchers are part of the evaluation committee: Elisa Gonzalez Boix (Vrije Universiteit Brussel), Tjark Weber (Uppsala University), Christoph Reichenbach (Lund University), and Mark S. Miller (Agoric).
I was sub-reviewer of ESOP papers.
I submitted my Ph.D. thesis with title “Abstractions to Control the Future”. The abstract follows:
Multicore and manycore computers are the norm nowadays, and users have expectations that their programs can do multiple things concurrently. To support that, developers use concurrency abstractions such as threads, promises, futures, and/or channels to exchange information. All these abstractions introduce trade-offs between the concurrency model and the language guarantees, and developers accept these trade-offs for the benefits of concurrent programming. Many concurrent languages are multi-paradigm, e.g., mix the functional and object-oriented paradigms. This is beneficial to developers because they can choose the most suitable approach when solving a problem. From the point of view of concurrency, purely functional programming languages are data-race free since they only support immutable data. Object-oriented languages do not get a free lunch, and neither do multi-paradigm languages that have imperative features. The main problem is uncontrolled concurrent access to shared mutable state, which may inadvertently introduce data-races. A data-race happens when two concurrent memory operations target the same location, at least one of them is a write, and there is no synchronisation operation involved. Data-races make programs to exhibit (unwanted) non-deterministic behaviour. The contribution of this thesis is two-fold. First, this thesis introduces new concurrent abstractions in a purely functional, statically typed programming language (Paper I -- III); these abstractions allow developers to write concurrent control- and delegation-based patterns. Second, this thesis introduces a capability-based dynamic programming model, named Dala, that extends the applicability of the concurrent abstractions to an imperative setting while maintaining data-race freedom (Paper IV). Developers can also use the Dala model to migrate unsafe programs, i.e., programs that may suffer data-races, to data-race free programs.
- I will TA the course Functional Programming I at Uppsala University, where students will learn about functional programming using Haskell. The course covers functions, recursion, inductive types, polymorphism (type variables and type classes), modules and IO.
Our paper Gradual Capabilities for Data Race Freedom (based on Dalarna: A Simplistic Capability-Based Dynamic Language Design For Data Race Freedom) has been rejected from OOPSLA 2020 (but we got really good feedback to continue improving our work).
- I am honored to be a program commitee member of the International Conference on Code Quality (ICCQ).
- I presented the paper Developing a Monadic Type Checker for an Object-Oriented Language for which I am a co-author at the Func Prog Sweden MeetUp, which was also the first time that I presented in an online event.
I am honored to be part of the ECOOP’20 Artifact Evaluation Committee.
Gave a talk about how to produce research artifacts, covering the motivation, and giving examples of my experience so far. I gave this talk to the CsD Department in IT in Uppsala University (slide here).
Finished a series of articles explaining how to use Pandoc, from producing epubs and websites, to writing research papers and software artifacts:
Our paper Developing a Monadic Type Checker for an Object-Oriented Language: An Experience Report received the Distinguished Artifact Award at the ACM SIGPLAN International Conference on Software Language Engineering (SLE’19). This is a joint effort with Elias Castegren. In a tutorial-like style, the paper explains how to design a monadic type checker in Haskell. The artifact contains an incremental implementation of the monadic type checker. This design is based on the work performed on the Encore compiler. We are grateful to Stephan Brandauer, Tobias Wrigstad, Dave Clarke, and Albert Mingkun Yang who influenced the design of the Encore compiler.
As part of my research visit at Victoria University of New Zealand, we have started a collaboration with researchers from Victoria University, James Noble and Isaac O. Gariano. This collaboration will extend the work from our VMIL paper, where we are exploring how to add gradual reference capabilities to an untyped language.
Our paper “Run, Actor, Run: Towards Cross-Actor Language Benchmarking” has been accepted at the Workshop on Programming based on Actors, Agents, and Decentralized Control (AGERE!). In this paper, we investigate runtime performance of the Savina benchmarks, and investigate how many programs have similar runtime characteristics, and/or that their runtime behaviour may drastically change nature (e.g.,go from essentially sequential to parallel) by tweaking some parameters. This observation lead us to propose 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.
Our paper “Towards Gradual Checking of Reference Capabilities” (work-in-progress) has been accepted at the Virtual Machines and Intermediate Languages Workshop (VMIL). In this paper, we propose to mix the ideas from the reference capability literature with gradual typing, leading to gradual reference capabilities.
Our artefact “Developing a Monadic Type Checker for an Object-Oriented Language” has been accepted at the International Conference on Software Language Engineering (SLE). In this artefact, you can find the multiple iterations of the monadic type checker from the paper. All the functions are documented, and the artefact guides the reader through the code. The type checker can be tested interactively from a REPL, and we include examples of different programs and how to type check them using different versions of the type checker, and their expected result.
I am visiting James Noble and his research group at Victoria University of Wellington from August until end of September.
Paper accepted at the International Conference on Software Language Engineering (SLE): Developing a Monadic Type Checker for an Object-Oriented Language (Experience Report) by Elias Castegren and myself. Preprint here.
Our ECOOP’19 paper, Godot: All the Benefits of Implicit and Explicit Futures received the Distinguished Artefact Award.
We presented our ECOOP Poster.
The Artefact Evaluation Committee for ECOOP accepted our paper artefact for Godot: All the Benefits of Implicit and Explicit Futures.
I will be presenting our ECOOP paper at the Programming Language Research Meetup @ Oracle, June 12, 2019, Stockholm, Sweden.
I am a member of the programme committee of the AGERE’19 workshop, co-located with SPLASH.
I presented our accepted ECOOP’19 paper. at the ABS workshop (Amsterdam, May 14).
Under the ACM-UU student chapter, we organised a privacy-related talk with Amelia Andersdotter. The call for participation is here:
Do you want to find out about current EU laws on data protection and privacy? Do you want to discuss how to minimize your digital footprint? Then come to the next CryptoParty!
What: CryptoParty  with ACM-W, guest speaker Amelia Andersdotter
When: Friday Apr 26th, 16:00–18:00
Where: Ångström library
Who: Everyone, no prior knowledge required
This time in collaboration with the ACM-W student chapter we have invited Amelia Andersdotter, a member of the Swedish Pirate Party and former member of the European Parliament. She will talk about data protection laws.
Title: Rights are not important if you don’t use them
Abstract: There is a new EU data protection legislation, GDPR, that asserts giving new protections to individuals. But is the legal framework enough to protect individuals? How do you actually make use of your data protection rights? Amelia Andersdotter will suggest some practical methods to protect personal data in spite of powerful companies and governments.
Our submission to ICFP was rejected. We got really useful feedback to improve it.
I will supervise Joy van den Eijkhof’s thesis, who will be working on the implementation of for-comprehensions a là Scala (with a twist) for the concurrent and parallel Encore language.
I will be part of the organising committee of SPLASH’19, as Student Volunteer co-chair.
Our paper “Godot: All the Benefits of Implicit and Explicit Futures” was accepted at ECOOP’19. The abstract of the paper reads as follows:
Godot: All the Benefits of Implicit and Explicit Futures
Concurrent programs often make use of future, which are handles to the results of asynchronous operations. Futures provide an instantly available means to communicate not yet computed results, and simplify the implementation of operations that must synchronise on the result of such asynchronous operations. Futures can be characterised as either implicit or explicit, depending on the typing discipline used to type them.
Existing approaches to implementing futures suffer from ``future proliferation’’, either at the type-level or at run-time. The former manifests itself through the addition of future type wrappers which expose the client to the asynchronous message indirections of an implementation and hinders subtype polymorphism. The latter manifests itself through increased latency, by traversing nested future structures at run-time. Many languages suffer both kinds.
Previous work offer partial solutions to these problems of future proliferation; 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.
I gave a seminar about the gamification methodology and design used for the course Advanced Software Design, at the Physics deparment.
As vice-secretary of ACM-W UU, after a meeting with the CTO of ID24, ID24 decided to issue a scholarship for 30_000 SEK, for a female student doing web research / programming, to attend to a top-conference.
I have been invited to give a teaching seminar, at the Physics department, about the gamification approach that we took for the course Advanced Software Design.
The article that I co-author with Lisa Passing has been accepted into DZone. This is not academic article, but it is about getting back control of your privacy when sending emails. Read the article here
I applied to the Ahlberg scholarship, to get funds to visit Victoria University, Wellington.
- We submitted to ECOOP’19. Title and details about the paper are omitted until the Author notification (Apr 2, 2019).
- I presented “Building a compiler: It is all about monads!” at @PartialConf, where I explain how one can create a typechecker with a clean design using monads and monads transformers.
I presented the paper “The impact of opt-in gamification on students’ grades in a software design course”. (link to pre-print)
An achievement-driven methodology strives to give students more control of their learning with enough flexibility to engage them in deeper learning. We observed in the course Advanced Software Design, which uses the achievement-driven methodology, that students fail to get high grades, which may hamper deeper learning. To motivate students to pursue and get higher grades we added gamification elements to the course. To measure the success of our gamification implementation, students filled out a questionaire rating the enjoyment and motivation produced by the game. We built a statistical regression model where enjoyment and motivation explain 55% of the variation in grades. However, only the relationship between motivation and grade is significant, which implies that notivation drives the overall effect of the model. The results suggest that the more the students were motivated by the game, the higher their grades on the course (and vice versa). This implies that if gamification indeed motivates students, then it makes them go beyond what is expected.
Meeting with Ludovic Henrio, Einar B. Johnsen, Dave Clarke and Tobias Wrigstad to discuss the difference between control-flow futures and data-flow futures, which was identified by Ludovic Henrio. At the end of the meeting, we are going to join efforts to highlight the difference between these futures and constructs to allow these futures to co-exist together. We will possibly produce an implementation in the Encore language.
Launched the book ICO for “GRASP principles for the Object-oriented mind”
Talk submitted to PartialConf has been accepted. The abstract is written below:
Building a compiler: it is all about monads
Writing compilers is a difficult task and consists of semantics-preserving transformations, from one phase of the compiler to the next, until the compiler outputs the target code.
Monads can help compiler-writers to create a clean design. For example, the Encore compiler uses a type checking monad, which is made up of the Reader, Error and State monads.
This talks shows why monads make your code cleaner and why you would want to use these three basic monads.
Paper submitted to EduSymp’18 has been accepted. The abstract is written below:
An achievement-driven methodology strives to give students more control of their learning with enough exibility to engage them in deeper learning.
We observed in the course Advanced Software Design, which uses the achievement-driven methodology, that students fail to get high grades, which may hamper deeper learning. To motivate students to pursue and get higher grades we added gamication elements to the course.
To measure the success of our gamication implementation, students filled out a form rating the enjoyment and motivation produced by the game. We built a statistical regression model where enjoyment and motivation explain 55% of the variation in grades. However, only the relationship between “Motivation” and “Grade” is significant, which implies that “Motivation” drives the overall effect of the model. The results suggest that the more the students were motivated by the game, the higher their grades on the course (and vice versa). This implies that if gamication indeed motivates students, then it makes them go beyond what is expected.
Send an abstract to Partial Conf 2018.
My proposed presentation to LambdaWorld’18 Cadiz was rejected.
I submitted the gamification approach that we took during the course Advanced Software Desgin to EduSymp’18. It was the first time that I have worked with Janina Hornbach, it was really fun and I am really happy with the result. Hopefully, we will be able to carry on the future work of the paper :)
The abstract can be found below (and the paper will be available once we know if it got accepted):
An achievement-driven methodology strives to give some degree of control of the students’ learning with enough flexibility to engage them in deeper learning.
We observed that, in the course Advanced Software Design, students fail to get high grades and, in turn, deeper learning. To motivate students to pursue and get higher grades we added gamification elements to the course.
To measure the success of our gamification implementation, students filled out a form rating the enjoyment and motivation produced by the game. We built a statistical regression model where enjoyment and motivation explain 55\% of the variation in grades. However, only the relationship between “Motivation” and “Grade” is significant, which implies that “Motivation” drives the overall effect of the model. The results suggest that the more the students were motivated by the game, the higher their grades on the course. This implies that gamification indeed motivates students and makes students go beyond what is expected.
I had a meeting with Anna Eckerdal and got feedback on an educational paper that uses an opt-in gamification approach.
I will be the new publicity chair for DisCoTec 2019.
My proposed presentation to ClojuTRE’18 was rejected. My abstract can be found below:
Monoids and Monads: The secret weapon to a parallel abstraction
Why should you consider monoids when designing a parallel abstraction? Why monads play an important role in this setting? What are the benefits of using monoids and monads?
In this talk, I will save you from creating a non-composable and non-parallelisable library design. To do this, I will show you why your next parallel abstraction is going to use monoids and monads, drawing examples from the (experimental) library ParT. ParT is a functional parallel abstraction that allows the developer to create and coordinate complex parallel workflows, such as asynchronous pipelines of (possibly speculative) parallel computations. Join me and let’s ParT with monoids and monads!
The paper Forward to a Promising Future has been accepted to COORDINATION and has received the Best conference paper award.
Submission of talk to clojuTRE’18 where I would like to present the functional abstraction ParT to the nordic Clojure community.
Submission of talk to LambdaWorld’18 (Cádiz) where I would like to present the importance of monoidal and monad structures when designing a parallel abstraction.
- Poster presentation of our work Motivating students with Opt-in gamification at TUK’18 in Uppsala. We present the opt-in gamification methodology used in the course Advanced Software Design. It lead to interesting discussions with professors from other engineering areas. Poster link here.
- Submission of the paper Forward to a Promising Future to COORDINATION.
- The paper A Survey of Active Object Languages has been published at the ACM Computing Surveys (CSUR) journal. This was a great effort from leading researchers working in active objects languages. We provide an overview of different active object languages and compare and contrast their differences.
- Presentation of the work Affine Killing (extended abstract) at TyDe’17. This paper extends previous work on the functional abstraction ParT and sketches a solution to the problem of stopping asynchronous parallel speculative tasks in the ParT abstraction. YouTube video recording available here.