Elixir Wizards is an interview-format podcast, focused on engineers who use the Elixir programming language. Initially launched in early 2019, each season focuses on a specific topic or topics, with each interview focusing on the guest's experience and opinions on the topic. Elixir Wizards is hosted by Eric Oestrich and Sundi Myint of SmartLogic, a dev shop that’s been building custom software since 2005 and running Elixir applications in production since 2015. Learn more about how SmartLogic uses Phoenix and Elixir. (https://smartlogic.io/phoenix-and-elixir?utm_source=podcast)
Paul Schoenfelder and Hans Elias Josephsen on Lumen and Performance
In line with our current working-with-Elixir theme, today we’re talking about performance with Paul Schoenfelder and Hans Elias Josephsen from DockYard. The two have been working on Lumen, and in this episode, they discuss how this project is incorporated with WebAssembly, a binary instruction format that ultimately allows Elixir to be run in the browser and preserve the semantics of the language. Paul and Hans talk about the specific aspects of Lumen they are working on; the data flow and process of writing Elixir; and the compiler, interpreter and run-time functions involved. Joining in this conversation, you will also hear how they approached starting developing Lumen as a brand new compiler, researching, the aspects Paul wanted to tackle first, and when users can expect Lumen to be released. We also talk about the performance concerns they encountered along the way, the many reasons why Rust was their programming language of choice, and their thoughts on generic associated types in Rust.
Key Points From This Episode:
• How Paul and Hans got introduced to Elixir and working for DockYard.
• An overview of what Lumen is and how it relates to WebAssembly.
• WebAssembly code to run Elixir in the browser and preserve the semantics of the language.
• The different aspects of the Lumen project that Paul and Hans are involved in.
• The data flow and process when writing Elixir and how the compiler function features.
• Taking advantage of optimizations that can be performed on the code that is generated.
• An explanation of the interpreter and run-time parts of the project.
• How they approached the major task of starting with a brand new compiler.
• The process of researching and why Paul wanted to get a frontend in place first.
• The production readiness of Lumen and when they expect to release it.
• Performance concerns they encountered during development.
• The relevance of code size for the WebAssembly backend to be usable.
• Why Rust was the best choice for building the compiler.
• Using Elixir to generate a standard binary that can run on any machine.
• A description of generic associated types in Rust and why they are controversial.
Links Mentioned in Today’s Episode:
Paul Schoenfelder on LinkedIn — https://www.linkedin.com/in/gotbones/
Paul Schoenfelder on Twitter — https://twitter.com/gotbones?lang=en
Hans Elias Josephsen on Twitter — https://twitter.com/hansihe
DockYard — https://dockyard.com
Elixir — https://elixir-lang.org
WebAssembly — https://webassembly.org
Rust — https://www.rust-lang.org
JavaScript — https://www.javascript.com
C++ — http://www.cplusplus.com
SmartLogic — https://smartlogic.io/
Special Guests: Hans Elias Josephsen and Paul Schoenfelder.