Description

With ElixirConf 2020 just around the corner, today’s episode is a sneak peek where we talk with six of this year’s speakers. Each speaker gives listeners an elevator pitch of their talk while throwing in extra details about who their talk is aimed at, what they learned through the process, and which talks they’re excited about attending.

Our first guest is Quinn Wilton, a developer at Tinfoil Security, whose talk is titled ‘Type-Safe LiveView with Gleam’. Quinn explains how she’s created a symbiosis between Elixir and Gleam that helps her create more consistent code while offsetting the disadvantages of dynamic typing.

We then chat with Dan Lindeman whose talk, ‘Short Circuit IoT Development Time with Nerves,’ is an overview of building custom hardware using Nerves and Elixir.

After Dan’s plug on how you can start programming Nerves on your laptop, we welcome Jeffrey Utter to the show. His talk is a deep dive into ‘Debugging Live Systems on the Beam.’ Teasing out the topic, we discuss inefficiencies in the debugging process and how many developers adopt a ‘whack-a-mole’ approach to dealing with bugs.

From debugging to UintSet, Luciano Ramalho, our next speaker, gives us a taste of his presentation, ‘UIntSet: enumerable, streamable, understandable.’ Luciano shares how the Go language inspired him to experiment with leveraging protocols and streams to build new idiomatic Elixir data structures from scratch. He also touches on the importance of being humble when learning new languages and gearing Elixir to a non-engineer user base.

After Luciano, we’re joined by Melvin Cedeno, a fellow Elixir Wizard from the SmartLogic family. Melvin brings his teaching experience to bear on the topic of ‘Teaching Functional Programming with Elixir.’ This is a key talk in growing our community, especially when considering the point that being an Elixir genius doesn’t necessarily mean that you’re well-suited to teach it.

Last but certainly not least, we speak with Japa Swadia from Podium about her talk, ‘Domain-Driven Design with Elixir’ — a subject that’s been a huge focus on the podcast. We chat about what domain-driven design means and why it’s an important foundational concept for beginners to learn.

Tune in for this tip-of-the-iceberg preview. It’s just a glimpse into the varied and wonderfully informative talks you can expect at ElixirConf 2020.

Key Points From This Episode:

• Introducing Quinn Wilton who is using Gleam to interact with Elixir.
• How being acquired by Synopsys has given Tinfoil Security access to greater resources.
• Balancing the advantages of Elixir with its drawbacks when it comes to dynamic analysis.
• What Gleam is and how it makes static typing more approachable.
• Teasing Quinn’s ElixirConf talk — ‘Talk Type-Safe LiveView with Gleam’
• What Quinn has learned from the process of creating his presentation.
• Building a dissembler and the talk that Quinn is most looking forward to attending.
• Dan Lindeman’s work at Very making solar micro-grids.
• The benefits of Elixir and Nerves when building custom hardware.
• Who Dan’s talk is aimed at and why it’s appropriate for any experience level.
• Working with smart minds and laboring through hardware docs that often lie.
• How scary it can be to work with hardware and the value of having your talk appeal to entry-level Elixir users.
• Jeffrey Utter unpacks his talk — ‘Debugging Live Systems on the Beam.’
• How most people play ‘whack-a-mole’ when dealing with live system bugs.
• Using match specs to hone in on your debugging process.
• Why most Elixir coders should learn about Jeffrey’s debugging system.
• Why is Recon Library is such an excellent tool and its potential uses in distributed systems.
• Hear which talks Jeffrey is looking forward to attending.
• How Go inspired Luciano Ramalho to explore applying different data structures to Elixir.
• What skill-level Luciano’s talk is aimed at and why.
• Developing a sense of how Elixir is idiomatic, despite being such a new language.
• Being humble when learning new languages and the importance of protocols in understanding idiomatic data structures.
• How Elixir is geared towards engineers which can create barriers of entry.
• Mark Cedeno gives an elevator pitch for his talk — ‘Teaching Functional Programming with Elixir.’
• Why knowing Elixir very well doesn’t mean that you can teach it.
• The benefits of remote learning; it can make your teaching more organized and to-the-point.
• Hear about the talks that Mark is excited about attending.
• Japa gives us a crash-course on domain-driven design.
• Creating a solid foundation for your app by considering the contexts in which it’s used.
• Why beginners or those wanting to switch to domain-orientated coding should attend Japa’s talk.
• Using schema to point to the same table in different contexts.
• Which talks Japa is attending and how she got selected for ElixirConf 2020.

Links Mentioned in Today’s Episode:

Elixir Wizards Listener Survey — https://smr.tl/podcastsurvey

SmartLogic — https://smartlogic.io/

