Elixir Talk

# Episode 156 - Desmond & Chris face-to-face

In todays special episode Desmond and Chris are together in NYC in-person for the first time in the history of recording Elixir talk.

In the episode we dig into Desmond’s new role as CTO at Payitoff and talk about how Elixir helps in managing the complexity of student loans processing. We also discuss best practices in Elixir, some common gotchas in working in the language and more.

## Todays topics include:

* Using tuples and tagged tuples

* Structuring control flow for Elixir

* Enforcing conventions in your codebase

* Behaviours vs Protocols

## Links:

* Payitoff: https://www.payitoff.io

* Credo: https://github.com/rrrene/credo

* Protocols in Elixir: https://elixirschool.com/en/lessons/advanced/protocols/

* Behaviours: https://elixirschool.com/en/lessons/advanced/behaviours/

* Plug Behavior: https://hexdocs.pm/plug/Plug.html#content

* Mocks and Explicit contracts: http://blog.plataformatec.com.br/2015/10/mocks-and-explicit-contracts/

# Episode #155 - A special look into Lumen

Today we have an extra special episode for you where we dig into a project you may have seen announced at the recent US Elixir Conference; Lumen, which is an alternate BEAM implementation, designed for WebAssembly.

On the show we’re joined by the core members of the Lumen team: Brian Cardarella, Paul Schoenfelder, Luke Imhoff, and Hans Elias Bukholm Josephsen. We get into a lot of the details about the project; why it exists, what the goals are, what the hell web assembly is, and where it’s going. Join us and get a glimpse of a future direction for Elixir!

## Links

* Lumen on GitHub: https://github.com/lumen/lumen

* Keynote from ElixirConf: https://www.youtube.com/watch?v=uMgTIlgYB-U&feature=youtu.be

* Hans talk from CodeBEAM on EIR: https://www.youtube.com/watch?v=xSWxlLCfF6s

* EIR: https://github.com/eirproject/eir

* web-sys crate in Rust: https://crates.io/crates/web-sys

* wasm-bindgen crate in Rust: https://crates.io/crates/wasm-bindgen

* Web Assembly Spec: https://github.com/WebAssembly/spec

* Scenic: https://github.com/boydm/scenic

* Issues for Lumen: https://github.com/lumen/lumen/issues

* Lumen on Elixir Slack: #lumen

ElixirTalk Episode 154 – ElixirConf recap and more!

We’re back with another ElixirTalk episode after a short break! This time featuring Chris and Desmond reflecting on a great ElixirConf! We discuss our standout talks, as well as digging into the keynotes from Dockyard (Lumen), José Valim, Justin Schneck and Chris McCord.

At the end of the episode we debate LiveView and it’s place in the broader JS ecosystem. Chris and Desmond somewhat disagree in this case. Let us know your thoughts, we’d love to hear more on this hotly debated subject.

## Links:

* https://elixirtraining.io

* https://elixirconf.com

* Day 1 Morning Keynote - Brian Cardarella, Luke Imhoff, Paul Schoenfelder: https://www.youtube.com/watch?v=uMgTIlgYB-U

* Day 2 Morning Keynote - Justin Schneck: https://www.youtube.com/watch?v=fRP_dVton7o

* Elixir & CQRS - Jon Grieman: https://www.youtube.com/watch?v=-d2NPc8cEnw

* BEAM Extreme Don’t Do This At Home - Miriam Pena: https://www.youtube.com/watch?v=-1j36z8SllI

* Contracts for Building Reliable Systems - Chris Keathley: https://www.youtube.com/watch?v=tpo3JUyVIjQ

* Norm library: https://github.com/keathley/norm

* Thursday PM Keynote - José Valim: https://www.youtube.com/watch?v=tpo3JUyVIjQ

* Return of Wabi-Sabi: Hastega Will Bring More and... - Susumu Yamazaki: https://www.youtube.com/watch?v=uCkPyfFhPxI

* Friday Evening Keynote - Chris McCord: https://www.youtube.com/watch?v=txk4WAlabvI

* EMPEX LA: https://empex.co/la

Episode 153 – The Dream stack with Rust & Elixir feat. Dave Lucia

We kick things off by hearing about the newly launched Elixir Training :tada: which y’all should check out if you’re looking to learn the language, or have friends who might.

In todays episode we’re joined by Dave Lucia, VP of Engineering at SimpleBet where we hear about the use of the “Dream Stack” (you heard it here first folks!), which is Elixir using Rust NIFs for performance reasons (in their case calculating real-time betting odds).

We spend a lot of time in the episode digging into what NIFs are, why Rust is a good fit for writing Elixir NIFs and what the pitfalls are. We get real technical with dirty schedulers, resource arcs in Rust, and all of the reasons for why you should and probably should not use NIFs unless you really need it.

Also in an Elixir Talk first Dave turns around and asks us a question at the end. And in maybe a podcast first we place an on-air bet on who can donate the most to the Erlang Ecosystem Foundation.

