Justin Schneck & Frank Hunleth on Nerves and Performance – Working with Elixir

About this Episode

Published December 12, 2019 | Duration: 38:47 | RSS Feed | Direct download

On today’s show, we welcome Justin Schneck and Frank Hunleth, luminaries from the Nerves team! We take a dive into the world of Nerves with them, covering themes of performance, problem-solving, transitioning to hardware, and breakthroughs in the field. We begin with a conversation on how Elixir handles performance issues on the range of devices they support and Frank gets into how the team solved an early boot time discrepancy between a PC and a Raspberry Pi board. Other big themes for today are ironing out the kinks in the system registry model and merging Erlang and into hard real-time. After squeezing some information out of the guys about their use of ugly code hacks we get into some visionary decisions as well as things the team wished they could have done differently at Elixir (see the release of the new networking stack). Finally, we end off with what Frank and Justin are excited about as far as developments in the Nerves community, so be sure to plug into this one!

**Key Points From This Episode:

  • What Justin did in Tokyo, from soaking in hot springs to debugging in Kanji.
  • An explanation of The Erlang Ecosystem Foundation, an embedded systems working group.
  • The use of the VintageNet library for setting up multi-hold nerve networks.
  • How Elixir handles performance issues on the range of devices they support.
  • A breakdown of troubleshooting processes as far as acceleration with FPGAs.
  • Issues with dependencies that occur when starting a network node on a Nerves device.
  • How Elixir is trying to evolve past the system registry model.
  • Identifying the challenge of reconfiguring early boot time which Elixir is facing.
  • How Elixir solved a load time discrepancy between a PC and the Raspberry Pi board.
  • Which situations require hardware when Elixir is too slow, such as video encoding.
  • Japanese research into GPU, FPGA and SIMD optimization involving wrapping code blocks.
  • Merging Erlang which is soft real-time into hard real-time.
  • Examples of ugly but fast code hacks in Elixir.
  • Hacks and the pitfalls of system registry such as returning to a prompt when an app crashes.
  • Things Elixir would have done differently in working with Nerves if could they rewind time.
  • Why releasing a new networking stack means Elixir could have done things differently.
  • Lessons Justin and Frank learned moving from OTP to functional programming at Elixir.
  • Exciting new developments and releases in the Nerves community.

Links Mentioned in Today’s Episode:

Nerves Project — https://nerves-project.org/
SmartLogic — https://smartlogic.io/
ElixirConf US — https://elixirconf.com/events
The Erlang Ecosystem Foundation — https://erlef.org/
GRiSP — https://www.grisp.org/
Vintage Net — https://github.com/nerves-networking/vintage_net
Joe Armstrong — https://joearms.github.io/
Erlang — https://www.erlang.org/
Linux — https://www.linux.org/

Special Guest: Frank Hunleth.