ElixirConf 2020 — https://2020.elixirconf.com/

Quinn Wilton — https://github.com/QuinnWilton/gleam-chip8

Quinn Wilton Twitter — https://twitter.com/wilton_quinn

‘Type-Safe LiveView with Gleam’ — https://2020.elixirconf.com/speakers/128/talk

Tinfoil Security — https://www.tinfoilsecurity.com/

Synopsys — https://www.synopsys.com/

Gleam — https://gleam.run/

Louis Pilfold GitHub — https://github.com/lpil

Phoenix LiveView — https://github.com/phoenixframework/phoenix_live_view

CHIP-8 — https://en.wikipedia.org/wiki/CHIP-8

Stephen Bussey — https://github.com/sb8244

‘The Joy of an Elixir Monolith’ — https://2020.elixirconf.com/speakers/121/talk

Code BEAM / Code Sync — https://codesync.global/

Dan Lindeman — https://github.com/DanLindeman

Dan Lindeman Twitter — https://twitter.com/lindemda

‘Short Circuit IoT Development Time with Nerves’ — https://2020.elixirconf.com/speakers/117/talk

Nerves Platform — https://www.nerves-project.org/

Very — https://www.verypossible.com/

Justin Schneck — https://www.linkedin.com/in/justinschneck/

Daniel Stoppard — https://www.linkedin.com/in/daniel-spofford-2307a655/

Jenn Gamble — https://2020.elixirconf.com/speakers/115/bio

Juliana Helena — https://2020.elixirconf.com/speakers/129/bio

‘How Elixir made me a better Java programmer’ — https://2020.elixirconf.com/speakers/129/talk

Nerves Hub — https://www.nerves-hub.org/

Jeffrey Utter — https://github.com/jeffutter

Bleacher Report — https://bleacherreport.com/

‘Debugging Live Systems on the Beam’ — https://2020.elixirconf.com/speakers/114/talk

Datadog — https://www.datadoghq.com/

Erlang Sys Trace 2 — https://erlang.org/doc/man/sys.html#trace-2

Recon Library — https://ferd.github.io/recon/

Erlang Debugger — http://erlang.org/doc/apps/debugger/debugger_chapter.html

Catalina Astengo — https://github.com/castengo

gRPC + Elixir Microservices = A Love Story? — https://2020.elixirconf.com/speakers/116/talk

KC Elixir — https://www.kcelixir.com/

Luciano Ramalho — https://github.com/ramalho/

Luciano Ramalho Twitter — https://twitter.com/ramalhoorg

‘UintSet: enumerable, streamable, understandable’ — https://2020.elixirconf.com/speakers/125/talk

ThoughtWorks — https://www.thoughtworks.com/

Go — https://golang.org/

The Go Programming Language — https://www.gopl.io/

Brian W. Kernighan — https://www.cs.princeton.edu/people/profile/bwk

Fluent Python — https://www.oreilly.com/library/view/fluent-python/9781491946237/

Simon de Haan — https://github.com/smn

‘Using Elixir and WhatsApp to launch WHO’s global COVID-19 response’ — https://2020.elixirconf.com/speakers/124/talk

Yutaka Kikuchi — https://github.com/kikuyuta

‘Applying Elixir for driving small hydropower plants with Nerves’

— https://2020.elixirconf.com/speakers/123/talk

Processing — https://processing.org/

Melvin Cedeno — https://github.com/thecraftedgem

‘Teaching Functional Programming With Elixir’ — https://2020.elixirconf.com/speakers/99/talk

Turing — https://turing.io/

Nicholas Henry — https://github.com/nicholasjhenry

‘The Upside Dimension of Elixir - An Introduction to Metaprogramming’ —

https://2020.elixirconf.com/speakers/120/talk

Brian Marick — https://github.com/marick/

‘Tricks and tools for writing Elixir tests’ — https://2020.elixirconf.com/speakers/109/talk

German Velasco — http://www.germanvelasco.com/

‘Testing LiveView’ — https://2020.elixirconf.com/speakers/119/talk

Lonestar Elixir — https://lonestarelixir.com/

Japa Swadia — https://github.com/japa-swadia

Podium — https://www.podium.com

‘Domain-Driven Design with Elixir’ — https://2020.elixirconf.com/speakers/105/talk

Design Patterns — https://en.wikipedia.org/wiki/Design_Patterns

Justus Eapen Social Handle — @JustusEapen

Eric Oestrich Social Handle — @EricOestrich

Sundi Myint Social Handle — @SundiKhin

Special Guests: Dan Lindeman, Japa Swadia, Jeffrey Utter, Luciano Ramalho, Melvin Cedeno, and Quinn Wilton.