Elixir Wizards

A special episode of Elixir Wizards highlighting Pattern Matching with Todd - a short format interview where our friend, Todd Resudek, asks different guests the same five questions. This week Todd spoke with Johanna Larsson. Johanna is active on the Elixir scene and is currently working as a Software Engineer at Duffel. Key Points From This Episode: Living in Malmo, Sweden. Johanna's love of languages. The complexities of written Japanese. How Johanna uses music to set the soundtrack to her work. Todd missing the boat on a cinematic and cultural masterpiece. Integrating and improving upon the hex diff project. Links Mentioned in Today’s Episode: Johanna Larsson on GitHub - https://github.com/joladev Johanna Larsson on Twitter - https://twitter.com/joladev Todd Resudek on Twitter — https://twitter.com/sprsmpl SmartLogic — https://smartlogic.io/ Special Guest: Johanna Larsson.

Real-time applications come with real challenges—persistent connections, multi-server deployment, and strict performance requirements are just a few. Our guest today is Steve Bussey, a software architect at SalesLoft and author of the new book, Real-Time Phoenix: Build Highly Scalable Systems with Channels. In this episode, Steve shares with us what he has written on real-time Elixir applications and how he has led development in the field. We discuss how Steve found Elixir, what system and application architecture means to him, and what he considers the differences between architecting and designing a system. Steve gives us his opinions on domain-driven design, umbrella apps, and Phoenix LiveView, and shares some of his personal processes when working on new real-time features, as well as what he believes are the toughest parts of developing and rolling out real-time applications. Finally, we talk about testing, security, and performance issues, and Steve sells us on his book. Tune in today! Key Points From This Episode: What Steve’s favorite pair of shoes is and how he got into sneakers. Where Steve is from and how long he has been doing programming. What system and application architecture means to Steve. The difference between architecting and designing a system. Steve’s opinions on domain-driven design. Eric’s opinion on umbrella apps and Steve’s response. Where Steve starts when he works on a new real-time feature. Steve’s personal and professional pre-code design processes. The toughest parts of developing and rolling out real-time applications. Testing real-time features and Steve’s thoughts on Phoenix LiveView. How Steve incorporates security into the architecture when designing applications. Multi-tenant applications and how Steve deals with performance issues. Deployment considerations when going into production with a real-time application. Steve sells us on his book and gives his final plugs and asks for the audience. Links Mentioned in Today’s Episode: Steve Bussey on Twitter – https://twitter.com/YOOOODAAAA Steven Bussey’s Website – https://stevenbussey.com/ Real-Time Phoenix on Pragmatic Bookshelf – https://pragprog.com/book/sbsockets/real-time-phoenix SmartLogic — https://smartlogic.io/ Justus Eapen on Twitter — https://twitter.com/justuseapen Eric Oestrich — https://oestrich.org/ Eric Oestrich on Twitter — https://twitter.com/ericoestrich Eric Oestrich on GitHub — https://github.com/oestrichSpecial Guest: Steve Bussey.

Today’s guest is Mohd Maqbool Alam, a software developer and Elixir fan from Delhi. He enjoys learning about programming language theory, distributed systems, Cloud Native technologies, and open source. As he is working towards building an Elixir community in Delhi, we caught up with him to find out how he came to be part of the Elixir world, and what drew him to programming in the first place. We also discuss Maqbool’s favorite Elixir resources and how Elixir has changed the way he thinks about architecture applications, as well as his opinions on microservices, APIs, and static typing. We talk about the real-world consequences of programming, using Neil Ferguson’s pandemic simulation model as an example, and Maqbool shares his favorite RPC (when we actually meant to ask him his favorite RFC)! The episode concludes with Pattern Matching with Todd. In this edition, he discusses Kubernetes and Beam with Principal Software Architect Cory O’Daniel. Key Points From This Episode: Maqbool tells us a bit about himself and how he came to be part of the Elixir community. What enticed Maqbool to programming. Maqbool’s favorite resources from Elixir. How Elixir has changed the way Maqbool thinks about architecting applications. Maqbool’s ‘aha’ moment in distributed programming and how he got into pattern matching. Phoenix Live Dashboard and why Maqbool and the team are excited about it. How Maqbool approaches the design process when building an application from scratch. The tools and methods Maqbool uses when designing information architecture and APIs. Maqbool’s opinions on microservices, Kubernetes, and Amazon Lambda. Protocols and non-standard protocols. Neil Ferguson’s pandemic simulation model using undocumented C-code. How we should think about the real world consequences of high-stakes programming. Maqbool’s opinion on static typing. Macbool’s favorite RPC and RFC. Pattern Matching with Todd Resudek, discussing Kubernetes and Beam with Cory O’Daniel. Links Mentioned in Today’s Episode: Justus Eapen on LinkedIn — https://www.linkedin.com/in/justuseapen/ Justus Eapen on Twitter — https://twitter.com/justuseapen Eric Oestrich — https://oestrich.org/ Eric Oestrich on Twitter — https://twitter.com/ericoestrich Eric Oestrich on GitHub — https://github.com/oestrich Mohd Maqbool Alam on Twitter – https://twitter.com/Maqboolism Elixir Forum – https://elixirforum.com/ Elixir in Action – https://www.amazon.com/Elixir-Action-Sa%C5%A1a-Juri-cacute/dp/161729201X Phoenix Live Dashboard – https://github.com/phoenixframework/phoenix_live_dashboard Absinthe – https://github.com/absinthe-graphql/absinthe Kubeless – https://kubeless.io/ Kubernetes — https://kubernetes.io/ Amazon Lambda – https://aws.amazon.com/lambda/ Groxio – https://grox.io/ Todd Resudek on Twitter — https://twitter.com/sprsmpl Cory O’Daniel on Twitter – https://twitter.com/coryodaniel Ziggy O’Doodle on Instagram – https://www.instagram.com/ziggy.odoodle/ SmartLogic — https://smartlogic.io/ Special Guests: Cory O'Daniel and Mohd Maqbool Alam.

As our first trilogy comes to a close, and we embark on the next one, we’re doing what all great trilogies do: Upending everything that made the initial one great and starting afresh. We have taken on board some excellent listener feedback to keep this the highest quality Elixir related podcast. So, for this launchisode, rather than doing a trailer, we are diving in headfirst with a full episode on system and application architecture, this season’s theme, with Justus Eapen, Dan Ivovich, and Eric Oestrich. We kick off the show by getting to know Dan and Eric a bit better. This season, as per listener requests, we will spend more time on our guests' personal lives. We learn about Dan and Eric’s time at SmartLogic, their experience working with Elixir, and their approaches to learning it. From there, we move onto tackling clients’ projects. We discuss the importance of letting ideas flow free as well as how to break projects down into manageable sized segments to work on. Following this, we touch on flexible architecture. As the world changes, sometimes at a pace faster than we anticipate, it is more important than ever to design systems that we can iterate on. Then, we discuss the future of applications and architecture and the exciting possibilities in-store. The show rounds off with our new segment, Pattern Matching with Todd, where our friend Todd Resudek gets to know someone in the community a bit better. Today, he talks with Connor Rigby of Binary Noggin, finding out more about his programing journey, his favorite music and movies, and his WiFi meshing project. We're so excited for this season, and we hope you join us on the journey. Tune in today! Key Points From This Episode: Dan’s background and how he came to be Director of Development Operations. How Eric started at SmartLogic and what his journey at the company has been like. Learn what convinced Dan to go all-in on Elixir and make the move from Rails Some of the educational materials and tools Dan and Eric used to learn Elixir. Dan’s preferred style of design and why he enjoys TDD. Why we think that Cucumber falls short and chose to move away from it. Find out what we think domain-driven design is. How Dan and Eric approach deconstructing clients’ projects. Pre-coding: Why it’s best to do free-form planning, with no constraints. Insights into the broad-reaching term of ‘API’ and what we mean by it. SOAP and REST APIs: What they are and the differences between them. How Dan, Eric, and Justus’s thinking about designing and application architecture has evolved. Object-oriented programming versus functional: Our take on the age-old debate. Is this finally the year that we get to kill micro-services? The relationship between team size and micro-services and some other constraints. What the future has in store for applications and architecting. Pattern-matching with Todd: Five questions to get to know Connor Rigby a bit better. Links Mentioned in Today’s Episode: Justus Eapen on Twitter — https://twitter.com/justuseapen Dan Ivovich on Twitter — https://twitter.com/danivovich Eric Oestrich on Twitter — https://twitter.com/ericoestrich Kalevala on GitHub — https://github.com/oestrich/kalevala Valve — https://www.valvesoftware.com/en/ Ecto — https://hexdocs.pm/ecto/Ecto.html Phoenix Elixir books — https://pragprog.com/book/phoenix14/programming-phoenix-1-4 Ruby on Rails — https://rubyonrails.org/ Designing for Scalability with Erlang — http://shop.oreilly.com/product/0636920024149.do Mike Amundsen on O’Reily Media — https://www.oreilly.com/pub/au/1192 Designing Elixir Systems With OTP — https://www.amazon.com/Designing-Elixir-Systems-OTP-Self-healing/dp/1680506617 Cucumber — https://cucumber.io/ Visual Studio Code — https://code.visualstudio.com/ SOAP vs REST APIs — https://www.soapui.org/learn/api/soap-vs-rest-api/ RESTFest — https://www.restfest.org/ ExVenture — https://exventure.org/ Kubernetes — https://kubernetes.io/ Phoenix — https://phoenixframework.org/ Nerves Project — https://www.nerves-project.org/ Todd Resudek on Twitter — https://twitter.com/sprsmpl Binary Noggin — https://binarynoggin.com/ Connor Rigby on GitHub — https://github.com/ConnorRigby The Big Lebowski — https://www.imdb.com/title/tt0118715/ Aesop Rock on Twitter — https://twitter.com/AesopRockWins All That Remains on Twitter — https://twitter.com/ATRhq Korn — https://www.kornofficial.com/ Eric Meadows-Jönsson on Twitter — https://twitter.com/emjii Donnie Darko — https://www.imdb.com/title/tt0246578/ Richard Kelly — https://www.imdb.com/name/nm0446819/ Frank Hunleth on Twitter — https://twitter.com/fhunleth SmartLogic — https://smartlogic.io/ Special Guests: Connor Rigby and Dan Ivovich.

Welcome back to part two of our betweenisode! Everybody is working remotely now including ourselves, so today we continue the catch ups we were having with a number of longstanding buddies and chat about life after social distancing! The show is a back-to-back of four different conversations, the first being with Amos King, Chris Keathley, and Anna Neyzberg from Elixir Outlaws. After that we talk to Paul Schoenfelder, before getting on the line with Sophie DeBenedetto and Meryl Dakin. Last but not least we catch up with Dave Thomas. Our four conversations cover the same broad themes, and we mostly share our thoughts about what is happening in the world right now, how we are coping with working remotely, and what particular projects have been keeping us busy. Our guests share varying perspectives about what it means that we are restructuring the way we do things. We talk about how even if you worked remotely before, things feel different now, and we also consider the extra burdens of being a remote software developer. Other topics include the line between complaints and constructive criticism, wild animals roaming the streets, and the general atmosphere in our different locations. From a tech point of view, we touch on IoT development, various GitHub projects to get involved with, why students aren’t learning how to program properly anymore, and a lot more. Get it all here and make sure you stay tuned for episode one of season four! Key Points From This Episode: Scaling up the NFL Draft website for remote screening. Home life and side projects in the quarantine: Mogde Podge, a baby, and game development. Shameless plugs from everybody: Binary Noggin, ElixirBridge, and Finch. Isolation, low supplies and trying to stay positive at present. Imagining roaming wild animals now that humans are in quarantine. Advice from Paul who works at home for surviving social distancing. What Paul is doing for Ockam to secure IoT devices. The danger of starting hack vulnerable tech companies. A plug from Paul to get involved with Lumen. Nature taking over; Meryl and Sophie’s experiences in Brooklyn and Westchester right now. Working from home versus working from home due to a global crisis. Domestic squabbles over bandwidth between Meryl and her software developer brother. Lessons learned to stay sane during quarantine: getting dressed. Extra tasks remote developers are having to do remotely; becoming project managers. The difference between complaints and legitimate critiques of work systems. Dave’s amazing remote communications setup 40 miles north of Dallas. The situation where Dave is with regard to coronavirus and freedom. How COBOL has not become too broad despite not using libraries. The history of programming languages that Dave teaches. That PDP-11 runs better emulated in Javascript than in its original hardware. A drawback of modern development: not understanding hardware. How Dave is digitizing his SMU courses due to teaching them online at present. All the effort Dave puts into grading his students’ exercises. Issues that coding is not taught rigorously enough; students can’t ‘program’. How well the human race is doing to mobilize en masse right now. Whether tech caused the crisis and humanity could manage this crisis 100 years ago. Links Mentioned in Today’s Episode: Eric Oestrich — https://oestrich.org/ Justus Eapen — https://www.linkedin.com/in/justuseapen/ Amos King — https://www.linkedin.com/in/amosking/ Chris Keathley — https://keathley.io/ Anna Neyzberg — https://www.linkedin.com/in/anna-neyzberg-93545316/ Elixir Outlaws — https://elixiroutlaws.com/ NFL Draft — https://www.nfl.com/draft/home Modge Podge — https://www.amazon.com/Mod-Podge-Waterbase-16-Ounce-CS11302/dp/B001IKES5O Star Trek — https://intl.startrek.com/ Sublime — https://www.sublimetext.com/ VSCode — https://code.visualstudio.com/ Binary Noggin — https://binarynoggin.com/ Connor Rigby — https://binarynoggin.com/author/connor/ ElixirBridge — http://elixirbridge.org/ Nico Piderman — https://github.com/sneako Quinn Wilton — https://github.com/QuinnWilton Jose Valim — https://github.com/josevalim Finch Library— https://github.com/keathley/finch Paul Schoenfelder — https://www.linkedin.com/in/gotbones/ Ockam — https://www.ockam.io/ Lumen — https://github.com/lumen/lumen Timex — https://github.com/bitwalker/timex Sophie DeBenedetto — https://www.linkedin.com/in/sophiedebenedetto/ Meryl Dakin — https://github.com/meryldakin Flatiron — https://flatironschool.com/ Sophie DeBenedetto’s GitHub Post — https://www.thegreatcodeadventure.com/my-long-distance-relationship-with-github/ Elixir School — https://elixirschool.com/en/ Meryl Dakin’s Watch if Your Dare Episode — https://www.stitcher.com/podcast/watch-if-you-dare/e/68798094?autoplay=true Luigi’s Mansion — https://www.nintendo.co.za/Games/Nintendo-Switch/Luigi-s-Mansion-3-1437312.html Dave Thomas — https://pragdave.me/ COBOL — https://www.tutorialspoint.com/cobol/index.htm PD-11 — https://history-compute