Links

- Elixir Training North American Tour 2019 – https://elixirtraining.io

- Elixir Conf – https://elixirconf.com

- SimpleBet – https://simplebet.io

- The Outline – https://theoutline.com

- Two Years of Elixir at The Outline – https://blog.usejournal.com/two-years-of-elixir-at-the-outline-ad671a56c9ce

- ConCache – https://github.com/sasa1977/con_cache

- IO Lists and Phoenix - https://www.bignerdranch.com/blog/elixir-and-io-lists-part-2-io-lists-in-phoenix/

- Using Rust to Scale Elixir at Discord – https://blog.discordapp.com/using-rust-to-scale-elixir-for-11-million-concurrent-users-c6f19fc029d3

- Rustler – https://github.com/rusterlium/rustler

- Rust ResourceArcs in Rustler – https://docs.rs/rustler/0.15.1/rustler/resource/struct.ResourceArc.html

- Erlang Dirty Scheduler Overhead – https://medium.com/@jlouis666/erlang-dirty-scheduler-overhead-6e1219dcc7

- Erlef – https://erlef.org

- Dave’s talk at CodeBeam SF 2019 – https://www.youtube.com/watch?v=wvfhrvAFOoQ

- Dave on Twitter – https://twitter.com/davydog187

- Dave on Github – https://github.com/davydog187

# Episode 152 - The joys of Ecto

This week it’s a Chris & Desmond episode! We kick things off by hearing all about Desmond’s latest project – Hire an Elixir Developer – a job board to help companies attract Elixir talent that’s launching soon.

We dig into how Desmond has been writing his latest project, hear a bit about how he’s using LiveView and how he’s chasing boring technology to get this project done (Phoenix & Elixir). Chris has also been writing lots of code this week (and has kept Elixirin’) – he talks a bit about how Elixir has mostly just been getting out of his way.

We then dig into one of our favorite subjects ... Ecto! We describe the joy of named binds, how we split up Ecto queries, and think about composing queries. We then go onto talk about lateral joins and the limits of Ecto preloads.

## Links

* Hire an Elixir Developer – https://www.hireanelixirdeveloper.com/

* Absinthe GraphQL – http://absinthe-graphql.org

* Ecto Named Binds – https://hexdocs.pm/ecto/Ecto.Query.html#module-named-bindings

* Ecto Preloads – https://hexdocs.pm/ecto/Ecto.Query.html?#preload/3

* Ecto update with an atomic increment – https://hexdocs.pm/ecto/Ecto.Query.html#update/3

* Ecto lateral joins – https://hexdocs.pm/ecto/Ecto.Query.html#join/5-joining-with-fragments

* Dataloader – https://hexdocs.pm/dataloader/Dataloader.html

* Lateral joins in Ecto – https://github.com/elixir-ecto/ecto/issues/1425

* Relay Connections – https://facebook.github.io/relay/graphql/connections.htm

* Absinthe Relay – https://github.com/absinthe-graphql/absinthe_relay

* Batch loading in Absinthe Relay while support first N – https://elixirforum.com/t/how-to-batch-load-with-absinthe-relay-while-supporting-first-x-and-after-cursor/14918

* CSS Grids – https://gridbyexample.com/examples/

* Brutalist Web Design – https://brutalist-web.design/

* ElixirConf – https://elixirconf.com/2019

# Episode 151 – Dave Thomas & Brian Mitchell

In this special episode of ElixirTalk we are joined by Dave Thomas and Brian Mitchell where we continue a discussion that

we had at EMPEX NYC this year as a fishbowl style format. If you haven’t yet seen the talk, you can do so here: https://youtu.be/pcbNT1iKebc –– probably best if you watch before listening, but you can also listen to this as a standalone episode.

This episode is long, but is packed with some great tidbits about Elixir and Erlang and we go into considerable depth about how applications work today as well as outlining a vision for the future.

## Key moments in the episode

- Dave lays out some of the key tenants of his argument about augmenting OTP to work better for a world that we’re in today

- Brian describes what OTP is and gives his thoughts on Dave’s initial thesis, questioning some of the static nature that Dave argues about OTP

- Dave lays out that what we’re doing in Elixir and Phoenix land is the OTP way (for better or for worse) and questions whether this is the best way to do things?

- We talk at length about configuration and how things work today in Elixir / Erlang. Brian does a great job of explaining the different tenants of configuration in OTP that exist and we dig into what a dynamic model might look like.

- We then talk about supervisors as they work in OTP and describe the concept of dynamic lifecycle management and a future vision of supervision that goes beyond just processes and extends into system observability.

- We discuss challenging conceived wisdom and why that helps move communities forward, looking at the interesting case of how Elixir inherits decisions from the Erlang community and how we might revisit some of those assumptions.

## Links for this show

- Dave and Brian’s discussion at EMPEX NYC: https://youtu.be/pcbNT1iKebc

