Elixir Mix is a weekly show focused on the Elixir programming community. Our panel discusses topics around functional programming, the Elixir ecosystem, and building real world apps with Elixir based tools and frameworks.
Similar Podcasts
The Rabbit Hole: The Definitive Developer's Podcast
Welcome to The Rabbit Hole, the definitive developers podcast. If you are a software developer or technology leader looking to stay on top of the latest news in the software development world, or just want to learn actionable tactics to improve your day-to-day job performance, this podcast is for you.
The Cynical Developer
A UK based Technology and Software Developer Podcast that helps you to improve your development knowledge and career,
through explaining the latest and greatest in development technology and providing you with what you need to succeed as a developer.
Flutter 101 Podcast
Weekly podcast focusing on software development with Flutter and Dart. Hosted by Vince Varga.
Episode 70: EMx 070: Home Automation Using Radio Frequencies with Jon Carstens
In this episode of Elixir Mix the panel interviews Jon Carstens about his work with Nerves. Michael Ries gives a little background on Jon, as they have worked together and Jon helps run the remote nerves meet up that Michael attends. Jon recently started working with Frank Hunleth at Smart Rent. Jon tells the panel what an adventure it is working at Smart Rent. The panel asks Jon about the parts of the Nerves ecosystem he has been working in. He explains how he has been working with NervesHub to manage collections or groups of devices. He has also been working with ShoeHorn controlling app start order and erlang heart stop module. Making sure that they can remote reboot devices. Jon talks more about what Smart Rent does. He explains that there are lots of brands and types of smart home devices, not all of which can connect to the internet. At Smart Rent, they connect various brands and devices using their own custom-built hub. Smart Rent has many benefits tenants and even more for property managers. Property managers can use Smart Rent to manage vacant properties, monitor for leaks, break-ins, fire, and dangerous temperatures. They can even set up open houses remotely, changing the temperature to comfortable levels, turning on and off lights, and unlocking and locking the doors for walkthroughs of the properties. Justin Schneck gave a keynote at ElixirConf 2019 where he showed of an IEX console Nerves device. The panel asks Jon about his role in building the devices. Jon explains how he was tasked with the project. He explains how the console works using an IO. The hardest part, Jon explains, was getting the ASCII characters right. He spent hours working on it, he shares the libraries and tools he used to help him get it right. The panel asks how the IEX server sessions work. Jon explains what would happen if you tried to SSH into an IEX session running through NervesHub on a device and other examples of how it all works. The panel discusses the benefits of debugging devices using the IEX console. Jon explains that it has been extremely beneficial in debugging remote devices. While the IEX console is very useful, Jon warns that it is not very pretty. The IEX console was designed by backend developers and he points out some of the things that could use a little love. The panel asks about contributing to this project and invites listeners to contribute on the Nerves GitHub pages. To finish, the panel asks Jon about his lightning talk. Jon launches into the story of his at-home Nerves projects. It all started when they replaced their old ceiling fan for one with a remote. The problem was that the frustrating design coupled with his remote thieving kids, the fan became an annoyance, to say the least. Jon discovered that the remote-operated using a radio frequency. He learned all he could about radio frequencies and how they worked. He warns listeners not to broadcast radio frequencies to far from their homes because there will be legal ramifications. Using a raspberry pi and a jumper cable, Jon built a device that now controls all devices in his home that operate using radio frequencies. He shares the tools he used to record the frequencies from the remotes and the library he built of the frequencies. Jon shares his dream of running all remote-controlled devices either through his phone or his voice. His next project is infrared. Panelists Mark Ericksen Eric Oestrich Michael Ries Guest Jon Carstens Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan Adventures in DevOps My Ruby Story CacheFly Links https://www.realflight.com/index.php http://www.wings3d.com/ https://www.flightgear.org/ https://github.com/nerves-project/shoehorn http://erlang.org/doc/man/heart.html https://www.nerves-hub.org/ https://smartrent.com/ https://beagleboard.org/black/ ElixirConf 2019 - Day 2 Morning Keynote - Justin Schneck https://github.com/nerves-hub/nerves_hub_web https://learnyousomeerlang.com/building-otp-applications https://github.com/nerves-hub/nerves_hub/blob/master/lib/nerves_hub/console_channel.ex https://www.npmjs.com/package/ansi-to-html https://github.com/stephlow/ansi_to_html https://twitter.com/JonCarstens/status/1169660675137912832 https://github.com/nerves-hub/nerves_hub_web https://embedded-elixir.com/post/2019-08-29-nerves-at-434-mhz/ ElixirConf 2019 - Lighting Talk - Nerves @ 433 MHZ Jon Carstens: Dadgineering with Elixir+Nerves https://github.com/jjcarstens/replex https://github.com/F5OEO/rpitx https://osmocom.org/projects/rtl-sdr/wiki/Rtl-sdr https://github.com/jjcarstens https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: Ecto 3.2 released PostgreSQL CTE information Eric Oestrich: https://github.com/oestrich/grapevine-ansi https://www.realflight.com/index.php Michael Ries: http://www.wings3d.com/ Flite Test Sea Duck Electric Airplane Kit Jon Carstens: Off to Be the Wizard
Episode 69: EMx 069: Distributed Databases with Wiebe-Marten ("Marten") Wijnja
Episode Summary In this week’s episode of Elixir Mix the panel follows up with Wiebe-Marten ("Marten") Wijnja about his talk at Elixir Conf EU, where he spoke about the distributed system his team was working on. They start by discussing the eight fallacies of distributed computing that Marten talked about in talk. He lays out a couple of the fallacies and invites listeners to watch his talk for all eight. Marten explains that these fallacies most commonly happen to developers who are used to working with a single system. The panel discusses how to be mindful of these mistakes and how developers take for granted of how easy one system is to use. Marten gives some tool recommendations to help with these fallacies. TLA+ is a small programming language that lets the developer describe their system and it will point out when something is wrong but it works purely on concepts. Erlang quick check implementation is also a tool that will help combat these problems. The last suggestion which was given by the panel is a library called comcast on github that will simulate poor network connections so the developer can see how the system runs on a poor connection. Marten describes the byzantine problem. Two nodes or generals are trying to agree on something but communication keeps failing. The various outcomes are considered and Mark Ericksen gives an additional example of he and Josh Adams trying to connect to record a podcast, and how the miscommunication could change the outcome. This is a big problem that complicates using a distributed system. The panel discussed CRDT’s and how they are a better way for nodes to sync up. Marten gives a very simple example of a CRDT as a counter. The panel discusses when to use CRDT’s and when not too. Marten explains what questions to ask before using CRDT’s. Another way of solving the byzantine problem is by connecting the nodes. The panel discusses the tools they use to connect their nodes. Partisan is one tool, instead of connecting all nodes, each node connects to a specific number of nodes. That way if one node goes down the whole system doesn’t stop, while at the same time not, overwhelming the nodes. Libcluster, another tool, uses Kubernetes and has multiple strategies for connecting nodes so developers can choose the right one for their system. The panel asks Marten about multicall and abcast. Marten explains that these tools help one node talk to all the other nodes in a cluster, and multicall will gather the results. Multicall also tells the developer which nodes failed to respond to the request. Mark shares an example of using these tools to effectively communicate between gen servers. In Marten’s talk, he described four distributed databases. The panel asks Marten to talk about each one of them. The first one is mnesia. Marten talks about his first experience with Mnesia and how he thought it was amazing. He soon realized while it is still a great tool it also has its quirks. He explains that each of these databases has its own quirks. Mnesia doesn't do conflict resolution, that along with a few other things the developer will need to build themselves. This can be a good and bad thing because developers can customize the database to their needs but it’s not ready out of the box. Mark explains the use cases mnesia is good for and even references the mnesia documentation. Cassandra is the next database Marten describes. Cassandra is the database discord uses. Cassandra does not let developers control their own conflict resolution. It always uses the latest time-stamp and with nodes that can be confusing. Couchdb is another database they discuss. Again, couchdb is also not made to deal with conflicts. It will either solve them randomly or the developer can opt into resolving it themselves. The panel discusses times when this is useful, such as when connectivity is intermittent. Riak is the final database and the one Marten’s team chose for their distributed system project. Riak was written in Erlang and is a key-value store and uses CRDT’s. It uses a CRDT conflict resolution. Marten shares his experience using Riak. The panel considers Riak’s history and need for some love. Marten gives an update on planga, the chat application they were building the distributed system for. Marten explains that during the talk they were in the middle of development. He shares the story of why they wanted a distributed system for this chat application. The client they were doing it for wanted to do video streaming but pulled out in the end. When the client no longer needed the video streaming solution they stopped building the distributed system. Marten is still hopeful they will go back and finish it. To end the episode Marten shares his programming journey. He started programming at age nine. At age 12 he started doing professional web development. After a few years of that, he started doing some frontend work in JavaScript. Once that got old, bitcoin was getting big so he and some friends got into that. Finally, he got a job doing backend work with Ruby while at university. When he heard about Elixir he was so excited he learned the basics in one weekend and has loved it ever since. Panelists Mark Ericksen Josh Adams Guest Wiebe-Marten ("Marten") Wijnja Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan Adventures in DevOps My Ruby Story CacheFly Links Wiebe Marten Wijnja - An adventure in distributed programming - ElixirConf EU 2019 https://elixirforum.com/ https://lamport.azurewebsites.net/tla/tla.html http://www.quviq.com/products/erlang-quickcheck/ https://github.com/tylertreat/Comcast https://en.wikipedia.org/wiki/Byzantine_fault#Byzantine_Generals'_Problem https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type https://github.com/bitwalker/libcluster http://partisan.cloud/ http://erlang.org/doc/man/mnesia.html https://learnyousomeerlang.com/mnesia How Discord Stores Billions of Messages https://pouchdb.com/ https://planga.io/ https://riak.com/ https://github.com/basho/riak_core https://riak.com/where-to-start-with-riak-core/ Using Erlang, Riak and the ORSWOT CRDT at bet365 (...) - Michael Owen - Erlang User Conference 2015 https://hex.pm/packages/effects https://github.com/graninas/automatic-whitebox-testing-showcase https://github.com/Qqwy/elixir-riak_ecto3 https://hex.pm/packages/sea https://twitter.com/WiebeMarten https://github.com/qqwy/ https://wmcode.nl https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: ElixirConf YouTube Channel Josh Adams: Automatic White-Box Testing with Free Monads Wiebe-Marten ("Marten") Wijnja: https://propertesting.com/ https://globalgamejam.org/ https://polyphasic.net/
Episode 68: EMx 068: Contributing to the Elixir Community with David Bernheisel & Cory Schmitt
Episode Summary In this week’s episode of Elixir Mix the panel is joined by David Bernheisel and Cory Schmitt, from Taxjar, to discuss the different ways developers can contribute to the community. The first way to contribute to the Elixir community is contributing to the Elixir core code. While David shares a little of his background, he shares his first experience contributing to the elixir code by submitting a pull request about asdf. The panel all thanking him for his contribution. The next form of contributing the panel discusses is open-sourcing projects. Cory and David share their experience getting their date-time parser open-sourced. They express gratitude at the support they received from Taxjar at open-sourcing the project. Before moving on to the next way to contribute the panel stops for a moment to ask Cory and David about their date-time parser. David and Cory explain why they decided to build a date-time parser after finding a problem in Timex and other time libraries. They talk about their first attempt at the parser and explains that it was a disaster. The panel expresses their interest in nimble parsec and asks our guests to share their experience using this library. Cory and David explain that it was easy to use and a little slower than libraries found in other languages but still fast enough for production. They go into more detail of what it was like to code in nimble parsec and give tips for optimizing performance with the library. The panel asks about future plans for the date-time parser. David and Cory explain what cereal time is and how it will soon be usable in the parser. The most interesting things they learned while building the parser are listed including some of the surprising results they got while testing the library. They also talk about the difficulty of time zone math and other problems with programming for time zones. The panel moves on to the next way you can contribute to the Elixir community is through running and attending meetups. The panel shares the places and types of meetups they run. Trying to prepare future meetup hosts, the panel shares their experiences starting up or taking over meetups, explaining what they need to know. Such as, not everyone that attends a meetup is going to be as hyped up about the language as you. Also, meetups are about building relationships and connections just as much as it is learning and sharing. Still talking about meetups, the panel gives tips to both the host and the members. To the hosts, they give ideas on how to run their meetups, such as project nights, lightning talks. They explain that a lot of the people coming to the meetups will be new to Elixir and warns not to dive too deep into the code and lose them. Instead, the panel recommends recruiting the developers new to Elixir that still have all their enthusiasm for the language to help you run the meetups. Another recommendation is to vary the depth and range of the topics, that way you can maintain the interest of your members. The panel talks about the financial part of running a meetup and advises hosts to find a good notification service and a sponsor. Speaking to meetup members, the panel reminds them that just by attending meetups they are contributing to the Elixir community. By going they make connections, share ideas and grow as developers in that community. The advice they give to members is to find ways to get more involved, explaining that no meetup host is going to turn down a willing speaker or a helping hand. They also discuss encouraging a comfortable environment and helping other members feel welcome in the community. The final form of contributing the panel discusses is attending and speaking at conferences. The panel shares their excitement for the upcoming Elixir Conf. They also discuss the value of smaller regional conferences that may be easier to attend. At regional conferences, it can be easier to connect with others since there is a smaller crowd. Also, a singletrack style conference may encourage you to attend talks you normally wouldn’t choose, allowing you to discover new and exciting technologies. The panel explains how the number of conferences has grown over the years giving more opportunities to both attend and speak. They encourage all developers to go to conferences often. Panelists Mark Ericksen Michael Ries Josh Adams Guest David Bernheisel Cory Schmitt Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan GitLab | Get 30% off tickets with the promo code: DEVCHATCOMMIT My Ruby Story CacheFly Links Falsehoods programmers believe about time and time zones https://elixirforum.com/ https://asdf-vm.com https://github.com/asdf-vm/asdf-elixir/pull/64 https://hexdocs.pm/date_time_parser/DateTimeParser.html https://github.com/plataformatec/nimble_parsec https://github.com/plataformatec/nimble_csv https://hexdocs.pm/date_time_parser/examples.html#content How to save datetimes for future events https://www.meetup.com/Triangle-Elixir/ https://github.com/elixir-lang/elixir/wiki/Conferences https://www.gigcityelixir.com/ https://www.thebigelixir.com/ https://empex.co/ EMPEX LA 2019 - Five Easy Ways To Start With Nerves - Michael Ries https://allthingsopen.org/ https://twitter.com/bernheisel https://github.com/dbernheisel https://bernheisel.com https://www.taxjar.com https://twitter.com/_GazD https://github.com/cas27 https://schmitty.me/ Elixir / Phoenix YouTube Channel https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: https://hex.pm/packages/phoenix_live_view http://npm.anvaka.com/#/view/2d/webpack Michael Ries: http://www.hpmorpodcast.com Josh Adams: https://package.elm-lang.org/packages/elm/time/latest/ David Bernheisel: http://ocremix.org/ Cory Schmitt: https://www.twitch.tv/josevalim https://taxjar.workable.com/jobs/1103271
Episode 67: EMx 067: What's New with Nerves with Frank Hunleth
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan GitLab | Get 30% off tickets with the promo code: DEVCHATCOMMIT My Ruby Story CacheFly Panel Mark Ericksen Michael Ries Josh Adams Eric Oestrich Joined by Special Guest: Frank Hunleth Summary Frank Hunleth, co-author of Nerves, shares where Nerves came from and how it got started. The panel discusses the Nerves 1.5 release and the improvements in it. Frank introduces Nerves Hub and Michael Ries gives a little marketing spin to it, explaining what you can do with Nerves Hub and why you would want to use it. The panel discusses the funding model for Nerves. Frank introduces Elixir Circuit, which helps you find libraries for your devices. He introduces Mountrap, a library that helps to switch between ports and NIFs. Frank introduces Grisp, what it is and how it compares to Nerves. Frank introduces Vintage Net and how it will help your devices stay online. Michael shares his experience with Nerves and gives some tips to make getting started with Nerves easy. The panel encourages programmers to get into embedded systems and explains how it will change the way they view coding. Links EMx 008: Nerves! with Frank Hunleth and Justin Schneck Actor Model Lisp Flavoured Erlang Nerves 1.5.0 released! https://www.nerves-hub.org/ https://opencollective.com/nerves-project ElixirConf 2018 - Keynote - Justin Schneck https://github.com/nerves-hub https://github.com/nerves-hub/nerves_key NervesKey Lonestar ElixirConf 2019 - Building a Smart Sprinkler Controller with Nerves - Todd Resudek https://elixir-circuits.github.io/ https://github.com/elixir-circuits/circuits_quickstart https://github.com/fhunleth/muontrap 15 Ports and Port Drivers GRiSP 2: DIVING DEEPER INTO EMBEDDED SYSTEMS GRiSP 2 https://www.gigcityelixir.com/ https://hex.pm/packages/blinkchain https://github.com/fhunleth/vintage_net https://twitter.com/smartlogic/status/1161982882036015104 https://twitter.com/fhunleth?lang=en https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: Boundaries Michael Ries: ElixirConf 2015 - Embedded Elixir in Action by Garth Hitchens ElixirConf 2017 - Building an Artificial Pancreas with Elixir and Nerves - Tim Mecklem Jon Carstens: Dadgineering with Elixir+Nerves 2 Watt Solar Charger Kit Josh Adams: 2017 National Electrical Code Eric Oestrich: Parsely The Big Elixir Frank Hunleth: Power Control https://hex.pm/packages/power_control Programming Boot Sector Games
Episode 66: EMx 066: Going with the Flow with John Mertens
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan GitLab | Get 30% off tickets with the promo code: DEVCHATCOMMIT My Ruby Story CacheFly Panel Mark Ericksen Michael Ries Joined by Special Guest: John Mertens Summary John Mertens, from change.org, joins the panel to discuss a recent talk he gave at ElixirConf EU. The panel starts off by discussing change.org’s adoption of Elixir and how John helped to bring that about. John discusses the value of Flow even though it is not part of the standard library. The panel discusses what the pieces of data look in John’s pipeline. After giving some context for his project, John gives details about his work in Flow and why they chose Flow for that project. The panel discusses tuning the numbers in Flow to make it faster. John shares his experience using Broadway and shares his favorite features. The panel asks him to compare Flow and Broadway in terms of configuration and understanding what is going on. John shares factors to consider when deciding to use Flow or Broadway for a project. The panel discusses supervision trees, using graceful shutdown, and the difficulty of messing up a flow. Links John Mertens - Lessons From Our First Trillion Messages with Flow - ElixirConf EU 2019 https://pragprog.com/book/tvmelixir/adopting-elixir GenStage and Flow - José Valim | ElixirLive 2016 https://elixir-lang.org/getting-started/debugging.html#observer https://github.com/beam-telemetry/telemetry https://github.com/change https://en.wikipedia.org/wiki/Amdahl%27s_law https://en.wikipedia.org/wiki/Embarrassingly_parallel https://github.com/mertonium https://twitter.com/mertonium?lang=en https://www.mertonium.com https://thoughtfulcoder.club https://www.change.org https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: http://avidemux.sourceforge.net/ John Mertens: Solid Ground Money Heist Michael Ries: https://nerves-project.org/
Episode 65: EMx 065: The Life Cycle of Elixir
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan React Native Radio iPhreaks CacheFly Panel Mark Ericksen Josh Adams Michael Ries Summary Mark Ericksen introduces the topic of framework life cycles hoping to address the concerns of new Elixir developers from other frameworks. The panel explains the various phases in a frameworks life and hype cycles using other frameworks as reference. COBOL, an older language, is on the tail end of its life but still kicking and it probably won’t ever fade out completely. Ruby on Rails is considered mainstream or widely adopted. The panel considers where Elixir is in its cycle. They all agree that Elixir is in the late stages of “early adoption”. The panel explains what this means for Elixir developers and why Elixir will become a widely adopted framework. They site the stability that Erlang provides to Elixir despite its young age and the solutions that Elixir provides the developing community. Mark Ericksen invites new Elixir developers to not only be patient but to be proactive in sharing Elixir at work and to developers around them. Links https://www.linkedin.com/pulse/clojure-technology-adoption-curve-jon-pither/ http://erlang.org/doc/man/HiPE_app.html http://user.it.uu.se/~kostis/ https://darklang.com/ https://en.wikipedia.org/wiki/Technology_adoption_life_cycle https://en.wikipedia.org/wiki/Hype_cycle https://ferd.ca/ten-years-of-erlang.html https://twitter.com/garybernhardt/status/1157025347948302341?s=20 https://www.ponylang.io/blog/2017/05/an-early-history-of-pony/ https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: This Erlang Life Josh Adams: Pony Michael Ries: RailsConf 2016 - Surviving the Framework Hype Cycle by Brandon Hayes Alex - The French Chef/Engineer
Episode 64: EMx 064: Refactoring Elixir with Hubert Lepicki
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Panel Mark Ericksen Josh Adams Joined by Special Guests: Hubert Łępicki Summary Hubert Łępicki joins the panel to discuss his blog post, “Refactoring Phoenix controllers”; he starts by sharing what made him decide to write this article. In the blog post, he outlines strategies and patterns to better organize your code. The first strategy discussed, which was not mentioned in the blog post is: Breaking down one controller into multiple controllers. Intrigued, the panel asks Hubert to explain exactly what he means by this. The second pattern is: extracting logic from a controller and using it in a plug instead. The panel discusses what the right code to put in a plug. The third pattern Hubert explains is: using business logic and workflow modules. The panel asks Hubert about his dislike for phoenix context. Hubert and the panel give better alternatives to phoenix controller and explains how they use modules. Having a Ruby background, Hubert explains the difference of using context and modules in Elixir compared to Ruby. Hubert shares how he uses the fourth pattern: Ecto using embedded schema. The episode ends with a little about Hubert's company and what they do. Links https://www.amberbit.com/blog/2019/6/29/refactoring-phoenix-controllers/ https://pcpartpicker.com/list/t7LBNQ https://www.techradar.com/sg/reviews/amd-ryzen-7-3700x https://www.pcgamer.com/the-best-graphics-cards/ https://www.amberbit.com/blog/2019/6/29/refactoring-phoenix-controllers/ https://github.com/elixir-plug/plug https://twitter.com/hubertlepicki/status/1156179338779385856 https://brainlid.org/elixir/2017/09/24/elixir-processes-and-state-abuse.html https://github.com/absinthe-graphql/absinthe https://graphql.org/ https://twitter.com/hubertlepicki https://www.amberbit.com https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: The Pragmatic Programmer, 20th Anniversary Edition https://twitter.com/D2BOWIE/status/1151134380439420933 Josh Adams: The Emperor's Blades: Chronicle of the Unhewn Throne, Book I https://postmarketos.org/ Hubert Łępicki: Expeditionary Force Series
Episode 63: EMx 063: Designing Elixir Systems With OTP with Bruce Tate and James Gray
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Panel Mark Ericksen Michael Ries Eric Oestrich Josh Adams Charles Max Wood Joined by Special Guests: Bruce Tate and James Gray Summary Bruce Tate and James Gray join the panel to discuss their new book, “Designing Elixir Systems With OTP”. Bruce and James share the story of how they decided to write this book together. The panel discusses the books target audience, Bruce and James explain that this is not for programmers who know nothing about Elixir. Resources and books for beginners to read are recommended. Bruce and James share many key points of the book and the main lesson they hope the reads come away with. The interesting mnemonic “Do Fun Things With Big Loud Wildebeests” is explained. Bruce and James share what this book will do for your applications. They address common misunderstandings for people moving from object-oriented programming into functional programming. Bruce and James share what it was like working with each other to write this book. The episode ends with Bruce and James sharing the stories of how the came to the elixir community. Links Designing Elixir Systems With OTP: Write Highly Scalable, Self-healing Software with Layers https://en.wikipedia.org/wiki/Second-system_effect https://devchat.tv/elixir-mix/emx-052-production-pitfall-pontification/ https://elixircards.co.uk/ Elixir in Action https://elixirschool.com/en/ Programming Phoenix 1.4 GOTO 2019 • The Soul of Erlang and Elixir • Saša Jurić Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages https://grox.io/ http://icanmakeitbetter.com/ https://twitter.com/redrapids https://twitter.com/JEG2 https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: https://github.com/lpil/mix-test.watch Designing Elixir Systems with OTP | Erlang Solutions Webinar Michael Ries: Functional Web Development with Elixir, OTP, and Phoenix https://www.destroyallsoftware.com/talks/boundaries Eric Oestrich: https://podcast.smartlogic.io/ Josh Adams: https://urbit.org/primer/ https://ivan.bessarabov.com/blog/famous-programmers-work-time Charles Max Wood: https://elixirconf.com/2019 Suggest a topic. Bruce Tate: https://10xdevelopers.com/demo/hanoi James Gray: Designing Elixir Systems with OTP | Erlang Solutions Webinar https://store.steampowered.com/app/294100/RimWorld/ https://www.lexaloffle.com/pico-8.php https://github.com/alexch/rerun
Episode 62: EMx 062: Elixir v1.9 and Hex.pm with Wojtek Mach
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Panel Mark Ericksen Michael Ries Eric Oestrich Josh Adams Joined by Special Guest: Wojtek Mach Summary Wojtek Mach shares his experiences at Plataformatec; what his team is like and what types of projects they work on. The panel asks Wojtek about the announcement for hex.pm and how it works. Wojtek shares his language background and how he got into Elixir. The panel discusses Wojtek’s experience moving from a distillery release to a mixed based release. My SQL library for Ecto is considered and the panel discusses Wojtek past libraries. Links https://github.com/elixir-ecto/myxql https://github.com/plataformatec/broadway https://github.com/hexpm/hexpm https://github.com/hexpm/bob https://repo.hex.pm/builds/elixir/builds.txt https://github.com/asdf-vm/asdf https://github.com/asdf-vm/asdf-elixir https://bobs-list.kobrakai.de/ https://hexdocs.pm/ecto_sql/Ecto.Migrator.html#with_repo/3 https://hexdocs.pm/mix/Mix.Tasks.Release.html https://github.com/xerions/mariaex https://github.com/elixir-ecto/myxql https://github.com/elixir-ecto/postgrex https://github.com/elixir-ecto/myxql/blob/master/MARIAEX_COMPATIBILITY.md José Valim - KEYNOTE: Announcing Broadway | Code BEAM SF 19 https://github.com/plataformatec/broadway/pull/91 https://github.com/elixir-ecto/myxql/blob/master/test/test_helper.exs#L218-L236 https://github.com/wojtekmach/oop Lightning Talks - Wojtek Mach (ElixirConfEU 2016) ElixirConf 2016 - Building Umbrella Project by Wojtek Mach https://github.com/wojtekmach/acme_bank https://github.com/hexpm/hexpm https://github.com/hexpm/hexdocs https://github.com/hexpm/hex/pull/698 https://github.com/hexpm/hex/pull/698 https://www.zdnet.com/article/backdoor-found-in-ruby-library-for-checking-for-strong-passwords/ https://twitter.com/wojtekmach https://github.com/wojtekmach https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: https://thinkingelixir.com/ Michael Ries: https://hex.pm/packages/veritaserum Dmytro Lytovchenko - ErlangRT, a BEAM VM reimplementation in Rust | Code BEAM Eric Oestrich: https://www.restfest.org/ Josh Adams: https://en.wikipedia.org/wiki/Capability-based_security https://medium.com/darklang/how-dark-deploys-code-in-50ms-771c6dd60671 http://www.erights.org/elib/capability/ode/ode-capabilities.html#simple-money https://fuchsia.dev/fuchsia-src/glossary.md Wojtek Mach: GOTO 2019 • The Soul of Erlang and Elixir • Saša Jurić https://pqrs.org/osx/karabiner/
Episode 61: EMx 061: Mutation Testing in Elixir with Daniel Serrano
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Panel Mark Ericksen Eric Oestrich Joined by Special Guest: Daniel Serrano Summary Daniel Serrano explains what mutation testing is and how it works. The panel discusses the purpose and benefits of mutation testing. Daniel shares how mutation testing can fit into your process. The panel considers Daniel’s exunit deep dive and how this helped building exavier, his library. Daniel shares how he came up with the name exavier. The panel asks Daniel about his experience load testing broadway. Daniel explains what broadway is and the benefits seen load testing it. Daniel shares how he got into distributed tracing and how it differs from tracing. Daniel tells the panel about his experience learning elixir and joining the community. Links https://en.wikipedia.org/wiki/Mutation_testing https://github.com/mbj/mutant http://pitest.org/ https://github.com/dnlserrano/exavier https://github.com/dnlserrano https://dnlserrano.dev/2019/05/26/exunit-deep-dive.html https://jmeter.apache.org/ https://twitter.com/brainlid José Valim - Keynote: Announcing Brodway - ElixirConf EU 2019 https://github.com/plataformatec/broadway https://aws.amazon.com/sqs/ https://opentracing.io/docs/overview/what-is-tracing/ https://github.com/spandex-project/spandex/ https://www.datadoghq.com/ https://aws.amazon.com/cloudwatch/ Daniel Serrano - From Noob to Contributing Noob - ElixirConf EU 2019 https://twitter.com/dnlserrano https://dnlserrano.dev/ https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: https://www.destroyallsoftware.com/talks/wat https://send.firefox.com Eric Oestrich: https://en.wikipedia.org/wiki/The_Eye_of_the_World Daniel Serrano: Dark https://github.com/itchyny/lightline.vim https://github.com/plataformatec/flow
Episode 60: EMx 060: Property-Based Testing, Dialyzer, & Inaka with Brujo Benavides
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Panel Mark Ericksen Eric Oestrich Michael Ries Joined by Special Guest: Brujo Benavides Summary Brujo Benavides shares what he is working on right now and how his team feels about working in both Elixir and Erlang. He shares what his team has gotten out of using Elixir and what he thinks his team will get out of Elixir in the future. The panel discusses property-based testing and Fred Hebert’s book on property-based testing. Brujo shares use cases that would benefit from property-based testing and those that would benefit from unit testing. The panel considers dialyzer and shares their experiences using it in their code. Brujo explains how he chooses which tools to use for a project. Inaka is discussed; Brujo explains what they are all about and how to join. Upcoming conferences that Inaka is organizing is outlined and details on how to buy tickets are given. Links EMx 031: Lessons from a Decade of Erlang with Brujo Benavides https://elixir-lang.org/docs.html EMx 047: Property Based Testing with PropEr and Fred Hebert My Take on Property-Based Testing for Erlang & Elixir https://github.com/proper-testing/proper Help Dialyzer Help You! http://erlang.org/doc/man/dialyzer.html http://erlang.org/doc/man/dialyzer.html#gui-0 http://erlang.org/doc/apps/dialyzer/dialyzer_chapter.html#dialyzer_gui Erlang Oddities - Brujo Benavides https://github.com/inaka/elvis https://hex.pm/packages/dialyxir https://github.com/inaka https://github.com/inaka/guidelines https://spawnfest.github.io/ https://www.elixirconf.la/ https://twitter.com/elbrujohalcon https://github.com/elbrujohalcon https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: https://www.destroyallsoftware.com/talks/wat I am Mother Eric Oestrich: https://grapevine.haus/ https://github.com/oestrich/telnet-elixir Michael Ries: Foam board https://devchat.tv/elixir-mix/ Brujo Benavides: http://spawnedshelter.com/ http://artemis.cslab.ece.ntua.gr:8080/jspui/handle/123456789/15777
Episode 59: EMx 059: Using Rust to Scale Elixir for 11 Million Concurrent Users with Matt Nowack
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small plan CacheFly Panel Mark Ericksen Josh Adams Michael Ries Eric Oestrich Joined by Special Guests: Matt Nowack Summary Matt Nowack, a developer at Discord, gives an intro to Discord and shares its origin story. The panel discusses the problems that Discord was having because of its 11 million concurrent users. Matt talks about when they knew there was a problem, how they used a runtime VM to find the problem, the tools they tried to fix the problem and how they landed on NIFs to fix the problem. The panel discusses the risks of using NIFs and how using Rust helps negate that risk. Matt discusses the reference counter in the rustler package and answers questions about using dirty schedulers. Discord developers publish many blogs and publish many open source projects; Matt shares the Discord philosophy on open sourcing and contributing to the Elixir community. Links https://github.com/discordapp/sorted_set_nif https://github.com/rusterlium/rustler Matthew Nowack - ZenMonitor: Scaling Distributed Monitoring at Discord | Code BEAM SF 19 https://en.wikipedia.org/wiki/Fates_Forever http://erlang.org/doc/tutorial/nif.html https://www.rust-lang.org/ https://blog.discordapp.com/using-rust-to-scale-elixir-for-11-million-concurrent-users-c6f19fc029d3 https://github.com/discordapp/sorted_set_nif https://www.erlang-solutions.com/blog/a-guide-to-tracing-in-elixir.html https://github.com/ferd/recon https://discordapp.com/jobs https://elixir-lang.org/blog/2019/06/24/elixir-v1-9-0-released/ https://github.com/ihumanable https://twitter.com/ihumanable https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: https://www.nps.gov/grca/planyourvisit/havasupai.htm https://waterfallsofthegrandcanyon.com/havasu-falls/havasupai-waterfalls/ Josh Adams: https://sorbet.org/blog/2019/06/20/open-sourcing-sorbet Michael Ries: https://www.raspberrypi.org/products/raspberry-pi-4-model-b/ https://www.youtube.com/user/flitetest Eric Oestrich: https://podcast.smartlogic.io/ Matt Nowack: http://discord.gg/elixir https://www.destroyallsoftware.com/talks/boundaries https://en.wikipedia.org/wiki/Halt_and_Catch_Fire_(TV_series)
Episode 58: EMx 058: Mint library with Eric Meadows-Jönsson & Andrea Leopardi
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small plan CacheFly Panel Mark Ericksen Josh Adams Michael Ries Joined by Special Guests: Eric Meadows-Jönsson & Andrea Leopardi Summary Eric Meadows-Jönsson and Andrea Leopardi, members of the Elixir core team discuss the upcoming Mint library. They tell the panel their experience working on the core team and on the Mint library. They explain what Mint is and why people should know about it. Mint doesn’t use processes; Eric and Andrea explain why and what that means for the library. The panel discusses the benefits of using Mint and the use cases it can be applied to. Eric and Andrea give an update on how Mint is coming and explains why mint is not part of Elixir core. The panel considers building an HTTP library; Eric and Andrea share their experience. Links http://erlang.org/doc/man/httpc.html https://github.com/ericmj/castore https://elixir-lang.org/blog/2019/02/25/mint-a-new-http-library-for-elixir/#safe-by-default-https https://github.com/appcues/mojito https://segment.com/blog/introducing-centrifuge/ https://github.com/hexpm/hex https://github.com/ericmj/mint https://hexdocs.pm/mint/api-reference.html https://elixir-lang.org/blog/2019/02/25/mint-a-new-http-library-for-elixir/ https://twitter.com/inconvergent/status/1139070281971118085?s=19 https://twitter.com/emjii https://twitter.com/whatyouhide https://thewirecutter.com/reviews/best-sous-vide-gear/ https://www.facebook.com/Elixir-Mix https://twitter.com/elixir_mix Picks Mark Ericksen: https://pragprog.com/book/phoenix14/programming-phoenix-1-4 - They added Chapter 14, “What’s Next?” In it we address LiveViewPubSub 2.0, adding “telemetry” information to Phoenix and other coming additions. Josh Adams: Meat https://inconvergent.net/2019/depth-of-field/ Michael Ries: Matthew Nowack - ZenMonitor: Scaling Distributed Monitoring at Discord | Code BEAM SF 19 My New Croissant Machine Is 3D-PRINTED ! Andrea Leopardi: https://github.com/whatyouhide/after8 https://github.com/appcues/mojito https://mizage.com/shush/ Eric Meadows-Jönsson: https://inkdrop.app/ https://pragprog.com/book/wmecto/programming-ecto
Episode 57: EMx 057: The Elixir Community with Adolfo Neto
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small plan Triplebyte offers a $1000 signing bonus CacheFly Panel Mark Ericksen Josh Adams Michael Ries Eric Oestrich Joined by Special Guest: Adolfo Neto Summary Adolfo Neto shares the background behind his Elixir Brazil 2019 talk. The panel discusses other talks of Elixir Brazil 2019, the organizing of the conference, and the diversity initiative. Adolfo shares his experience in the U.S., attending meetups for other programming languages, comparing them to Elixir. The panel considers the Elixir code formatter and gives protips for using it. The best way to teach Elixir and functional programming is considered; the panel shares experiences and resources for learning functional programming. Links A Comunidade de Elixir, Adolfo Neto, Elixir Brasil 2019 https://medium.com/@adolfont/elixir-brazil-2019-4de3fc06b18f https://twitter.com/clojure_conj?lang=en https://collaboration.csc.ncsu.edu/laurie/ https://www.tripinfo.com/maps/NC-ResearchTriangle.htm https://www.meetup.com/elixircwb/ https://twitter.com/elixir_brasil https://2019.elixirbrasil.com/ https://www.eventials.com/locaweb/events/elixir-brasil/ Introducing HDD: Hughes Driven Development - José Valim - Elixir Conf EU 2018 https://github.com/phoenixframework/firenest https://github.com/phoenixframework/phoenix_pubsub https://ieeexplore.ieee.org/document/8116569 https://en.wikipedia.org/wiki/ML_%28programming_language%29 Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages (Pragmatic Programmers) https://elixirschool.com/en/ https://github.com/nashfp/nashfp.github.com/wiki/erlang-school https://twitter.com/thompson_si https://github.com/erlware/erlang-camp https://www.pluralsight.com/courses/meet-elixir https://codestool.coding-gnome.com/courses/elixir-for-programmers https://github.com/lodash/lodash https://github.com/immutable-js/immutable-js https://hex.pm/packages/sorted_set_nif https://hex.pm/packages/rustler https://twitter.com/TheErlef/status/1136705985442189312 https://pragprog.com/book/cdc-elixir/learn-functional-programming-with-elixir https://twitter.com/adolfont https://twitter.com/elixir_mix https://www.facebook.com/Elixir-Mix Picks Mark Ericksen: Wintergatan - Marble Machine Josh Adams: https://blog.ploeh.dk/2017/10/04/from-design-patterns-to-category-theory/ Michael Ries: Using Rust to Scale Elixir for 11 Million Concurrent Users Eric Oestrich: Meetup Organizers Adolfo Neto: Aquarius Kiss of the Spider Woman City of God Learn Functional Programming with Elixir: New Foundations for a New World (The Pragmatic Programmers) (English Edition)
Episode 56: EMx 056: Sobelow and Security with Griffin Byatt
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small plan Triplebyte offers a $1000 signing bonus CacheFly Panel Mark Ericksen Josh Adams Joined by Special Guest: Griffin Byatt Summary Griffin Byatt shares his background and what he is doing now as a security consultant for NCC Group. The panel discusses his security library, Sobelow, and their experiences using it. Griffin explains how it works, how it came into being and the goal of Sobelow. The panel wonders who contributes to Sobelow and Griffin invites anyone to contribute. Vulnerabilities that are commonly seen across all frameworks and those specific to Elixir are discussed. Elixir’s security features are considered and Griffin shares his experiences working to improve the ecosystem. Griffin gives advice and recommends resources to developers. Links Substitute Teacher - Key & Peele https://www.nccgroup.trust/us/ https://brakemanscanner.org/ https://github.com/nccgroup/sobelow https://github.com/nccgroup/sobelow/blob/master/lib/sobelow/traversal/file_module.ex https://www.owasp.org/index.php/XML_External_Entity_(XXE)_Processing ElixirConf 2017 - Plugging the Security Holes in Your Phoenix Application - Griffin Byatt https://github.com/ueberauth/guardian https://oauth.net/ https://github.com/riverrun/phauxth https://github.com/riverrun/comeonin https://www.owasp.org/ https://www.owasp.org/index.php/Category:OWASP_Top_Ten_Project The Web Application Hacker's Handbook: Finding and Exploiting Security Flaws https://griffinbyatt.com/ https://twitter.com/griffinbyatt https://twitter.com/elixir_mix https://www.facebook.com/Elixir-Mix Picks Mark Ericksen: https://stedolan.github.io/jq https://github.com/elixir-lang/elixir/releases Josh Adams: https://librem.one/ https://puri.sm/products/librem-5/ Griffin Byatt: https://www.freehaven.net/anonbib/ https://www.nccgroup.trust/us/our-research/assessing-unikernel-security/?research=Whitepapers