The world has changed so much since the end of season 3, that we thought we’d put together a special Betweenisode to tide you over until Season 4 launches. In this episode, we talk to several friends and respected members of the Elixir community, about how they’re coping and tips they have for retaining some normalcy in your life if you’re suddenly having to work from home. Our first guest, Saša Jurić, of Very Big Things, and author of the unrivaled Elixir in Action, has had the privilege of working from home for several years. He shares the importance of having a routine, connecting with people, and why you should get out of your pajamas and into some real clothes when you work. He also shares what it’s been like in his home city of Zagreb, and how previous devastating events have in some way prepared him for what’s currently happening. Bruce and Maggie Tate of Groxio, an educational platform to learn languages, also join us. Maggie shares more on her culinary adventures, and the importance of having a definite start and finish time to your day. Bruce talks about some of the professional projects he’s working on, and why he believes it’s crucial to tackle difficult technical skills outside of developing. Other guests include James Edward Gray II, who shares more about the incredible way he and his daughter have been bonding, Jim Freeze, founder of ElixirConf, and his son Chris, who share some of the benefits of working from home, and show us how to see the silver lining during this difficult time, and Frank Hunleth, of Nerves Project, who talks about what he’s up to. There have certainly been more changes in the world than we could have anticipated, so it was wonderful to catch up and see how people in our community have been coping. Be sure to tune in today! Key Points From This Episode: Learn what’s happening in Saša’s home city, Zagreb, and what he’s doing to keep busy. Saša’s advice for coping during the pandemic and preventing information overload. The transition to remote work in Saša’s company and the impacts it’s had on workload. How Saša started working remotely and the main lessons he has learned from doing it. What Saša believes the future of virtual events and conferences will be. Find out how Bruce and Maggie are dealing with these strange times. Groxio’s mission in terms of learning and Bruce and Maggie’s tip for working from home. Current projects that Bruce and Maggie are working on both at Groxio and personally. What’s in the pipeline with Groxio’s Elixir material and Bruce and Maggie’s plugs. How James is holding up and his take on the COBOL debacle. Find out what motivated James to transition from Ruby to Elixir and what it’s been like. James’s experience working from home and tips for people who are new to it. Specific versus general solutions: The difference and how James thinks we can tackle this. Hear James’s ExVenture plug, which is Eric’s project. Jim’s and Chris’s experience of the lockdown and the silver linings that have come from it Find out Jim and Chris’s necessities for working from home and being productive. Jim’s plans for ElixirConf for this year and 2021, and Chris and Jim’s final plug. Frank’s tips for working from home and his product plugs. Links Mentioned in Today’s Episode: Saša Jurić on Twitter — https://twitter.com/sasajuric Saša Jurić on LinkedIn — https://hr.linkedin.com/in/sa%C5%A1a-juri%C4%87-21b23186 Erlangelist — https://www.theerlangelist.com/ Very Big Things — https://verybigthings.com/ Elixir in Action — https://www.manning.com/books/elixir-in-action-second-edition Bruce Tate — https://www.linkedin.com/in/bruce-tate-a836b Bruce Tate on Twitter — https://twitter.com/redrapids Maggie Tate on LinkedIn — https://www.linkedin.com/in/maggie-tate-230234171 Groxio — https://grox.io/ Programmer Passport — https://elixirforum.com/t/programmer-passport-grox-io-pragprog/28253 Lonestar Elixir — https://lonestarelixir.com/ James Edward Gray II — https://twitter.com/JEG2 COBOL — https://www.tutorialspoint.com/cobol/index.htm Gray Inc — http://graysoftinc.com/ Programming Erlang — https://pragprog.com/book/jaerlang2/programming-erlang Nathan Long — https://twitter.com/sleeplessgeek POV-Ray — http://www.povray.org/ Elixir Wizards S02 Eric on ExVenture — https://podcast.smartlogic.io/season-two-oestrich Jesse Link — http://www.jesselink.com/ Jim Freeze on Twitter— https://twitter.com/jimfreeze ElixirConf — https://elixirconf.com/2020 Chris Freeze on Twitter— https://twitter.com/chrisfreeze_ Tesla Car Lot — https://teslacarlot.com/ David Antaramian — https://www.linkedin.com/in/davidantaramian/ PepsiCo — https://www.pepsico.com/ Nerves Project — https://www.nerves-project.org/ Frank Hunleth on Twitter — https://twitter.com/fhunleth SmartLogic — https://smartlogic.io/ Special Guests: Bruce Tate, Chris Freeze, Dr. Jim Freeze, Frank Hunleth, James Gray, Maggie Tate, and Saša Jurić.

In this episode, we take a look into the current contexts and home lives many of us find ourselves in today, offering top tips for working remotely from home during these challenging times. The lockdowns have caused many of us to reflect. To reflect on our lives, our work, what we’re grateful for, and in this case, our epic last season of Elixir Wizards! Here, we take you through the highlights, the lowlights, our biggest lessons, our juiciest debates, and what you can expect for Season 4 – in sickness and in health. Stay safe, listen, and enjoy! Key Points from This Episode: The importance of demarcating your workspace, especially when the kids are home! Always put your pants on: Why sticking to your morning schedule helps productivity. Ways to eliminate the potential for distraction when working from home. How working from home is enabling programmers to see one another’s human side. Taking a break from conferences, cognition, and learning how to birth a baby Oestrich. Third dimensions and entering the tangential learning plane with Brooklyn Zelenka. The Surprise Toddcast: Why the improvised episode was a hit. What it was like interviewing entrepreneurial couple, Bruce & Maggie Tate. Remember the time the father and son roasted each other on the podcast mic? Why your podcast audience wants to know your guests on a more personal level. A recap of the numbers from Season 1-3 and the 40,000+ Elixir Wizards downloads. A sneak peek into the new Elixir Wizards theme for the upcoming Season 4. Lib versus Web and other essential tips for the lazy Phoenix users out there. Why we need a whole season on application architecture and one-letter module names. The debate sparked by the disagreement between Chris Keathley and Brooklyn Zelenka. Hackers, painters, Paul Graham, and the argument made in favor of dynamic typing. Find out more about Sophie and Meryl’s epic takeover of Elixir Wizards! Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ Eric Oestrich — https://twitter.com/ericoestrich?lang=en Justus Eapen — https://twitter.com/justuseapen Brooklyn Zelenka on Witchcraft — https://podcast.smartlogic.io/season-two-zelenka Brooklyn Zelenka — https://twitter.com/expede?lang=en Bruce and Maggie Tate from Groxio on Training — https://podcast.smartlogic.io/s3e8-groxio Saša Jurić — https://twitter.com/sasajuric Bonus Toddcast & Lonestar Preview — https://podcast.smartlogic.io/s3e14-bonus-toddcast-and-lonestar-preview The Lonestar Lunchisode — https://podcast.smartlogic.io/s3-lonestar-lunchisode-2020 Dave Thomas — https://www.davethomas.net/talks_index.html Bonus Episode: Outlaws and The Wizards — https://podcast.smartlogic.io/s3-bonus-outlaws-and-wizards Chris Keathley — https://twitter.com/ChrisKeathley Paul Graham — http://www.paulgraham.com/ Sean Lewis from Divvy on Performance, Hiring and Training — https://podcast.smartlogic.io/s3e12-divvy Devin C. Estes — https://twitter.com/devoncestes?lang=en Muzak — https://www.kickstarter.com/projects/devonestes/muzak-a-mutation-testing-library-for-elixir-and-erlangSpecial Guest: Todd Resudek.

Welcome to another extra special episode of Elixir Wizards! We have guest hosts today, Meryl Dakin of Frame.io and Sophie DeBenedetto of Github, and they welcome Steven Nunez, Staff Engineer at the Flatiron School, and Sean Callan, creator of Elixir School, to the show. Where some would see the fact that Elixir doesn’t have a ton of readily available answers out there as a restriction to mastering the language, our guests argue that this is the best educational environment. Writing about challenges and teaching others how you overcame them are some of the best ways to learn. We also discuss concurrency and other contrasts with prominent languages. Our guests weigh in on dealing with students and how far enthusiasm and openness can go in helping inspire other minds. Steven stresses the need for greater resources, especially at a beginner level, as this will lower the barrier to entry for new programmers and ultimately benefit the entire Elixir community. Key Points From This Episode: An introduction to Sean and Steven, their work and experience with Elixir. Work and professional horoscopes for the panel of today's podcast! The accidental path that led Sean to Elixir and the translations that affirmed his work. The use of writing and blogging in your own education; teaching is learning twice! Steven's early attraction to Elixir and the obsession and evangelism that followed. Concurrency visibility and differences between Elixir and other languages. Different tracks for learning; coming into Elixir as a beginner or as someone with experience. The evolution of thought around education and things that have changed at Elixir School. Learning that includes reasons why; you don't know what you don't know! Knowing your students and keeping them excited to maintain a passion for learning. Growing confidence and the benefits of great resources for the spread of increasing skills. Scratching your own itch; write the educational information that you cannot find yourself. Our guest's Elixir wish lists; more learning opportunities, widespread adoption and beginner-friendly content. Requests about Elixir from our guests, a few plugs and how to connect with them! Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ Sophie DeBenedetto — https://twitter.com/sm_debenedetto Meryl Dakin — https://twitter.com/meryldakin Steven Nunez — https://twitter.com/_stevennunez Sean Callan — https://twitter.com/doomspork System 76 — https://system76.com/ Flatiron — https://flatironschool.com/ Elixir School — https://elixirschool.com GitHub — https://github.com/ Erlang — https://www.erlang.org/ Phoenix — https://www.phoenixframework.org/ Kubernetes — https://kubernetes.io/ The Developer's Guide to Content Creation — https://www.developersguidetocontent.com/ Stephanie Morillo — https://www.stephaniemorillo.co/ Elixir and The Beam: How Concurrency Really Works https://www.thegreatcodeadventure.com/elixir-and-the-beam-how-concurrency-really-works/Special Guests: Sean Callan and Steven Nunez.

Saša Jurić is a household name in the Elixir and Erlang space and we are so glad to finally welcome him on to the show today! Author of Elixir in Action, Saša is here to discuss training and his thoughts on getting a team up to speed with regards to testing and beyond. We hear from our guest about his discovery of Elixir, his uncharacteristic early adoption of the language, and why he chose it. From there, Saša talks a bit about his book, the opportunity that arose for him to write it after Manning approached him and how he views its place among other prominent pieces of literature on the subject. We discuss early steps in the process of learning Elixir for new programmers and old, and Saša weighs in on when it might be a good idea to put in the effort. We also get to hear about very big things, where Saša works and the central work and services of the agency. The last part of our conversation is spent on more technical aspects of Saša's work, his approach to coding in general and then approaches to testing and the training side of this. Join us today for this great conversation! Key Points From This Episode: Saša's discovery of Elixir and his first experiences of the language. A lucky opportunity to write a book that presented itself to Saša! The complementary nature of Elixir in Action; reading it in conjunction with other books. Ideas on how to introduce the concepts of Elixir to new programmers and the unfamiliar. The effort needed in order to understand and adopt the new paradigm of Elixir. Saša's work at very big things and the services that the agency offers. The most useful idioms that Saša uses and the modes of operation at that agency. Saša's use of Dialyzer for debugging despite its imperfections. The exploratory nature of good coding and finding solutions as you go. Helper libraries and comparing functions from Saša's own one! Training for unit, feature and integration testing; Saša's approach for his team. Differentiating between the different types of testing and the importance of naming. Clarifying Saša's philosophy on testing and his understanding of the term 'unit'. Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ Saša Jurić on Twitter — https://twitter.com/sasajuric The Erlangerist — https://www.theerlangelist.com/ Elixir in Action — https://www.manning.com/books/elixir-in-action-second-edition?query=sa%C5%A1a - use special code podexwizards20 for 40% off your purchase at Manning Publications! Michael Stevens — https://www.linkedin.com/in/michaelstephens2 Manning — https://www.manning.com/ Programming Elixir — https://pragprog.com/book/elixir16/programming-elixir-1-6 Learn Functional Programming with Elixir — https://pragprog.com/book/cdc-elixir/learn-functional-programming-with-elixir very big things — https://verybigthings.com/ Dialyzer — https://hexdocs.pm/dialyzex/Mix.Tasks.Dialyzer.html Hackers & Painters — http://shop.oreilly.com/product/9780596006624.do Paul Graham — http://www.paulgraham.com/ Justin Searls Blog - https://blog.testdouble.com/ Marie Kondo — https://konmari.com/Special Guest: Saša Jurić.

