Home

Popular Podcasts

Latest Podcasts

Latest Episodes

Latest AI-processed

Categories

Setting
Elixir Mix
Technology
Business
Charles M Wood
Join 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.
Total 281 episodes
1234
5
6
Go to
EMx 081: Discussing Deployment
EMx 081: Discussing Deployment
In this episode of Elixir Mix the panel has a conversation about a few things they have been thinking about. First, they shout out to anyone who would love to chat about config change callbacks. Then they dive into deployment discussing the updates that have happened this year. They share their experiences with the changes and compare the Elixir release to Distillery.  There are many options for deployment and they discuss some of the ones they have used. They consider services and do it yourself options. The panel shares lessons learned through their deployment experiences and give pro-tips for beginners and those new to Elixir.  The next topic they discuss is hot code reload. Michael shares his fascination with this practice and explains what it is. The panel discusses the possibilities and use-cases for hot code reload. Hot code upgrade is also discussed.  Panelists Mark Ericksen Michael Ries Eric Oestrich Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Links grapevine  Deploying with Docker  https://hexdocs.pm/phoenix/heroku.html  https://www.heroku.com/  https://cloud.google.com/kubernetes-engine/  https://www.ansible.com/  https://gigalixir.com/  deploy.sh  Running migrations  release_tasks.ex  Configuration and releases  mix release  observer_cli  Erlang: The Movie  Using Erlang Distribution to test hardware  The Athens Affair  ElixirConf 2018 - Docker and OTP Friends or Foes - Daniel Azuma  Richard Carlsson - The art of the live upgrade - 10 yrs of evolving a live system | Code BEAM SF 19  https://www.facebook.com/Elixir-Mix  https://twitter.com/elixir_mix Picks Mark Ericksen: Hot Rod   Install Elixir using asdf  Michael Ries: https://twitter.com/fhunleth/status/1195524113617637376  scenic sensor  Eric Oestrich: Elixir Wizards  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.
51:3610/12/2019
EMx 080: The Big Elixir Favorites
EMx 080: The Big Elixir Favorites
In this episode of Elixir Mix the panel syncs up by discussing The Big Elixir Conference, their favorite talks and what they are working on. The first talk they discuss is Scott Southworth’s talk about medical messaging and the impressive work he does with the HL7 parser.  Next, they discuss Ben Church’s talk about business logic where he talks about leex and yecc. The panel discusses leex, yeccs and their own work with parsers. Cory O’Daniel’s talk on Kubereneters the panel found particularly funny and interesting. Elixir Mix’s very own Eric Oestrich was the keynote speaker at the talk, he summarizes his talk for the panel.The Live View talk given by Sophie DeBenedetto is discussed as well and the panel shares their biggest take away from the talk.    The panel discusses a little of what they have been working on. They ask Eric about his Ponchbrella project. He explains what it is and how it works. Using this hybrid of poncho and umbrella projects for grapevine made more sense to him. He invites everyone to take a look as grapevine is open source. The episode ends as the panel praises Elixir’s flexibility and other great qualities.  Panelists Mark Ericksen Josh Adams Eric Oestrich Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan ElixirCasts | Get 10% off with the promo code "elixirmix"CacheFly Links https://www.thebigelixir.com/  https://hexdocs.pm/elixir_hl7/HL7.Query.html  https://github.com/HCA-Healthcare/elixir-hl7  http://erlang.org/doc/man/leex.html  http://erlang.org/doc/man/yecc.html  https://github.com/ympons/expreso  RegEx match open tags except XHTML self-contained tags  https://github.com/elm/parser  Wilford Brimley On His Diabetes - Original Video  Wilford Brimley Diabeetus Remix  https://twitter.com/knewter/status/1192831261624164352  https://github.com/oestrich/grapevine/tree/master/apps  https://www.facebook.com/Elixir-Mix  https://twitter.com/elixir_mix Picks Mark Ericksen: https://github.com/elixir-lang/elixir/releases/tag/v1.9.3  Josh Adams: https://jenkins-x.io/  Eric Oestrich: https://podcast.smartlogic.io/ 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.
31:3703/12/2019
EMx 079: Oban with Parker Selbert
EMx 079: Oban with Parker Selbert
In this episode of Elixir Mix the panel interviews Parker Selbert. Parker lives in Chicago and runs a consultancy with his wife. He joins the panel to discuss a library that he wrote, Oban. Parker starts by explaining what Oban is and why he wrote it. Oban is a way to run reliable background jobs by persisting them in the database. Oban is akin to Sidekick, Parker explains, he wanted something similar to Sidekick for Elixir. He made a few improvements including moving it to Postgres from Redis. He shares the common problems found using Redis and how easy Postgres was to use for this library.  The panel asks Parker about his Oban Recipes. Parker explains why he wrote the recipes and what some of them contain. After releasing Oban he received many questions asking about how to use Oban. Parker took the most common questions and wrote 7 blog post outlining how to use Oban.  Parker shares his favorite features found in Oban and walks the panel through its architecture. The panel asks him about the maturity and usage of the library. Parker tells them that the usage has been steadily climbing. The episode ends with the panel discussing the Oban UI and how it works.   Panelists Mark Ericksen Josh Adams Eric Oestrich Guest Parker Selbert Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan ElixirCasts | Get 10% off with the promo code "elixirmix"CacheFly Links https://github.com/sorentwo/obanhttps://oban.dev/Oban Recipes Part 1: Unique JobsOban Recipes Part 2: Recursive JobsOban Recipes Part 3: Reliable SchedulingOban Recipes Part 4: Reporting ProgressOban Recipes Part 5: Batch JobsOban Recipes Part 6: Expected FailuresOban Recipes Part 7: Splitting QueuesOban — Reliable and Observable Job ProcessingOban UI: Private BetaGithub Starts Won’t Pay Your Renthttps://twitter.com/sorentwo?lang=enSeven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages  https://github.com/sorentwo/kiq  https://www.postgresql.org/docs/current/sql-notify.html  https://www.postgresql.org/docs/current/sql-listen.html  https://www.postgresql.org/docs/9.5/sql-select.html  https://www.postgresql.org/docs/9.4/explicit-locking.html  https://github.com/sorentwo/oban/blob/master/lib/oban/pruner.ex  https://github.com/elixirs/faker  https://oban.dev/#sign-up  https://www.facebook.com/Elixir-Mix  https://twitter.com/elixir_mix Picks Mark Ericksen: https://twitter.com/CodeWisdom/status/1189602991701184512  Josh Adams: How to write a commit message Eric Oestrich: Godzilla: The Showa-Era Films, 1954–1975  Parker Selbert: The Rust Programming LanguageCopper Fox DistillerySpecial Guest: Parker Selbert. 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.
42:0026/11/2019
The MaxCoders Guide To Finding Your Dream Developer Job
The MaxCoders Guide To Finding Your Dream Developer Job
"The MaxCoders Guide to Finding Your Dream Developer Job" by Charles Max Wood is available on Amazon. Get your copy here today only for $2.99! 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.
14:3320/11/2019
EMx 078: Phoenix Phrenzy with Nathan Long
EMx 078: Phoenix Phrenzy with Nathan Long
In this episode of Elixir Mix the panel interviews  Nathan Long about Pheonix Phrenzy. Nathan explains what Pheonix Phrenzy is and what the contest is all about. The panel explains how exciting it is for everyone to see what Live View can really do. With all the submissions open-sourced, the consider what a great resource the submissions are for those learning to use Live View.  Nathan explains his motivations behind Pheonix Phrenzy. He explains what they learned from this contest and what they may do in future contests. Nathan shares how wonderful it was to work with everyone at Dockyard on Pheonix Phrenzy. He explains how the competition worked, the role of the VIP judges and how the site was designed to make the contest as fair as possible.  The top three submissions are shared, the panel is impressed by how different each of the projects are. Nathan shares all the amazing things developers get when they use Live View. The panel considers when to use Live View. The episode finishes as Nathan shares what he would like to see in the future versions of Live View. Panelists Mark Ericksen Josh Adams Michael Ries Guest Nathan Long Sponsors   Sentry– use the code “devchat” for two months free on Sentry’s small plan ElixirCasts | Get 10% off with the promo code "elixirmix"My Angular StoryCacheFly Links https://phoenixphrenzy.com/resultshttps://twitter.com/sleeplessgeekhttp://nathanmlong.com/blog/Ranking Programming Languages by GitHub Users   GOTO 2019 • The Soul of Erlang and Elixir • Saša Jurić  https://twitter.com/ScenicFramework/status/1189646397147992064  https://hexdocs.pm/scenic/Scenic.Components.html  https://www.facebook.com/Elixir-Mix  https://twitter.com/elixir_mix Picks Mark Ericksen: https://alicevision.org/  https://github.com/alicevision/meshroom  Josh Adams: Jesus is King by Kanye West  Michael Ries: Scenic Components Nathan Long: https://apps.ankiweb.net/https://www.owasp.org/index.php/SameSite  Special Guest: Nathan Long. 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.
52:4619/11/2019
EMx 077: Elixir at PepsiCo eCommerce with Jason Fertel
EMx 077: Elixir at PepsiCo eCommerce with Jason Fertel
In this episode of Elixir Mix the panel interviews Jason Fertel who runs the marketing automation team at PepsiCo eCommerce. Jason shares the story of bringing Elixir to PepsiCo eCommerce and explains how it became their go-to for application development.   Jason explains what they do at PepsiCo eCommerce. They build software to optimize everything from supply chain to marketing and sales for big companies in eCommerce like Amazon.com and InstaCart. He explains the difference between what they do at PepsiCo eCommerce and other CPG’s.  The panel asks Jason about what Elixir has brought to the table at PepsiCo eCommerce. He explains why he chose Elixir when he started out as a one-man development team. Elixir is powerful, straight forward and easy to learn. It is efficient and has everything you need out of the box. Jason shares how using Elixir has also had a positive effect on hiring. The panel considers how using Elixir has benefitted hiring at their companies as well.  The episode ends with Jason outlining their stack and sharing the tools they are using. He also overviews some of the projects they are working on, including sales and marketing automation, end to end supply chain optimization and something exploratory with IoT. They try to foster a culture of exploration and innovation at PepsiCo eCommerce and Jason talks about a Nerves project they are working on to alert consumers when it is time to purchase more snacks.  Panelists Mark Ericksen Michael Ries Guest Jason Fertel Sponsors   Sentry | use the code “devchat” for two months free on Sentry’s small plan ElixirCasts | Get 10% off with the promo code "elixirmix"CacheFly ________________________________________________________________________________________________________________________ "The MaxCoders Guide to Finding Your Dream Developer Job" by Charles Max Wood will be out on November 20th on Amazon.  Get your copy on that date only for $1. ________________________________________________________________________________________________________________________ Links https://www.scaledagileframework.com/  https://www.erlang-solutions.com/  https://elixir-lang.org/getting-started/mix-otp/dependencies-and-umbrella-projects.html  https://github.com/absinthe-graphql/absinthe  https://druid.apache.org/  https://nerves-project.org/  https://beagleboard.org/bone  https://www.keycon.info/https://twitter.com/Fertel  https://www.pepsicojobs.com/main/jobs?keywords=elixir&page=1  https://twitter.com/fertelhttps://github.com/fertelhttps://www.facebook.com/Elixir-Mix  https://twitter.com/elixir_mix Picks Mark Ericksen: https://thinkingelixir.com/elixir-in-vs-code/  Michael Ries: https://github.com/boydm/scenic  Spiff  Jason Fertel: http://hilolife.com/  https://maivino.com/savethepinot   Special Guest: Jason Fertel. 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.
44:1912/11/2019
EMx 076: MUD Development and Grapevine
EMx 076: MUD Development and Grapevine
On this episode of Elixir Mix the panelists interview Eric Oestrich, one of the regular panelists for the show. Eric is a developer at SmartLogic where he works with Elixir and recently has been working with deployments. He has a project called Grapevine which is similar to steam but for text games. Mark opens up the discussion by asking Eric to talk about his game ExVenture which is a MUD game. MUD stands for multi user dungeon and ExVenture is a multi user version of a text adventure game from 1978 called Dungeon. He shares more details of the game and how it’s played. Erit explains that Grapevine was spawned from ExVenture and Mark asks him to expound more on Grapevine.  ExVenture is open source and it is an application that is currently running in production. This provides opportunity for those not interested in making or playing a MUD to get involved and work on a project. Eric also goes into detail about the livestreaming he does and how to get involved. Since the project is open source, Eric is able to do development live, on screen and this allows the viewer to see the development process first hand and watch Eric work through challenges in the code. The topic then shifts to some of the features that are in Grapevine. Eric details some of the OTP style concepts used, the types of servers used and how they’re used, and how telnet sessions are maintained for connecting. The Elixir Mix panelists also discuss how this application is deployed. The application is on DigitalOcean with 2 dedicated cores and he uses Docker to build the releases. Eric also explains how he uses scripting with his releases and how his deployments work. The panelists also discuss how Eric is using Docker for releases but not on the server and why he’s doing deployments the way he is. The last topic covered by the elixir experts is statistics. They cover the metrics section in Grapevine, how he uses Telemetry events, and other methods he uses to gather metrics Panelists Mark Ericksen Josh Adams Erik Oestrich Sponsors Sentry | Use code “devchat” for two months free on Sentry’s small plan.  ElixirCasts | Get 10% off with the promo code "elixirmix" Links SmartLogicPhoenixErlangMUDGrapevineExVentureTelemetrySmartlogicTv TwitchSmartlogicTv YoutubeLocal Clusters with epmd by Erik OestrichEPMD man pageHello, productionGrapevine StatsGrapevine Metrics GithubEric Oestrich TwitterEric Oestrich GrapevineEric Oestrich GithubDockerDigitalOcean Picks Josh Adams Radiohead Glastonbury FestivalLinux of 2000 article Mark Ericksen TheOatmeal Comic: Running Eric Oestrich Squabble Playing the violin and cello   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.
36:2605/11/2019
EMx 075: Live View Implementation With Jeff Kreeftmeijer
EMx 075: Live View Implementation With Jeff Kreeftmeijer
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.comLive View articleComputers and GoBuilding the Go Game in Elixir: Time Travel and the Ko RuleMultiplayer Go with Elixir’s Registry, PubSub and Dynamic SupervisorsDynamic SupervisorPubSubHayago GithubGenServerFunctional Web Development With Elixir, OTP, and PhoenixAsciiquariumTerminal AsciiquariumThe NeuroEvolution of Augmenting Topologies User PageThe NeuroEvolution of Augmenting TopologiesJeff Kreeftmeijer TwitterJeff Kreeftmeijer.com   Picks Josh Adams Haskell Parser Eric Oestrich Dragon Quest 11Wingspan Michael Ries Fireball IslandObserver CLI   Mark Ericksen Acquired   Jeff Kreeftmeijer Go (game)Mansions of MadnessAlphago DocumentarySpecial Guest: Jeff Kreeftmeijer. 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.
34:2429/10/2019
EMx 074: Inky Displays With Lars Wikman and Emilio Nyaray
EMx 074: Inky Displays With Lars Wikman and Emilio Nyaray
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 .NETRuby Rogues Links Lars’ writing on InkyNervesE-Ink Inky pHATInky wHATRaspberry PieArduinoElixir Forum E-Ink DisplayPhoenixElixir CircuitsMysensors.orgConnor Rigby GithubInstinct.vetOpensoundcontrol.orgJoe Arms Controlling Sound With OSCCodesync.globalBoyd Multerer GithubErlang eprof documentationErlang fprof documentationErlang cprof documentationEflame GithubLars Wikman: @lawik on twitterEmilio Nyaray: @nyaray on twitterEmilio Nyaray Github   Picks Josh Adams autofsKodi.tv Michael Ries Jehu Garcia youtube Mark Ericksen FizzBuzz Enterprise EditionLogitech G29 Driving Force   Lars Wikman Scenic Layout-O-MaticNerves Input Event LibrarySpecial Guests: Emilio Nyaray and Lars Wikman. 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.
52:5422/10/2019
EMx 073: Application Monitoring Using Telemetry With Arkadiusz Gil
EMx 073: Application Monitoring Using Telemetry With Arkadiusz Gil
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.ioAdventures in DevOpsAdventures in Angular   Links Erlang SolutionsObservability Working GroupErlang Ecosystem FoundationErlang TelemetryTelemetry.MetricsAWS CloudWatch EventsProgramming ElixirOpenCensusOpenTelemetryOpenTelemetry.ioOpenTracingarkgil on GitHub Exometer - Erlang Implementation PackagePrometheus.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 CodePhilosophy of Software DesignThe Anatomy of NextSpecial Guest: Arkadiusz Gil. 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.
40:4015/10/2019
EMx 072: People-Centered Solutions with Travis Elnicky
EMx 072: People-Centered Solutions with Travis Elnicky
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 SoftwareViews on VueCacheFly Links Two Years of Elixir at Podium: Thoughtshttps://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.exhttps://github.com/jeremyjh/dialyxir#explanations  https://www.linkedin.com/in/travis-elnicky-4a3b2844/https://twitter.com/_elnickyhttps://twitter.com/podium_eng?lang=enhttps://www.facebook.com/Elixir-Mix  https://twitter.com/elixir_mix Picks Mark Ericksen: https://thinkingelixir.com/  Eric Oestrich: Links Awakening  Michael Ries: Hacktoberfesthttps://nats.io/  Travis Elnicky: Designing Elixir Systems with OTP  https://www.acquired.fm/ Special Guest: Travis Elnicky. 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.
48:0108/10/2019
EMx 071: The Problem with Dialyzer with Chris Keathley
EMx 071: The Problem with Dialyzer with Chris Keathley
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 BlockchainReact Round UpCacheFly Links ElixirConf 2019 - Contracts for Building Reliable Systems - Chris Keathleyhttps://github.com/keathley/normEMx 040: Elixir Outlaws and Adopting Elixir with Chris KeathleyEMx 003: Chris Keathleyhttps://keathley.io  https://twitter.com/chriskeathley?lang=enhttps://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 Chiusanohttps://github.com/unisonweb/unison  Chris Keathley: Daniels' Running Formula  Special Guest: Chris Keathley. 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.
47:4001/10/2019
EMx 070: Home Automation Using Radio Frequencies with Jon Carstens
EMx 070: Home Automation Using Radio Frequencies with Jon Carstens
In this episode of Elixir Mix the panel interviews Jon Carstens about his work with Nerves. Michael Ries gives a little background on Jon, as they have worked together and Jon helps run the remote nerves meet up that Michael attends.  Jon recently started working with Frank Hunleth at Smart Rent. Jon tells the panel what an adventure it is working at Smart Rent.   The panel asks Jon about the parts of the Nerves ecosystem he has been working in. He explains how he has been working with NervesHub to manage collections or groups of devices. He has also been working with ShoeHorn controlling app start order and erlang heart stop module. Making sure that they can remote reboot devices.    Jon talks more about what Smart Rent does. He explains that there are lots of brands and types of smart home devices, not all of which can connect to the internet. At Smart Rent, they connect various brands and devices using their own custom-built hub. Smart Rent has many benefits tenants and even more for property managers. Property managers can use Smart Rent to manage vacant properties, monitor for leaks, break-ins, fire, and dangerous temperatures. They can even set up open houses remotely, changing the temperature to comfortable levels, turning on and off lights, and unlocking and locking the doors for walkthroughs of the properties.    Justin Schneck gave a keynote at ElixirConf 2019 where he showed of an IEX console Nerves device. The panel asks Jon about his role in building the devices. Jon explains how he was tasked with the project. He explains how the console works using an IO. The hardest part, Jon explains, was getting the ASCII characters right. He spent hours working on it, he shares the libraries and tools he used to help him get it right.    The panel asks how the IEX server sessions work. Jon explains what would happen if you tried to SSH into an IEX session running through NervesHub on a device and other examples of how it all works. The panel discusses the benefits of debugging devices using the IEX console. Jon explains that it has been extremely beneficial in debugging remote devices.    While the IEX console is very useful, Jon warns that it is not very pretty. The IEX console was designed by backend developers and he points out some of the things that could use a little love. The panel asks about contributing to this project and invites listeners to contribute on the Nerves GitHub pages.     To finish, the panel asks Jon about his lightning talk. Jon launches into the story of his at-home Nerves projects. It all started when they replaced their old ceiling fan for one with a remote. The problem was that the frustrating design coupled with his remote thieving kids, the fan became an annoyance, to say the least.    Jon discovered that the remote-operated using a radio frequency. He learned all he could about radio frequencies and how they worked. He warns listeners not to broadcast radio frequencies to far from their homes because there will be legal ramifications. Using a raspberry pi and a jumper cable, Jon built a device that now controls all devices in his home that operate using radio frequencies. He shares the tools he used to record the frequencies from the remotes and the library he built of the frequencies. Jon shares his dream of running all remote-controlled devices either through his phone or his voice. His next project is infrared. Panelists Mark Ericksen Eric Oestrich Michael Ries Guest Jon Carstens Sponsors   Sentry– use the code “devchat” for two months free on Sentry’s small plan Adventures in 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.
38:0924/09/2019
EMx 069: Distributed Databases with Wiebe-Marten ("Marten") Wijnja
EMx 069: Distributed Databases with Wiebe-Marten ("Marten") Wijnja
Episode Summary   In this week’s episode of Elixir Mix the panel follows up with Wiebe-Marten ("Marten") Wijnja about his talk at Elixir Conf EU, where he spoke about the distributed system his team was working on.    They start by discussing the eight fallacies of distributed computing that Marten talked about in talk. He lays out a couple of the fallacies and invites listeners to watch his talk for all eight. Marten explains that these fallacies most commonly happen to developers who are used to working with a single system. The panel discusses how to be mindful of these mistakes and how developers take for granted of how easy one system is to use.    Marten gives some tool recommendations to help with these fallacies. TLA+ is a small programming language that lets the developer describe their system and it will point out when something is wrong but it works purely on concepts. Erlang quick check implementation is also a tool that will help combat these problems. The last suggestion which was given by the panel is a library called comcast on github that will simulate poor network connections so the developer can see how the system runs on a poor connection.    Marten describes the byzantine problem. Two nodes or generals are trying to agree on something but communication keeps failing. The various outcomes are considered and Mark Ericksen gives an additional example of he and Josh Adams trying to connect to record a podcast, and how the miscommunication could change the outcome. This is a big problem that complicates using a distributed system.    The panel discussed CRDT’s and how they are a better way for nodes to sync up. Marten gives a very simple example of a CRDT as a counter. The panel discusses when to use CRDT’s and when not too. Marten explains what questions to ask before using CRDT’s.    Another way of solving the byzantine problem is by connecting the nodes. The panel discusses the tools they use to connect their nodes. Partisan is one tool, instead of connecting all nodes, each node connects to a specific number of nodes. That way if one node goes down the whole system doesn’t stop, while at the same time not, overwhelming the nodes. Libcluster, another tool, uses Kubernetes and has multiple strategies for connecting nodes so developers can choose the right one for their system.     The panel asks Marten about multicall and abcast. Marten explains that these tools help one node talk to all the other nodes in a cluster, and multicall will gather the results. Multicall also tells the developer which nodes failed to respond to the request. Mark shares an example of using these tools to effectively communicate between gen servers.    In Marten’s talk, he described four distributed databases. The panel asks Marten to talk about each one of them. The first one is mnesia. Marten talks about his first experience with Mnesia and how he thought it was amazing. He soon realized while it is still a great tool it also has its quirks.    He explains that each of these databases has its own quirks. Mnesia doesn't do conflict resolution, that along with a few other things the developer will need to build themselves. This can be a good and bad thing because developers can customize the database to their needs but it’s not ready out of the box. Mark explains the use cases mnesia is good for and even references the mnesia documentation.     Cassandra is the next database Marten describes. Cassandra is the database discord uses. Cassandra does not let developers control their own conflict resolution. It always uses the latest time-stamp and with nodes that can be confusing.    Couchdb is another database they discuss. Again, couchdb is also not made to deal with conflicts. It will either solve them randomly or the developer can opt into resolving it themselves. The panel discusses times when this is useful, such as when connectivity is intermittent.    Riak is the final database and the one Marten’s team chose for their distributed system project. Riak was written in Erlang and is a key-value store and uses CRDT’s. It uses a CRDT conflict resolution. Marten shares his experience using Riak. The panel considers Riak’s history and need for some love.     Marten gives an update on planga, the chat application they were building the distributed system for. Marten explains that during the talk they were in the middle of development. He shares the story of why they wanted a distributed system for this chat application. The client they were doing it for wanted to do video streaming but pulled out in the end. When the client no longer needed the video streaming solution they stopped building the distributed system. Marten is still hopeful they will go back and finish it.    To end the episode Marten shares his programming journey. He started programming at age nine. At age 12 he started doing professional web development. After a few years of that, he started doing some frontend work in JavaScript. Once that got old, bitcoin was getting big so he and some friends got into that. Finally, he got a job doing backend work with Ruby while at university. When he heard about Elixir he was so excited he learned the basics in one weekend and has loved it ever since.  Panelists - Mark Ericksen - Josh Adams Guest - Wiebe-Marten ("Marten") Wijnja Sponsors   - 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.
01:14:2217/09/2019
EMx 068: Contributing to the Elixir Community with David Bernheisel & Cory Schmitt
EMx 068: Contributing to the Elixir Community with David Bernheisel & Cory Schmitt
Episode Summary In this week’s episode of Elixir Mix the panel is joined by David Bernheisel and Cory Schmitt, from Taxjar,  to discuss the different ways developers can contribute to the community. The first way to contribute to the Elixir community is contributing to the Elixir core code. While David shares a little of his background, he shares his first experience contributing to the elixir code by submitting a pull request about asdf. The panel all thanking him for his contribution.    The next form of contributing the panel discusses is open-sourcing projects. Cory and David share their experience getting their date-time parser open-sourced. They express gratitude at the support they received from Taxjar at open-sourcing the project.    Before moving on to the next way to contribute the panel stops for a moment to ask Cory and David about their date-time parser. David and Cory explain why they decided to build a date-time parser after finding a problem in Timex and other time libraries. They talk about their first attempt at the parser and explains that it was a disaster.    The panel expresses their interest in nimble parsec and asks our guests to share their experience using this library. Cory and David explain that it was easy to use and a little slower than libraries found in other languages but still fast enough for production. They go into more detail of what it was like to code in nimble parsec and give tips for optimizing performance with the library.   The panel asks about future plans for the date-time parser. David and Cory explain what cereal time is and how it will soon be usable in the parser. The most interesting things they learned while building the parser are listed including some of the surprising results they got while testing the library. They also talk about the difficulty of time zone math and other problems with programming for time zones.    The panel moves on to the next way you can contribute to the Elixir community is through running and attending meetups. The panel shares the places and types of meetups they run. Trying to prepare future meetup hosts, the panel shares their experiences starting up or taking over meetups, explaining what they need to know. Such as, not everyone that attends a meetup is going to be as hyped up about the language as you. Also, meetups are about building relationships and connections just as much as it is learning and sharing.    Still talking about meetups, the panel gives tips to both the host and the members. To the hosts,  they give ideas on how to run their meetups, such as project nights, lightning talks. They explain that a lot of the people coming to the meetups will be new to Elixir and warns not to dive too deep into the code and lose them. Instead, the panel recommends recruiting the developers new to Elixir that still have all their enthusiasm for the language to help you run the meetups. Another recommendation is to vary the depth and range of the topics, that way you can maintain the interest of your members. The panel talks about the financial part of running a meetup and advises hosts to find a good notification service and a sponsor.    Speaking to meetup members, the panel reminds them that just by attending meetups they are contributing to the Elixir community. By going they make connections, share ideas and grow as developers in that community. The advice they give to members is to find ways to get more involved, explaining that no meetup host is going to turn down a willing speaker or a helping hand. They also discuss encouraging a comfortable environment and helping other members feel welcome in the community.    The final form of contributing the panel discusses is attending and speaking at conferences. The panel shares their excitement for the upcoming Elixir Conf. They also discuss the value of smaller regional conferences that may be easier to attend. At regional conferences, it can be easier to connect with others since there is a smaller crowd. Also, a singletrack style conference may encourage you to attend talks you normally wouldn’t choose, allowing you to discover new and exciting technologies. The panel explains how the number of conferences has grown over the years giving more opportunities to both attend and speak. They encourage all developers to go to conferences often.   Panelists - Mark Ericksen - Michael Ries - Josh Adams Guest - David Bernheisel - Cory Schmitt Sponsors   - 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.
01:11:4710/09/2019
EMx 067: What's New with Nerves with Frank Hunleth
EMx 067: What's New with Nerves with Frank Hunleth
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan GitLab | Get 30% off tickets with the promo code: DEVCHATCOMMIT My Ruby 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.
01:17:3403/09/2019
EMx 066: Going with the Flow with John Mertens
EMx 066: Going with the Flow with John Mertens
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan GitLab | Get 30% off tickets with the promo code: DEVCHATCOMMIT My Ruby 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.
01:08:0527/08/2019
EMx 065: The Life Cycle of Elixir
EMx 065: The Life Cycle of Elixir
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.
54:2020/08/2019
EMx 064: Refactoring Elixir with Hubert Lepicki
EMx 064: Refactoring Elixir with Hubert Lepicki
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Panel Mark Ericksen Josh Adams Joined by Special Guests: Hubert Łępicki Summary Hubert Łępicki joins the panel to discuss his blog post, “Refactoring Phoenix controllers”; he starts by sharing what made him decide to write this article. In the blog post, he outlines strategies and patterns to better organize your code. The first strategy discussed, which was not mentioned in the blog post is: Breaking down one controller into multiple controllers. Intrigued, the panel asks Hubert to explain exactly what he means by this. The second pattern is: extracting logic from a controller and using it in a plug instead. The panel discusses what the right code to put in a plug.    The third pattern Hubert explains is: using business logic and workflow modules. The panel asks Hubert about his dislike for phoenix context. Hubert and the panel give better alternatives to phoenix controller and explains how they use modules. Having a Ruby background, Hubert explains the difference of using context and modules in Elixir compared to Ruby. Hubert shares how he uses the fourth pattern: Ecto using embedded schema. The episode ends with a little about Hubert's company and what they do.  Links https://www.amberbit.com/blog/2019/6/29/refactoring-phoenix-controllers/https://pcpartpicker.com/list/t7LBNQ  https://www.techradar.com/sg/reviews/amd-ryzen-7-3700x  https://www.pcgamer.com/the-best-graphics-cards/  https://www.amberbit.com/blog/2019/6/29/refactoring-phoenix-controllers/  https://github.com/elixir-plug/plug  https://twitter.com/hubertlepicki/status/1156179338779385856  https://brainlid.org/elixir/2017/09/24/elixir-processes-and-state-abuse.html  https://github.com/absinthe-graphql/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.
01:01:4813/08/2019
EMx 063: Designing Elixir Systems With OTP with Bruce Tate and James Gray
EMx 063: Designing Elixir Systems With OTP with Bruce Tate and James Gray
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Panel Mark Ericksen Michael Ries Eric Oestrich Josh Adams Charles Max Wood Joined by Special Guests: Bruce Tate and James Gray Summary Bruce Tate and James Gray join the panel to discuss their new book, “Designing Elixir Systems With OTP”. Bruce and James share the story of how they decided to write this book together. The panel discusses the books target audience, Bruce and James explain that this is not for programmers who know nothing about Elixir. Resources and books for beginners to read are recommended. Bruce and James share many key points of the book and the main lesson they hope the reads come away with. The interesting mnemonic “Do Fun Things With Big Loud Wildebeests” is explained.   Bruce and James share what this book will do for your applications. They address common misunderstandings for people moving from object-oriented programming into functional programming. Bruce and James share what it was like working with each other to write this book. The episode ends with Bruce and James sharing the stories of how the came to the elixir community.   Links Designing Elixir Systems With OTP: Write Highly Scalable, Self-healing Software with Layers   https://en.wikipedia.org/wiki/Second-system_effect  https://devchat.tv/elixir-mix/emx-052-production-pitfall-pontification/  https://elixircards.co.uk/  Elixir in Action  https://elixirschool.com/en/  Programming Phoenix 1.4  GOTO 2019 • The Soul of Erlang and Elixir • Saša Jurić  Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages https://grox.io/  http://icanmakeitbetter.com/  https://twitter.com/redrapids  https://twitter.com/JEG2  https://www.facebook.com/Elixir-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.
01:23:2206/08/2019
EMx 062: Elixir v1.9 and Hex.pm with Wojtek Mach
EMx 062: Elixir v1.9 and Hex.pm with Wojtek Mach
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Panel Mark Ericksen Michael Ries Eric Oestrich Josh Adams Joined by Special Guest: Wojtek Mach Summary Wojtek Mach shares his experiences at Plataformatec; what his team is like and what types of projects they work on. The panel asks Wojtek about the announcement for hex.pm and how it works. Wojtek shares his language background and how he got into Elixir. The panel discusses Wojtek’s experience moving from a distillery release to a mixed based release. My SQL library for Ecto is considered and the panel discusses Wojtek past libraries.  Links https://github.com/elixir-ecto/myxql  https://github.com/plataformatec/broadway  https://github.com/hexpm/hexpm  https://github.com/hexpm/bob  https://repo.hex.pm/builds/elixir/builds.txt  https://github.com/asdf-vm/asdf  https://github.com/asdf-vm/asdf-elixir  https://bobs-list.kobrakai.de/  https://hexdocs.pm/ecto_sql/Ecto.Migrator.html#with_repo/3  https://hexdocs.pm/mix/Mix.Tasks.Release.html  https://github.com/xerions/mariaex  https://github.com/elixir-ecto/myxql  https://github.com/elixir-ecto/postgrex  https://github.com/elixir-ecto/myxql/blob/master/MARIAEX_COMPATIBILITY.md  José Valim - KEYNOTE: Announcing Broadway | Code BEAM SF 19  https://github.com/plataformatec/broadway/pull/91  https://github.com/elixir-ecto/myxql/blob/master/test/test_helper.exs#L218-L236  https://github.com/wojtekmach/oop  Lightning Talks - Wojtek Mach (ElixirConfEU 2016)  ElixirConf 2016 - Building Umbrella Project by Wojtek Mach  https://github.com/wojtekmach/acme_bank  https://github.com/hexpm/hexpm  https://github.com/hexpm/hexdocs  https://github.com/hexpm/hex/pull/698  https://github.com/hexpm/hex/pull/698  https://www.zdnet.com/article/backdoor-found-in-ruby-library-for-checking-for-strong-passwords/  https://twitter.com/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.
01:04:1630/07/2019
EMx 061: Mutation Testing in Elixir with Daniel Serrano
EMx 061: Mutation Testing in Elixir with Daniel Serrano
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Panel Mark Ericksen Eric Oestrich Joined by Special Guest: Daniel Serrano Summary Daniel Serrano explains what mutation testing is and how it works. The panel discusses the purpose and benefits of mutation testing. Daniel shares how mutation testing can fit into your process. The panel considers Daniel’s exunit deep dive and how this helped building exavier, his library. Daniel shares how he came up with the name exavier.    The panel asks Daniel about his experience load testing broadway. Daniel explains what broadway is and the benefits seen load testing it. Daniel shares how he got into distributed tracing and how it differs from tracing. Daniel tells the panel about his experience learning elixir and joining the community.  Links https://en.wikipedia.org/wiki/Mutation_testing  https://github.com/mbj/mutant  http://pitest.org/  https://github.com/dnlserrano/exavier  https://github.com/dnlserrano  https://dnlserrano.dev/2019/05/26/exunit-deep-dive.html  https://jmeter.apache.org/  https://twitter.com/brainlid  José Valim - Keynote: Announcing Brodway - ElixirConf EU 2019  https://github.com/plataformatec/broadway  https://aws.amazon.com/sqs/  https://opentracing.io/docs/overview/what-is-tracing/  https://github.com/spandex-project/spandex/  https://www.datadoghq.com/  https://aws.amazon.com/cloudwatch/  Daniel Serrano - From Noob to Contributing Noob - ElixirConf EU 2019  https://twitter.com/dnlserrano  https://dnlserrano.dev/https://www.facebook.com/Elixir-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.
54:5223/07/2019
EMx 060: Property-Based Testing, Dialyzer, & Inaka with Brujo Benavides
EMx 060: Property-Based Testing, Dialyzer, & Inaka with Brujo Benavides
Sponsors Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Panel Mark Ericksen Eric Oestrich Michael Ries Joined by Special Guest: Brujo Benavides Summary Brujo Benavides shares what he is working on right now and how his team feels about working in both Elixir and Erlang. He shares what his team has gotten out of using Elixir and what he thinks his team will get out of Elixir in the future. The panel discusses property-based testing and Fred Hebert’s book on property-based testing. Brujo shares use cases that would benefit from property-based testing and those that would benefit from unit testing. The panel considers dialyzer and shares their experiences using it in their code. Brujo explains how he chooses which tools to use for a project. Inaka is discussed; Brujo explains what they are all about and how to join. Upcoming conferences that Inaka is organizing is outlined and details on how to buy tickets are given.   Links EMx 031: Lessons from a Decade of Erlang with Brujo Benavides  https://elixir-lang.org/docs.html  EMx 047: Property Based Testing with PropEr and Fred HebertMy Take on Property-Based Testing for Erlang & Elixir  https://github.com/proper-testing/proper  Help Dialyzer Help You!http://erlang.org/doc/man/dialyzer.html  http://erlang.org/doc/man/dialyzer.html#gui-0  http://erlang.org/doc/apps/dialyzer/dialyzer_chapter.html#dialyzer_gui  Erlang Oddities - Brujo Benavides  https://github.com/inaka/elvis  https://hex.pm/packages/dialyxir  https://github.com/inaka  https://github.com/inaka/guidelines  https://spawnfest.github.io/  https://www.elixirconf.la/  https://twitter.com/elbrujohalcon  https://github.com/elbrujohalcon  https://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Mark Ericksen: https://www.destroyallsoftware.com/talks/wat  I am Mother  Eric Oestrich: https://grapevine.haus/  https://github.com/oestrich/telnet-elixir  Michael Ries: Foam board https://devchat.tv/elixir-mix/ Brujo Benavides: http://spawnedshelter.com/  http://artemis.cslab.ece.ntua.gr:8080/jspui/handle/123456789/15777 Special Guest: Brujo Benavides. 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.
01:08:0816/07/2019
EMx 059: Using Rust to Scale Elixir for 11 Million Concurrent Users with Matt Nowack
EMx 059: Using Rust to Scale Elixir for 11 Million Concurrent Users with Matt Nowack
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small plan CacheFly Panel Mark Ericksen Josh Adams Michael Ries Eric Oestrich Joined by Special Guests: Matt Nowack Summary Matt Nowack, a developer at Discord, gives an intro to Discord and shares its origin story. The panel discusses the problems that Discord was having because of its 11 million concurrent users. Matt talks about when they knew there was a problem, how they used a runtime VM to find the problem, the tools they tried to fix the problem and how they landed on NIFs to fix the problem. The panel discusses the risks of using NIFs and how using Rust helps negate that risk. Matt discusses the reference counter in the rustler package and answers questions about using dirty schedulers. Discord developers publish many blogs and publish many open source projects; Matt shares the Discord philosophy on open sourcing and contributing to the Elixir community.  Links https://github.com/discordapp/sorted_set_nifhttps://github.com/rusterlium/rustlerMatthew Nowack - ZenMonitor: Scaling Distributed Monitoring at Discord | Code BEAM SF 19https://en.wikipedia.org/wiki/Fates_Forever  http://erlang.org/doc/tutorial/nif.html  https://www.rust-lang.org/  https://blog.discordapp.com/using-rust-to-scale-elixir-for-11-million-concurrent-users-c6f19fc029d3  https://github.com/discordapp/sorted_set_nif  https://www.erlang-solutions.com/blog/a-guide-to-tracing-in-elixir.html  https://github.com/ferd/recon  https://discordapp.com/jobs  https://elixir-lang.org/blog/2019/06/24/elixir-v1-9-0-released/  https://github.com/ihumanablehttps://twitter.com/ihumanablehttps://www.facebook.com/Elixir-Mix  https://twitter.com/elixir_mix Picks Mark Ericksen: https://www.nps.gov/grca/planyourvisit/havasupai.htm  https://waterfallsofthegrandcanyon.com/havasu-falls/havasupai-waterfalls/  Josh Adams: https://sorbet.org/blog/2019/06/20/open-sourcing-sorbet Michael Ries: https://www.raspberrypi.org/products/raspberry-pi-4-model-b/  https://www.youtube.com/user/flitetest  Eric Oestrich: https://podcast.smartlogic.io/  Matt Nowack: http://discord.gg/elixir  https://www.destroyallsoftware.com/talks/boundaries  https://en.wikipedia.org/wiki/Halt_and_Catch_Fire_(TV_series) Special Guest: Matt Nowack. 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.
54:2809/07/2019
EMx 058: Mint library with Eric Meadows-Jönsson & Andrea Leopardi
EMx 058: Mint library with Eric Meadows-Jönsson & Andrea Leopardi
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small plan CacheFly Panel Mark Ericksen Josh Adams Michael Ries Joined by Special Guests: Eric Meadows-Jönsson & Andrea Leopardi Summary Eric Meadows-Jönsson and Andrea Leopardi, members of the Elixir core team discuss the upcoming Mint library. They tell the panel their experience working on the core team and on the Mint library. They explain what Mint is and why people should know about it. Mint doesn’t use processes; Eric and Andrea explain why and what that means for the library. The panel discusses the benefits of using Mint and the use cases it can be applied to. Eric and Andrea give an update on how Mint is coming and explains why mint is not part of Elixir core. The panel considers building an HTTP library; Eric and Andrea share their experience. Links http://erlang.org/doc/man/httpc.html  https://github.com/ericmj/castore  https://elixir-lang.org/blog/2019/02/25/mint-a-new-http-library-for-elixir/#safe-by-default-https  https://github.com/appcues/mojito  https://segment.com/blog/introducing-centrifuge/  https://github.com/hexpm/hex  https://github.com/ericmj/mint  https://hexdocs.pm/mint/api-reference.html  https://elixir-lang.org/blog/2019/02/25/mint-a-new-http-library-for-elixir/  https://twitter.com/inconvergent/status/1139070281971118085?s=19  https://twitter.com/emjii  https://twitter.com/whatyouhide  https://thewirecutter.com/reviews/best-sous-vide-gear/  https://www.facebook.com/Elixir-Mix  https://twitter.com/elixir_mix Picks Mark Ericksen: https://pragprog.com/book/phoenix14/programming-phoenix-1-4  - They added Chapter 14, “What’s Next?” In it we address LiveViewPubSub 2.0, adding “telemetry” information to Phoenix and other coming additions. Josh Adams: Meat https://inconvergent.net/2019/depth-of-field/  Michael Ries: Matthew Nowack - ZenMonitor: Scaling Distributed Monitoring at Discord | Code BEAM SF 19  My New Croissant Machine Is 3D-PRINTED !  Andrea Leopardi: https://github.com/whatyouhide/after8  https://github.com/appcues/mojito  https://mizage.com/shush/  Eric Meadows-Jönsson: https://inkdrop.app/https://pragprog.com/book/wmecto/programming-ectoSpecial Guests: Andrea Leopardi and Eric Meadows-Jönsson. 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.
01:01:5102/07/2019
EMx 057: The Elixir Community with Adolfo Neto
EMx 057: The Elixir Community with Adolfo Neto
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small plan Triplebyte offers a $1000 signing bonus CacheFly Panel Mark Ericksen Josh Adams Michael Ries Eric Oestrich Joined by Special Guest: Adolfo Neto Summary Adolfo Neto shares the background behind his Elixir Brazil 2019 talk. The panel discusses other talks of Elixir Brazil 2019, the organizing of the conference, and the diversity initiative. Adolfo shares his experience in the U.S., attending meetups for other programming languages, comparing them to Elixir. The panel considers the Elixir code formatter and gives protips for using it. The best way to teach Elixir and functional programming is considered; the panel shares experiences and resources for learning functional programming.   Links A Comunidade de Elixir, Adolfo Neto, Elixir Brasil 2019https://medium.com/@adolfont/elixir-brazil-2019-4de3fc06b18fhttps://twitter.com/clojure_conj?lang=enhttps://collaboration.csc.ncsu.edu/laurie/https://www.tripinfo.com/maps/NC-ResearchTriangle.htmhttps://www.meetup.com/elixircwb/https://twitter.com/elixir_brasilhttps://2019.elixirbrasil.com/https://www.eventials.com/locaweb/events/elixir-brasil/Introducing HDD: Hughes Driven Development - José Valim - Elixir Conf EU 2018https://github.com/phoenixframework/firenesthttps://github.com/phoenixframework/phoenix_pubsubhttps://ieeexplore.ieee.org/document/8116569https://en.wikipedia.org/wiki/ML_%28programming_language%29Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages (Pragmatic Programmers)https://elixirschool.com/en/https://github.com/nashfp/nashfp.github.com/wiki/erlang-schoolhttps://twitter.com/thompson_sihttps://github.com/erlware/erlang-camphttps://www.pluralsight.com/courses/meet-elixirhttps://codestool.coding-gnome.com/courses/elixir-for-programmershttps://github.com/lodash/lodashhttps://github.com/immutable-js/immutable-jshttps://hex.pm/packages/sorted_set_nifhttps://hex.pm/packages/rustlerhttps://twitter.com/TheErlef/status/1136705985442189312https://pragprog.com/book/cdc-elixir/learn-functional-programming-with-elixirhttps://twitter.com/adolfonthttps://twitter.com/elixir_mixhttps://www.facebook.com/Elixir-Mix Picks Mark Ericksen: Wintergatan - Marble Machine Josh Adams: https://blog.ploeh.dk/2017/10/04/from-design-patterns-to-category-theory/ Michael Ries: Using Rust to Scale Elixir for 11 Million Concurrent Users Eric Oestrich: Meetup Organizers Adolfo Neto: Aquarius   Kiss of the Spider Woman   City of GodLearn Functional Programming with Elixir: New Foundations for a New World (The Pragmatic Programmers) (English Edition)Special Guest: Adolfo Neto. 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.
01:00:0525/06/2019
EMx 056: Sobelow and Security with Griffin Byatt
EMx 056: Sobelow and Security with Griffin Byatt
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small planTriplebyte offers a $1000 signing bonusCacheFly Panel Mark EricksenJosh Adams Joined by Special Guest: Griffin Byatt Summary Griffin Byatt shares his background and what he is doing now as a security consultant for NCC Group. The panel discusses his security library, Sobelow, and their experiences using it. Griffin explains how it works, how it came into being and the goal of Sobelow. The panel wonders who contributes to Sobelow and Griffin invites anyone to contribute. Vulnerabilities that are commonly seen across all frameworks and those specific to Elixir are discussed. Elixir’s security features are considered and Griffin shares his experiences working to improve the ecosystem. Griffin gives advice and recommends resources to developers. Links Substitute Teacher - Key & Peelehttps://www.nccgroup.trust/us/https://brakemanscanner.org/https://github.com/nccgroup/sobelowhttps://github.com/nccgroup/sobelow/blob/master/lib/sobelow/traversal/file_module.exhttps://www.owasp.org/index.php/XML_External_Entity_(XXE)_ProcessingElixirConf 2017 - Plugging the Security Holes in Your Phoenix Application - Griffin Byatthttps://github.com/ueberauth/guardianhttps://oauth.net/https://github.com/riverrun/phauxthhttps://github.com/riverrun/comeoninhttps://www.owasp.org/https://www.owasp.org/index.php/Category:OWASP_Top_Ten_ProjectThe Web Application Hacker's Handbook: Finding and Exploiting Security Flawshttps://griffinbyatt.com/https://twitter.com/griffinbyatthttps://twitter.com/elixir_mixhttps://www.facebook.com/Elixir-Mix Picks Mark Ericksen: https://stedolan.github.io/jqhttps://github.com/elixir-lang/elixir/releases Josh Adams: https://librem.one/https://puri.sm/products/librem-5/ Griffin Byatt: https://www.freehaven.net/anonbib/https://www.nccgroup.trust/us/our-research/assessing-unikernel-security/?research=Whitepapers   Special Guest: Griffin Byatt. 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.
46:5818/06/2019
EMx 055: Params Modules for Phoenix with Kuba Subczynski
EMx 055: Params Modules for Phoenix with Kuba Subczynski
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small planTriplebyte offers a $1000 signing bonusCacheFly Panel Mark EricksenMichael Ries Joined by Special Guest: Kuba Subczynski Summary Kuba Subczynski starts by introducing params modules and the story behind the pattern. The panel discusses their heuristics for deciding when to bring on a dependency and when to build something yourself. Kuba defines an embedded schema and walks through the login controller use case for the params modules. The panel discusses the highlights from the article and the benefits of using params modules. Kuba warns that this pattern isn’t for everything and discusses with the panel when to use params modules. Kuba discusses his team and what it was like adopting Phoenix and Elixir. Links https://www.sandimetz.com/https://kubasub.proseful.com/params-modules-for-phoenixhttps://github.com/vic/paramshttps://github.com/vichttps://medium.com/@alves.lcs/phoenix-strong-params-9db4bd9f56d8https://www.sandimetz.com/https://codeclimate.com/blog/7-ways-to-decompose-fat-activerecord-models/https://www.thescore.com/https://twitter.com/kubasubhttps://twitter.com/elixir_mixhttps://www.facebook.com/Elixir-Mix Picks Mark Ericksen: http://blog.erlang.org/OTP-22-Highlights/ Michael Ries: https://ferd.ca/it-s-about-the-guarantees.html Kuba Subcynski: https://proseful.com/Special Guest: Kuba Subczynski. 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.
56:5411/06/2019
EMx 054: Phoenix LiveView with Leandro Pereira
EMx 054: Phoenix LiveView with Leandro Pereira
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small planTriplebyte offers a $1000 signing bonusCacheFly Panel Michael RiesJosh AdamsMark Ericksen Joined by Special Guest: Leandro Pereira Summary Leandro Pereira starts by sharing what the Elixir community is like in Brazil. He explains what applications Phoenix LiveView works well for and those that it does not. The panel discusses why people are so excited for LiveView. JavaScript in LiveView is discussed, including where it is, what it does and Javascript fatigue in the community. Leandro shares where people can find demo projects. The panel discusses drab and why it didn’t catch on. The benefits of LiveView are discussed including, pain problems it will solve, avoiding the duplication of code, and the magic that happens in web end development. The panel shares projects they are working on or thinking of. Links https://lnasystems.com.br/https://medium.com/@ericclemmons/javascript-fatigue-48d4011b6fc4Swapping React for Phoenix LiveViewhttps://elixirforum.com/t/phoenix-liveview-is-now-live/20889/73https://elixirforum.com/tags/liveviewhttps://elixirforum.com/t/liveview-demos-examples-and-sample-apps-thread/21073https://hexdocs.pm/drab/Drab.Live.htmlhttps://elixirforum.com/t/drab-and-liveview-community-oddities/16483https://github.com/JakeBecker/vscode-elixir-ls/pullshttps://github.com/patrick-steele-idem/morphdomhttps://twitter.com/lucianparvu/status/1109087821581742080https://twitter.com/_zorbash/status/1112859727845904385https://github.com/leandrocphttps://twitter.com/leandrocesquinihttps://twitter.com/elixir_mixhttps://www.facebook.com/Elixir-Mix Picks Michael Ries: https://dudewheresmydesk.live/https://pragprog.com/book/jgotp/designing-elixir-systems-with-otp Josh Adams: https://github.com/antoyo/relmHome Warranties Mark Ericksen: Chris McCord Keynote: Phoenix LiveView - Interactive, Real TIme Apps - No need to write Javascripthttps://elixirforum.com/ Leandro Pereira: https://pragprog.com/book/jgotp/designing-elixir-systems-with-otpSpecial Guest: Leandro Pereira. 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.
01:02:0004/06/2019
EMx 053: Building beautiful systems with Phoenix Contexts and DDD with Andrew Hao
EMx 053: Building beautiful systems with Phoenix Contexts and DDD with Andrew Hao
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small plan Triplebyte offers a $1000 signing bonus CacheFly Panel Mark Ericksen Josh Adams Joined by Special Guest: Andrew Hao Summary Andrew Hao joins the panel to discuss a recent talk he gave; he shares his background and his origin story with domain driven design. Andrew introduces an exercise that helped him called “Context Mapping”. The panel discusses how to context map and the benefits of doing this exercise with your team. Andrew explains what to model as methods and functions in context style mapping. Andrew explains aggregate roots. The panel discusses using these design tools in GraphQL and Phoenix Live View. Andrew warns against overusing these tools, leading to a discussion about how much is too much. Links ElixirDaze 2018 - Building beautiful systems with Phoenix contexts... by Andrew HaoDomain-Driven Design: Tackling Complexity in the Heart of Software Domain-Driven Design: Tackling Complexity in the Heart of Software   https://www.g9labs.comhttps://twitter.com/andrewhaohttps://github.com/andrewhaohttps://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Mark Ericksen: http://blog.plataformatec.com.br/2019/04/whats-new-in-elixir-apr-19/ Josh Adams: https://github.com/telegramdesktop/tdesktop Andrew Hao: Domain-Driven Design Distilledhttps://www.amazon.com/Manga-Guide-Linear-Algebra/dp/1593274130Special Guest: Andrew Hao. 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.
50:2128/05/2019
EMx 052: Production Pitfall Pontification
EMx 052: Production Pitfall Pontification
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small planTriplebyte offers a $1000 signing bonusCacheFly Panel Michael RiesJosh Adams Summary Michael Ries and Josh Adams share mistakes they have made and common pitfalls developers fall into during production. They start by discussing Heroku and Josh explains what pushed him away from Heroku. They discuss alternatives to Heroku and give tips on finding that “deployment sweet spot”. Moving on to configuration, they discuss the most common configuration error and their favorite configuration tools. Michael and Josh share the ways they use clustering. Using their own experiences they explain how they fell into these pitfalls warning new elixir developers, giving advice and sharing career hacks. Links https://nanobox.io/https://gigalixir.com/https://hex.pm/packages/conformhttps://github.com/bitwalker/toml-elixirhttps://github.com/keathley/vaporhttps://github.com/coryodaniel/bonnyhttps://hex.pm/packages/libclusterhttp://blog.plataformatec.com.br/2019/04/whats-new-in-elixir-apr-19/https://jenkins.io/projects/jenkins-x/https://hex.pm/packages/lbm_kvhttps://twitter.com/elixir_mixhttps://www.facebook.com/Elixir-Mix Picks Michael Ries: http://www.erlang-in-anger.com/https://hex.pm/packages/reconManipulating the YouTube Algorithm Josh Adam: https://noagendaplayer.com/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.
52:4821/05/2019
EMx 051: Nerves and Farmbot with Connor Rigby
EMx 051: Nerves and Farmbot with Connor Rigby
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small planTriplebyte offers a $1000 signing bonusCacheFly Panel Mark EricksenMichael RiesCharles Max Wood Joined by Special Guest: Connor Rigby Summary Connor Rigby, a core member of the Nerves team, answers the panel's questions about Farmbot and his experience working with Nerves. The panel discusses the great things about nerves. Connor shares his favorite tools for productions and testing practices. The panel discusses NervesKeys and NervesHub. Connor tells the panel what it was like working with NASA. Known for experimenting with Nerves, Connor talks about some of his projects. Links https://farm.bot/https://github.com/nerves-projecthttp://wiki.ros.org/sig/Embeddedhttps://elixirforum.com/t/sqlite-ecto2-new-maintainer/15611https://github.com/elixir-sqlite/sqlite_ecto2https://www.rosepoint.com/https://github.com/RosePointNavElixirConf 2015 - Embedded Elixir in Action by Garth HitchensMocks and explicit contractshttps://www.nerves-hub.org/https://www.media.mit.edu/projects/personal-food-computer/overview/https://smartrent.com/https://github.com/boydm/scenichttps://opencv.org/https://www.verypossible.com/https://github.com/ConnorRigby/elixir-opencvhttps://github.com/elixir-circuits/circuits_gpiohttps://github.com/elixir-circuits/https://www.grisp.org/https://beagleboard.org/blackhttps://codesync.global/media/clixir-mixing-c-and-elixir-code/https://twitter.com/pressy4piehttps://github.com/ConnorRigbyhttps://twitter.com/elixir_mixhttps://www.facebook.com/Elixir-Mix Picks Mark Ericksen: https://twitter.com/FrancescoC/status/1119596234166218754 Charles Max Wood: https://twitter.com/NervesMeetuphttps://podwrench.com/ Michael Ries: Cees de Groot - Clixir - mixing C and Elixir code | Code BEAM SF 19 Connor Rigby: https://www.gbstudio.dev/Special Guest: Connor Rigby. 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.
01:01:5014/05/2019
EMx 049: Standard Library Treasures
EMx 049: Standard Library Treasures
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small plan Triplebyte offers a $1000 signing bonus .TECH – Go.tech/Elixir and use the coupon code “ELIXIR.TECH” and get a 1 year .TECH Domain at $9.99 and 5 Year Domain at $49.99. Hurry! CacheFly Panel Josh Adams Michael Ries Summary Josh Adams and Michael Ries discuss some of their favorites found in standard libraries and other tools. Michael starts by defining Ets, Dets, and Mnesia. They share the best ways to use these tools and when to use them. They also share uses cases and stories from times they have used these tools. Josh shares his work with UI’s and Michael discusses his work with nerves. They end by discussing the right time for new developers to learn how to use the tools discussed. Links https://showoff.riesd.com/https://hex.pm/packages/lbm_kvhttps://gist.github.com/mmmries/54c2110bb93af61ebfa1aff36acec9cahttps://twitter.com/elixir_mixhttps://twitter.com/elixir_mix Picks Michael Ries https://blog.usejournal.com/elixir-scenic-snake-game-b8616b1d7ee0 Josh Adams https://tylerscript.dev/ecto-filtering-tutorial/https://www.youtube.com/watch?v=OR2Gc6_Le2U 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.
45:5630/04/2019
EMx 048: Introducing Newest Panelist: Michael Ries
EMx 048: Introducing Newest Panelist: Michael Ries
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small planTriplebyte offers a $1000 signing bonus.TECH – Go.tech/Elixir and use the coupon code “ELIXIR.TECH” and get a 1 year .TECH Domain at $9.99 and 5 Year Domain at $49.99. Hurry!CacheFly Panel Mark Ericksen Joined by Special Guest: Michael Ries Summary Mark Ericksen interviews the newest member of the Elixir Mix panel, Michael Ries. Michael shares a bit of his background and how he got into Elixir. While sharing what he loves about Elixir, Michael gives advice to developers new to Elixir. Mark asks Michael about all his experimental projects. Michael discusses his play with TCP subscriptions, monitoring, nerves, and robotics. Michael talks about Hackaway, a cabin retreat for developers, how he runs it and how it all got started. Links https://github.com/mmmries/gnathttps://github.com/mmmries/roombexhttps://pragprog.com/book/elixir16/programming-elixir-1-6https://nats.io/https://www.youtube.com/user/birdnandnerdhttps://gist.github.com/mmmries/08fe44fdd47a6f8838936f41170f270ahttps://hexdocs.pm/elixir/Process.html#monitor/1https://github.com/elixir-ecto/postgrexhttps://hexdocs.pm/elixir/Supervisor.html#module-strategieshttps://twitter.com/NervesMeetuphttps://github.com/mmmries/roombexhttps://www.irobot.com/about-irobot/stem/create-2https://github.com/chrismccord/phoenix_live_view_examplehttps://github.com/mmmries/gnat/pull/79https://twitter.com/mmmrieshttps://twitter.com/brainlidhttps://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Mark Ericksen https://github.com/phoenixframework/phoenix_live_viewhttps://github.com/elixir-lang/ex_doc Michael Ries https://hex.pm/packages/telemetryAdvertising 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.
01:10:2423/04/2019
EMx 047: Property Based Testing with PropEr and Fred Hebert
EMx 047: Property Based Testing with PropEr and Fred Hebert
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small planTriplebyte offers a $1000 signing bonus.TECH – Go.tech/Elixir and use the coupon code “ELIXIR.TECH” and get a 1 year .TECH Domain at $9.99 and 5 Year Domain at $49.99. Hurry!CacheFly Panel Mark Ericksen Joined by Special Guest: Fred Hebert Summary Fred Hebert shares his experience writing “Learn You Some Erlang for Great Good!: A Beginner's Guide” and “Stuff Goes Bad: Erlang in Anger”. He talks about why he wrote these books and explains the whimsical illustrations in “Learn you some Erlang”. Mark Ericksen asks Fred about his latest book “Property-Based Testing with PropEr, Erlang, and Elixir: Find Bugs Before Your Users Do”. Fred gives an overview of property-based testing, explaining what it is, why it is important and sharing tips for getting started in property-based testing. Mark and Fred discuss PropEr and Fred’s inclusion of Elixir in this book. The ecosystems of Erlang and Elixir are explored and Fred shares what he would like to see from the Elixir community as an Erlang developer. They end the episode by discussing Fred’s time at Heroku and Fred’s current interests. Links https://learnyousomeerlang.com/https://github.com/ferd/reconhttps://www.erlang-in-anger.com/https://propertesting.com/https://github.com/proper-testing/properhttps://propertesting.com/toc.htmlhttps://erlef.org/https://www.youtube.com/watch?v=OR2Gc6_Le2Uhttps://twitter.com/mononcqchttps://twitter.com/elixir_mixhttps://www.facebook.com/Elixir-Mix Picks Fred Hebert https://www.hillelwayne.com/post/metamorphic-testing/ Mark Ericksen https://en.wikipedia.org/wiki/Dave_BrailsfordSpecial Guest: Fred Hebert. 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.
58:2716/04/2019
EMx 046: Don't Repeat Your Domain Knowledge with Yiming Chen—
EMx 046: Don't Repeat Your Domain Knowledge with Yiming Chen—
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small plan Triplebyte offers a $1000 signing bonus .TECH – Go.tech/Elixir and use the coupon code “ELIXIR.TECH” and get a 1 year .TECH Domain at $9.99 and 5 Year Domain at $49.99. Hurry! CacheFly Panel Mark Ericksen Josh Adams Joined by Special Guest: Yiming Chen Summary Yiming Chen and the panel discusses his recent blog post about not repeating domain knowledge. Yiming Chen describes what he means by domain knowledge and how this differs from the well known “do not repeat yourself” rule. The panel discusses how this changes the code and this leads to a conversation about good testing practices. Live view is discussed and the panel asks Yiming Chen what he is looking forward to in elixir. Yiming Chen talks about what the elixir community is like in China and his experience switching from ruby to elixir. Links https://dsdshcym.github.io/blog/2018/10/26/dont-repeat-your-domain-knowledge/https://en.wikipedia.org/wiki/Domain-driven_designhttps://en.wikipedia.org/wiki/Don%27t_repeat_yourselfhttps://pragprog.com/book/tpp/the-pragmatic-programmerhttps://github.com/schrockwell/bodyguardhttps://thoughtbot.com/bloghttp://bikeshed.fm/186https://github.com/plataformatec/moxhttps://www.youtube.com/watch?v=5SbWapbXhKohttp://dsdshcym.github.io/https://twitter.com/dsdshcymhttps://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Mark Ericksen https://twitter.com/chris_mccordhttps://www.youtube.com/watch?v=l3VgbSgo71E Josh Adams https://elixirforum.com/t/code-beam-sf-2019-talks/20984https://2018.elm-conf.us/schedule/matthew-griffith/ Yiming Chen https://contexts.co/https://thoughtbot.com/blog/books-freehttps://learning.oreilly.com/library/view/accelerate/9781457191435/ Special Guest: Yiming Chen. 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.
53:4309/04/2019
EMx 045: Where the Wild Things Are with Johnny Winn
EMx 045: Where the Wild Things Are with Johnny Winn
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small plan Triplebyte offers a $1000 signing bonus .TECH – Go.tech/Elixir and use the coupon code “ELIXIR.TECH” and get a 1 year .TECH Domain at $9.99 and 5 Year Domain at $49.99. Hurry! CacheFly Panel Charles Max Wood Mark Ericksen Josh Adams Joined by Special Guests: Johnny Winn and Michael Ries Summary Johnny Winn share his story with the panel starting with how elixir fountain got started. The panel compares elixir to other languages and share what they appreciate about it. After Johnny talks about what he is working on and his love for experimenting with elixir, the panel reveals some of the dumb, fun experiments that they have done in the past. Johnny shares how he burned himself out and the panel picks Johnny’s brain on signs that a someone might be burning out. This leads the panel into a deeper discussion of Johnny’s story and how he overcame that hard time in his life. Johnny shares a lot of tips and advice about how to stay positive and live a happy productive life. The panel ends with a throw back to the elixir fountain by doing a “five behind the code” with Johnny. Links Exercises for Programmers: 57 Challenges to Develop Your Coding Skills by Brian P. Hogan   https://github.com/nurugger07/inflexhttps://vimeo.com/108441214https://github.com/nurugger07/calliopehttps://erlangcentral.org/videos/viva-la-evolucion-replicating-life-with-otp-by-johnny-winn/https://www.youtube.com/watch?v=wh68a1UKY5whttps://elixirforum.com/https://twitter.com/elixirfountainhttps://twitter.com/johnny_ruggerhttps://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Charles Max Wood https://www.vrbo.comhttps://www.hotwire.com/ Las Vegas, NV Josh Adams https://news.ycombinator.com/item?id=19414775http://www.liquidity-lang.org/ Michael Ries https://elixir-circuits.github.io/https://embedded-elixir.com/https://twitter.com/NervesMeetup Johnny Winn https://preloaded.com/work/science-museum-rugged-rovers/ Science Museum of London https://www.cruiseamerica.com/Special Guests: Johnny Winn and Michael Ries. 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.
01:25:2902/04/2019
EMx 044: Dangers of GenServers in Elixir with Mika Kalathil
EMx 044: Dangers of GenServers in Elixir with Mika Kalathil
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small planTriplebyte offers a $1000 signing bonus.TECH – Go.tech/Elixir and use the coupon code “ELIXIR.TECH” and get a 1 year .TECH Domain at $9.99 and 5 Year Domain at $49.99. Hurry!CacheFly Panel Charles Max WoodJosh AdamsMark Ericksen Joined by Special Guest: Mika Kalathil Summary Mika Kalathil introduces genservers and how they are misused. The panel plays with an analogy that explains how people think genservers work versus how genservers actually work. Mika Kalathil shares some ways to avoid the common mistakes with genservers. Tasks are introduced and explained by Mika Kalathil; the panel adds their input on the usefulness and the importance of tasks. Mika Kalathil shares his background and his transition to elixir from javascript. The panel asks Mika Kalathil questions about the libraries he uses, the types of projects that he works on and what improvements he would like to see in elixir. The episode ends with a discussion about the wonderful elixir community. Links https://lure.is/blog/elixir/dangers-of-genservhttps://lure.is/blog/elixir/dangers-of-genservershttps://elixir-slackin.herokuapp.com/  https://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Mark Ericksen https://www.youtube.com/watch?v=Cpv1fxCV3sI&feature=youtu.behttps://brainlid.org/elixir/2019/03/06/pattern-match-format-text.html Josh Adams https://twitter.com/TaylorPearsonMe Charles Max Wood https://podfestexpo.com/https://podcastmovement.com/Find a positive placecharlesmaxwood.com Mika Kalathil exercism.iohttps://github.com/discordapp   Special Guest: Mika Kalathil. 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.
42:5526/03/2019
EMx 043: Using GenServers and Tasks Together to Create Fault-Tolerant Apps with Jack Marchant
EMx 043: Using GenServers and Tasks Together to Create Fault-Tolerant Apps with Jack Marchant
Sponsors Sentry use the code “devchat” for 2 months free on Sentry small planTriplebyte offers a $1000 signing bonus.TECH - Go.tech/Elixir and use the coupon code “ELIXIR.TECH” and get a 1 year .TECH Domain at $9.99 and 5 Year Domain at $49.99. Hurry!CacheFly Panel Mark EricksenJosh Adams Joined by Special Guest: Jack Marchant Summary Mark Ericksen and Josh Adams ask Jack Marchant, a software engineer from Australia, about a few of his blog articles. Jack Marchant compares supervision trees to react component trees using his background in both the frontend and the backend. The panel exchanges views on what these observations might look like and how they can help elixir developers. Mark Ericksen turns the discussion to Jack Marchant's articles on genservers, and the lessons he learned in working with genservers. Jack Marchant explains that there are so many different uses for a genserver. The panel considers when it is useful to use a genserver and when it is better not to. Jack Marchant shares a way to better manage work using a task and genservers for asynchronous work.  The panel reviews a few things that they appreciate about elixir and how productive it makes developers. Jack Marchant shares his experience working in an elixir based company, in hiring, training, and productivity. The panel discusses the experience of switching to elixir and asks Jack Marchant about his experience coming from PHP. Jack Marchant shares and discusses with the panel some highlights from the lonestar elixir conference and updates the panel on phoenix live view. Links https://reactjs.org/http://absinthe-graphql.org/https://reactjs.org/docs/error-boundaries.htmlhttps://www.jackmarchant.com/articles/you-might-not-need-a-genserverhttps://www.jackmarchant.com/articles/using-a-genserver-to-handle-asynchronous-concurrent-taskshttps://www.jackmarchant.com/articles/lonestar-elixir-conf-2019-highlightshttps://medium.com/@Bettio/atomvm-how-to-run-elixir-code-on-a-3-microcontrollerhttps://twitter.com/jackmarchant10https://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Josh Adams https://github.com/spencertipping/writing-self-modifying-perl Mark Ericksen Deep Work by Cal Newport Jack Marchant https://www.jackmarchant.comSpecial Guest: Jack Marchant. 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.
54:0219/03/2019
EMx 042: Updates on ExVenture with Eric Oestrich
EMx 042: Updates on ExVenture with Eric Oestrich
Sponsors Sentry use the code “devchat” for $100 creditTriplebyteCacheFly Panel Josh AdamsMark Ericksen Guest: Eric Oestrich Episode Summary In this episode of Elixir Mix, Mark Ericksen and Josh Adams chat with guest, Eric Oestrich, a developer at SmartLogic and creator of ExVenture and Grapevine, two open source Elixir applications centered around text based games. Eric gives updates on ExVenture and Grapevine. Mark and Josh both have referenced ExVenture before, for using different ideas. They mention Prometheus and Grafana, two monitoring platforms that work well with Elixir applications.  Eric also describes how Grapevine and ExVenture interact to help gamers get profiled with their achievements. Eric shares his experiences getting ExVenture set up with a continuous integration (CI) server. Panelists agree having side projects help developers try out new technology without deadline pressure. Eric does live development every Monday at 12:00 pm EST on smartlogictv. Eric and Mark both share their experiences with live coding. Josh mentions an article he liked on live coding: “Lessons from my first year of live coding on Twitch” by Suz Hinton. Eric talks about what he has been working on outside of ExVenture and Grapevine. They briefly compare ease of shelling out in Python, Elixir and Ruby. SmartLogic now has a podcast called “Smart Software with SmartLogic” and Mark was a guest on one of the episodes “Elixir in Production”. Links http://erlang.org/doc/man/sys.html#get_state-1http://oestrich.org/http://blog.oestrich.org/https://twitter.com/ericoestrichhttps://www.smartlogic.com/https://exventure.org/https://grapevine.haus/https://blog.oestrich.org/2019/01/exventure-updateshttps://prometheus.io/https://grafana.com/https://travis-ci.org/https://semaphoreci.com/https://jenkins.io/https://twitter.com/alicegoldfuss/status/1098604563664420865https://circleci.com/https://about.gitlab.com/https://github.com/Trevoke/dwarlixirhttps://www.twitch.tv/smartlogictvLessons from my first year of live coding on Twitch by Suz Hintonhttps://obsproject.com/https://github.com/alco/porcelainhttp://bert-rpc.org/https://github.com/mojombo/bertrpchttps://podcast.smartlogic.io/https://github.com/oestrich/ex_venture/https://www.clustertruck.com/https://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Josh Adams: https://github.com/beerriot/goma Mark Ericksen: http://blog.plataformatec.com.br/2019/02/announcing-broadway/ Eric Oestrich: http://www.restfest.org/Special Guest: Eric Oestrich. 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.
42:1412/03/2019
EMx 041: What Really Makes Erlang and Elixir Fault Tolerant and Scalable with Francesco Cesarini
EMx 041: What Really Makes Erlang and Elixir Fault Tolerant and Scalable with Francesco Cesarini
Sponsors Sentry use the code “devchat” for $100 creditTriplebyteCacheFly Panel Josh AdamsMark EricksenCharles Max Wood Guest: Francesco Cesarini Episode Summary In this episode of Elixir, Charles Wood, Josh Adams and Mark Ericksen chat with guest, Francesco Cesarini, Founder and Technical Director at Erlang Solutions about how to build reliable and scalable systems within the Elixir and Erlang world. Erlang Solutions provides consultancy to customers who are not familiar with Elixir and offers training when necessary. With their WOMBATOAM tool that can handle very large-scale systems like WhatsApp with its fault tolerant capability. Francesco talks about how he likes Elixir which is an up and coming language that focuses on UI/UX usability and compares Erlang and Elixir languages.  Francesco mentions he is impressed with the emphasis Elixir community places on user-friendliness. The guest discusses pros and cons of handling shared memory and concurrency. Supervisors and OTP help handle errors by creating escalation strategies. Going beyond the software, Francesco then shares some of his favorite real life experiences of power outages and switch failures he faced while building fault tolerant systems. Links https://www.erlang-solutions.com/https://www.erlang-solutions.com/products/wombatoam.htmlhttps://github.com/erlang/otphttps://github.com/francescochttps://twitter.com/FrancescoC   Picks Josh Adams: https://en.wikipedia.org/wiki/CyberneticsThe Origins of Opera and the Future of Programming by Jessica Kerr Mark Ericksen: Mark’s Blog: https://brainlid.org/elixir/2018/01/17/people-are-processes.html Charles Max Wood: https://www.vrbo.com/Canon EOS M6 Francesco Cesarini: Property Based Testing by Fred Herberthttps://news.ycombinator.com/item?id=19105908Special Guest: Francesco Cesarini. 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.
01:08:2105/03/2019
EMx 040: Elixir Outlaws and Adopting Elixir with Chris Keathley
EMx 040: Elixir Outlaws and Adopting Elixir with Chris Keathley
Sponsors Sentry use the code “devchat” for $100 creditTriplebyteCacheFly Panel Josh AdamsMark EricksenCharles Max Wood Joined by special guest: Chris Keathley Episode Summary In this episode of Elixir Mix, Chris Keathley introduces himself briefly and starts with talking about his work at Bleacher Report - a company specializing in sports culture - with respect to handling web traffic during major sports events and the implications of moving from Rails to Elixir as a backend system. He briefly touches on scaling issues, performance and the services they are running on their website. He then describes his Elixir journey until now and certain new areas he is working with, such as property based testing and distributed systems. He talks about maintaining the Wallaby library which is developed by him, mentions existing and upcoming exciting things in Elixir, and explains a few features of the Distillery and Vapor libraries. He also gives advice to people that are starting to work with Elixir on what must be learnt and more, and discusses certain projects and topics he wants to pursue and build knowledge in, in the near future. Links Functional Web Development with Elixir, OTP, and Phoenix: Rethink the Modern Web AppLance HalvorsenBleacher ReportWallabyDistilleryVaporElixir OutlawsLonestar ElixirConf – Chris KeathleyElixirConf EUBenefits of Elixir: How Elixir helped Bleacher Report handle 8x more traffic Picks Josh Adams: Axe - toolGraphQL – Zero to Awesome Mark Ericksen: Bash command “cd -” to go back to the last working directory Charles Max Wood: ZapierCanon EOS M6 CameraRode Microphone Chris Keathley: Moka Express Coffee MakerPicross S2Stamping on Event-StreamSpecial Guest: Chris Keathley. 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.
01:10:2627/02/2019
EMx 039: Types in Erlang / Elixir with Zachary Kessin
EMx 039: Types in Erlang / Elixir with Zachary Kessin
Sponsors Sentry use the code "devchat" for $100 credit   Episode Summary In this episode, the panelists, Josh Adams, Mark Erickson and guest Zachary Kessin, author of the book "Building Web Applications with Erlang", discuss types in Erlang and Elixir. Expert inputs with examples of implemented projects that use the Erlang and Elixir data types, were discussed. Here are the highlights of the discussion: Different data types in Erlang and Elixir such as structs, tuples.Differences in the Erlang/Elixir data types to other languages.Using data types to generate error messagesDecoding and validating input data into functions.Getting type information from a running application.Coding patterns and rules engine in Erlang/Elixir.Dialyzer testing tool that validates code and catches any bugs.Changes in Erlang and Elixir code over the yearsElixir ecosystem and the Beam Community Links DialyzerPropErSheriffDialyxirTyped_StructBeam_TypesGB_TreesProgramming Languages on the BEAMA reactive game stack: Using Erlang, Lua and VoltdbRobert VirdingZachary KessinBEAM Channel - Erlang & Elixirhttps://github.com/ejpcmac/typed_struct Picks Josh Adams Elixir Components: A 12 minute introductionaws-lambda-elixir-runtime Mark Ericksen BalenaEtcher Zach Kessin Elixir Release Ecourse Shalva BandSpecial Guest: Zachary Kessin. 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.
47:5519/02/2019
EMx 038: Slax and SAX Parsers with Ben Schmeckpeper
EMx 038: Slax and SAX Parsers with Ben Schmeckpeper
Sponsors Sentry use the code "devchat" for $100 credit Panel Charles Max WoodJosh AdamsMark Ericksen Joined by special guest Ben Schmeckpeper Episode Summary Charles would expressed how in this episode they had a good time learning about “SAX parsers and about some of the issues with migrating and sharing space between systems.” They discussed the benefits of using SAX (Simple API for XML). One of these benefits is that of being event based. Elixir and Ruby are also discussed, with a greater focus on Elixir. One benefits of using Elixir is that of pattern matching. Lots is also shared on “containers” and the pros and cons of these. Links Ben Schmeckpeper TwitterBen Schmeckpeper bloghttps://photos.app.goo.gl/17v3dnxGoYsgkTvn6https://photos.app.goo.gl/zH17oda67NKPr1rL9 xmerl XML parser Erlsom - Erlang library to parse XML documents BERT - Binary ERlang Term BERT and BERT-RPC 1.0 Specification Saxy - an XML SAX parser and encoder in Elixir  Genstage SlaxSAX - Wikipedia Picks Josh: Who gives an F*** about rails in 2019 Mark:  Mental model for understanding Elixir GenServers   Charles: Episode 400 of Ruby Rogues Villinous Disney Game  Ben: The Soul of a New MachineReflections on Trusting TrustThe Rise of Worse is Better  Flameshot Special Guest: Ben Schmeckpeper. 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.
47:2312/02/2019
EMx 037: The Elixir Language Service with Mitchell Hanberg
EMx 037: The Elixir Language Service with Mitchell Hanberg
Sponsors Sentry use the code "devchat" for $100 creditTripleByte offers $1000 signing bonusCachefly Panel: Mark EricksenJosh Adams Special Guest:  Mitchell Hanberg Notes: This episode welcomes guest Mitchell Hanberg, software developer for SEP in Carmel, IN. Currently, he is working with Rails at his job and writes Elixir at home. Mitchell wrote a blog post about how to use Elixir LS with Vim. He is working on integrating ALE and Elixir LS for Vim. The panelists discuss some problems they are having with Elixir LS crashing. The panelists conclude by discussing their favorite features of the Elixir/ALE integration and their favorite features of VIM. Terms: ErlangVS CODE GithubVimALE (asynchronos linting engine)Visual Studio CodeVim LSPNeoVimOniVimintelliJASDFEmacs Picks: Mark https://rg3.github.io/youtube-dl/ Josh https://urbit.org/primer/https://xi-editor.io/xi-editor/ Mitchell Hanberg http://calnewport.com/books/deep-work/https://www.amazon.com/All-new-Kindle-Paperwhite-Waterproof-Storage/Special Guest: Mitchell Hanberg. 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.
38:0405/02/2019
EMx 036: Gremlex and Graph Databases with Kevin Moore & Barak Karavani
EMx 036: Gremlex and Graph Databases with Kevin Moore & Barak Karavani
Sponsors Sentry use the code "devchat" for $100 credit TripleByte Panel Mark Ericksen Josh Adams Joined by Special Guests: Kevin Moore and Barak Karavani Summary Kevin Moore and Barak Karavani start by introducing Gremlex; they also define graph databases and explain what graph databases are used for. The panel asks Kevin and Barak about their work with chatbots and why they chose to use a graph database for this project. Amazon Neptune is introduced, Kevin and Barak explain why they chose to use Neptune and its role in them using Gremlin. The panel discusses open sourcing. Kevin and Barak share what it was like to open source Gremlex and the benefits they have seen in their company because of it. They discuss licensing and give advice for developers who would like to convince their company to open source. The features of Gremlex are discussed and Kevin and Barak share sources for getting started with Gremlex, including recommendations for running Gremlex and test support recommendations. The episode ends as Kevin and Barak explain why they chose elixir and how they teach elixir. Links Gremlex Home PageGremlex Github RepoGremlex Medium Posthttps://aws.amazon.com/neptune/https://gremlex.carlabs.ai/https://www.carlabs.ai/https://neo4j.com/https://dgraph.io/https://orientdb.com/https://medium.com/carlabs/introducing-gremlex-6f685adf73bdhttp://tinkerpop.apache.org/https://pragprog.com/book/elixir/programming-elixirhttp://plataformatec.com.br/https://www.manning.com/books/the-little-elixir-and-otp-guidebookhttps://github.com/rrrene/credohttp://erlang.org/doc/man/dialyzer.htmlhttps://github.com/nccgroup/sobelowhttps://github.com/hmemcpy/milewski-ctfp-pdfhttps://github.com/kevmojayhttps://github.com/barakyohttps://twitter.com/kevmojayhttps://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Mark Ericksen https://www.makemkv.com/ Josh Adams https://github.com/infinitered/torchhttps://blog.ispirata.com/get-started-with-elm-0-19-and-phoenix-1-4-291beebb350b   Kevin Moore https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/Nudge: Improving Decisions About Health, Wealth, and Happiness Barak Karavani http://haskellbook.com/Special Guests: Barak Karavani and Kevin Moore. 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.
52:2330/01/2019
EMx 035: Adopting Elixir with Tiago Duarte
EMx 035: Adopting Elixir with Tiago Duarte
Sponsors Sentry use the code "devchat" for $100 creditTripleByteSpecial Guest: Tiago Duarte. 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.
59:0924/01/2019
EMx 034: My First Nerves Project with Anders Smedegaard Pedersen
EMx 034: My First Nerves Project with Anders Smedegaard Pedersen
Sponsors Sentry use the code "devchat" for 2 months free on Sentry small planTripleByte offers a $1000 signing bonusCacheFly Panel Mark EricksenJosh Adams Joined by Special Guest: Anders Smedegaard Pedersen Summary Anders Smedegaard Pedersen shares how he got into Elixir and his experience joining the elixir community. He shares with the panel his initial frustration with the community and his confusion on the “correct” way to do things. He tells the panel of his experience at elixir conf meeting Claudio Ortolina, the advice he got, and how this led him to his first nerves project. Mark Ericksen and Josh Adams give advice to new elixir developers. The three of them compare umbrella structure and poncho structure. Links http://erlang.org/doc/apps/jinterface/jinterface_users_guide.htmlhttps://elixirforum.com/t/do-you-really-need-a-database/4567/15https://smedegaard.io/my-first-nerves-project-pt-2/ElixirConf 2018- My first Nerves Project Bioreactor - David Schainkerhttps://farm.bot/https://hexdocs.pm/nerves/user-interfaces.htmlhttps://embedded-elixir.com/post/2017-05-19-poncho-projects/https://smedegaard.io/anders-smedegaard-pedersen/https://www.facebook.com/Elixir-Mixhttps://twitter.com/elixir_mix Picks Mark Ericksen Set a larger goal (like 30-day goal) and do something every day to move you toward that goal. Even if only 10 minutes. Keep your momentum. Josh Adams https://levelup.gitconnected.com/a-recap-of-frontend-development-in-2018-715724c9441dhttps://elm-lang.org/ Anders Smedegaard Pedersen Search Inside Yourself: The Unexpected Path to Achieving Success, Happiness (and World Peace)Property-Based Testing with PropEr, Erlang, and Elixir Special Guest: Anders Smedegaard Pedersen. 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.
58:1215/01/2019
EMx 033: Databases and Elixir with Kamil Lelonek
EMx 033: Databases and Elixir with Kamil Lelonek
Panel: Mark EricksenCharles Max Wood Special Guest: Kamil Lelonek  In this episode of Elixir Mix, the panel talks with Kamil Lelonek who is a full-stack developer and programmer. Chuck, Mark, and Kamil talk about Elixir, Postgrex, databases, and so much more! Check it out! Show Topics: 0:00 – Advertisement: Get A Coder Job!  0:48 – Chuck: Hello! Our panel today is Mark and myself. Friendly reminder to listeners: check out my show the DevRev. Our guest today is Kamil Lelonek! 1:23 – Guest. 1:43 – Chuck: Today, we are talking about databases. 1:55 – Guest. 3:10 – Mark: We have your blog that you wrote in our show notes. Talk about your experience with exploring these features? 3:39 – Chuck. 3:46 – Mark: I didn’t know those features are in Postgrex. Can you talk about your experience and your journey? 4:10 – Guest. 6:17 – Mark: I am curious, what problem were you trying to solve? 6:31 – Guest. 8:12 – Mark: I like you saying: rather than modifying the application code itself, you created a separate application. I think Elixir is a good fit for that – what’s your experience with this? 8:40 – Guest: I agree with this, but let’s think about it in the other way. 9:48 – Mark: Yeah I can see that. It’s good to be aware of the upsides and downsides. It’s an interesting idea. 10:40 – Guest. 11:38 – Chuck: My experience is mostly in Rails. The other way I have solved this problem is “pulling” but this way is more elegant. Before we have talked with Chris McCord about LiveVue. Is there a way to hook this handler up to LiveVue to stream the changes all the way up to the frontend of web application with Phoenix? 12:20 – Guest. 12:55 – Mark talks about Elixir and GenServer. 13:29 – Guest. 13:49 – Mark: Please go and read Kamil’s blog post because it’s simple and it’s written well! Mark: I think Elixir is a great usage for GenServers. 14:28 – Guest. 14:35 – Chuck: You setup a store procedure, which I don’t see a lot of people doing within the communities. How necessary is that store procedure that you’ve created there? 15:00 – Guest. 16:16 – Chuck: What if you want to do targeted notifications? 16:28 – Guest. 17:33 – Mark: I am curious if you have experimented with the practical limitations of this? Like at one point does it start to break down? 18:00 – Guest. 20:00 – Chuck: I will be honest I am kind of lazy. Outside of the general use I don’t go looking for these, but when I hear about them I say: wow! 20:09 – Guest. 20:57 – Chuck. 21:15 – Guest talks about solutions that he’s found. 22:08 – FreshBooks! 23:17 – Mark: What other kind of databases have you had experience with for comparison reasons? 23:40 – Guest. 24:56 – Mark: You talked about defaults and I want to come back to this topic. 25:08 – Mark asks Chuck a question. 25:12 – Chuck: I don’t know. 25:23 – Mark talks about the databases that his work utilizes. 26:45 – Mark and Chuck go back-and-forth. 27:49 – Guest mentions a solution to the before-mentioned problem that Mark gave. 28:47 – Mark: It can get messy. I don’t repose this as a permanent solution, but it allows you do a staged-migration. 29:15 – Chuck: Do you run into problems with Postgrex? Most technologies if you don’t run into problems you aren’t pushing it enough (at least that’s my experience). 29:29 – Guest answers the question. 30:26 – Mark talks about active, active, active. 31:14 – Guest. 33:25 – Mark: In Elixir, we talk about the things that are in the box and one thing that comes up is “mnesia.” Can you talk about this please? 33:47 – Guest talks about mnesia. 35:17 – Mark talks about mnesia some more. Mark: It is an available option (mnesia), but I don’t know if it’s something that people want when they are looking for something more traditional. 37:04 – Guest. 37:30 – Mark: Yeah something people should be aware of. If you are encountering problems it’s good to know the different tools that are out there and available. 38:42 – Mark: One question: What are some of your favorite features of Postgrex? 38:57 – Guest. 41:08 – Mark talks about Postgrex’s features. 42:14 – Guest. 43:10 – Mark: I had a case where Elixir and Erlang and you can convert term to binary and binary to term. I took some data structure and converted it to a binary and using Ecto and tell it: serialize this and when it loads back out it is a native Elixir type. It’s not always the right solution, but in my cases it actually worked. 43:59 – Guest talks about a library that he wrote back-in-the-day. 44:40 – Chuck: Anything else? Nope? Okay – Picks! 44:52 – Ad: Lootcrate.com END – CacheFly! Links: RubyElixirElixir: GenServerGenServersElmJavaScriptVisual Studio CodeReact“How to use LISTEN and NOTIFY PostgreSQL commands in Elixir?" By Kamil LelonekGuest’s Medium BlogPostgrex.NotificationsRedis.ioEvent StorePostgreSQLMongoDBErlang: mnesiaGitHub: cachexGitHub: meh / amnesiaPostGISWhen to use Ecto, when to use MnesiaPostgreSQLEcto.TypeGitHub: ExnumeratorYouTube: EntreprogrammersKamil’s Twitter Sponsors: Loot CrateGet a Coder Job!Fresh BooksCacheFly Picks: Mark Being professionally proactive! Chuck Get A Coder Job eBookChallenge: Pomodoro Technique Kamil Book: Thinking, Fast and Slow by Daniel KahnemanMy BlogMy SiteSpecial Guest: Kamil Lelonek. 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.
51:0525/12/2018
EMx 032: Using Ecto with Edgar Pino
EMx 032: Using Ecto with Edgar Pino
Panel: - Mark Ericksen- Josh Adams Special Guest: Edgar Pino    In this episode of Elixir Mix, the panel talks with https://github.com/edgar971?tab=followers who talks with the panel about the latest version of Ecto! They discuss Ecto’s new features and how easy of a transition it was to go from the previous to the newest version. https://github.com/edgar971?tab=followers is a software engineer who currently resides in Utah! Check out today’s episode! Show Topics: 0:00 – https://devchat.tv/get-a-coder-job/  1:04 – Mark: Hello! Please give us your background? 1:16 – Guest: I have been in https://elixir-lang.org for the past year or two and I have been living in Utah. 1:48 – Mark: I love the nature and state parks. Winter is coming, so I hope you are ready! 1:58 – Guest: Winter...hopefully it will be great! 2:20 – Panelists and guest go back-and-forth. 2:30 – Mark: Let’s talk about your blog posts about Ecto. What are your new announcements? 2:52 – Guest: Our new version was released a few weeks ago. 3:32 – Panel. 3:38 – The guest talks about the old and new versions of Ecto. 4:03 – Panel: What is new and how is this going to affect me (the new version)? 4:11 – Panel: The transition was pretty painless for me. The only change was the breaking-up of the adapter ad also the timestamp bit. That was it. 4:34 – Panel: Yeah that micro-timestamp surprised me for a second, but it wasn’t that bad after all. 4:52 – Guest: Yeah it was painless for me, too. 5:19 – Panel: Edgar can you talk about the change and what they did with the timestamps? 5:32 – The guest answers the question. 5:54 – Panel: Elm opted to use the micro-millisecond, too. Time zones aren’t a thing. 6:24 – Mark. 7:08 – Panel: My tests are the only reason why I care about the millisecond. 7:21 – Mark: With the upgrade don’t do what I did. Mark talks about how he updated and the issues he had. 8:47 – Guest: Pattern matching? 8:53 – Mark: Yep that sort of stuff. I didn’t need to do it and it was a learning experience. Edgar, please give us an introduction to the blog posts? Why did you want to document it? 9:18 – Guest: I always used Ecto with Phoenix but started learning Ecto by itself. I jotted down notes that I thought was interesting. That’s how it started. 10:17 – Mark: See links in the show notes. Using a gen to use the repo – this is one thing that I didn’t know was an option. 10:46 – Guest. 11:01 – Mark asks a question. 11:10 – Guest: Not really PHP applications but listening to web messages and hot topics but you are doing the database and serving data... 11:40 – Guest talks about Ecto and the different versions and features. 12:09 – Mark chimes-in. 12:23 – Panel: Yep – it’s under the hood and it’s for business logic and doesn’t have a web piece. Stop writing tings for the web – it’s a fad. 12:50 – Mark: It’s an umbrella and saw this through the Phoenix generators. 13:54 – Guest talks about web applications. 14:06 – Mark: Let’s talk about schema and databases? 14:23 – Panelist chimes-in. 14:51 – Panelists and guest talk about schemas, apps, and more. Check it out here. 16:13 – Guest: You will get the data and pass it in as a structure and... 16:23 – Mark: Here is a map of what I’d like you to do on my behalf. It goes to a chain set and I will turn it into a string and this is why it’s failed. 17:25 – Panel. 17:31 – Mark: It’s not hard and it’s pretty easy. Let’s talk about blog posts.  18:10 – Panel. 18:22 – Mark: I use https://github.com/absinthe-graphql/absinthe in the library in Elixir to support https://graphql.org 18:50 – Panel. 19:06 – Guest: The total number of results and only once did I need a more complicated thing. 19:34 – Mark: I haven’t had a need for those. 20:01 – Panelists and guests talk about the hypothetical situations where and how they would use certain features for said situations. 20:23 – Guest: You don’t have to understand right out-of-the-box. 20:40 – Panel: Have you used stored functions as meta-columns in an https://hexdocs.pm/ecto/Ecto.html schema? 20:48 – Panelist explains. 21:24 – Guest: I have used them in the past and now I don’t. For me it was hard to debug – maybe it’s just me. 21:43 – Panel: I was introduced to them through a colleague of mine. 21:53 – Mark chimes-in and talks about him being a DOT NET developer. 22:18 – Panelist chime-in, too! 22:50 – Mark. 23:16 – Panel: It was an awful time and not a good idea. 70 pages! Debugging it was hard. 23:35 – Mark: That experience was apart of that burn that I had before. I wanted to stay far away from it as far as I could. 24:00 – Panel: When I was doing it in DOT NET we didn’t have migrations. 24:12 – Panelist continues. 24:32 – Guest: I wonder if... 24:37 – Panel: It’s just a sequel – it’s not just an https://hexdocs.pm/ecto/Ecto.html specific feature. 24:48 – Guest. 24:53 – https://www.freshbooks.com 26:01 – Mark: Edgar you were interested also in HOW Ecto was built. What experience did you have? 26:21 – Guest answers the question. 28:22 – Panel: No you typed REPO there. 28:30 – Guest: Whenever you save or make an update it’s a method. Unlike Ecto you have to all it something else. 28:47 – Panel: Hey let me get those article posted and someone did it in Loop and that is a lot of queries. 29:03 – Guest: Yeah that’s a good point. 29:45 – Mark: Something I’ve noticed is that they talk about performance improvements and better memory usage. Go read about it- it’s great. They talk about HOW Ecto is working and what is behind the scenes. 31:15 – Mark: Another feature that I have seen is UPSERTS. 31:50 – Guest talks about UPSERTS, too. 32:34 – Mark: Say I have a system that has 3 servers and it’s rolling updates (it will take down one and put up the new code, etc. and it will cycle) one thing they added was a lock on the migration table. I don’t know if you’ve had this – once it hits production data it is slow. Mark continues. 33:20 – Panel: I think it was just luck of the draw. 33:30 – Mark continues. 33:57 – The guest talks about his experience with the above-mentioned scenario. 34:20 – Mark: I like that you both have had goo experiences with your upgrades. I want people to be excited and know that there are great features out there. 34:49 – Guest: Yes, I have found that the blog post is helpful. It’s good to get adapted to the new changes. 35:17 – Panel: Yeah I normally don’t have teasers up to the actual upgrade. 35:28 – Panel: The community is nice and people made a good effort to communicate and help people. They did a GOOD job of helping people to feel comfortable within the transition from one version to the next! 41:37 – https://www.lootcrate.com END – https://www.cachefly.com Links: - https://www.ruby-lang.org/en/- https://elixir-lang.org- https://elixir-lang.org/getting-started/mix-otp/genserver.html- https://elixir-lang.org/getting-started/mix-otp/genserver.html- https://elm-lang.org- https://www.javascript.com- https://code.visualstudio.com- https://reactjs.org- https://edgardev.com/getting-started-with-ecto-part-1/- http://blog.plataformatec.com.br/2018/10/a-sneak-peek-at-ecto-3-0-breaking-changes/- https://hexdocs.pm/ecto/Ecto.html- https://en.wikipedia.org/wiki/Active_record_pattern- https://martinfowler.com/eaaCatalog/repository.html Sponsors: - https://www.lootcrate.com- https://devchat.tv/get-a-coder-job/- https://www.freshbooks.com- https://www.cachefly.com Picks: Mark - https://www.plex.tv/#modal-tidal Josh - https://erlang-life.tumblr.com Guest - https://hexdocs.pm/ecto/Ecto.html Documentation!- https://edgardev.com – My blog!Become a supporter of this podcast: https://www.spreaker.com/podcast/elixir-mix--6102049/support.
46:2318/12/2018