Elixir Mix

Jeff Kreeftmeijer works at Appsignal where they create a tool for application monitoring that works in Ruby and Elixir. He works specifically with integrations focusing in Elixir and also writes articles for their Elixir and Ruby newsletters. Jeff started as a Ruby programmer but had an interest in functional programming which lead him to gain an interest in Elixir. When he started at Appsignal they were already considering an Elixir integration and that made it a perfect fit.  Jeff then shares more details about his involvement in Appsignal’s two newsletters called Ruby magic and Elixir alchemy, both of which are aimed at more experienced programmers. He also details his experience with articles that he wrote on Live Share and how he came to write them. The panelists also introduce the Go game that is written about in these articles. The next topic covered by the Elixir experts is the Go game Live View implementation mentioned in Jeff’s articles. The panelists draw comparisons of how something similar could have been implemented in React. Jeff highlights that he doesn’t have to write JavaScript and doesn’t have to worry about state either. However, in part 1 of Jeff’s current implementation he used a struct to track the state. In part 2 of the implementation, where he implements the code rule, he has another struct that tracks the game.  The panelists then discuss how Jeff maintains the game state. In the first version of the implementation he keeps it in the Live View process and when he implemented multiplayer he had to move the game state to a GenServer. He also shares some of the details of why using a GenServer is necessary for multiplayer. Jeff is then asked what his experience was like using a dynamic supervisor and he shares the technical ideas of how this helped him in the project.  Next the conversation moves to how the game is able to communicate moves between players to each other. The issue with connecting two sessions to the same Live View is that one player won’t be updated if the other makes a move. Jeff details how using a Pub/Sub helps to overcome this issue. The panelists also discuss ideas of how the game could be implemented in a multi server instance.  Jeff shares how his article series still has many more installments that can come out, specifically citing that they haven’t even covered assigning player connections with different player callers. This kind of functionality would handle the assignment of which players controlled which pieces. Jeff closes with highlighting the convenience that comes from using the libraries that they are using as they natively come with technologies they find helpful for building out an interactive, collaborative project. Lastly, the panelists discuss what Jeff is currently doing to work more with these same technologies. Jeff shares that he has a side project where he tries to build a fish tank with artificial intelligence and how he uses Live View for this project.  Panelists

• Mark Ericksen
• Eric Oestrich
• Josh Adams
• Michael Ries

  Guest

• Jeff Kreeftmeijer

Sponsors

• Sentry.io | Use code “devchat” for two months free.
• ElixirCasts | Get 10% off with the promo code "elixirmix" 
• JavaScript Jabber

Links

• Appsignal.com
• Live View article
• Computers and Go
• Building the Go Game in Elixir: Time Travel and the Ko Rule
• Multiplayer Go with Elixir’s Registry, PubSub and Dynamic Supervisors
• Dynamic Supervisor
• PubSub
• Hayago Github
• GenServer
• Functional Web Development With Elixir, OTP, and Phoenix
• Asciiquarium
• Terminal Asciiquarium
• The NeuroEvolution of Augmenting Topologies User Page
• The NeuroEvolution of Augmenting Topologies
• Jeff Kreeftmeijer Twitter
• Jeff Kreeftmeijer.com

  Picks Josh Adams

• Haskell Parser

Eric Oestrich

• Dragon Quest 11
• Wingspan

Michael Ries

• Fireball Island
• Observer CLI

  Mark Ericksen

• Acquired

  Jeff Kreeftmeijer

• Go (game)
• Mansions of Madness
• Alphago Documentary

Special Guest: Jeff Kreeftmeijer.

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