Elixir Outlaws invited us to join them for a special crossover episode, recorded live at Lonestar Elixir 2020. Join us for a conversation around fun and learning in development, highlights from day one of the conference, remembering Joe Armstrong, and more. Guests / Hosts Justus Eapen @justuseapen Anna Neyzberg @ANeyzb Amos King @adkron Bruce Tate @redrapids Susumu Yamazaki @zacky1972 Melvin Cedeno @TheCraftedGem Tim Mecklem @tim_mecklem Elixir Outlaws https://elixiroutlaws.com/ Lonestar Elixir https://lonestarelixir.com/Special Guests: Amos King, Anna Neyzberg, Bruce Tate, Chris Keathley, Melvin Cedeno, Susumu Yamazaki, and Tim Mecklem.

Our guest today, Devon Estes, approached us about the possible opportunity for Elixir to optimize and build out the pandas data analysis and manipulation tool, sharing why he thinks it would be a valuable addition to the Elixir open source ecosystem. But Devon joins us to contribute to our ongoing discussion about performance and training in the Elixir world, sharing about his current work on the beta for Sketch Cloud, his previous Erlang consultancy role at one of the largest banks in Europe, and the massive responsibility he carried while working on the bottom line application. He continues to advise listeners on the considerations for optimizing Erlang performance and solving database-specific problems, and the memory constraints he comes up against in the Sketch Cloud application. Devon talks about Benchee, a benchmarking library created by his friend, and how the two of them have continued to develop this tool, including its performance testing capabilities and how they deconstructed the benchmarking steps to build out the library. He also talks more broadly about the importance of considering the data when distinguishing between facts and opinions in conversations about performance. Key Points From This Episode: What Devon believes would be a valuable addition to the Elixir open source ecosystem. Why optimizing and building out the pandas tool will be worth a company’s time and effort. Devon’s experience with pandas and Python, and recognizing the opportunity for Elixir. Working on the beta for Sketch’s Cloud that will allow real-time collaboration. Devon’s consultancy role at Klarna, one of the largest banks in Europe. The responsibility involved in working on the bottom-of-the-stack application at Klarna. Considerations for optimizing Erlang performance and why you should look at the tail. Solving the database performance problems – running queries and searches – at Klarna. The unique memory constraints of Sketch Cloud and the problem with receiving large files. More about Benchee, a benchmarking library, and all its performance testing capabilities. Deciding whether a function is responsible for other things when benchmarking. The time Devon spends on optimizing performance and the first two steps in the process. The profiling process of determining which function is slow and writing a benchmark for it. Distinguish between a fact and an opinion by considering the data (or lack thereof). Keeping in mind that truth is time-bound, and it also applies to benchmarking. Deconstructing the steps in the process of further developing Benchee. How Devon became a maintainer of the Elixir track for Exercism, and what the role involves. Links Mentioned in Today’s Episode: Devon Estes — http://www.devonestes.com Devon Estes on Twitter — https://twitter.com/devoncestes?lang=en Devon Estes on GitHub — https://github.com/devonestes pandas — https://pandas.pydata.org Python — https://www.python.org Sketch — https://www.sketch.com Klarna — https://www.klarna.com/international/ Erlang — https://www.erlang.org PostgreSQL — https://www.postgresql.org Ruby — https://www.ruby-lang.org/en/ Adopting Elixir — https://www.amazon.com/Adopting-Elixir-Production-Ben-Marx/dp/1680502522 Exercism — https://exercism.io JavaScript — https://www.javascript.com Benchee — https://github.com/bencheeorg SmartLogic — https://smartlogic.io/ Elixir — https://elixir-lang.org Elixir Wizards Podcast — https://podcast.smartlogic.io Update: What's Inside a Reduction? http://www.devonestes.com/inside-a-reductionSpecial Guest: Devon Estes.

Welcome back to the show for this special edition Lunchisode, coming to you live from the Lonestar Elixir 2020 Conference! We have a revolving door of speakers at this informal roundtable and a few friends and associates stop by to introduce themselves, share their thoughts on the conference so far and subjects that they care about. We follow up on some of the ideas raised in the Lonestar preview episode as well as hear about new and interesting ways that Elixir is being used at a variety of companies, including SalesLoft, ActiveProspect, SmartRent and more! We also consider the place of Elixir education and go deeper on the topic of finding fun and meaning in our programming pursuits and beyond. Join us for this special edition and stay tuned for the next installment soon. Key Points From This Episode: Thoughts on the conference so far — the talks and venue. SalesLoft's Elixir adoption and how the decision was made by those in power. Bruce Williams' current work at GitHub and his project on Absinthe. Elixir usage in Mexico and the prominent organizations and companies that use it. Some information on the Observability Working Group and what they are currently busy with. Differences between tracing and logging; tracing is essentially distributed logging. What it means for the programmer when they bump up against a challenge! The amount of effort that should go into developing entry points for new Elixir developers. Education in the Elixir space and the success of the bootcamp model. Considering the ongoing utility of unit tests and changing up training strategies. The work done by SmartRent in real estate and how Elixir fits into their tech stack. Links Mentioned in Today’s Episode: Lonestar Elixir — https://lonestarelixir.com/ Bruce Tate — https://twitter.com/redrapids Steve Bussey — https://twitter.com/YOOOODAAAA Bruce Williams — https://twitter.com/wbruce Ricardo Echavarria — https://twitter.com/r_icarus Brain Naegele — https://twitter.com/bside_bryan Frank Kumro — https://twitter.com/frigidcode Zach Thomas — https://twitter.com/ZachDCThom Dave Thomas — https://twitter.com/pragdave Jon Carstens — https://twitter.com/JonCarstens Todd Resudek — https://twitter.com/sprsmpl SmartLogic — https://smartlogic.io/ SalesLoft — https://salesloft.com/ Absinthe — https://github.com/absinthe-graphql/absinthe Sophie DeBenedetto — http://sophiedebenedetto.nyc/ RestFest — https://www.restfest.org/ Observability Working Group — https://erlef.org/wg/observability GigCity Elixir Conference — https://www.gigcityelixir.com/ ActiveProspect — https://activeprospect.com/ The Pragmatic Programmer — https://pragprog.com/book/tpp20/the-pragmatic-programmer-20th-anniversary-edition SmartRent — https://smartrent.com/ Blinker — https://www.blinker.com/Special Guests: Brain Naegele, Bruce Tate, Bruce Williams, Dave Thomas, Frank Kumro, Jon Carstens, Ricardo Echavarria, Steve Bussey, Todd Resudek, and Zach Thomas.

This week we're delighted to share a special format bonus episode! We are joined by guest co-host Todd Resudek as well as a number of guests who each share a little bit about what they're working on and in many cases their upcoming presentations at Lonestar Elixir. Special episode guests: Angel Jose, Senior Platform Engineer at Cars.com Dave Lucia, VP of Engineering at SimpleBet Greg Mefford, Senior Back-End Engineer at Bleacher Report Melvin Cedeno, Elixir Developer at SplitGyms Zach Thomas, API Developer at Blinker Most of our guests weigh in about their upcoming presentations at the event and we also get to chat about a few near and dear topics with our rotating cast. We hear about where they are working, their experiences with Elixir and their thoughts on education and company culture. It's an unusual episode but one we are so glad to have had the chance to make! We also find time to touch on our focus for the next season of the podcast, which is very exciting for all of us over here at the show. Remember to stay plugged in for more on Lonestar Elixir and attend if you can! Key Points From This Episode: Some thoughts on LiveView and its adoption by new developers. Angel's work at Cars and how they are using Elixir and LiveView to rewrite everything. Chatbots and the immediate benefits of using Elixir to rewrite them. The elevator pitch on SimpleBet and the tech stack, skillset and ecosystem of the company. Why Dave and his team have moved away from Rust! A quick tease of what to expect for Season 4 of the podcast: Architecture of Applications! How Bleacher Report is using Elixir to build the 'third space' for sports fans. Team building and expansion at Bleacher Report and the stages of scaling. A sneak preview of Greg's upcoming talk at Lonestar! How Greg got started with Nerves and why it has a special place in his heart. The theme of Melvin's talk at Lonestar; untraditional routes and emotions in tech. Considering the usefulness of boot camps, the value of ISAs and CS programs. Zach's background in Elixir and his current work at Blinker with the language. Experiences at Turing and in liberal arts during college. Zach's Lonestar talk elevator pitch: 'Getting the Frog out of the Well'. The allegory of the cave, 'what is water' and how this differs from Zach's idea. Why don't we like statically typed things as much as we should? Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ Lonestar Elixir 2020 — https://lonestarelixir.com/ Todd Resudek — https://medium.com/@toddresudek Todd Resudek on Twitter — https://twitter.com/sprsmpl Angel Jose — https://github.com/ajose01 Dave Lucia — https://github.com/davydog187 Greg Mefford — https://github.com/GregMefford/blinkchain Melvin Cedeno — https://gist.github.com/normanrs/eeb5cc91cb10eeb7d3e43168396efb27 Zack Thomas — https://github.com/zeam-vm/pelemay Sophie DeBenedetto — http://sophiedebenedetto.nyc/ LiveView — https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html ElixirConf — https://elixirconf.com/events Cars — https://www.cars.com/ SimpleBet — https://www.simplebet.io/ Full Stack Developer Horse Drawing Meme — https://knowyourmeme.com/photos/1624070-unfinished-horse-drawing Conway's Law — https://www.thoughtworks.com/insights/blog/applying-conways-law-improve-your-software-development ElixirConf 2019 - Lighting Talk - Are There Benefits Of Crying In Tech — https://www.youtube.com/watch?v=oW5Plkroyxk TRON — https://www.rottentomatoes.com/m/tron Smart Mirror Blog Post — https://medium.com/@toddresudek/building-a-smart-mirror-with-phoenix-liveview-18193ee6438f Bleacher Report — https://bleacherreport.com/ Team Topologies — https://teamtopologies.com/ Nerves — https://nerves-project.org/ Turing — https://turing.io/ CIRR — https://cirr.org/ David Heinemeier Hansson — https://dhh.dk/ Blinker — https://www.blinker.com/ David Foster Wallace — http://www.davidfosterwallacebooks.com/ Gödel, Escher, Bach — https://www.goodreads.com/book/show/24113.G_del_Escher_BachSpecial Guests: Angel Jose, Dave Lucia, Greg Mefford, Melvin Cedeno, Todd Resudek, and Zach Thomas.

Today on the show, we’re joined by Mike Binns and Alex Garibay of DockYard. In this episode, Mike and Alex share their journeys of how they came to work at DockYard and give us a view into DockYard’s hiring and training processes, systems, and philosophies. Here they share what they enjoy most about working at DockYard and their emphasis on being supported in your continual growth as an employee and human being. Key Points from This Episode: Find out how Mike and Alex both got their jobs at DockYard in 2016. Working for a fully remote company: Mike and Alex share their experiences. The amount of languages used at DockYard and what the day-to-day looks like. React VS Ember: Find out DockYard’s opinion on the debate between the two. How to know whether you should be using JavaScript or Live View on your projects. The importance of inclusion and empowerment in the onboarding process at DockYard. How to support and train new employees in “soft” skills, such as communication. Personal strategies Mike and Alex use to help “soften the blow” of feedback and criticism. Discover what DockYard does to support the learning growth of their employees. Learn more about DockYard Friday and the exciting projects that have emerged from it. Helpful resources for learning Elixir and how to remain a curious learner as a developer. Find out the top skills that make a great engineering manager at DockYard today. Links Mentioned in Today’s Episode: Mike Binns on Twitter — https://twitter.com/1stAvenger Mike Binns on LinkedIn — https://www.linkedin.com/in/mikebinns Alex Garibay — https://alexgaribay.com/ Alex Garibay on Twitter — https://twitter.com/_AlexGaribay Alex Garibay on LinkedIn — https://www.linkedin.com/in/alexandergaribay/ DockYard — https://DockYard.com/ SmartLogic — https://smartlogic.io/ RailsConf — https://railsconf.com/ Chris McCord — http://chrismccord.com/ Ember — https://emberjs.com/ Live View — https://support.google.com/maps/thread/11554255?hl=en Elixir in Action — https://www.amazon.com/Elixir-Action-Sa%C5%A1a-Juri-cacute/dp/1617295027 Elixir Conf 2014 Keynote by Dave Thomas — https://www.youtube.com/watch?v=5hDVftaPQwY Sarah Drasner — https://sarahdrasnerdesign.com/ Lonestar Elixir — https://lonestarelixir.com/ Programming Phoenix — https://www.amazon.com/Programming-Phoenix-Productive-Reliable-Fast/dp/1680501453 Jason Goldberger — https://twitter.com/jsonlouis_Special Guests: Alex Garibay and Mike Binns.

