Dr Kiko Fernandez-Reyes

Dr Kiko Fernandez-Reyes

Erlang OTP core member. Ex-Software Engineer@Klarna. Previously, PhD student researching a concurrent, actor-based programming language, and main lecturer of the course Advanced Software Design at Uppsala University. Ex-Software Engineer@Trifork

News

April 2024

  • Adolfo Neto interviewed me in his YouTube Channel for my role as co-chair of the Erlang Workshop 2024.
  • I presented “Ericsson’s Forgotten Open Source Gem” at the Ericsson Developer Conference 2024, chosen among more than 500 submissions.

March 2024

  • Erlang 2024 workshop proposal accepted to be co-located with ICFP.
  • I am happy to honoured to be PC member of FUNARCH 2024
  • We submitted a joint EU project proposal together with industrial and academic partners to improve the security and efficiency of the Erlang programming language (some proposals work on the Erlang language and other optimisations at the BEAM level).

January 2024

  • Submitted together with Laura Voinea our Erlang 2024 workshop proposal to ICFP.

December 2023

  • Ingela A. Andin and myself, both working on OTP, where invited to BEAM Radio to talk about the Erlang programming language, how we started, and how we work in the OTP team maintaining and developing the Erlang programming language.

October 2023

  • Happy to announce that I will be the industrial supervisor of a master student from Uppsala University who will work on type migration from structural success typing to a nominal gradual type system

September 2023

July 2023

  • Our paper “TLS The Erlang/OTP Way” was accepted to the Erlang 2023 workshop. Download it for free below :)

December 2022

November 2022

  • I am honored to co-chair the Erlang 2023 Workshop that will be organized as a co-located event of ICFP 2023.

July 2022

  • I am honored to be a program commitee member of the Onward! Papers conference that will be organized as a co-located event of SPLASH 2022.

Feb 2022

  • The pull request that I co-submitted with Draft-06 of the Schema Validation library for Erlang has been accepted (here).

  • I will be part of the committee of the Typed Functional community in Klarna, where we will set new directives for improving the use of typed functional languages at Klarna.

Jan 2022

  • My KonferenSE talk “The Three Little Monadic Pigs And Their Friends” is available on YouTube here.

  • I am honored to be a program commitee member of the 21st Edition of the Erlang Workshop that will be organized as a co-located event of ICFP 2022.

June 2021

  • Our paper “Dala: A Simple Capability-Based Dynamic Language Design For Data Race-Freedom” has been accepted at Onward! Papers track. Abstract follows:

    Dynamic languages like Erlang, Clojure, JavaScript, and E adopted data-race
freedom by design. To enforce data-race freedom, these languages either deep
copy objects during actor (thread) communication or proxy back to their owning
thread. We present Dala, a simple programming model that ensures data-race
freedom while supporting efficient inter-thread communication. Dala is a
dynamic, concurrent, capability-based language that relies on three core
capabilities: immutable values can be shared freely; isolated mutable objects
can be transferred between threads but not aliased; local objects can be
aliased within their owning thread but not dereferenced by other
threads. Objects with capabilities can co-exist with unsafe objects, that are
unchecked and may suffer data races, without compromising the safety of safe
objects. We present a formal model of Dala, prove data race-freedom and state
and prove a dynamic gradual guarantee. These theorems guarantee data
race-freedom when using safe capabilities and show that the addition of
capabilities is semantics preserving modulo permission and cast errors.

May 2021

  • My submitted talk to Code BEAM V was not selected; they liked it and my talk has been scheduled as a backup talk, i.e., if a speaker cannot present, then I am next in line to present.

  • We submitted a paper to Onwards!

  • My talk The Three Little Monads (And Their Friends) has been accepted to TheKonferenSE’21. Abstract follows:

  Once upon a time, mother sent their three little monads to type-check an evil
  wolf program. Little MonadReader was good at remembering the surrounding
  environment but the wolf knew how to trick her; little pig MonadError knew
  when to exit and leave the current task, but the wolf knew that alone little
  MonadError could not type-check the program by herlself; little pig
  MonadWriter knew how to aggregate things but not much more. The three little
  monads learnt that together they can create a powerful yet simple static
  analysis tool to type-check evil programs. Together with their friends Monoid
  and Type State, the three little monads know how to forbid the wolf from
  knocking on their homes.

  This talk assumes knowledge of Haskell, three basic monads, and some knowledge/intuition
  for monad transformers. The goal is to build a type-checker taking inspiration
  from Purescript and the Encore type-checkers. If time allows, we can dive
  into type-level computations to type state, which statically forbids
  unannotated abstract syntax trees to be returned as annotated (type-checked)
  abstract syntax trees. This technique lends well to any other static
  analysis, e.g., checking reference uniqueness. Based on the paper
  'Developing a monadic type checker for an object-oriented language: an
  experience report' (https://dl.acm.org/doi/10.1145/3357766.3359545) but
  going to the core and meat of the problem :)

March 2021

  • 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.

January 2021

December 2020

November 2020

  • 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.

September 2020

  • 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.

July 2020

June 2020

April 2020

January 2020

October 2019

September 2019

  • 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.

August 2019

July 2019

June 2019

May 2019

April 2019

  • 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 [0] 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.

March 2019

  • 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.

February 2019

  • 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.

January 2019

  • We submitted to ECOOP’19. Title and details about the paper are omitted until the Author notification (Apr 2, 2019).

November 2018

  • 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.

October 2018

  • I presented the paper “The impact of opt-in gamification on students’ grades in a software design course”. (link to pre-print)

    Abstract:

    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.

September 2018

  • 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.

August 2018

  • 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.

July 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.

June 2018

  • I had a meeting with Anna Eckerdal and got feedback on an educational paper that uses an opt-in gamification approach.

  • Our team (Dave Clarke, Elias Castegren, Phuc Vo and me) received best COORDINATION 2018 paper and best DisCoTec 2018 paper award.

  • 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!

May 2018

  • 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.

March 2018

  • 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.

February 2018

  • Submission of the paper Forward to a Promising Future to COORDINATION.

November 2017

  • 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.

September 2017

  • 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.