This episode of Elixir mix opens with Lars Wikman and Emilio Nyaray sharing how they came to be working together on a project called Inky. Inky is an E-Ink display that works with Nerves and Elixir. The project started when Lars wanted to use the Inky device from Nerves but didn’t want to install Python to do it. Emilio wanted to join because he found it fascinating to be able to control this device with Elixir. Lars and Emilio share some details of how this project came about and how it works.  The inky comes in multiple sizes with the smaller pHAT display being about the size of a business card and the Inky wHAT being closer to the size of a Raspberry Pi. Lars shares that one of the biggest gotchas with these displays is the refresh rate. Once the pixels are changed the device can be turned off and still remain the same because they are physically changing. The panelists highlight that very little troubleshooting time had to go in to the Nerves portion of the project. Lars describes how he began looking at using Nerves just after it was announced and how he decided to use it in this project. He also shares how he wants to take on a project to put together a cross stitch of a bigger display that can change each day. One way to do this is by putting multiple pHATs together but Lars would prefer to use a wHAT. The conversation then moves to Emilio sharing his journey to the Inky project. He has been working with Erlang professionally for a year. Ever since he worked with a startup in 2012-2013 where they used Erlang, he has had a strong desire to work with functional programming. This desire eventually lead him to work with Elixir and Phoenix to write a timesheet application as a consultant. When he got in to working with Nerves he borrowed a touchscreen at work and was blown away by how it worked. Emilio also details an audio controller interface side project that he is currently working on. The panelists then talk about the elixir community, what they love about it, the friendliness of the small community, and some individuals that have had an impact on them. The discussion then moves on to the profiling tools eprof, fprof, and cprof. These tools are built into the Erlang Ecosystem. Eprof is a time profiling tool. Fprof is a time profiling tool as well, but it uses trace to file for minimal performance impact. Cprof is a simple call count profiling tool. Emilio shares how he came to be familiar with these, how he used them, and the benefits he saw in his application from using these tools. These profiling tools are also available in Elixir. The panelists also discuss eflame which is a flame graph profiling tool that is very easy to use. Emilio and Lars detail how they used a low dependency approach to be able to fake a display on the desktop for Inky and develop on the desktop. 
  Panelists

• Mark Ericksen
• Josh Adams
• Michael Ries

  Guest

• Lars Wikman
• Emilio Nyaray

Sponsors

• Sentry.io use code “devchat” for two months free on Sentry’s small plan
• Adventures in .NET
• Ruby Rogues

Links

• Lars’ writing on Inky
• Nerves
• E-Ink
• Inky pHAT
• Inky wHAT
• Raspberry Pie
• Arduino
• Elixir Forum E-Ink Display
• Phoenix
• Elixir Circuits
• Mysensors.org
• Connor Rigby Github
• Instinct.vet
• Opensoundcontrol.org
• Joe Arms Controlling Sound With OSC
• Codesync.global
• Boyd Multerer Github
• Erlang eprof documentation
• Erlang fprof documentation
• Erlang cprof documentation
• Eflame Github
• Lars Wikman: @lawik on twitter
• Emilio Nyaray: @nyaray on twitter
• Emilio Nyaray Github

  Picks Josh Adams

• autofs
• Kodi.tv

Michael Ries

• Jehu Garcia youtube

Mark Ericksen

• FizzBuzz Enterprise Edition
• Logitech G29 Driving Force

  Lars Wikman

• Scenic Layout-O-Matic
• Nerves Input Event Library

Special Guests: Emilio Nyaray and Lars Wikman.

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

This episode of Elixir Mix features Arkadiusz Gil. Arkadiusz is a software engineer at Erlang Solutions. He is also a member of the observability working group of the Erlang Ecosystem Foundation. The purpose of this working group is to nurture different areas of the community to maintain libraries, improve tooling, and create documentation. He became a member of this group because of his work on Telemetry. The panelists discuss the background of Telemetry and Arkadiusz explains how it was originally written in Elixir and why they decided to switch over to Erlang. Arkadiusz explains how he became involved in Elixir and Erlang. When Mark asks why he prefers Elixir to Erlang he responds with explaining his affinity for the Elixir syntax and tooling that’s available.  The conversation then moves to how Telemetry came about. Telemetry started with the goal of creating a tool for monitoring Elixir applications but the creators had no idea what that application would be like. Arkadiusz then describes how he did an exercise with colleagues to identify the specific needs for such an application and how to implement it. The panelists discuss how Telemetry is integrated. They also discuss how to get started with Telemetry metrics and Arkadiusz shares some of the details of how the monitoring service works.  The next topic that the Elixir experts cover is how to monitor business data and activity. Arkadiusz explains the mechanism that can be used to attach to events in a custom way to retrieve the exact data that the user needs. He shares that Telemetry can really be used any time a user wants to expose a specific piece of data at runtime. Mark asks how this attaching works and this leads to a deeper technical discussion on how Telemetry attaches a mechanism to the application and returns that data, as well as how the listeners work when an event is fired and new data is sent to it.  The panelists then discuss how OpenCensus works with Telemetry. OpenCensus is a project created to culminate API’s that can be used in different languages to create metrics and other data. Arkadiusz shares a hypothetical example of how this works and how Telemetry works with it. The observability working group has helped contribute to OpenCensus. OpenCensus has a smooth integration and is built to run as smooth as possible. A user can use OpenCensus to build metrics based off of Telemetry events. The OpenCensus project is now called OpenTelemetry and it is a merger of OpenCensus and OpenTracing. Finally the Elixir experts cover real world examples of users implementing Telemetry as well as how to get involved with the observability working group and Telemetry. For the observability working group it is best to reach out to them telling them what kind of tooling that would be great to work across the ecosystem and other help they need. One of their goals is to put together a set of best practices for monitoring services.  Panelists