Today on Elixir Wizards we are delighted to be joined by Sean Lewis, a senior backend architect at Divvy. One of the many impressive facts about Sean is that he is entirely self-taught, from dabbling in Python and coding to eventually writing a bunch of Ruby tests and working his way up in the product development sphere. In his free time, he likes to play around with electronics and work on other tech-related projects such as developing custom smart home devices. In this episode, Sean discusses his recent Meetup talk on the implementation of Broadway and explains Divvy’s tech stack choices that include React, Elixir, and Python. He dives into the topic of hiring for Elixir, outlining the challenges and providing strategies and resources to equip new developers in the area of functional programming. For Sean, the most important aspect of onboarding is teaching newcomers to ask the right questions since this is the foundation of the problem-solving process. He shares about Divvy’s approach to recruitment, his role as mentor, how they go about retaining and continuously growing their developers, the importance of being teachable, and then Sean concludes by giving listeners practical advice for ensuring data fidelity. Key Points From This Episode: Sean’s self-taught journey and role as senior backend architect at Divvy. The smart home projects he has recently worked on, including a smart garage. An overview of Broadway and Sean’s Meetup talk regarding implementation. The straightforward tech stack at Divvy: React, Elixir, and Python. The difficulty of hiring for Elixir and finding fintech companies that use Elixir. Strategies and resources for training new engineers on Elixir and functional programming. Why fintech works well with functional programming in the context of authorization. Training state-minimization as a primary concern. Onboarding: a process of teaching developers to ask the right questions. Divvy’s approach to finding and recruiting new employees. Thoughts on why so many Utahn companies use Elixir and the city’s exponential growth. How Sean was recruited by Divvy, his progression to architect, and his role as a mentor. Critical practices for onboarding developers, including assimilating them into the culture. How Devvy continues to grow and retain its engineers. The importance of challenging yourself, constantly learning, and staying teachable. Implementing high-quality checkpoints and other advice for ensuring data fidelity. Links Mentioned in Today’s Episode: Sean Lewis on LinkedIn — https://www.linkedin.com/in/sean-lewis-40375077/ Sean Lewis on Twitter — https://twitter.com/fricsean?lang=en Sean Lewis on GitHub — https://github.com/SophisticaSean Divvy — https://getdivvy.com Ruby — https://www.ruby-lang.org/en/ Broadway — https://hexdocs.pm/broadway/amazon-sqs.html Utah Elixir Meetup — https://www.meetup.com/utah-elixir React — https://reactjs.org Elixir — https://elixir-lang.org Susumu Yamazaki on Twitter — https://twitter.com/zacky1972 Domain Modeling Made Functional — https://www.amazon.com/Domain-Modeling-Made-Functional-Domain-Driven-ebook/dp/B07B44BPFB Slack — https://slack.com/ MongoDB — https://www.mongodb.com PostgreSQL — https://www.postgresql.org Elixir Wizards Podcast — https://podcast.smartlogic.io SmartLogic — https://smartlogic.io/ Special Guest: Sean Lewis.

In line with our current working-with-Elixir theme, today we’re talking about performance with Paul Schoenfelder and Hans Elias Josephsen from DockYard. The two have been working on Lumen, and in this episode, they discuss how this project is incorporated with WebAssembly, a binary instruction format that ultimately allows Elixir to be run in the browser and preserve the semantics of the language. Paul and Hans talk about the specific aspects of Lumen they are working on; the data flow and process of writing Elixir; and the compiler, interpreter and run-time functions involved. Joining in this conversation, you will also hear how they approached starting developing Lumen as a brand new compiler, researching, the aspects Paul wanted to tackle first, and when users can expect Lumen to be released. We also talk about the performance concerns they encountered along the way, the many reasons why Rust was their programming language of choice, and their thoughts on generic associated types in Rust. Key Points From This Episode: • How Paul and Hans got introduced to Elixir and working for DockYard. • An overview of what Lumen is and how it relates to WebAssembly. • WebAssembly code to run Elixir in the browser and preserve the semantics of the language. • The different aspects of the Lumen project that Paul and Hans are involved in. • The data flow and process when writing Elixir and how the compiler function features. • Taking advantage of optimizations that can be performed on the code that is generated. • An explanation of the interpreter and run-time parts of the project. • How they approached the major task of starting with a brand new compiler. • The process of researching and why Paul wanted to get a frontend in place first. • The production readiness of Lumen and when they expect to release it. • Performance concerns they encountered during development. • The relevance of code size for the WebAssembly backend to be usable. • Why Rust was the best choice for building the compiler. • Using Elixir to generate a standard binary that can run on any machine. • A description of generic associated types in Rust and why they are controversial. Links Mentioned in Today’s Episode: Paul Schoenfelder on LinkedIn — https://www.linkedin.com/in/gotbones/ Paul Schoenfelder on Twitter — https://twitter.com/gotbones?lang=en Hans Elias Josephsen on Twitter — https://twitter.com/hansihe DockYard — https://dockyard.com Elixir — https://elixir-lang.org WebAssembly — https://webassembly.org Rust — https://www.rust-lang.org JavaScript — https://www.javascript.com C++ — http://www.cplusplus.com SmartLogic — https://smartlogic.io/ Special Guests: Hans Elias Josephsen and Paul Schoenfelder.

Today on the show we are joined by Sophie DeBenedetto from GitHub and Meryl Dakin from Frame.io to talk about the processes involved in training others and building Elixir projects. They share about studying and working together at the Flatiron School and what they do now in their respective new roles at Github and Frame.io. During their time at Flatiron, they worked on various projects, often collaborating with engineering teams from other companies and having to train these team members in Elixir. They talk about how they managed to develop new features while simultaneously onboarding new people and getting everyone on the same page. For them, the pair programming model had been most beneficial, and they discuss the habits and practices they implemented to encourage team members, optimize each learning experience, and share knowledge during training events. Sophie and Meryl also share the Elixir-specific challenges they encountered while developing applications for 2U, how Elixir’s failure-first programming capability guided them, how they prepare for training workshops, and the productivity hacks that keep them focused and energized. Key Points From This Episode: • How Sophie and Meryl know each other from working and studying at the Flatiron School. • Frame.io as a tool that facilitates the communication between video editors and clients. • Meryl’s new role as a full-stack developer working with Elixir and React. • The projects they worked on at Flatiron and partnering with various companies like 2U. • Their secret to developing new features while also introducing new team members to Elixir. • The benefits of pair programming and teaching a programming language to others. • Reserving time to celebrate wins and knowledge share during training events. • Key lessons they learned from their collaboration with the 2U team. • Elixir-specific challenges during the development of the applications project with 2U. • How Elixir’s failure-first programming capability ultimately helps developers. • Sophie and Meryl’s experience using LiveView at Flatiron and the problems encountered. • The work that went into preparing for training workshops. • Advice for teaching someone who is not technical to become a working developer. • Productivity hacks to stay focused and regain energy. Links Mentioned in Today’s Episode: Sophie DeBenedetto on LinkedIn — https://www.linkedin.com/in/sophiedebenedetto/ Sophie DeBenedetto on Twitter — https://twitter.com/sm_debenedetto Meryl Dakin in LinkedIn — https://www.linkedin.com/in/meryldakin/ Meryl Dakin on Twitter — https://twitter.com/meryldakin Eric Oestrich — https://oestrich.org Frame.io — https://frame.io GitHub — https://github.com Flatiron School — https://flatironschool.com Elixir — https://elixir-lang.org React — https://reactjs.org 2U — https://2u.com Kubernetes — https://kubernetes.io Ruby — https://www.ruby-lang.org/en/ Elixir School — https://elixirschool.com/en/ Drawing on the Right Side of the Brain — https://www.amazon.com/Drawing-Right-Side-Brain-Definitive/dp/1585429201 Etsy — https://www.etsy.com EMPEX NYC Conference — https://empex.co/nyc.html SmartLogic — https://smartlogic.io/ Special Guests: Meryl Dakin and Sophie DeBenedetto.

In today’s episode we have one of our favorite recurring guests, Brooklyn Zelenka, joining us once again! Brooklyn has been on the show in both the first and second seasons to speak about Elixir and functional programming. In those conversations, it came up that this topic is far from exhausted, and since Season 3's theme is working with Elixir, we thought it would be great to have Brooklyn on for a third time. Today, Brooklyn does not speak to Elixir specifically though, but on functional programming more broadly. Fission, her company which is working on developing next-generation hostless apps, actually uses Haskel, but Brooklyn has a ton of experience across the board. She gives us some great insights into what makes the functional versus OOP paradigm great and helps us to understand some of the inner workings of both worlds, talking about abstraction, application, data orientation, and more. Interestingly, Brooklyn does employ some imperative programming in her company through the use of Typescript, but uses a functional style to get around the context switch. We spend some time toward the end of the show digging deeper into macros, and Brooklyn helps to revise understandings of them as code which writes more code as well as clarifies the term 'homoiconic' as it relates to ASTs. Brooklyn covers a whole lot more today so hop on for a deep dive into functional programming with today's great guest. Key Points From This Episode: • Why Brooklyn uses FPE: it can be reused and reasoned about. • Two things that functions provide: abstraction and application. • Data orientation and hiding information: imperative vs functional paradigms. • Understanding imperative programming: it’s less structured and hard to reason about. • Challenges experienced imperative programmers face with functional programming. • Differences between Elixir, Erlang, Haskel, Elm, and Clojure. • Using Clojure: tradeoffs, distinctions, tooling, flexibility, and compatibility with Java. • The language Brooklyn could use if only one existed: Racket. • Bridging functional and imperative paradigms through disciplined use of style. • Segfaults in Haskell related to its compatibility with lib C. • How to use Musl instead of lib C by employing docker files. • Algebraic types and why static types aren’t hindrances in functional languages. • Preferences for tests or proofs and their role in finding types valuable. • Macros as compile-time functions that are difficult to debug. • A definition of a ‘homoiconic’: high-level syntax which represents the AST. • What makes C macros different from Lisp ones. • Architecture in Elixir and the need for a more user-friendly Haskell. Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ Brooklyn Zelenka on LinkedIn — https://www.linkedin.com/in/brooklynzelenka/ Fission — https://fission.codes/ Seven Languages in Seven Weeks — https://www.amazon.com/Seven-Languages-Weeks-Programming-Programmers/dp/193435659X Chris Keathley — https://keathley.io/ Hackers and Painters — https://www.amazon.com/Hackers-Painters-Big-Ideas-Computer/dp/1449389554 Paul Graham — http://www.paulgraham.com/Special Guest: Brooklyn Zelenka.

Groxio is a great platform that allows programmers to learn new languages easily and broaden their horizons. Our guests today are the team behind Groxio, Bruce and Maggie Tate! In our discussion, we cover the basics and the not so basics of what they do, from how they got into the Elixir world and founded Groxio to the conferences they run and the books they have published. We also talk about the benefits of learning multiple languages and Bruce makes a strong argument for the influence that smaller coding languages have had on his Elixir skills. Maggie and Bruce open up about having a professional and personal partnership and how they manage their marriage and businesses side by side. To finish off we hear about all the exciting things to expect at the Lonestar Conference this year and how it is going to be even better than last year's! Key Points From This Episode: • Bruce and Maggie's background in Elixir and how they started Groxio. • What sets Groxio apart from similar technical education companies. • The inspiration that Bruce got from the Crystal and Pony languages. • How curiosity and dopamine are linked; following new and interesting pathways. • Maggie and Bruce's personal and professional partnership and how they manage it. • The Elixir books that still need to be written and under-appreciated published ones. • A guide to Bruce's books and which to read for particular applications. • Running a conference; the stressful and fun parts for Maggie and Bruce. • Aspirations for the conferences and what to expect at this year's events. • Exciting speakers that will be appearing at the Lone Star Conference. • The controversy around the new Lone Star bat logo! • A few special plugs from our guests for things they are passionate about. Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ Bruce and Maggie Tate — https://grox.io/about Bruce Tate on Twitter — https://twitter.com/redrapids Maggie Tate on Twitter — https://twitter.com/gardenertate Groxio — https://grox.io/ Gig City Elixir — https://www.gigcityelixir.com/ Lone Star Elixir — https://lonestarelixir.com/ Crystal — https://crystal-lang.org/ Pony — https://www.ponylang.io/ Joe Armstrong — https://joearms.github.io/ Elixir in Action — https://www.amazon.com/Elixir-Action-Sa%C5%A1a-Juri-cacute/dp/161729201X Designing Elixir Systems — https://www.amazon.com/Designing-Elixir-Systems-OTP-Self-healing/dp/1680506617/ Andrea Leopardi — https://confengine.com/user/andrea-leopardiSpecial Guests: Bruce Tate and Maggie Tate.

On today's show, we are joined by Dan Ivovich from our team here at SmartLogic! Dan is the Director of Development Operations and has already been a guest and cohost a few times on the show. Today we are talking about hiring and training and his experience with these tasks at the company and especially concerning Elixir. We discuss the challenges Dan has faced in recruiting and the ways in which SmartLogic has lined up resumes and possible candidates through events and meetups. Dan explains some of the difficulties that are common for programmers transitioning into Elixir and how the company approaches the tasks of onboarding and ongoing support. We also get into Dan's favorite resources and tools for staying abreast of Elixir and his recommendations for practices to learn fast as a newcomer before he explains how he thinks about continual learning and expanding his own skillset. The conversation finishes with some thoughts and reflections on functional programming from our guest, so make sure to tune in for all of that and more! Key Points From This Episode: Dan's role at SmartLogic and how he leads the team. Recruiting new employees; collecting resumes and attending events. Challenges posed by recruiting good Elixir programmers and who to look for. Sticking points for people transitioning into Elixir from other languages. The stack at SmartLogic and the number of projects based in Elixir. Onboarding at the company; skills that are transferable to Elixir. Professional development and ongoing support for team members. Dan's favorite tools and resources for learning Elixir. Continual learning and Dan's strategies for growing his skillset. A simple definition of functional programming and Dan's early experiences with it. Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ Dan Ivovich — https://www.danivovich.com/ Dan Ivovich on Twitter — https://twitter.com/danivovich ElixirConf — https://elixirconf.com/events Java — https://www.java.com/ Ruby — https://www.ruby-lang.org/ Python — https://www.python.org/ Rails — https://rubyonrails.org/ Rust — https://www.rust-lang.org/ GO — https://golang.org/ Twitch — https://www.twitch.tv/ Bruce Tate — https://codesync.global/speaker/bruce-tate/ Scala — https://www.scala-lang.org/Special Guest: Dan Ivovich.