- Dave Thomas on Twitter: https://twitter.com/pragdave

- Brian Mitchell on Twitter: https://twitter.com/strmpnk

- Partisan: https://github.com/lasp-lang/partisan

- Chris Meiklejohn’s talk on Partisan: https://www.youtube.com/watch?v=KrwhOkiifQ8

- ERLEF: https://erlef.org

Episode 150 - Clojerl with Juan Facorro

This week on the show we’re joined by Juan Facorro, an avid Erlang-er and creator of Clojerl, a Clojure port written in Erlang.

We give you an update about Elixir Training, and tell you a bit more about a potential bar / meetup we at EMPEX will be hosting during ElixirConf this year in Denver (if we can find a bar).

We then get Juan to give us a run through of Clojerl, diving into the project, his motivations for creating it and going in-depth to some of the challenges Juan had along the way. We understand why you’d even want Clojure on the BEAM in the first place and where the Erlang concurrency model is advantageous here.

Links:

- https://twitter.com/jfacorro

- https://www.klarna.com/us/

- https://clojure.org/

- http://clojerl.online/

- Implementing Clojure on a new VM, clojureD: https://www.youtube.com/watch?v=NkHdMbI_08I

- Clojure on the BEAM: https://www.youtube.com/watch?v=Ow8o9Mm_N7M

- https://github.com/clojerl/

- https://erlang-slack.herokuapp.com/

- https://www.elixirtraining.io/blog/why-elixir-training

This week we don’t have a guest, so it’s just Chris & Desmond. We kick things off discussing our opening music and how weird it is listening to yourself on a podcast.

Desmond tells us about his exploration into webflow and his love (hate) for CSS. We dig into bits in the language that still trip us up, even now with our experience in the language. We dig into some Ecto: query syntax that trips us up, materialized views, application logic vs database logic and lots of other database goodies.

Desmond tells us how Phoenix contexts trip him up and we go into some depth about how both of us structure contexts and code in our Phoenix applications.

We tell you about ElixirTraining, which is our new venture to help teach more engineers the beauty of Elixir, as well as engineering leaders about why Elixir is a great fit for your organization.

Oh, and sorry we said we’d answer some community questions and then never did.

Links:

- Webflow: https://webflow.io

- Database tables explained: https://twitter.com/joygao/status/1141125981748383745?s=20

- Materialized views in Ecto: https://medium.com/@kaisersly/materialized-views-in-ecto-8887bc89efa5

- Ecto Postgres: https://github.com/bryanjos/geo_postgis

- Rules for Phoenix contexts: http://devonestes.herokuapp.com/a-proposal-for-context-rules

- Phoenix contexts in context: https://michal.muskala.eu/2017/05/16/putting-contexts-in-context.html

- Andrew Hao’s talk on contexts: https://www.youtube.com/watch?v=l3VgbSgo71E

- https://elixirtraining.io

- https://elixirconf.com

Elixir Talk 148 - Feat Maxim Federov

Desmond gives us an update on his truck and the work he’s been doing there. Chris tells us about how he’s been getting back into coding and how he’s been writing Absinthe and GraphQL.

We announce a special new announcement: the launch of Elixir Training, our new business where we’re going out and looking to train more folks on Elixir across the US.

We also have a special guest on the show this week: Maxim Federov a Software Engineer at WhatsApp. We dive into some of the joys of using Erlang at bonkers scale (~1.5 billion+ users), using 10k servers and attempt to ask some moderately interesting questions, that Maxim answers like a champ.

Interesting links:

- https://elixirtraining.io

- Maxim’s talk about the architecture of WhatsApp: https://codesync.global/media/maxim-fedorov-scaling-erlang-cluster-to-10-000-nodes/

- https://www.infoq.com/presentations/whatsapp-scalability/

- https://erlef.org

- https://www.facebook.com/careers/areas-of-work/whatsapp/?teams%5B0%5D=WhatsApp

- https://codesync.global/media/mid-air-airplane-repair-troubleshooting-at-whatsapp/

- Live upgrade talk: https://codesync.global/media/the-art-live-upgrade-richard-carlsson/

- Hot upgrades in Elixir: https://medium.com/blackode/how-to-perform-hot-code-swapping-in-elixir-afc824860012\

- Mnesia at WhatsApp: http://highscalability.com/blog/2014/3/31/how-whatsapp-grew-to-nearly-500-million-users-11000-cores-an.html

- erlperf: https://github.com/max-au/erlperf

*SHOW NOTES*

- https://murumed.com

- https://github.com/absinthe-graphql/absinthe

- https://www.amazon.com/Craft-GraphQL-APIs-Elixir-Absinthe-ebook/dp/B07CSMHPKY/

- https://www.dropbox.com/s/6nn78jtf8ighry0/desmond-truck.jpg?dl=0

- https://crevalle.io

- https://www.youtube.com/watch?v=JvBT4XBdoUE

- https://www.instagram.com/thecolossusofroads/