Stay ConnectedJoin our weekly discussion of the popular functional language built on top of the Erlang virtual machine. Each week, we discuss the world of Elxiir, Phoenix, OTP, and then BEAM.
Become a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix–6102049/support.
Copyright: © 2018 Intentional Excellence Productions, LLC
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
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_mix
Become 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/1103271
Become a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.
Sponsors
Sponsors
Sponsors
Sponsors
PanelSponsors
PanelSponsors
PanelSponsors
Panel
Our TOPPODCAST Picks 