We are happy to be joined in this episode by Eric Meadows Jönsson, creator of the hexpm package manager, and an amazing resource who works tirelessly to build the Elixir community. Eric presently works at Brex and was part of the core team at Forza previously. In keeping with our current topic of all things working with Elixir, Eric takes a deep dive into the work he is doing to optimize various interfaces at Brex. He gives us the rundown on the static compile-time checking project he is working on, talking about his aims to build in different warnings and what we can expect from the new release in that regard. You’ll also hear about Eric’s journey learning Elixir and how he had to change his OOP mindset when he got introduced to functional programming at university. He shares the story behind hexpm and Mint, his thoughts about the future of Hex, and some of the processes around accessing the private repositories on its website. We also hear more about Eric’s hiring procedure while working at Forza, how he teaches functional programming to students at ElixirConf, and some of the major performance bottlenecks he experiences using Hex. Tap into the incredible resource that is Eric and hear more about how you can link with him online to learn further in the future by tuning in! Key Points From This Episode: Jose Valim, the Ecto library, and Eric’s journey with Elixir since 2012 at a coding camp. Early-stage static compile-time checks that Eric is adding to the compiler at Brex. Whether the static compile-time checks Eric is adding constitute a type system or not. Static compile-time checks in the current system such as undefined function warnings. Features of the new static compile-time check release: refactored checks, etc. Currently, these checks happen at compile-time, or when Elixir compiles into the byte code. Whether these checks will move into BEAM: currently it’s in Elixir and at an early stage. The Erlang compiler already does type inference during compilation. Eric’s Erlang proficiency and why he had to brush up on it through using Elixir. What makes Eric helpful with Hex: his debugging skills and availability to answer questions. How Eric got started with Hex adding an intake for Git packages. The story behind Hex regarding ties to Elixir and Devinus from Pool Boy. Todd’s perspective on Eric as a smart and nice mentor who sleeps very little. Changes that Eric sees happening in Elixir. Hex will no longer support older Elixir versions so that it can enable better maintenance. Another change will be a refactoring of the resolution version algorithm. Security-related updates that Todd has been working on. Private versus public repositories on the hex.pm website. Hiring challenges at Forza and how Eric found the right team out of scarce people. Eric looks for people who love being programmers and have a passion for learning. Tactics Eric uses to train functional programming such as hosting ElixirConf workshops. Important fundamentals in functional programming: using data structures to model data, etc. Differences between functional and object-oriented programming: data vs classes. The role of types in Eric coming to understand functional programming better. Performance bottlenecks in Hex such as dependency resolution. How every package manager/resolver compromises, exemplified by NPM and Rebar3. Origins of Mint: wanting http2 support for Hex, and more. Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ Eric Meadows Jönsson on GitHub – https://github.com/ericmj Eric Meadows Jönsson on Hexpm — https://hex.pm/users/ericmj Brex — https://brex.com/ Todd Resudek on LinkedIn — https://www.linkedin.com/in/toddresudek Justus Eapen on LinkedIn — https://www.linkedin.com/in/justuseapen/ Eric Oestreich on LinkedIn — https://www.linkedin.com/in/eric-oestreich-8b55aab/ hexpm on GitHub — https://github.com/hexpm Google Summer of Code — https://summerofcode.withgoogle.com/ Jose Valim on GitHib — https://github.com/josevalim Pool Boy — https://github.com/devinus/poolboy Devin Alexander Torres — https://github.com/devinus Voitech — https://www.voitech.biz/ Hex — https://hex.pm/ hexpm specifications — https://github.com/hexpm/specifications Slack — https://slack.com IRC —https://hexchat.github.io/ Forza — https://www.forzafootball.com/women ElixirConf — https://elixirconf.com/events Chalmers University — https://www.chalmers.se/en/Pages/default.aspx Fastly — https://www.fastly.com/ NPM — https://www.npmjs.com/ Rebar 3 — https://github.com/erlang/rebar3 Mint — https://www.mint-lang.com/ Ruby Gems — https://rubygems.org/ Andrea Leopardi on GitHub — https://github.com/whatyouhide?tab=overview&org=ForzaElixirSpecial Guest: Todd Resudek.

Our guest on the show today is blogger, software cowboy, and podcast host Chris Keathley. Chris is a senior engineer at Bleacher Report, co-host of Elixir Outlaws, and writer of an assemblage of open-source software. He joins us today to speak about his new projects, his journey with functional programming, and what it is like to run Bleacher Report’s infrastructure on Elixir. Chris gives us the lowdown on Norm, a data validating interface he recently completed, weighing in on how it is different from Dialyzer and what it can offer as far as scalability. We hear more about how Chris got introduced to Elixir through Haskell, why he wishes he learned Clojure sooner, and why Ruby on Rails isn’t going anywhere soon. Chris also gets into the tradeoffs these languages make to correlate with Erlang. He argues that Elixir can only be more widely adopted if more people build cool things in it, and then lays out some of its power in supporting Bleacher Report’s user interface. We pick Chris’s brain about what his company is trying to optimize at the moment and hear about their preference for capacity over speed, and their techniques for failing gracefully during traffic spikes. Chris tells us how much he loves Elixir due to its use of ETS and other functionality which allows Bleacher Report to keep running even above capacity. Finally, we hear about some of the observability practices that Bleacher Report uses when deploying new systems and predicting future spikes. Plug in for a great conversation and hear why you should get building with Elixir now! Key Points From This Episode: Chris’s explanation of Norm, his new software that describes data moving through a system. Chris’s introduction to functional programming through learning Haskell, Clojure, and Elixir. What makes a great functional language: immutable data and first class functions. Things that make Clojure great, such as its thought out, holistic design. Characteristics of Cons lists versus RRB trees, and what makes the latter better. An acknowledgment of the necessity of the tradeoffs Elixir makes to interact with Erlang. A little bit about the language Chris wrote to do the admin of code challenges in. Why Ruby (on Rails) will not be replaced by Elixir due to commoditization that surrounds it. An argument that Elixir can only be more widely adopted if more people build with it. Why any language can build any program thus comparisons between them are arbitrary. Where Chris sets the bar as to when something is performant. Chris’s preference for high user capacity capability over speed of delivery at Bleacher Report. Optimization projects at Bleacher Report such as using few boxes and handling traffic spikes. Things Chris loves about Elixir such as its ability to deliver more from its boxes. Elixir’s use of ETS and how Chris coded a complex problem in half a day using it. How Chris detects spikes using time series, StatsD, and other observability tools. Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ Chris Keathley on GitHub — https://github.com/keathley Chris Keathley Blog — https://keathley.io/ ElixirConf 2019, Contracts for Building Reliable Systems presented by Chris Keathley — https://www.youtube.com/watch?v=tpo3JUyVIjQ The Big Elixir 2019 - Keynote: Adoption - Brian Cardarella — https://www.youtube.com/watch?v=ghpIiQKRfQ4 Bleacher Report — https://bleacherreport.com/ Elixir Outlaws Podcast — https://elixiroutlaws.com/ Norm — https://github.com/keathley/norm Dialyzer — http://erlang.org/doc/man/dialyzer.html Haskell — https://www.haskell.org/ Clojure — https://clojure.org/ Erlang — https://www.erlang.org/ Chris Okasaki — https://github.com/chrisokasaki Discord — https://discordapp.com/company StatsD — https://www.datadoghq.com/blog/statsd/ Prometheus — https://prometheus.io/ Opentracing — https://opentracing.io/Special Guest: Chris Keathley.

On today’s show, we welcome Justin Schneck and Frank Hunleth, luminaries from the Nerves team! We take a dive into the world of Nerves with them, covering themes of performance, problem-solving, transitioning to hardware, and breakthroughs in the field. We begin with a conversation on how Elixir handles performance issues on the range of devices they support and Frank gets into how the team solved an early boot time discrepancy between a PC and a Raspberry Pi board. Other big themes for today are ironing out the kinks in the system registry model and merging Erlang and into hard real-time. After squeezing some information out of the guys about their use of ugly code hacks we get into some visionary decisions as well as things the team wished they could have done differently at Elixir (see the release of the new networking stack). Finally, we end off with what Frank and Justin are excited about as far as developments in the Nerves community, so be sure to plug into this one! **Key Points From This Episode: What Justin did in Tokyo, from soaking in hot springs to debugging in Kanji. An explanation of The Erlang Ecosystem Foundation, an embedded systems working group. The use of the VintageNet library for setting up multi-hold nerve networks. How Elixir handles performance issues on the range of devices they support. A breakdown of troubleshooting processes as far as acceleration with FPGAs. Issues with dependencies that occur when starting a network node on a Nerves device. How Elixir is trying to evolve past the system registry model. Identifying the challenge of reconfiguring early boot time which Elixir is facing. How Elixir solved a load time discrepancy between a PC and the Raspberry Pi board. Which situations require hardware when Elixir is too slow, such as video encoding. Japanese research into GPU, FPGA and SIMD optimization involving wrapping code blocks. Merging Erlang which is soft real-time into hard real-time. Examples of ugly but fast code hacks in Elixir. Hacks and the pitfalls of system registry such as returning to a prompt when an app crashes. Things Elixir would have done differently in working with Nerves if could they rewind time. Why releasing a new networking stack means Elixir could have done things differently. Lessons Justin and Frank learned moving from OTP to functional programming at Elixir. Exciting new developments and releases in the Nerves community. Links Mentioned in Today’s Episode: Nerves Project — https://nerves-project.org/ SmartLogic — https://smartlogic.io/ ElixirConf US — https://elixirconf.com/events The Erlang Ecosystem Foundation — https://erlef.org/ GRiSP — https://www.grisp.org/ Vintage Net — https://github.com/nerves-networking/vintage_net Joe Armstrong — https://joearms.github.io/ Erlang — https://www.erlang.org/ Linux — https://www.linux.org/Special Guest: Frank Hunleth.

Our theme this season is working with Elixir, and joining in the conversation today is Brad Traylor from Podium. Brad shares his expertise in hiring and training for Podium, a position he is passionate about since it gives him the opportunity to work on the people and tech side of things. We begin by hearing a bit of Brad’s background, when and how he was first introduced to Elixir and the standout qualities that attracted him to Podium. He discusses the hiring process, including what he looks for in an engineer, why they don’t recruit much but rather work with referrals, the step-by-step of onboarding new devs and the resources he recommends to anyone in the industry. Another great talk with a stand-up guy — be sure to tune in! Key Points From This Episode: When Brad was first exposed to Elixir and how he became the engineering manager. Searching for rocket ship startups and what specifically drew him to Podium. Having a desire to work with the people and the tech side of the industry. The growth trajectory of Podium from a management perspective. Hiring predominantly from referrals rather than recruiting developers. The biggest challenge with hiring Elixir devs, including the scarcity of good ones! Two things Brad looks for when hiring engineers: the drive to learn and a cultural fit. The benefit of hiring younger developers. Thoughts on training different languages and adding them to Podium’s tech stack. An overview of the typical onboarding process for a new engineer. Elixir 101 and other ways they keep training and refining the skills of developers. Resources that Brad has recently learned and those he always recommends to devs. **Links Mentioned in Today’s Episode: Brad Traylor on LinkedIn — https://www.linkedin.com/in/bradtraylor Brad Traylor on Twitter — https://twitter.com/btjordan23 Podium — https://www.podium.com SmartLogic — https://smartlogic.io/ Elixir — https://elixir-lang.org University of Michigan — https://umich.edu Java — https://www.java.com/en/ Python — https://www.python.org Rust — https://www.rust-lang.org Ruby — https://www.ruby-lang.org/en/ TypeScript — https://www.typescriptlang.org Pragmatic Institute — https://www.pragmaticinstitute.com/courses The Manager’s Path — https://www.amazon.com/Managers-Path-Leaders-Navigating-Growth-ebook/dp/B06XP3GJ7F Camile Fournier — https://twitter.com/skamilleSpecial Guest: Brad Traylor.