• Mark Ericksen
• Eric Oestrich
• Josh Adams

  Guest

• Arkadiusz Gil

Sponsors

• Sentry.io
• Adventures in DevOps
• Adventures in Angular

  Links

• Erlang Solutions
• Observability Working Group
• Erlang Ecosystem Foundation
• Erlang 
• Telemetry
• Telemetry.Metrics
• AWS CloudWatch Events
• Programming Elixir
• OpenCensus
• OpenTelemetry
• OpenTelemetry.io
• OpenTracing
• arkgil on GitHub 
• Exometer - Erlang Implementation Package
• Prometheus.ex

Picks Eric Oestrich

• UCL parser in Elixir

Josh Adams

• The Depths of Deep Space Nine - YouTube

Mark Ericksen

• How to Create Desktop Application With Elixir
• Terminal command “lscpu”

Arkadiusz

• Alchemist’s Code
• Philosophy of Software Design
• The Anatomy of Next

Special Guest: Arkadiusz Gil.

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

In this week’s episode of Elixir Mix the panel interviews Travis Elnicky, software architect at Podium. Podium is Utah based company that has been using Elixir for three years. Travis explains Podium’s history and its experience adopting Elixir.  When Travis started at Podium they were a small startup with, he was their 16th employee. They were using Ruby on Rails and focusing on collecting reviews for local businesses. When they saw a need for a messenger application, they tried a few solutions choosing Elixir because of the familiarity they felt coming from a Rails background. After switching to Elixir, Podium grew rapidly. Now Podium has 700 employees, 130 of whom are engineers.  Travis discusses with the panel how things are run over at Podium. Their teams are aligned around products and features. This makes all their engineers' full-stack developers. Podiums teams run with a lot of autonomy, they also have teams that help with internal tooling to tie the products together. The panel is curious about the recruitment process at Podium. Travis explains that their hiring is mostly based on referrals, which they found has been pretty reliable. The panel discusses the value of referrals incentives programs. By hiring referrals they save money placing ads and going to fairs. Referrals tend to be more aware of the job they are going into and already have a friend to help them transition jobs and frameworks. Next, Travis walks through what it is like for a new hire at Podium. After onboarding, the new hire sits down with their team lead and codes, taking it all the way to production. The panel considers the advantages of new hires diving in, whether or not they know Elixir. It introduces them to the work they will be doing, gives them confidence by contributing to the team, and the one on one attention shows them the culture of unity at Podium. Podium has a lot to offers its developers. It has a team whose focus is internal developer experience. Podium maintains a focus on learning and growing in Elixir. They offer training for those who are unfamiliar with Elixir. Once per week, they do a Nerd Lunch, the company buys them all lunch while Podium engineers teach their fellows about software.  Elixir 101 training also happens every week and is also taught by Podium engineers. Allowing Podium engineers to teach gives learners a chance to teach which in turn helps them learn. It also allows engineers to network outside their assigned teams. The panel considers how people-centered all the solutions are at Podium.  The panel wonders if Podium ever uses outside trainers or services. Travis shares the wonderful experience they have been having by using Plataformatec’s Elixir Development subscription. He says it has been incredible to be able to jump on a call, talk to them and get some feedback. Using the subscriptions allows their senior developers to level up, while the other classes and lunches helps the junior developers to level up.  Podium recently sponsored ElixirConf and send a big crowd to a few different conferences every year. Travis explains the value of the conference is not only in the education received by the engineers who get to go. At Podium, the engineers who go to the conferences then come back and present what they learned at the conference, sharing what they think Podium could apply to their stack. This makes the conferences valuable to the entire team.  The last topic the panel discusses in the episode is the CI at Podium. The panel explains that most of the feedback for a new developer should be coming from the CI. Travis explains how the CI is set up. When he started they were using Github and has moved to Gitlab. They use credo checks, unit tests, sobelow, and dialyzer.  The panel asks about Elixir formatter and how they check format in the CI. Travis explains what he likes about credo and gives tips for running it. The panel has Travis introduces sobelow and what it does for Podium. Dialyzer is considered by the panel, they explain the trade-off of using dialyzer while sharing times that it had saved their bacon. Panelists

• Mark Ericksen
• Eric Oestrich
• Michael Ries

Guest

• Travis Elnicky

Sponsors  

• Sentry– use the code “devchat” for two months free on Sentry’s small plan
• Sustain Our Software
• Views on Vue
• CacheFly

Links

