Elixir Mix

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 DevOpsMy Ruby StoryCacheFly 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/jjcarstenshttps://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 Special Guest: Jon Carstens. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

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   - http://sentry.io/– use the code “devchat” for two months free on Sentry’s small plan - https://devchat.tv/adventures-in-devops/- https://devchat.tv/my-ruby-story/- https://www.cachefly.com/ Links - https://www.youtube.com/watch?v=u-b4rJ0RTrk- 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  - https://blog.discordapp.com/how-discord-stores-billions-of-messages-7fa6ec7ee4c7?source=---------0-----------------------  - https://pouchdb.com/  - https://planga.io/  - https://riak.com/  - https://github.com/basho/riak_core  - https://riak.com/where-to-start-with-riak-core/  - https://www.youtube.com/watch?v=WXmO1IvzIZY  - 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_mixBecome a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

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   - http://sentry.io/– use the code “devchat” for two months free on Sentry’s small plan - https://devchat.tv/gitlabcommit | Get 30% off tickets with the promo code: DEVCHATCOMMIT - https://devchat.tv/my-ruby-story/- https://www.cachefly.com/ Links - http://www.creativedeletion.com/2015/01/28/falsehoods-programmers-date-time-zones.html  - 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  - http://www.creativedeletion.com/2015/03/19/persisting_future_datetimes.html  - 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/  - https://www.youtube.com/watch?v=BfWac2y7cJM  - 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/- https://www.youtube.com/channel/UCVjoWz7bfn6QwU6PV01eoqg- 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/1103271Become a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

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 StoryCacheFly 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 SchneckActor 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=enhttps://www.facebook.com/Elixir-Mixhttps://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_controlProgramming Boot Sector GamesSpecial Guest: Frank Hunleth. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

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 StoryCacheFly 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 2016https://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/mertoniumhttps://twitter.com/mertonium?lang=enhttps://www.mertonium.comhttps://thoughtfulcoder.clubhttps://www.change.orghttps://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Mark Ericksen: http://avidemux.sourceforge.net/  John Mertens: Solid Ground  Money Heist Michael Ries: https://nerves-project.org/  Special Guest: John Mertens. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan React Native RadioiPhreaksCacheFly 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-Mixhttps://twitter.com/elixir_mix Picks Mark Ericksen: This Erlang Life  Josh Adams: Pony Michael Ries: RailsConf 2016 - Surviving the Framework Hype Cycle by Brandon HayesAlex - The French Chef/Engineer  Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

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/absinthehttps://graphql.org/https://twitter.com/hubertlepicki  https://www.amberbit.com  https://www.facebook.com/Elixir-Mixhttps://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 Ihttps://postmarketos.org/  Hubert Łępicki: Expeditionary Force Series  Special Guest: Hubert Lepicki. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

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-Mixhttps://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   Special Guests: Bruce Tate and James Edward Gray. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

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/wojtekmachhttps://github.com/wojtekmachhttps://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Mark Ericksen: https://thinkingelixir.com/  Michael Ries: https://hex.pm/packages/veritaserumDmytro 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_securityhttps://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/  Special Guest: Wojtek Mach. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

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-Mixhttps://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 Special Guest: Daniel Serrano. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.