Today on Elixir Wizards we are joined by none other than José Valim, the inventor of Elixir! Coming from the Ruby on Rails world, José found his way to functional programming and we hear all about the evolution of his philosophy and thought process around the time of the creation of the language. He gives us some great insight into why functional programming is so appealing to him and the problems he wanted to solve by creating Elixir. We chat about other languages and his use of Erlang, Elixir's three biggest influences and some important characters in the story. José also shares a bit of personal, behind the scenes stuff about his schedule and how he tries to stay as productive as possible. We finish off the chat, talking about performance and the measures José has taken in this regard. For all this and more from a true Elixir wizard, be sure to tune in! Key Points From This Episode: José's thoughts on our recent podcast name-change! The first steps for José in the process of writing a language. Reason for José's decision to step out of the Ruby on Rails world. The 'aha' moment that José had when moving into functional programming. Some of the inspiration for Elixir from other languages. A few of the people that have mentored and inspired José in his career. The research and development phase for Elixir and José strategy for this. José's work habits, his typical day and the influence of his kids on his flow. Why José still considers himself an Elixir programmer despite his proximity. Elixir and machine learning; why the two are not more closely linked. Steps in the measurement process for José and Elixir. The time that José has spent on the performance side of the language. Sacrifices and substitution in optimizing Elixir's performance. Some of the things on the horizon that are exciting José. Links Mentioned in Today’s Episode: SmartLogic José Valim Plataformatec Harry Potter Erlang Ruby Clojure ElixirConfSpecial Guest: José Valim.

Welcome to Elixir Wizards, today we are joined by Dr. Jim Freeze to talk about his passion for and history in Elixir and functional programming. Dr. Freeze is one of the organizers of one of our favorite things in the world, Elixir Conf! He shares his story of coming to functional programming and his early days with Elixir, what he sees as the most important aspects of the conference before diving into what is on offer for those that attend. We talk about how employers can get Elixir newcomers up to speed on the language and the most effective ways Dr. Freeze stays abreast of developments in the field. Our guest also recommends a few resources for those wanting an introduction to Elixir and makes a great argument for the usefulness of a functional approach to programming. For all this and a whole bunch more, join us today! Key Points From This Episode: How Dr. Freeze got started with Elixir and his programming background. A little bit about the early days of Elixir Conf and what the first events were like. The particulars of Dr. Freeze's doctorate and his title. Education, networking and how Elixir Conf fits into the developer hiring game. The training that is offered at the conference and the philosophy to serving attendees. Dr. Freeze's recommendations for employers bringing newbies up to speed with Elixir. How our guest continues his learning and stays focused on what is necessary. Useful resources and materials for Elixir, according to Dr. Freeze. Contemplating functional programming and its key components. Why to consider functional programming coming from an object-based background. The biggest hurdles in moving over to functional programming and Elixir. Following the data and how much the simplicity of this directive can help. Dr. Freeze's favorite thing in the functional world! Links Mentioned in Today’s Episode: SmartLogic Dr. Jim Freeze on Twitter ElixirConf Sophie DeBenedetto Elixir Radar Phoenix In Action Geoffrey Lessel Saša Jurić Sandi MetzSpecial Guest: Dr. Jim Freeze.

Welcome back to Season 3! Our theme this time around is Working with Elixir. Listen for more on our theme, upcoming guests, and our new name.

Welcome to the last episode of Season 2 of the podcast! We are taking this opportunity to recap what we covered in the season and talk about what we liked and what we didn't like so much. We do not have a guest for today's show so it is just Eric and Justus doing some reflection. We do want to take this opportunity to thank all of our guests that have appeared on this season and shared their expertise with us, we definitely feel we learned a lot during this time! In Season 3 we will be focussing on functional programming, performance and teaching Elixir, so make sure to keep an eye out for when that drops in the future! Key Points From This Episode: The possibility of longer episodes for next season Reflections on ElixirConf and the time we spent there this year. The upcoming conference in New Orleans that Eric is keynoting. Thoughts on the future of the podcast and the promise of Season 3. Reach out! We want to hear from you! And much more! Links Mentioned in Today’s Episode: SmartLogic — https://www.smartlogic.io Brooklyn Zelenka — https://github.com/expede Bryan Joseph — https://github.com/bryanjos Paul Schoenfelder — https://github.com/bitwalker Meryl Dakin— https://github.com/meryldakin René Föhring— https://twitter.com/rrrene Michal Muskala — https://michal.muskala.eu/ Todd Resudek — https://www.linkedin.com/in/toddresudek/ Shanti Chellaram— https://github.com/shantiii Sophie DeBenedetto — http://sophiedebenedetto.nyc/ Dave Lucia — https://www.linkedin.com/in/david-lucia-a395441b ElixirConf — https://elixirconf.com/2019 The Big Elixir — https://www.thebigelixir.com/ Le Petit Theatre — http://www.lepetittheatre.com Lone Star Elixir — https://www.lonestarelixir.com The Empire Strikes Back — https://www.rottentomatoes.com/m/empire_strikes_back

Our guest today on the show is Dave Lucia, who is currently the Vice President of Engineering at SimpleBet. He is here as part of Elixir Internals series, to talk to us and all our listeners about Rustler and the contribution he made to the library! According to our guest, Rustler acts as a bridge between Rust and Elixir and allows users to employ the power of Rust within Elixir and a great example of this can be found in Dave's work at SimpleBet. He explains some of this application and the functionality and improvement it offers and the big difference the machine learning models make to this work. Dave also gives us some background to his work and career, previous employment and early explorations of open-source software. He also shares some great tips for problem-solving and learning and improving at programming in Rust. We unpack some of the biggest challenges that faced the creation of Rustler, notable differences between Rust and Elixir and the technical components of the library that the team created. For all this and then some, join us for this great episode! Key Points From This Episode: More about our guest and his current work at SimpleBet. How Dave got started with Elixir while at Bloomberg. The interesting and beautiful way in which The Outline used Elixir. Dave's early forays and experiences with open source software. Problem finding and solving; Dave's tips to those wanting to improve. Dave's employers' contribution and allowance for open source projects. Introducing Rustler and what users can do with it! The biggest challenges of using multiple languages in the backend. How Rustler works; the core, the code generator and more. The most important differences between Rust and Elixir. Dave's best advice and resources for learning and mastering Rust. And much more! Links Mentioned in Today’s Episode: SmartLogic — https://www.smartlogic.io Dave Lucia — https://www.linkedin.com/in/david-lucia-a395441b Rustler — https://github.com/rusterlium/rustler SimpleBet — https://simplebet.io Dave Lucia on Twitter — https://twitter.com/davydog187 Dave Lucia Email — [email protected] Elixir — https://elixir-lang.org Python — https://www.python.org JavaScript — https://www.javascript.com Rust — https://www.rust-lang.org Bloomberg — https://www.bloomberg.com Slack — https://slack.com Vox Media — https://www.voxmedia.com The Outline — https://theoutline.com The Rust Programming Language — https://www.amazon.com/Rust-Programming-Language-Steve-Klabnik/dp/1593278284 Rust Playground — https://play.rust-lang.org Elm Compiler — https://github.com/elm/compilerSpecial Guest: Dave Lucia.

This season on Smart Software Season 2, we are focused on the inner workings of Elixir and the inner workings of popular Elixir libraries, or Elixir internals. Today, I have the pleasure of interviewing my colleague, Eric Oestrich who's responsible for the wildly successful Elixir MUD framework ExVenture. ExVenture - https://exventure.org/ MUDs - https://en.wikipedia.org/wiki/MUD Ecto - https://github.com/elixir-ecto/ecto Eric's Going Multi-Node presentation at ElixirConf - https://www.youtube.com/watch?v=lCUKQnkjajo The Big Elixir - https://www.thebigelixir.com/ Eric's Prometheus presentation at Lonestar Elixir - https://www.youtube.com/watch?v=ETUD9SaRCjY Prometheus - https://prometheus.io/ Go - https://golang.org/ Celluloid - https://celluloid.io/ Phoenix - https://phoenixframework.org/ Grapevine - https://grapevine.haus/ Gossip - https://mudcoders.com/gossip-the-mud-chat-network-3156cf24edf/ Learn more about how SmartLogic uses Phoenix and Elixir.

Welcome to another episode of the podcast everybody! As we continue our journey into Elixir internals in Season 2, we welcome Sophie DeBenedetto to tell us about the two libraries she and the Flatiron School created! We talk about Encrypt and Railway and a bunch of other great stuff from the world of Elixir and open source and Sophie shares so much about why she is particularly excited about things at the moment. She talks about the maturation of the Elixir community and her first and most important open-source experiences before diving into her hopes for the future of these platforms. We also discuss the ins and out of the two libraries and our guest does a fantastic job of explaining their functions and the reasons they were built. Sophie shares the major challenges that faced her and the team in creating them and a whole lot more, so make sure to tune in today for all this great information! Key Points From This Episode: A brief introduction to Sophie's career, the Flatiron School and her Elixir work. Sophie's first experiences with open source, contributing to the Elixir School. Flatiron's support of open source and their attitude towards the growth of engineers. Why Elixir and Ruby are such important languages to Sophie and Flatiron. Sophie's wishes for Elixir and what she wants to see more of in the community. Introducing Encrypt and Excrypt for Elixir and why Flatiron chose to build them. The hardest parts of building the library, the challenges of encryption. Elixir's built-in option parser; convenience and accessing data easily. The Railway hex package and what it enables users to do. Breaking down the functions of RabbitMQ for Erlang. The two things that Sophie is most excited about in the Elixir space right now! And much more! Links Mentioned in Today’s Episode: Sophie DeBenedetto — http://sophiedebenedetto.nyc/ Flatiron School — http://sophiedebenedetto.nyc/ Elixir School — https://elixirschool.com/en/ Encrypt — https://github.com/flatiron-labs/encrypt Escript — https://hexdocs.pm/mix/master/Mix.Tasks.Escript.Build.html Ruby — https://www.ruby-lang.org/en/ Kafka — https://kafka.apache.org Ecto — https://hexdocs.pm/ecto/Ecto.html Erlang — https://www.erlang.org RabbitMQ — https://www.rabbitmq.com Phoenix — https://phoenixframework.org LiveView — https://dockyard.com/blog/2018/12/12/phoenix-liveview-interactive-real-time-apps-no-need-to-write-javascript Elixir Conf — https://elixirconf.com/2019Special Guest: Sophie DeBenedetto.

Today on the show we welcome Shanti Chellaram to talk about a couple of Erlang libraries she has created! We hear from her about Pri-Queue and raft_erl, and her motivation behind making them and some of the things we wishes she did differently! Shanti shares some of her background, early coding experiences, affinity for open source and her current work situation. From there we look at Pri-Queue, the problem it addresses and what a priority queue is. A highlight of the show is Shanti giving the best explanation of a bootstrapped skew binomial heap we have heard before explaining some of the main issues she faced in creating Pri-Queue. We then turn to raft_erl, how she got started with it and her hopes for its future. Throughout the conversation Shanti shares her philosophy towards open source and coding going forward as well as offering advice for newcomers to Erlang. Make you you join us for this fantastic episode! Key Points From This Episode: A little bit about Shanti's background and current employment. Shanti's early experiences and what got her into open source software. Some coding decisions that Shanti would make differently in retrospect. The problem that Pri-Queue solves; the dearth of data efficient libraries. What is a priority queue? Ordering your data with scores. Shanti explains a bootstrapped skew binomial heap! Some of the hurdles that Shanti faced in writing Pri-Queue. How Shanti got started on her other library, raft_erl. The three Raft protocols and how much of it is implemented in the library. Shanti's next goals for raft_erl; bug free and widely used. The importance of distributed systems and Shanti's philosophy looking to the future. Advice for someone just starting out in Elixir! And much more! Links Mentioned in Today’s Episode: SmartLogic — https://www.smartlogic.io/ Shanti Chellaram Linkedin— https://www.linkedin.com/in/shanti-chellaram-495444187 Shanti Chellaram on Twitter — https://twitter.com/theccoder Shanti Chellaram on github — https://github.com/shantiii Erlang — https://www.erlang.org/ Elixir — https://elixir-lang.org/ Pri-Queue — https://github.com/okeuday/pqueue raft_erl — https://github.com/shantiii/raft_erl MailChimp — https://mailchimp.com Teachers Pay Teachers — https://www.teacherspayteachers.com/ Purely Functional Data Structures — https://www.amazon.com/Purely-Functional-Structures-Chris-Okasaki-ebook/dp/B00AKE1V04 Rust — https://www.rust-lang.org/ Raft — https://raft.github.io/ Raspberry Pi — https://www.raspberrypi.org/ ElixirConf — https://elixirconf.com/2019 Partisan — https://partisan.cloud/Special Guests: Dan Ivovich and Shanti Chellaram.

Today on the show we are joined by Michal Muskala, who is currently a freelance software engineer and he is here to talk to us about his work on the Ecto and jason libraries. With Ecto we continue our journey into Elixir and Michal explain how he became involved in the project and the work he did on it. He explains a little of its inner workings, issues and what excited him about it initially. We then turn to jason, a widely popular library that Michal created for parsing JSON. Michal unpacks its particulars, differentiating for us between the driver and adapter and the lessons he learned working on them. The last bit of our conversation is spent talking about open source and Michal's commitment to its philosophy. We discuss making time to work on projects, buy in from employers and and why getting involved can be scary yet is so important! For all this and more, join us for this great episode! Key Points From This Episode: A little bit about Michal's work background and how he got started on Elixir. The parts of Ecto that Michal worked on at Google Summer of Code. Differentiating between the driver and the adapter; communicating with the database. Structuring the code and what Michal would do differently now. Creating jason, the default JSON parser and the impetus behind it. Understanding lexing and tokenizing; largely the same thing with different names. Macros on jason and forcing the VM to use optimizations in particular cases. Performance on jason; how Michal achieved the speeds he did. Michal's path to open source software and what followed his work in MongoDB. Finding time to work on open source projects while employed. BEAM, alternative implementations and why they are important. Michal's call to action for our listeners! And much more! Links Mentioned in Today’s Episode: SmartLogic — https://www.smartlogic.io/ Elixir — https://elixir-lang.org/ Michal Muskala — https://michal.muskala.eu/ Michal Muskala on Twitter — https://twitter.com/michalmuskala?lang=en Ecto — https://hexdocs.pm/ecto/Ecto.html jason — https://github.com/michalmuskala/jason Google Summer of Code — https://summerofcode.withgoogle.com/ MondoDB — https://www.mongodb.com/ Erlang — https://www.erlang.org/ Binary Optimization in Erlang Documentation — https://rhye.org/post/erlang-binary-matching-performance/ (Please verify link) BEAM — https://blog.stenmans.org/theBeamBook/ Erjang — https://jaxenter.com/introducing-erjang-erlang-for-the-jvm-108005.html Atom VM — http://atomvm.sourceforge.net/Special Guest: Michał Muskała.