• Two Years of Elixir at Podium: Thoughts
• https://www.podium.com/ 
• http://pages.plataformatec.com.br/elixir-development-subscription 
• https://docs.gitlab.com/ee/ci/ 
• https://github.com/rrrene/credo/ 
• https://github.com/nccgroup/sobelow 
• https://hex.pm/packages/dialyxir 
• https://hexdocs.pm/mix/master/Mix.Tasks.Format.html 
• https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/calendar.ex
• https://github.com/jeremyjh/dialyxir#explanations 
• https://www.linkedin.com/in/travis-elnicky-4a3b2844/
• https://twitter.com/_elnicky
• https://twitter.com/podium_eng?lang=en
• https://www.facebook.com/Elixir-Mix 
• https://twitter.com/elixir_mix

Picks Mark Ericksen:

• https://thinkingelixir.com/ 

Eric Oestrich:

• Links Awakening 

Michael Ries:

• Hacktoberfest
• https://nats.io/ 

Travis Elnicky:

• Designing Elixir Systems with OTP 
• https://www.acquired.fm/

Special Guest: Travis Elnicky.

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

In this week’s episode of Elixir Mix the panel interviews Chris Keathley about Norm and his recent talk at ElixirConf. Chris is currently working at Bleacher Report, working mostly on backend systems. The panel starts by complimenting his presentation skills and asking him about his dislike for dialyzer.    Chris share the many problems he has with dialyzer. Dialyzer takes a lot of time and has crappy ergonomics. While it tells you a lot about an Erlang system that benefit doesn’t extend to Elixir systems. Neither doesn’t understand protocols. Mostly he feels that most type algebras don’t allow for growth, making changes and making the breaking changes. Explaining that type systems all have their costs and benefits, he feels that you don’t see the benefits of dialyzer until your system is up and running.   The panel wonders about Norm, a library written by Chris. Chris explains what it is and what its aims are. He wrote the library to solve some of the problems seen with dialyzer and other problems he was having at work. It is mostly for validating data. He wanted to be able to put checks in where ever he wanted and to make it very hard to break systems. Norm lets you describe data in your system, by taking an arbitrary predicate and making it into a spec. Chris explains how this works and how it will not make any changes until you tell it to. He shares some of the other features offered by Norm.    The sweet spot for using Norm is the next subject broached by the panel. Chirs explains that Norm fits well into the boundaries of systems, this is the most obvious place and the best place to start. The least intuitive way Chris has used Norm is to specify the options you need to pass to gen servers. He explains that it is not the most obvious use for Norm but it has been really helpful with the API.   Next, the panel asks about changesets and how that works with Norm. Chris explains that changesets are very specific while Norm allows more freedom. The biggest difference between the two is that Norm won’t do casting for you. They intentionally built Norm that way because of the way Bleacher Report uses string and atom keys.    In his talk, Chris explains the concept of design by contract. It means that for every function that you have you can specify preconditions and postconditions. Preconditions are things that have to be true prior to calling the function. Postconditions are things that have to be true after the functions been called. Right now Norm doesn’t provide preconditions and postconditions which provides a way to avoid some of the more expensive costs in production.   Chris uses Norm in all his opensource projects and in projects at work. He shares the benefits he has seen. He believes that most systems will see benefits from Norm if they have room to grow. In his experience, every time they run into something new and think they may need to expand or change Norm, they find that Norm already has everything they need. Chris asks listeners who want to help contribute to Norm to try it out and to give him feedback. Panelists

• Mark Ericksen
• Eric Oestrich
• Josh Adams

Guest

• Chris Keathley

Sponsors  

• Sentry– use the code “devchat” for two months free on Sentry’s small plan
• Adventures in Blockchain
• React Round Up
• CacheFly

Links

• ElixirConf 2019 - Contracts for Building Reliable Systems - Chris Keathley
• https://github.com/keathley/norm
• EMx 040: Elixir Outlaws and Adopting Elixir with Chris Keathley
• EMx 003: Chris Keathley
• https://keathley.io 
• https://twitter.com/chriskeathley?lang=en
• https://elixiroutlaws.com/ 
• https://en.wikipedia.org/wiki/Design_by_contract 
• https://www.facebook.com/Elixir-Mix 
• https://twitter.com/elixir_mix

Picks Mark Ericksen:

• zFRAG 

Eric Oestrich:

• War Machine 

Josh Adams:

• "Unison: a new distributed programming language" by Paul Chiusano
• https://github.com/unisonweb/unison 

Chris Keathley:

• Daniels' Running Formula 

Special Guest: Chris Keathley.

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.

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

Special Guest: Jon Carstens.

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

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 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

• 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

Special Guest: Frank Hunleth.

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become 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 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/ 

Special Guest: John Mertens.

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.