Workshop Erlang 2021 – Author Index

A B C D E F H K L M R S V

	Attard, Duncan Paul	Erlang '21: "Graft: General Purpose Raft ..." Graft: General Purpose Raft Consensus in Elixir Matthew Alan Le Brun, Duncan Paul Attard, and Adrian Francalanza (University of Malta, Malta) We present Graft, a generic tool for creating distributed consensus clusters running the Raft algorithm using state machines in Elixir. Our tool exhibits performance that is comparable to that of the Raft implementation supporting the original proposal, as well as the performance of other state-of-the-art Raft implementations running on the BEAM. The correctness of our tool is also ascertained through a number of complementary verification methods. @InProceedings{Erlang21p2, author = {Matthew Alan Le Brun and Duncan Paul Attard and Adrian Francalanza}, title = {Graft: General Purpose Raft Consensus in Elixir}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {2--14}, doi = {10.1145/3471871.3472963}, year = {2021}, } Publisher's Version
	Bieniusa, Annette	Erlang '21: "Bidirectional Typing for Erlang ..." Bidirectional Typing for Erlang Nithin Vadukkumchery Rajendrakumar and Annette Bieniusa (TU Kaiserslautern, Germany) Erlang is a strict, dynamically typed functional programming language popular for its use in distributed and fault-tolerant applications. The absence of static type checking allows ill-typed programs to cause type errors at run time. The benefits of catching these type errors at compile time are the primary motivation for introducing a static type system for Erlang. The greatest challenge is to find a balance between keeping the type checking sound while retaining the flexibility and philosophy of the Erlang. However, since Erlang allows higher-rank polymorphism, it is unavoidable to require type annotations for some functions to ensure decidability. In this paper, we propose a static type system for Erlang based on bidirectional type checking. In bidirectional type checking, terms are either used to infer a type, or they are checked against a given type. With the bidirectional type checking, we are trying to keep type checking sound without limiting the language’s philosophy. In addition, type annotations are only required when inference fails, which only occurs at predictable places, such as usage of higher-ranked polymorphism. @InProceedings{Erlang21p54, author = {Nithin Vadukkumchery Rajendrakumar and Annette Bieniusa}, title = {Bidirectional Typing for Erlang}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {54--63}, doi = {10.1145/3471871.3472966}, year = {2021}, } Publisher's Version
	Castro, Laura M.	Erlang '21: "Detecting Oxbow Code in Erlang ..." Detecting Oxbow Code in Erlang Codebases with the Highest Degree of Certainty Fernando Benavides Rodríguez and Laura M. Castro (NextRoll, Spain; Universidade da Coruña, Spain) The presence of source code that is no longer needed is a handicap to project maintainability. The larger and longer-lived the project, the higher the chances of accumulating dead code in its different forms. Manually detecting unused code is time-consuming, tedious, error-prone, and requires a great level of deep knowledge about the codebase. In this paper, we examine the kinds of dead code (specifically, oxbow code) that can appear in Erlang projects, and formulate rules to identify them with high accuracy. We also present an open-source static analyzer that implements these rules, allowing for the automatic detection and confident removal of oxbow code in Erlang codebases, actively contributing to increasing their quality and maintainability. @InProceedings{Erlang21p28, author = {Fernando Benavides Rodríguez and Laura M. Castro}, title = {Detecting Oxbow Code in Erlang Codebases with the Highest Degree of Certainty}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {28--40}, doi = {10.1145/3471871.3472961}, year = {2021}, } Publisher's Version
	De Barrio, Luis Eduardo Bueso	Erlang '21: "Makina: A New QuickCheck State ..." Makina: A New QuickCheck State Machine Library Luis Eduardo Bueso de Barrio, Lars-Åke Fredlund, Ángel Herranz, Clara Benac Earle, and Julio Mariño (Universidad Politécnica de Madrid, Spain) This article presents Makina, a new library and a domain specific language for writing property-based testing models for stateful programs. Models written in the new domain specific language are, using Elixir macros, rewritten into normal QuickCheck state machines. Our main goals with Makina are to facilitate the task of developing correct and maintainable models, and to encourage model reuse. To meet these goals, Makina provides a declarative syntax for defining model states and model commands. In particular, Makina encourages the typing of specifications, and ensures through its rewrite rules that such type information can be used by, e.g., the Dialyzer tool, to effectively typecheck models. Moreover, to promote model reuse, the domain specific language provides constructs to permit models to be defined in terms of collections of previously defined models. @InProceedings{Erlang21p41, author = {Luis Eduardo Bueso de Barrio and Lars-Åke Fredlund and Ángel Herranz and Clara Benac Earle and Julio Mariño}, title = {Makina: A New QuickCheck State Machine Library}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {41--53}, doi = {10.1145/3471871.3472964}, year = {2021}, } Publisher's Version
	Earle, Clara Benac	Erlang '21: "Makina: A New QuickCheck State ..." Makina: A New QuickCheck State Machine Library Luis Eduardo Bueso de Barrio, Lars-Åke Fredlund, Ángel Herranz, Clara Benac Earle, and Julio Mariño (Universidad Politécnica de Madrid, Spain) This article presents Makina, a new library and a domain specific language for writing property-based testing models for stateful programs. Models written in the new domain specific language are, using Elixir macros, rewritten into normal QuickCheck state machines. Our main goals with Makina are to facilitate the task of developing correct and maintainable models, and to encourage model reuse. To meet these goals, Makina provides a declarative syntax for defining model states and model commands. In particular, Makina encourages the typing of specifications, and ensures through its rewrite rules that such type information can be used by, e.g., the Dialyzer tool, to effectively typecheck models. Moreover, to promote model reuse, the domain specific language provides constructs to permit models to be defined in terms of collections of previously defined models. @InProceedings{Erlang21p41, author = {Luis Eduardo Bueso de Barrio and Lars-Åke Fredlund and Ángel Herranz and Clara Benac Earle and Julio Mariño}, title = {Makina: A New QuickCheck State Machine Library}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {41--53}, doi = {10.1145/3471871.3472964}, year = {2021}, } Publisher's Version
	Fördős, Viktória	Erlang '21: "What Are the Critical Security ..." What Are the Critical Security Flaws in My System? Viktória Fördős (Cisco Systems, Sweden; Eötvös Loránd University, Hungary) Delivering secure software is a challenge that every software engineering team needs to face and solve. Methods based on static analysis can help programmers identify security risks in the software. Security checkers built using static analysis methods are a great help but they can overload the users with their findings. Today there is no security checker for Erlang that understands the severity of the found vulnerability and uses the information to prioritise the found vulnerabilities when presenting the results to the programmers. In this paper we discuss how to prioritise vulnerabilities in Erlang programs. We propose a static analysis that determines the severity of a vulnerability. Building on top of our previous work, we extend the trust zone analyser algorithm with the proposed analysis to return prioritised results to the programmers. Our early evaluation shows that the trust zone analyser is able to identify and prioritise the most critical security flaws in an Erlang system. @InProceedings{Erlang21p64, author = {Viktória Fördős}, title = {What Are the Critical Security Flaws in My System?}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {64--71}, doi = {10.1145/3471871.3472965}, year = {2021}, } Publisher's Version Info
	Francalanza, Adrian	Erlang '21: "Graft: General Purpose Raft ..." Graft: General Purpose Raft Consensus in Elixir Matthew Alan Le Brun, Duncan Paul Attard, and Adrian Francalanza (University of Malta, Malta) We present Graft, a generic tool for creating distributed consensus clusters running the Raft algorithm using state machines in Elixir. Our tool exhibits performance that is comparable to that of the Raft implementation supporting the original proposal, as well as the performance of other state-of-the-art Raft implementations running on the BEAM. The correctness of our tool is also ascertained through a number of complementary verification methods. @InProceedings{Erlang21p2, author = {Matthew Alan Le Brun and Duncan Paul Attard and Adrian Francalanza}, title = {Graft: General Purpose Raft Consensus in Elixir}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {2--14}, doi = {10.1145/3471871.3472963}, year = {2021}, } Publisher's Version
	Fredlund, Lars-Åke	Erlang '21: "Makina: A New QuickCheck State ..." Makina: A New QuickCheck State Machine Library Luis Eduardo Bueso de Barrio, Lars-Åke Fredlund, Ángel Herranz, Clara Benac Earle, and Julio Mariño (Universidad Politécnica de Madrid, Spain) This article presents Makina, a new library and a domain specific language for writing property-based testing models for stateful programs. Models written in the new domain specific language are, using Elixir macros, rewritten into normal QuickCheck state machines. Our main goals with Makina are to facilitate the task of developing correct and maintainable models, and to encourage model reuse. To meet these goals, Makina provides a declarative syntax for defining model states and model commands. In particular, Makina encourages the typing of specifications, and ensures through its rewrite rules that such type information can be used by, e.g., the Dialyzer tool, to effectively typecheck models. Moreover, to promote model reuse, the domain specific language provides constructs to permit models to be defined in terms of collections of previously defined models. @InProceedings{Erlang21p41, author = {Luis Eduardo Bueso de Barrio and Lars-Åke Fredlund and Ángel Herranz and Clara Benac Earle and Julio Mariño}, title = {Makina: A New QuickCheck State Machine Library}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {41--53}, doi = {10.1145/3471871.3472964}, year = {2021}, } Publisher's Version
	Herranz, Ángel	Erlang '21: "Makina: A New QuickCheck State ..." Makina: A New QuickCheck State Machine Library Luis Eduardo Bueso de Barrio, Lars-Åke Fredlund, Ángel Herranz, Clara Benac Earle, and Julio Mariño (Universidad Politécnica de Madrid, Spain) This article presents Makina, a new library and a domain specific language for writing property-based testing models for stateful programs. Models written in the new domain specific language are, using Elixir macros, rewritten into normal QuickCheck state machines. Our main goals with Makina are to facilitate the task of developing correct and maintainable models, and to encourage model reuse. To meet these goals, Makina provides a declarative syntax for defining model states and model commands. In particular, Makina encourages the typing of specifications, and ensures through its rewrite rules that such type information can be used by, e.g., the Dialyzer tool, to effectively typecheck models. Moreover, to promote model reuse, the domain specific language provides constructs to permit models to be defined in terms of collections of previously defined models. @InProceedings{Erlang21p41, author = {Luis Eduardo Bueso de Barrio and Lars-Åke Fredlund and Ángel Herranz and Clara Benac Earle and Julio Mariño}, title = {Makina: A New QuickCheck State Machine Library}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {41--53}, doi = {10.1145/3471871.3472964}, year = {2021}, } Publisher's Version
	Kalbusch, Sébastien	Erlang '21: "The Hera Framework for Fault-Tolerant ..." The Hera Framework for Fault-Tolerant Sensor Fusion with Erlang and GRiSP on an IoT Network Sébastien Kalbusch, Vincent Verpoten, and Peter Van Roy (Université Catholique de Louvain, Belgium) Classical sensor fusion approaches require to work directly with the hardware and involve a lot of low-level programming, which is not suited for reliable and user-friendly sensor fusion for Internet of Things (IoT) applications. In this paper, we propose and analyze Hera, a Kalman filter-based sensor fusion framework for Erlang. Hera offers a high-level approach for asynchronous and fault-tolerant sensor fusion directly at the edge of an IoT network. We use the GRiSP-Base board, a low-cost platform specially designed for Erlang and to avoid soldering or dropping down to C. We emphasize on the importance of performing all the computations directly at the sensor-equipped devices themselves, completely removing the cloud necessity. We show that we can perform sensor fusion for position and orientation tracking at a high level of abstraction and with the strong guarantee that the system will keep running as long as one GRiSP board is alive. With Hera, the implementation effort is significantly reduced which makes it an excellent candidate for IoT prototyping and education in the field of sensor fusion. @InProceedings{Erlang21p15, author = {Sébastien Kalbusch and Vincent Verpoten and Peter Van Roy}, title = {The Hera Framework for Fault-Tolerant Sensor Fusion with Erlang and GRiSP on an IoT Network}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {15--27}, doi = {10.1145/3471871.3472962}, year = {2021}, } Publisher's Version
	Le Brun, Matthew Alan	Erlang '21: "Graft: General Purpose Raft ..." Graft: General Purpose Raft Consensus in Elixir Matthew Alan Le Brun, Duncan Paul Attard, and Adrian Francalanza (University of Malta, Malta) We present Graft, a generic tool for creating distributed consensus clusters running the Raft algorithm using state machines in Elixir. Our tool exhibits performance that is comparable to that of the Raft implementation supporting the original proposal, as well as the performance of other state-of-the-art Raft implementations running on the BEAM. The correctness of our tool is also ascertained through a number of complementary verification methods. @InProceedings{Erlang21p2, author = {Matthew Alan Le Brun and Duncan Paul Attard and Adrian Francalanza}, title = {Graft: General Purpose Raft Consensus in Elixir}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {2--14}, doi = {10.1145/3471871.3472963}, year = {2021}, } Publisher's Version
	Mariño, Julio	Erlang '21: "Makina: A New QuickCheck State ..." Makina: A New QuickCheck State Machine Library Luis Eduardo Bueso de Barrio, Lars-Åke Fredlund, Ángel Herranz, Clara Benac Earle, and Julio Mariño (Universidad Politécnica de Madrid, Spain) This article presents Makina, a new library and a domain specific language for writing property-based testing models for stateful programs. Models written in the new domain specific language are, using Elixir macros, rewritten into normal QuickCheck state machines. Our main goals with Makina are to facilitate the task of developing correct and maintainable models, and to encourage model reuse. To meet these goals, Makina provides a declarative syntax for defining model states and model commands. In particular, Makina encourages the typing of specifications, and ensures through its rewrite rules that such type information can be used by, e.g., the Dialyzer tool, to effectively typecheck models. Moreover, to promote model reuse, the domain specific language provides constructs to permit models to be defined in terms of collections of previously defined models. @InProceedings{Erlang21p41, author = {Luis Eduardo Bueso de Barrio and Lars-Åke Fredlund and Ángel Herranz and Clara Benac Earle and Julio Mariño}, title = {Makina: A New QuickCheck State Machine Library}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {41--53}, doi = {10.1145/3471871.3472964}, year = {2021}, } Publisher's Version
	Rajendrakumar, Nithin Vadukkumchery	Erlang '21: "Bidirectional Typing for Erlang ..." Bidirectional Typing for Erlang Nithin Vadukkumchery Rajendrakumar and Annette Bieniusa (TU Kaiserslautern, Germany) Erlang is a strict, dynamically typed functional programming language popular for its use in distributed and fault-tolerant applications. The absence of static type checking allows ill-typed programs to cause type errors at run time. The benefits of catching these type errors at compile time are the primary motivation for introducing a static type system for Erlang. The greatest challenge is to find a balance between keeping the type checking sound while retaining the flexibility and philosophy of the Erlang. However, since Erlang allows higher-rank polymorphism, it is unavoidable to require type annotations for some functions to ensure decidability. In this paper, we propose a static type system for Erlang based on bidirectional type checking. In bidirectional type checking, terms are either used to infer a type, or they are checked against a given type. With the bidirectional type checking, we are trying to keep type checking sound without limiting the language’s philosophy. In addition, type annotations are only required when inference fails, which only occurs at predictable places, such as usage of higher-ranked polymorphism. @InProceedings{Erlang21p54, author = {Nithin Vadukkumchery Rajendrakumar and Annette Bieniusa}, title = {Bidirectional Typing for Erlang}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {54--63}, doi = {10.1145/3471871.3472966}, year = {2021}, } Publisher's Version
	Rodríguez, Fernando Benavides	Erlang '21: "Detecting Oxbow Code in Erlang ..." Detecting Oxbow Code in Erlang Codebases with the Highest Degree of Certainty Fernando Benavides Rodríguez and Laura M. Castro (NextRoll, Spain; Universidade da Coruña, Spain) The presence of source code that is no longer needed is a handicap to project maintainability. The larger and longer-lived the project, the higher the chances of accumulating dead code in its different forms. Manually detecting unused code is time-consuming, tedious, error-prone, and requires a great level of deep knowledge about the codebase. In this paper, we examine the kinds of dead code (specifically, oxbow code) that can appear in Erlang projects, and formulate rules to identify them with high accuracy. We also present an open-source static analyzer that implements these rules, allowing for the automatic detection and confident removal of oxbow code in Erlang codebases, actively contributing to increasing their quality and maintainability. @InProceedings{Erlang21p28, author = {Fernando Benavides Rodríguez and Laura M. Castro}, title = {Detecting Oxbow Code in Erlang Codebases with the Highest Degree of Certainty}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {28--40}, doi = {10.1145/3471871.3472961}, year = {2021}, } Publisher's Version
	Sagonas, Konstantinos	Erlang '21: "Fifteen Years of Successfully ..." Fifteen Years of Successfully Dialyzing Erlang and Elixir Code (Invited Talk) Konstantinos Sagonas (Uppsala University, Sweden; National Technical University of Athens, Greece) As various researchers have discovered, the hard way, it is not easy to impose static type systems into dynamically typed languages, especially to those for which a significant amount of code already exists. Still, using types for documenting programmer intentions and for catching some programming errors early is widely recognized as important. This summer marked the fifteen year anniversary of the publication of the "Success Typings" paper [Lindahl and Sagonas, 2006], which described the basic idea and first version of the type inference algorithm that Dialyzer defect detection tool is based on. The optimistic, 'never-wrong for defect detection', approach to type inference that success typings advocate has been key in Dialyzer's successful adoption not only by Erlang programmers but also more recently by the Elixir community. At various points during the same time period, other approaches to typing Erlang and Elixir code have not managed to gain similar levels of adoption. In this invited talk, I will present the history behind success typings, their use and evolution within Dialyzer, and some reflections on what in my opinion were the key ingredients for Dialyzer's success within the communities of Erlang and Elixir programmers. I will also share some thoughts on what could have done better and/or differently, and where to go from here. @InProceedings{Erlang21p1, author = {Konstantinos Sagonas}, title = {Fifteen Years of Successfully Dialyzing Erlang and Elixir Code (Invited Talk)}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {1--1}, doi = {10.1145/3471871.3480952}, year = {2021}, } Publisher's Version
	Van Roy, Peter	Erlang '21: "The Hera Framework for Fault-Tolerant ..." The Hera Framework for Fault-Tolerant Sensor Fusion with Erlang and GRiSP on an IoT Network Sébastien Kalbusch, Vincent Verpoten, and Peter Van Roy (Université Catholique de Louvain, Belgium) Classical sensor fusion approaches require to work directly with the hardware and involve a lot of low-level programming, which is not suited for reliable and user-friendly sensor fusion for Internet of Things (IoT) applications. In this paper, we propose and analyze Hera, a Kalman filter-based sensor fusion framework for Erlang. Hera offers a high-level approach for asynchronous and fault-tolerant sensor fusion directly at the edge of an IoT network. We use the GRiSP-Base board, a low-cost platform specially designed for Erlang and to avoid soldering or dropping down to C. We emphasize on the importance of performing all the computations directly at the sensor-equipped devices themselves, completely removing the cloud necessity. We show that we can perform sensor fusion for position and orientation tracking at a high level of abstraction and with the strong guarantee that the system will keep running as long as one GRiSP board is alive. With Hera, the implementation effort is significantly reduced which makes it an excellent candidate for IoT prototyping and education in the field of sensor fusion. @InProceedings{Erlang21p15, author = {Sébastien Kalbusch and Vincent Verpoten and Peter Van Roy}, title = {The Hera Framework for Fault-Tolerant Sensor Fusion with Erlang and GRiSP on an IoT Network}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {15--27}, doi = {10.1145/3471871.3472962}, year = {2021}, } Publisher's Version
	Verpoten, Vincent	Erlang '21: "The Hera Framework for Fault-Tolerant ..." The Hera Framework for Fault-Tolerant Sensor Fusion with Erlang and GRiSP on an IoT Network Sébastien Kalbusch, Vincent Verpoten, and Peter Van Roy (Université Catholique de Louvain, Belgium) Classical sensor fusion approaches require to work directly with the hardware and involve a lot of low-level programming, which is not suited for reliable and user-friendly sensor fusion for Internet of Things (IoT) applications. In this paper, we propose and analyze Hera, a Kalman filter-based sensor fusion framework for Erlang. Hera offers a high-level approach for asynchronous and fault-tolerant sensor fusion directly at the edge of an IoT network. We use the GRiSP-Base board, a low-cost platform specially designed for Erlang and to avoid soldering or dropping down to C. We emphasize on the importance of performing all the computations directly at the sensor-equipped devices themselves, completely removing the cloud necessity. We show that we can perform sensor fusion for position and orientation tracking at a high level of abstraction and with the strong guarantee that the system will keep running as long as one GRiSP board is alive. With Hera, the implementation effort is significantly reduced which makes it an excellent candidate for IoT prototyping and education in the field of sensor fusion. @InProceedings{Erlang21p15, author = {Sébastien Kalbusch and Vincent Verpoten and Peter Van Roy}, title = {The Hera Framework for Fault-Tolerant Sensor Fusion with Erlang and GRiSP on an IoT Network}, booktitle = {Proc.\ Erlang}, publisher = {ACM}, pages = {15--27}, doi = {10.1145/3471871.3472962}, year = {2021}, } Publisher's Version

17 authors

proc time: 2.35