Today on the show we get stuck into the inner workings of Hex 1.0 and are happy to be joined by returning guest, Todd Resudek. As you might already know, Todd is the Senior Software Engineer at Weedmaps, a regular speaker on the conference scene, and one of the three core team members at Hex. With the total downloads sitting at 641 million, the Hex community is growing rapidly and shows no signs of slowing down. In this episode, we discover what makes the Hex packages some of the most popular packages out there today, as well as the new and improved features currently in the pipeline. In addition, we find out how Todd first got involved with the Hex team and how the team makes decisions and problem solves. Key Points From This Episode: Transferring a new library into an old ecosystem. Todd’s challenges learning Elixir and Hex. Learn more about the functions of Alphabetify. An introduction to the uses of ETS storage. Contributing to Open Source while working at Weedmaps. Discover how Todd got involved with the Hex team. Learn more about the different faces of Hex. Find out how decisions are made within the Hex team. Just how busy is the Hex community right now? The top five underground features of Hex. Discover the latest features now available on Hex. Find out what new Hex features are in the pipeline. And much more! Links Mentioned in Today’s Episode: Todd Resudek — https://www.linkedin.com/in/toddresudek/ Weedmaps — https://weedmaps.com/ Hex — https://hex.pm/ rebar3 — https://www.rebar3.org/ Alphabetify — https://hex.pm/packages/alphabetify ETS — https://elixirschool.com/en/lessons/specifics/ets/ Elixir Mix Podcast — https://devchat.tv/elixir-mix/ Voitek — https://voitekk.com/ Erlef Erlang Ecosystem Foundation — https://erlef.org/ Crates — https://crates.io/crates/hex Smart Software with SmartLogic — https://podcast.smartlogic.io/ Nerves MeetUp on Twitter — https://twitter.com/nervesmeetup The Big Elixir — https://www.thebigelixir.com/Special Guest: Todd Resudek.

In this episode of the podcast we are joined by Chris Keathley to continue our exploration of Elixir internals as he tells us about two very popular libraries that he developed, Wallaby and Raft. We start off with some background and his initial experiences with Elixir and open source projects before diving into Wallaby and some of the biggest lessons that Chris learned during and after his work on the library. Chris does a great job of explaining concurrent tests and the Sandbox and some of the reasons he has pretty much stopped working on the front end of projects. From there we move onto another one of Chris' exciting projects, Raft! In order to introduce the library, Chris explains more about consensus algorithms, Leslie Lamport and his groundbreaking work on Paxos. Raft is, in some ways, a simplified, more accessible version of Paxos for Elixir and Chris goes on to give a brief rundown of its inner workings. For this great conversation with a great guest, join us today! Key Points From This Episode: Chris' background, history with Elixir and his current employment. How Chris got started with open source work. Why Chris has moved away from front end work in the last while. The major lessons Chris learned while building Wallaby. How the concurrent tests work on Wallaby and the Sandbox. Why Chris is still excited about Raft, even though he hasn't touched it in a while. Explaining Raft, consensus algorithms and Paxos. How the Raft library actually works; building Raft systems and processes. Where to find and connect with Chris online! And much more! Links Mentioned in Today’s Episode: SmartLogic — https://www.smartlogic.io/ Chris Keathley — https://keathley.io/ Chris Keathley on github — https://github.com/keathley Bleacher Report — https://bleacherreport.com/ Wallaby — https://hexdocs.pm/wallaby/Wallaby.html Raft — https://raft.github.io/ Erlang — https://www.erlang.org/ Slack — https://slack.com/ Leslie Lamport — http://www.lamport.org/ Paxos Made Live — https://blog.acolyer.org/2015/03/05/paxos-made-live/ Elixir Outlaws Podcast — https://elixiroutlaws.com/Special Guest: Chris Keathley.

Welcome back to the SmartLogic Podcast where we talk about the latest developments and best practices in the web and mobile software industry. In continuing with our theme of Elixir Internals, we’re having a conversation about the inner workings of one of the most popular Elixir libraries, Credo, and we are joined by the author René Föhring. René shares the story of how he was introduced to Elixir while doing his PhD and looking for a new programming language and then shares the philosophy and inspiration Credo was developed on. Wanting Credo to be a less rule-based, authoritative code analysis tool and more user friendly, René focused on creating it to act as a type of digital mentor to the many developers out there who do not have a human mentor. He also shares about some of the launching hiccups, what he would have done differently had he been given another opportunity and some of the most important lessons that he has learned working in the open source community. Be sure to join us for all the inside info! Key Points from This Episode: More about René’s job as head of product development at 5 Minds and what they do. What he does in his free time: open source maintenance and conference speaking. How he got started with Elixir and wanting to learn a new programming language. What Credo is all about, why you’d want to use it and what makes it different. The inspiration behind writing Credo and wanting a more positive, less dogmatic tool. Starting off building on Dogma but then pivoting and going in an independent direction. The hiccups René experienced when first releasing Credo and what he’d do differently. The different checks in Credo and how they function and respond to issues. How Elixir 1.6 impacted the development of Credo. What’s new with the Credo 1.1 release? René’s experience working with open source and the first library he contributed to. Important lessons he has learned by being part of the open source community. And much more! Links Mentioned in Today’s Episode: Elixir — https://elixir-lang.org/ Credo — http://credo-ci.org/ René Föhring on Twitter — https://twitter.com/rrrene?lang=en 5 Minds IT – Solutions — https://www.5minds.de/ GitHub — https://github.com/ Ruby — https://www.ruby-lang.org/en/ Go — https://golang.org/ Cplusplus — http://www.cplusplus.com/ StyleCop — https://github.com/StyleCop/StyleCop Dogma — https://github.com/lpil/dogma Hex — https://hex.pm/ Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: René Föhring.

Today on the show we continue our series on the inner workings of several different Elixir libraries and are happy to be joined by Meryl Dakin, Software Engineer at the Flatiron School and author of Token Alchemist. In this episode, we discover how Meryl got started with Elixir and what the process was like for her transitioning from Ruby to Elixir. We learn more about the internal functions of Token Alchemist within the school context and discuss the unique opportunities Meryl has discovered in Elixir, as well as the trickier language features that programmers are likely to experience in their learning process. Meryl also shares the challenges that Token Alchemist attempts to overcome – delving deeper into LTI, the Learn.co platform, OAuth and JSON. For all this and more, be sure to click play! Key Points From This Episode: Discover why Meryl first got started with Elixir. Learn more about the Flatiron Bootcamp for coders. Meryl’s experience in transitioning from Ruby to Elixir. The opportunities for concurrency and fault tolerance in Elixir. Discover the top three tricky language features in Elixir. The benefits of going back to the basics of Elixir. Find out the problems that Token Alchemist attempts to solve. Meryl explains LTI and the Learn.co platform for students. Learn more about custom parameters in Token Alchemist. The process of learning OAuth in Token Alchemist. What to consider when using LTI in Elixir. The benefits of resource link history ID’s in the LTI spec. Opportunities for you with Token Alchemist. And much more! Links Mentioned in Today’s Episode: We Work — https://www.wework.com/ Flatiron School — https://flatironschool.com/ Elixir — https://elixir-lang.org/ Ruby — https://www.ruby-lang.org/en/ Learn.co — https://learn.co/ Meryl on LinkedIn — https://www.linkedin.com/in/meryldakin/ Meryl on Twitter — https://twitter.com/meryldakin Meryl on GitHub — https://github.com/meryldakin Token Alchemist on GitHub — https://github.com/meryldakin/token_alchemist Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: Meryl Dakin.

Welcome back to show everyone and today in our exploration of Elixir libraries we are talking to Paul Schoenfelder! He is here to unpack Distillery, his own creation from the world of Elixir and tell us about how it works. We also discuss how Paul made the transition from bigger corporations into the startup world, his early experiences of different coding languages and the initial steps he took in writing Distillery. Paul is very honest about the unclear future of the library and he shares his hopes for it for the short term as well as clarifying its key concepts and functions. He gives great advice and directions for learning more about the resource and how you can help him and his projects out if you use them. For all this and then some, be sure to join us today for the show! Key Points From This Episode: Paul's work background, language history and the last few years working Elixir. The first library that Paul contributed to and created on his own! What brought about the creation of Distillery. Clarifying releases, compiling, generating, deployment and more. Where to learn more and find out details about the library. The first steps Paul took when writing this latest version of the Distillery. Looking to the future of Distillery and its current best use cases. Hot upgrades and who they can be useful to when it comes to Elixir. Let Paul know if you are using or want to contribute to a project of his! And much more! Links Mentioned in Today’s Episode: Smartlogic — https://www.smartlogic.io/ Paul Schoenfelder — https://github.com/bitwalker Bitwalker — http://bitwalker.org/ Distillery — https://hex.pm/packages/distillery DockYard — https://dockyard.com/ Erlang — https://www.erlang.org/ Phoenix — https://phoenixframework.org/ Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: Paul Schoenfelder.

Today on the show we continue our series on the inner workings and various libraries of Elixir and are very happy to welcome Bryan Joseph of Revelry to talk about his very own ElixirScript. ElixirScript is essentially an Elixir to JavaScript compiler, allowing users to run Elixir online more easily. We ask Bryan what inspired this project and about some of the major challenges that have faced it. We also talk about the role of his company, Revelry in his career and work in open source. Bryan tells us about his very own conference, The Big Elixir and why you should be traveling to New Orleans to check it out! Other topics covered include the architecture of ElixirScript, binary pattern matching, Bryan's other experiences of libraries and his hopes for ElixirScript's future. For all this and then some, be sure to listen in today! Key Points From This Episode: Some background on Bryan, his work and how he got started with Elixir. What is ElixirScript? What does it do? How Brian got the idea! ElixirScript's architecture; the inner workings of the compiler. The major problems and challenges that face this task with JavaScript. Step one in the process; the conversion of concepts. Binary pattern matching and the implementation of strings. The things Bryan would do differently looking back on the product. Bryan's other experiences of libraries, contributions and fixes. Marketing, posting and getting the word out on ElixirScript. The current state of the project and hopes for the future. A little bit about The Big Elixir and what sets it apart from other conferences. And much more! Links Mentioned in Today’s Episode: Smartlogic — https://www.smartlogic.io/ ElixirScript — https://elixirscript.github.io/ Bryan Joseph — https://github.com/bryanjos Revelry — https://revelry.co/ The Big Elixir— https://www.thebigelixir.com/ Metaprogramming Elixir — https://www.amazon.com/Metaprogramming-Elixir-Write-Less-Code/dp/1680500414 Chris McCord — http://chrismccord.com/ Erlang — https://www.erlang.org/ ElixirCon — https://www.elixirlabs.net/events/elixircon-2018 Lonestar Elixir — https://www.lonestarelixir.com/ Operation Spark — https://operationspark.org/ Flatiron — https://flatironschool.com/ Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: Bryan Joseph.

Hey everybody and welcome back to Season 2 of the podcast! This season we will be talking about Elixir internals, libraries and the inner workings of the language. In our first episode we are very happy to be joined by Brooklyn Zelenka to start off our journey on the subject with an exploration of her very own Witchcraft. In this episode we talk to Brooklyn about her history with Elixir, how she got started and what attracts her to it. Brooklyn explains the influence that open source philosophy has had on her career in developing and from there she gives a pretty comprehensive introduction to what Witchcraft is, expanding its key concepts. Although this is quite a high level discussion about Elixir and Witchcraft, we are confident that with Brooklyn's expert help even our most uninitiated listener can get some benefit from our conversation. We also talk about type systems, property-based checking and Dialyzer, so for all of this and more make sure to join us as we kick things off for Season 2! Key Points From This Episode: A quick introduction to Brooklyn, where she works and how she got started with Elixir. The influence of open source and library contributions on Brooklyn's development. Getting to grips with Witchcraft; defining monads and functors. Why some of these scary terms do not need to frighten you. A few little things that differentiate Witchcraft and some surprising elements. The convenient guarantees that Witchcraft provides around your data structure. Why there is no type system baked into Elixir; overheads, inputs and outputs. Property-based checking and compile times in Witchcraft. Merging of Elixir and Dialyzer; benefits and problems. Getting in touch with Brooklyn and getting involved with Witchcraft and Elixir. And much more! Links Mentioned in Today’s Episode: Smartlogic — https://www.smartlogic.io/ Brooklyn Zelenka — https://github.com/expede Brooklyn Zelenka on Twitter — https://twitter.com/expede Brooklyn Zelenka Email — [email protected] Fission — https://fission.codes/ Elixir — https://elixir-lang.org/ Witchcraft — https://hex.pm/packages/witchcraft Dialyzer — https://github.com/jeremyjh/dialyxir Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: Brooklyn Zelenka.

We’re excited to announce our season two topic, Elixir Internals. In this season we talk with developers behind some of the most popular Elixir libraries, including Witchcraft, ElixirScript, Distillery, Ecto, and more!

With this season over, we bring Dan Ivovich back to talk about what we learned. Dan Ivovich - Director of Development Operations @ SmartLogic 00:43 - Why are you using Elixir in production? 01:20 - Advantages / disadvantages of Elixir 02:38 - How do you deploy? 03:48 - Zero downtime deploys 05:40 - Clustering 06:56 - Elixir App performance 09:00 - Background task processing 10:36 - Common Libraries 14:40 - 3rd Party Services 16:16 - Do you have a story where Elixir saved the day in production? 17:56 - OTP features 18:31 - Tip to developers Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: Dan Ivovich.

We talk with Jeffrey Matthias from Community about their current and past Elixir projects and how they are deployed. Jeffrey Matthias - Community Find Jeffrey elsewhere online: http://github.com/idlehands https://twitter.com/idlehands 0:47 - Give us a quick overview of the Elixir projects you have in production. 3:29 - Why are you using Elixir in production? 6:04 - What are some of the high level advantages / disadvantages of Elixir, from your perspective? 10:14 - What do you use to host your Elixir app? Linode, AWS, DO Heroku Enmesos mesos How do you deploy your application? Ansible Deploy scripts Distillery 14:19 - Are you able to get zero downtime deploys? If so, how? 17:06 - Do you cluster the application? If so, how? 22:53 - How does your Elixir App perform compared to others in your environment? Response time Throughput Jobs/hr 25:01 - How are you solving background task processing? 29:17 - What libraries are you using? Phoenix 33:53 - Third party apps 37:28 - Do you have a story where Elixir saved the day in production? 40:42 - If you could give one tip to developers out there who are or may soon be running Elixir in production, what would it be? Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: Jeffrey Matthias.

We talk with Jay Ashe from Cava about their current and past Elixir projects and how they are deployed. Jay Ashe - Cava Find Jay elsewhere online: https://twitter.com/jgashe 0:40 - Give us a quick overview of the Elixir projects you have in production. CAVA is a fast-casual mediterranean restaurant chain with 75 stores across the US. Elixir and phoenix power CAVA’s online ordering platform (order.cava.com and the CAVA app). We’ve got a REST (and websockets) api sitting behind react and our mobile apps, and we use phoenix templates for some of our back of house systems. 1:11 - Why are you using Elixir in production? We have from the start! The application was originally implemented by Chris Bell and his team at madebymany. Chris, by the way, has a fantastic talk from ElixirConf 2016 that goes into our architecture and how we use elixir and OTP constructs to model our business logic. Chris will occasionally talk about the CAVA project on his Elixir podcast, ElixirTalk. Chris’ Talk - https://www.youtube.com/watch?v=fkDhU-2NWJ8 1:58 - What are some of the high level advantages / disadvantages of Elixir, from your perspective? Advantages: Elixir and Phoenix gives you rails-esque productivity/developer experience that scales. I think phoenix channels are a great example of this. Build a channel with complex real-time functionality and let it scale effortlessly. Disadvantages: Hiring and onboarding, depending on your mindset, can be difficult. If you’re used to hiring for experience in your stack, its just going to be more difficult. Lately we’ve started doing one-hour weekly knowledge shares that cover elixir basics and are closely tied to our usage of them. So, here’s a test case, and here are all of the test helpers that we have set up that will help you write that test. We also just sent a new Elixir dev to lonestar elixir 3:59 - What do you use to host your Elixir app? Heroku How do you deploy your application? Heroku-buildpack-elixir https://github.com/HashNuke/heroku-buildpack-elixir 4:44 - Are you able to get zero downtime deploys? As close as possible! We get that out of the box with heroku. When we deploy, heroku won’t point traffic to the new dyno until the app is healthy. We make extensive use of Phoenix channels over websockets, and our clients will reconnect automatically and transparently. 5:10 - Do you cluster the application? Nope. 5:52 - How does your Elixir App perform compared to others in your environment? I can’t really talk about numbers here, but Elixir is not at all our bottleneck. We don’t have other production applications 6:25 - How are you solving background task processing? Quantum for cron jobs, genservers for everything else. We’re running a single elixir application that handles all synchronous and async processing 7:07 - What libraries are you using? Phoenix Phoenix_swagger for API documentation that integrates with controller tests https://github.com/xerions/phoenix_swagger Ex_rated for rate limiting calls to our integrations https://github.com/grempe/ex_rated Timex and calendar for datetime support with timezones https://github.com/bitwalker/timex A combination of httpotion and httpoison for HTTP clients, but im interested in trying Mint https://github.com/ericmj/minthttps://github.com/appcues/mojito Bamboo for transactional emails, like order confirmations etc https://github.com/thoughtbot/bamboo 8:59 - 3rd Party Services (i.e. Email, Payment Processing, etc) Sendgrid for email, Google for geocoding, slack for some internal alerting of application health, LevelUp for payments. https://www.thelevelup.com/ 10:07 - Do you have a story where Elixir saved the day in production? Yes and no. So I could tell this story by explaining the issue we saw and the underlying cause at the same time, but I think it would be more fun to tell it like our team experienced it. One day at lunch our application started going down. Lots of 500 errors. Red lights flashing. Panic ensuing. Lunch is our busiest time of day, so 1) we thought it was load related and 2) we really needed to fix it None of our traditional resources (database, cpu, memory) were constrained and our integrations that were synchronous were fine. Our logs were littered with errors from an analytics integration that ran asynchronously on genservers, but it didn’t seem related because we could see the error logs at times when our application was otherwise healthy. The team that used the analytics didn’t have a pressing need for them, and we deprioritized fixing the issue because the bug we were working on was so much more important (that’s foreshadowing). I spent a little time looking at websockets, but I was easily able to match the load of the websocket portion of our application on my local machine with no degradations in performance (thanks, phoenix), so that was out. At this point the issue was going on every day at lunch and I was getting annoyed at seeing the logs from the analytics integration when debugging, so I spent like

We talk with Frank Hunleth from the Nerves core team about their current and past Elixir projects and how they are deployed. Frank Hunleth - Nerves Find Frank elsewhere online: https://twitter.com/fhunleth https://github.com/fhunleth 0:53 Frank intro 2:02 Give us a quick overview of the Elixir projects you have in production. 4:25 Why are you using Elixir in production? 8:00 What are some of the high level advantages / disadvantages of Elixir, from your perspective? 9:25 What hardware do you deploy to? 12:05 How do you get code to hardware after deployment? 13:47 How do you secure the code? 18:12 Do you cluster? If so, how? How does your Elixir App perform compared to others in your environment? 22:45 How does Elixir compare to other languages? 26:15 More information about Nerves Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: Frank Hunleth.

We talk with Mark Ericksen from Elixir Mix about their current and past Elixir projects and how they are deployed. Mark Ericksen - Elixir Mix Find Mark elsewhere online: https://twitter.com/brainlid https://brainlid.org/ 00:32 Intro 0:58 Mark intro Developing a long time. C#, then Rails. Webforms were terrible. Rails is “Wow, this is how web development should be… I moved across the country to work with this technology” The Rails Community is strong. Dave Thomas got Mark into Elixir 2:48 What Elixir projects do you have in production? A Rails app and a number of Elixir Micro-liths 4:29 Why do you use Elixir 6:45 Trends in moving from Ruby and Rails to Elixir Ruby Syntax Pattern Matching Concurrency primitives Fault Tolerance and a functional paradigm Erlang/OTP 6:48 Comparing Elixir community to Ruby community to C# community 8:27 Any disadvantages to using Elixir? Building releases. Configuring releases. mix.release 10:13 Where are you hosting these bad boys? AWS Kubernetes in Production. So Fresh. Docker and Distillery 2.0 Releases Yaml files and Bash Scripts Makefiles 10:53 What else are you using besides docker 12:36 Helm and Ksonnet. 13:55 Deploys 14:39 Clustering 17:50 How do your Elixir apps compare to the Ruby apps? Big Elixir Apps 20:00 How Mark handles background jobs Easy to write yourself with BEAM primitives 21:27 Libraries - Quantum, Bamboo, ex_machina, prometheus_ex via Eric’s influence 23:29 Third party integrations. Major ones were easy. Banks were bad. Literally had to FTP files. Had to use java to write xml spreadsheets. The horror. 25:26 Has Elixir ever saved the day for you in Production? 29:42: Cool OTP features 30:57 Tips to developers 35:36 Where to find Mark Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: Mark Ericksen.

We talk with Brooklyn Zelenka from SPADE Co. about their current and past Elixir projects and how they are deployed. Brooklyn Zelenka - SPADE Co. Find Brooklyn elsewhere online: https://twitter.com/expede https://github.com/expede 1:08 - Brooklyn’s Background Brooklyn's background and experience with Elixir is deep. Huge open source contributor. Got started in Elixir just after Phoenix got to 1.0. 1:53 - Worked on several Elixir projects in production. 2:43 - Why she got into Elixir. Real Time More performant than Rails. Great documentation Industrial-grade 4:38 - When you wouldn't use Elixir. Easy to get stakeholder buy-in. Just point to WhatsApp. Elixir is made for 2019 CLI tools Repl-driven development TDD tools built in by default All the best practices we have today are built in. 7:14 - Where has Brooklyn hosted her apps? Heroku for POC's. AWS for production. Dockerized because "kubernetes is the new hotness" 9:40 - Do you do any clustering? Load balanced above. AWS load balancing is very standard. They're well understood and have a nice developer experience. 10:29 Are you able to get any zero downtime deploys? Zero downtime deploys. Awesome but impractical. Rolling deploys are easier and usually more appropriate. Some requirements make it valuable. Erlang error states. Exceptional. Allows you to build for the happy path. Don't worry about error handling all the time. Witchcraft and dark magic. Monads. Poke around the standard library. 12:50 - How does Elixir compare to Rails in terms of response times, and other aspects? 15:32 - What libraries do you use and what have you built? 22:41 - Any cool features of OTP you are using? 25:36 - One tip to developers new to Elixir Build up a peer-to-peer cli chat from scratch in one GenServer. Find her at @expede everywhere on the internet. Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: Brooklyn Zelenka.

We talk with Todd Resudek from Weedmaps about their current Elixir projects and how they are deployed. Todd Resudek - Weedmaps Find Todd elsewhere online: https://twitter.com/sprsmpl https://github.com/supersimple 00:00 - Intro 01:06 - Tom introduces himself 02:54 - What is Weedmaps? 04:33 - Overview of the Elixir projects you have in production. 06:25 - Why are you using Elixir in production? 07:21 - Advantages / disadvantages of Elixir 10:37 - What do you use to host your Elixir app? 10:50 - How do you deploy your application? 11:22 - Are you able to get zero downtime deploys? 12:00 - Do you cluster the application? 13:00 - How does your Elixir App perform compared to others in your environment? 14:15 - How are you solving background task processing? 16:40 - What libraries are you using? 21:09 - 3rd Party Services 23:56 - Do you have a story where Elixir saved the day in production? 24:22 - Are you using any cool OTP features? 24:39 - Tip to developers 25:12 - Where you can find him 25:32 - Outro Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: Todd Resudek.

We sat down with numerous developers, including José Valim and Chris McCord, during the Saturday lunch at Lonestar ElixirConf 2019. Hear what they had to say about the state of Elixir! Guests: José Valim - Creator of Elixir Chris McCord - Creator of Phoenix Paul Schoenfelder - Creator of Distillery, Timex, Libcluster, and many others Chris Keathley - Host of Elixir Outlaws, developer at Bleacher Report Amos King - Host of Elixir Outlaws Jim Freeze - Organizer of ElixirConf, ElixirConf EU, and others Susumu Yamazaki - Creator of Hastega Brian Cardarella - CEO of Dockyard Osa Gaius - Engineer at Mailchimp Spectating: Bruce Tate and Ben Marx 00:00 - Intro 01:47 - LoneStar begins 02:03 - Panelists introduce themselves 09:15 - Where is Elixir going? 10:14 - Releases 19:04 - The issue with hype 26:30 - Osa Intro 29:00 - Define lists 40:00 - How can Elixir displace Java? Learn more about how SmartLogic uses Phoenix and Elixir.

We talk with Ryan Billingsley from ClusterTruck about their current Elixir projects and how they are deployed. Ryan Billingsley - ClusterTruck Find Ryan elsewhere online: https://twitter.com/ryanbillingsley https://horriblenight.com/ 00:00 - Fade In 00:50 - Ryan introduces us to ClusterTruck. 02:00 - How did Ryan get into Elixir? 03:12 - Where does the name ClusterTruck come from? 04:17 - Tell us about the projects you have in production. 05:50 - Why are you using Elixir in these projects. 08:11 - Disadvantages of using Elixir 09:22 - Comparing Elixir with Ruby, Node, Go. 11:38 - Where is ClusterTruck hosting their applications? 15:03 - Kubernetes? 16:03 - Zero Downtime Deployments? 16:42 - Do you do any clustering? 18:06 - How does Elixir perform compared to other project environments you’ve worked in? 19:52 - How are you solving background task processing? 21:09 - Other libraries? 23:34 - Other third party integrations? 25:46 - Is there a time Elixir has saved the day in Production? 27:47 - Cool OTP Features! 29:45 - Tips to devs thinking about running Elixir in Production. 31:17 - Outro Learn more about how SmartLogic uses Phoenix and Elixir.Special Guest: Ryan Billingsley.