Elixir Wizards

Elixir Wizards

By SmartLogic LLCTechnologyEducationHow To
Download on the App Store

Elixir Wizards episodes

  • Brian Howenstein on How ClusterTruck is Innovating Food Delivery

    ClusterTruck, a master of vertical integration, is rewriting the method of end-to-end food delivery and ghost kitchens. Today we speak with ClusterTruck Product VP Brian Howenstein to find out more about his journey in programming, ClusterTruck as an end-to-end food service, and how Elixir became mission-critical to the success of the business.

    We kick things off by hearing more on Brian’s childhood and how he became interested in programming. We then hear about his internship at Apple where he was part of the Core OS networking team. Brian touches on brushing shoulders with Steve Jobs, Jony Ivy, and Tim Cook, and shares how these personalities changed his view of the tech industry. Later in the show, we turn our attention to current times. Brian expands on his role at ClusterTruck and shares details on how Elixir has played a vital role in the company’s success. We hear his take on vertical integration, why they’d never consider third-party delivery companies, and much more. We then briefly digress to Brian’s hobby: the Scottish Games, before returning to ClusterTruck to find out what his favorite menu items are and what the future holds for food delivery and ghost kitchens.

    Be sure to stay tuned to enjoy our mini-feature where we speak with Michelle Morry, a software engineer at FuturePet. For all things Elixir, be sure to join us today!

    Bonus: If you’re in Indianapolis, IN, Columbus, OH, or Kansas City, MO, download the ClusterTruck app and use code “ELIXIRWIZARDS” at checkout for a one-time 25% discount on your ClusterTruck order. Good for a single use for both new and returning customers.

    Key Points From This Episode:

    • A call to all talented engineering managers to join our team!
    • Introducing today’s guest, Brian Howenstein.
    • Brian tells us about his company, ClusterTruck.
    • Hear about Brian’s background in technology and programming.
    • What inspired Brian to do programming professionally.
    • Brian tells us about his internship at Apple.
    • Hear one of Brian’s fondest anecdotes about Jony Ive.
    • Brian shares notes on his path to Elixir.
    • Why Elixir has had such an impact on ClusterTruck’s success.
    • ClusterTruck’s origin story.
    • Brian talks about ClusterTruck’s vertical integration model.
    • How Brian got the people around him to buy into Elixir and the hurdles that came with it.
    • Brian talks about his journey to become a ClusterTruck VP.
    • Brian tells us about his hobby and we digress to World’s Strongest Man controversy.
    • How COVID has affected Brian’s business.
    • Nerves projects at ClusterTruck and how it’s being used.
    • What the future looks like for ClusterTruck.
    • Brian’s advice for people who are trying to get their company to code in Elixir.
    • How ClusterTruck is using LiveView.
    • Brian’s favorite and least favorite menu items.
    • Stay tuned for our quick mini-feature.
    • Links Mentioned in Today’s Episode:

      ClusterTruck — https://www.clustertruck.com/

      ClusterTruck Hiring — https://www.notion.so/clustertruck/Engineering-Openings-at-ClusterTruck-ef2372d2c2ab43b3b82f56a097c86eeb
      Cabermetrics — https://www.cabermetrics.com/
      Brain Howenstein on LinkedIn — https://www.linkedin.com/in/brianhowenstein/
      Brain Howenstein on Twitter — https://twitter.com/hwrd
      Indianapolis Scottish Games Festival — https://indyscotgamesandfest.com/
      Purdue University — https://www.purdue.edu/
      SimCity — https://www.ea.com/en-gb/games/simcity
      Apple — https://www.apple.com/
      Jony Ive — https://www.britannica.com/biography/Jonathan-Ive
      Tim Cook — https://twitter.com/tim_cook
      Steve Jobs — https://www.biography.com/business-figure/steve-jobs
      Uber Eats — https://www.ubereats.com/za
      ExactTarget — https://www.linkedin.com/company/exacttarget/
      Salesforce — https://www.salesforce.com/
      DoorDash — https://www.doordash.com/en-US
      GrubHub — https://www.grubhub.com/
      The World’s Strongest Man — http://theworldsstrongestman.com/
      Raspberry Pi — https://www.raspberrypi.org/
      Indy Elixir - Using Elixir at ClusterTruck: Milliseconds Matter When Your Users are Hangry — https://www.youtube.com/watch?v=9LMzYTK6dsE&ab_channel=IndyElixir
      Indy Elixir - /hungry until food arrives: How ClusterTruck uses Elixir to make ordering for a Team Simple — https://www.youtube.com/watch?v=ZY2XeIENMRw&ab_channel=IndyElixir
      ClusterTruck: Liberate Your Appetite — https://www.youtube.com/watch?v=xNC3vrrxNWM&ab_channel=ClusterTruck
      Sean in the City: ClusterTruck Indy — https://www.youtube.com/watch?v=-nusA13LYJI&ab_channel=B105.7Indy
      ClusterTruck + Slack — https://www.youtube.com/watch?v=C6t8aZQPB68&ab_channel=ClusterTruck

      Special Guest: Brian Howenstein.

      1 hr
    • Yair Flicker on SmartLogic’s Origin, Evolution, and Elixir Adoption Process

      Building a successful development company requires having a leader with technical know-how and excellent management skills. Today we speak with SmartLogic President and Founder Yair Flicker about his company’s origin story, evolution, and their Elixir adoption process. Early in the episode, we talk about Yair’s first jobs before diving into how he founded SmartLogic. An important transition point, we then chat about how he moved from writing code to running a business. Reflecting on his tech background, Yair opens up about how he learned to code before he shares insights into the languages that his company programs in, how they discovered Elixir, and how they integrated it into their practice. In a discussion that’s sure to resonate with startup managers, Yair unpacks what he does to grow as a manager, along with best practices for companies looking to adopt Elixir. We ask Yair about the benefits of coding in Elixir, how SmartLogic has retained its top employees, why he prioritizes employee happiness, and the role that company values play in strengthening SmartLogic. After hearing about Yair’s vision for the future, we jump into our mini-segment where we interview Jake Johnson, the Director of Software Engineering at TaxJar. For more on building strong companies and advice on adopting Elixir, be sure to tune in and benefit from our conversations with Yair and Jake.

      Key Points From This Episode:

      • SmartLogic Founder Yair Flicker talks about his first job.
      • Yair shares details about SmartLogic’s humble origins.
      • Early challenges SmarLogic faced and Yair’s move from coding to running a business.
      • We ask Yair about how he learned to code.
      • SmartLogic’s coding evolution and how they discovered Elixir.
      • The Maker vs. Manager distinction; what Yair did to grow as a manager.
      • Exploring the benefits of adopting Elixir.
      • Yair’s advice for companies wanting to adopt Elixir.
      • Why Elixir allows for more scalability than many other languages.
      • How SmartLogic has been able to retain some of its top employees.
      • The link between having happy employees and happy clients.
      • How Yair lives his company’s values.
      • Yair shares his recipe for creating productive meetings.
      • Hear about Yair’s vision for SmartLogic’s future.
      • For our mini-feature segment, we chat with Jake Johnson from TaxJar.
      • Why TaxJar adopted Elixir and details on Jake’s background.
      • Links Mentioned in Today’s Episode:

        SmartLogic — https://smartlogic.io/

        Elixir Wizards Email — [email protected]
        Yair Flicker on LinkedIn — https://www.linkedin.com/in/yflicker/
        Yair Flicker on Twitter — https://twitter.com/yflicker
        Jake Johnson on LinkedIn — https://www.linkedin.com/in/jakej/
        TaxJar — https://www.taxjar.com/
        Music and Arts — https://www.musicarts.com/
        Johns Hopkins University — https://www.jhu.edu/
        Hackers — https://www.imdb.com/title/tt0113243/
        National Conference of Synagogue Youth — https://ncsy.org/
        Stanley Black & Decker — https://www.stanleyblackanddecker.com/
        Reddit — https://reddit.com/
        Discord — https://discord.com/
        Instagram — https://www.instagram.com
        Amazon Web Services — https://aws.amazon.com/
        Sales Tax for Developers — https://salestax.dev
        Backstreet Boys — https://linktr.ee/backstreetboys

        Special Guest: Yair Flicker.

        56 min
      • Alexandra Chakeres on Moving Towards an Inclusive Elixir Community

        Despite its welcoming character, the Elixir community struggles with diversity; as the 2020 ElixirConf community survey shows, only 2% of Elixirists are women. Today we speak with Blinker software engineer Alexandra Chakeres about her experience of the community, as well as what we can do to make it more inclusive. We open by exploring Alexandra’s background and coding career. After expressing her enthusiasm for the Turing School, we talk about Alexandra’s learn-by-doing approach to picking up Elixir. She shares how she landed her first Elixir job before we chat about her current role at Blinker. We discuss why the small size of the community means that Alexandra doesn’t recommend Elixir to coding beginners. We then dive into the topic of Elixir diversity, touching on factors that limit inclusivity, including how few Elixir positions are available for juniors. Alexandra unpacks solutions, like how organizations can shift their hiring pipeline and the need to approach diversity organizations with openings. Later, listeners will enjoy our mini-feature segment where we interview Instinct Science engineer Bill Peregoy about how their team uses Elixir. Tune in for more on what we can do to create a more diverse community.

        Key Points From This Episode:

        • Hear how co-host Sundi Myint first met Alexandra.
        • Alexandra shares details about her coding background.
        • Why Alexandra feels so passionately about Turing Boot Camp.
        • Details about Alexandra’s first Elixir job.
        • What Alexandra’s current team builds in Elixir and her experience using umbrella apps.
        • Comparing Ruby with Elixir and insights into what Elixir is missing.
        • Why Alexandra doesn’t recommend that junior engineers first learn Elixir.
        • How restricted Elixir hirings lead to a lack of diversity in the community.
        • Exploring ways to make the Elixir community more diverse.
        • What Alexandra most enjoys about coding in Elixir.
        • Alexandra’s top advice for minorities in the Elixir community.
        • Why it’s up to all of us to create a more inclusive community.
        • We talk to Bill Peregoy about how the team at Instinct Science uses Elixir.
        • Bill’s challenges and benefits to writing in Elixir.
        • How Bill would help new hires learn Elixir.
        • Links Mentioned in Today’s Episode:

          SmartLogic — https://smartlogic.io/

          Elixir Wizards Email — [email protected]
          Alexandra Chakeres on LinkedIn — https://www.linkedin.com/in/alexandrachakeres/
          Alexandra Chakeres on GitHub — https://github.com/chakeresa
          Blinker — https://www.blinker.com/
          ElixirConf — https://elixirconf.com
          Brian Cardarella — https://twitter.com/bcardarella
          Turing School — https://turing.io/
          Angelfire — https://www.angelfire.lycos.com/
          Melvin Cedeno — https://twitter.com/thecraftedgem
          Weedmaps — https://weedmaps.com/
          Denver Erlang and Elixir Meetup — https://www.meetup.com/Denver-Erlang-Elixir/
          DC |> Elixir Meetup — https://www.meetup.com/DC-Elixir/
          DispatchHealth — https://www.dispatchhealth.com/
          Autotrader — https://www.autotrader.com/
          José Valim - https://github.com/josevalim
          Diversified Tech — https://www.diversifytech.co/
          Women Who Code D.C — https://www.womenwhocode.com/dc
          Bruce Tate — https://twitter.com/redrapids
          Bill Peregoy on LinkedIn — https://www.linkedin.com/in/billperegoy/
          Instinct Science — https://www.instinct.vet/
          AppSense — https://www.ivanti.com/company/history/appsense

          Special Guest: Alexandra Chakeres.

          49 min
        • Brian Cardarella on Adopting Elixir

          Elixir is a dynamic, functional language that packs a punch. Built on the strengths of its predecessors like Ruby and Erlang, it sits comfortably in a space where performance and scalability are at a premium. Today we speak with Brian Cardarella, owner and former member of DockYard, to find out more about Elixir and why he feels it serves companies and employees so well. We open the show by studying Elixir’s DNA, learning more about Ruby on Rails and what made it so attractive as an offering during its heyday. Brian then shifts scope and talks about why Ember has steadily failed, and touches on a lack of efficiency and poor marketing strategies as the obvious catalysts for its demise. As our conversation develops, Brian dives deeper into Elixir, sharing nuggets of wisdom and entertaining anecdotes along the way. Listeners will hear why Elixir performs so strongly and how he believes companies should go about adopting the language. Brian expands on the topic and shares which types of clients should be open to Elixir and the methods you can use to convert them. As we near the end of the episode, we hear from Brian about Lumen’s characteristics and at what point developers will be able to write an app without JavaScript in Elixir. To find out more, be sure to join us today!

          Key Points From This Episode:

          • Introducing today’s guest, DockYard’s Brian Cardarella.
          • Why Brian doesn’t think Ember is relevant as a topic of conversation.
          • What made Ruby on Rails the go-to language for a new generation of developers.
          • The reasons for Ember’s failing, according to Brian.
          • Brian’s transition from Ruby on Rails to Elixir.
          • The challenges that come with organizing software conferences.
          • Areas where Elixir is performing and lagging.
          • Why Brian prefers supporting companies that do not have huge corporate backing.
          • Hear why Brian wanted to introduce Elixir at DockYard.
          • How Brian believes companies should go about adopting Elixir.
          • The challenges that come with junior and senior developers.
          • Brain talks about the intricacies of optional type systems and real type systems.
          • How Elixir adoption should be performed.
          • Brian describes Lumen’s characteristics.
          • Find out at what point you will be able to code without JavaScript in Elixir.
          • Links Mentioned in Today’s Episode:

            BCardarella on Twitter - https://twitter.com/bcardarella

            Brian Cardarella on Slack - BCardarella
            Ember - https://emberjs.com/
            Ruby on Rails - https://rubyonrails.org/
            Elixir Ecosystem Survey 2020 results - https://elixirforum.com/t/2020-elixir-community-survey-results/34189/7
            DHH - https://dhh.dk/
            José Valim - https://github.com/josevalim
            Johnny Boursquiat - https://www.linkedin.com/in/jboursiquot/
            Dave Thomas - https://pragdave.me/
            The Pragmatic Programmer Book https://pragprog.com/titles/elixir16/programming-elixir-1-6/
            Bruce Tate - https://www.linkedin.com/in/bruce-tate-a836b/
            Grox.io - https://grox.io/
            Type Systems - https://en.wikipedia.org/wiki/Type_system
            TypeScript - https://www.typescriptlang.org/
            Gleam - https://gleam.run/
            Elm - https://elm-lang.org/
            Python - https://www.python.org/
            Elixir Case Studies - https://elixir-lang.org/blog/
            Elixir Bridge - http://elixirbridge.org/
            Lumen - https://github.com/lumen/lumen
            Web Assembly Spec - https://github.com/WebAssembly/spec
            Lumen Twitter - https://twitter.com/getlumen
            DockYard - https://dockyard.com/
            Netflix - https://about.netflix.com/en
            LinkedIn - https://www.linkedin.com/
            The Standells - https://www.allmusic.com/artist/the-standells-mn0000923618/biography
            The Red Sox - https://www.mlb.com/redsox
            Shipyard Beer - https://shipyard.com/
            GoDaddy - https://za.godaddy.com/
            ElixirConf - https://www.elixirconf.eu/
            thoughtbot - https://thoughtbot.com/
            Apple - https://www.apple.com/
            Disqus - https://disqus.com/profile/login/

            Special Guest: Brian Cardarella.

            56 min
          • Matt Nowack and Jake Heinz on Elixir and Discord; Bonus: Arthi Radhakrishnan, Community.com

            In this episode we continue our conversation about adopting Elixir, this time with Matt Nowack and Jake Heinz from Discord, hearing them get into the features of Elixir that make it a great fit for building a real-time chat infrastructure system! We also invite Arthi Radhakrishnan from community.com for our mini-interview in the last chunk of the episode. Our chat begins with Jake and Matt telling Elixir developers exactly why they should not use Mnesia. They subsequently dive into their journeys in programming and the process of learning Elixir after joining Discord. They share a few aha-moments as well as challenging projects that asked them to get their heads around some of the more powerful features of Elixir, highlighting a way they used immutability for a project that asked them to efficiently calculate deltas for large member list updates. From there we get into the culture around onboarding new devs at Discord, the company’s popular open-source Elixir contributions, and some brags about the high performance of features of Discord built in Elixir. Wrapping up with Jake and Matt, we hear their suggestions for teams and devs hoping to adopt Elixir, where they strongly advise on learning OTP as well as Elixir’s standard library. After that, it’s time for our chat with Arthi, where we hear about her programming journey, how Elixir is being put to use at Community.com, how the company supports new devs learning Elixir, and more!

            Key Points From This Episode:

            • Our guests’ thoughts on why Elixir developers shouldn’t use the database driver Mnesia.
            • How Jake and Matt got into programming and learned Elixir after joining Discord.
            • The history of the use of Elixir at Discord and some of the projects Jake helped build since.
            • The nuts and bolts of OTP; Jake’s experiences learning it along with Elixir at Discord.
            • Different projects Matt worked on after joining Discord and how they helped him learn Elixir.
            • Aha moments of learning Elixir; features of the language that acted as force multipliers in the development of different Discord projects.
            • Processes at Discord for helping new developers learn Elixir.
            • Open-source contributions from Discord to the Elixir community and the culture around this at Discord.
            • Issues around logging and memory allocation in Elixir and what our guests think could change.
            • The sheer power Elixir brought to the Discord project allowing rapid scale with a small team.
            • Jake weighs in on the strengths of Python, Rust and Elixir, as well as BEAM processes versus Goroutines.
            • Discord as a native Electron app and whether we will see it written in Rust.
            • Advice regarding adopting Elixir about the power of OTP and the standard library.
            • Introducing Arthi Radhakrishnan for our mini-interview at the end of the show.
            • Previous languages Arthi worked in and how she learned Elixir after joining community.com.
            • The fan chat service offered at community.com and some famous users.
            • Features of the community.com architecture built in Elixir.
            • The size of the team, the culture of hiring Elixir devs, and Arthi’s onboarding process at Community.com.
            • Links Mentioned in Today’s Episode:

              SmartLogic — https://smartlogic.io/

              Matt Nowack on GitHub — https://github.com/ihumanable
              Mat Nowack on Twitter — https://twitter.com/ihumanable?lang=en
              Jake Heinz on GitHub — https://github.com/jhgg
              Apply for a Position at Discord — https://discord.com/jobs
              Stanislav Vishnevskiy on LinkedIn — https://www.linkedin.com/in/svishnevskiy/
              ZenMonitor — https://github.com/discord/zen_monitor
              SortedSet Nif — https://github.com/discord/sorted_set_nif
              The BEAM Book — https://github.com/happi/theBeamBook
              Semaphore — https://github.com/discord/semaphore
              ExHashRing — https://github.com/discord/ex_hash_ring
              erts_alloc Documentation — https://erlang.org/doc/man/erts_alloc.html
              Arthi Radhakrishnan on LinkedIn — https://www.linkedin.com/in/arthiradhakrishnan/
              Community.com
              Andrea Leopardi on LinkedIn — https://www.linkedin.com/in/anleopardi/?originalSubdomain=it

              Special Guests: Jake Heinz and Matt Nowack.

              54 min
            • Jason Axelson on the Elixir Language Server

              Welcome back to the Elixir Wizards podcast! In this episode, we will be continuing our conversation on the theme of adopting elixir, and our great guest for today is Jason Axelson! Jason is a back-end developer for a mixed reality studio called Animal Repair Shop and has also made some significant contributions to the Elixir Language Server project. We kick off our conversation with Jason hearing about his programming journey and then dive into the event chat service app he helped build using Elixir while he was working at Hobnob. From there, we talk about some of his aha moments while learning Elixir and some of his favorite features about the language which he is putting to use building out the back end for Animal Repair Shop. Next, we turn our attention to Elixir Language Server and Jason weighs in on the IDE type features it offers, why he got started as a collaborator on the project, and some of their challenges in the field of shared governance. Wrapping up for today, Jason makes a few suggestions for how devs who love Elixir can convince their teams to adopt it as a more mainstream option. Tune in for a great chat on the topic of adopting Elixir!

              Key Points From This Episode:

              • An introduction to Jason Axelson and the story of how he got into programming.
              • Some of the books our hosts and guests read as kids and how they relate to programming.
              • How Jason got into Elixir while working on a chat service for events app at Hobnob.
              • Jason’s current project using Elixir to build the back end for Animal Repair Shop.
              • What caused Hobnob to switch to Elixir for their chat app and Jason’s aha moments learning it.
              • The TLDR version of the project that birthed ‘Road to 2 Million WebSocket Connections’.
              • What Jason loves about Elixir — pattern matching, immutability, explicitness.
              • Why Jason and his team at Animal Repair Shop are building their back end in Elixir.
              • The features provided by the Elixir Language Server for giving IDEs Elixir type support.
              • Jason’s involvement with GitHub/ElixirLSP; why he got involved, the project’s architecture, etc.
              • Some of the most challenging aspects of working on ElixirLS for Jason.
              • Jason’s talk on ElixirLS at ElixirConf – its content, doing it virtually, and more.
              • New features in the pipeline for ElixirLS; formatting speed improvements and more.
              • The role that good tooling plays in being able to learn a language more easily.
              • What needs to happen for Elixir to become a more mainstream back end option.
              • Advice from Jason regarding ways to convince your firm to adopt Elixir.
              • Links Mentioned in Today’s Episode:

                SmartLogic — https://smartlogic.io/

                Jason Axelson on LinkedIn — https://www.linkedin.com/in/jasonaxelson
                Jason Axelson on GitHub — https://github.com/axelson
                Jason Axelson on Twitter — https://twitter.com/bostonvaulter?lang=en
                Priv_check by Jason Axelson — https://github.com/axelson/priv_check
                Jason Axelson ElixirConf ElixirLS Talk — https://2020.elixirconf.com/speakers/126/talk
                A Definitive Guide to JavaScript — https://www.oreilly.com/library/view/javascript-the-definitive/9781491952016/
                Hobnob — https://hobnob.app/
                Elixir for Programmers by Dave Thomas — https://codestool.coding-gnome.com/courses/elixir-for-programmers
                Animal Repair Shop — https://www.animalrepairshop.com/about/
                ‘Road to 2 Million WebSocket Connections’ — https://phoenixframework.org/blog/the-road-to-2-million-websocket-connections
                Elixir Getting Started Guide — https://elixir-lang.org/getting-started/introduction.html
                GitHub/ElixirLP — https://github.com/elixir-lsp/elixir-ls
                Adopting Elixir — https://pragprog.com/titles/tvmelixir/adopting-elixir/
                Elixir Slack — https://elixir-slackin.herokuapp.com/
                elixir-lsp/elixir-ls: Issue #274 — https://github.com/elixir-lsp/elixir-ls/issues/274
                elixir-lsp/elixir-ls: Issue #381 — https://github.com/elixir-lsp/elixir-ls/issues/381

                Special Guest: Jason Axelson.

                34 min
              • Steve Domin on Innovating Travel APIs

                Anyone who has written software for the travel industry can tell you that it is in desperate need of innovation — shockingly many of their cobwebbed systems were built in the 70s. Today we speak with Duffel CEO Steve Domin, who is building tech that can finally align travel with the expectations of modern consumers. We open by exploring Steve’s journey into coding before diving into how Duffel is innovating travel. After touching on how the pandemic has impacted Duffel’s roll-out, Steve shares horror stories about the outdated tech and API systems that airlines use. We discuss Duffel’s service offerings and why Elixir is uniquely suited to solve the problems that Steve’s company is addressing. Steve then talks about the types of engineers that Duffel hires, his client base, and where his company is heading. Near the end of the episode, we ask Steve for his advice on selling your company on Elixir and we chat about the status of the London Elixir Meetup. Tune in for more insights on how Steve is using Elixir to make travel an effortless experience.

                Key Points From This Episode:

                • Introducing Duffel CEO Steve Domin.
                • Steve shares details about his coding journey and career highlights.
                • Insights into the old school ecosystem of Flash, Flex, and ActionScript.
                • Exploring how Duffel is innovating the travel industry.
                • Why Duffel accelerated their roll-out due to the pandemic.
                • Steve unpacks the outdated tech and API systems that airlines use.
                • Why Duffel decided to use Elixir to tackle their problems.
                • The benefits of using Elixir when dealing with airline data.
                • Steve gives listeners an overview of Duffel’s pipeline.
                • Insights into the types of engineers that Duffel hires.
                • Who Duffel’s clients are and how they’re onboarded.
                • Steve reflects on some airline API horror stories.
                • Hear about Duffel’s roadmap — the future is bright.
                • What Elixir has uniquely enabled Duffel to do.
                • Steve’s advice on selling Elixir to stakeholders in your company.
                • The status of the London Elixir Meetup.
                • Links Mentioned in Today’s Episode:

                  SmartLogic — https://smartlogic.io/

                  Steve Domin — https://stevedomin.com/about
                  Steve Domin on LinkedIn — https://www.linkedin.com/in/stevedomin/
                  Steve Domin on Twitter — https://twitter.com/stevedomin
                  Duffel — https://duffel.com/
                  Duffel Careers — https://duffel.com/careers
                  José Valim — https://twitter.com/josevalim
                  Flex — https://www.adobe.com/products/flex.html
                  Passenger Service System — https://en.wikipedia.org/wiki/Passenger_service_system
                  Global Distribution System — https://en.wikipedia.org/wiki/Global_distribution_system
                  Sabre — https://www.sabre.com/
                  Amadeus — https://amadeus.com/en
                  ‘Why does NDC matter to my travel business?’ — https://duffel.com/blog/why-does-ndc-matter-to-my-travel-business
                  IATA — https://www.iata.org/
                  Next.js — https://nextjs.org/
                  GoCardless — https://gocardless.com/
                  Twilio — https://www.twilio.com/
                  Stripe — https://stripe.com/
                  Thomas Bates — https://www.linkedin.com/in/thomas-bates-3908a74b/
                  Elixir London Meetup — https://www.meetup.com/Elixir-London/
                  Baris Balic — https://twitter.com/barisbalic

                  Special Guest: Steve Domin.

                  39 min
                • Shawn Vo on Elixir as a Competitive Advantage

                  To beat out their competitors, startups need to code quickly, simply, and in a language that attracts top engineers. Enter Elixir. Today we speak with Shawn Vo, Axle Payments Co-Founder and CTO, about his journey with Elixir and how it has given his company a competitive advantage. We open our conversation by exploring how Shawn got into coding while automating his work as an investment banker. After touching on why he sees programming as a superpower for adding value, he shares his growth hacks for learning a language — these range from reading old books to attending coding meetups. We then dive into Axle Payments’ business model, with Shawn highlighting the business opportunity of creating tech for industries that “people don’t think about.” A key theme in this episode, Shawn talks about how building in Elixir has helped Axle Payments hire the best engineers. We also discuss how Elixir allows them to quickly and efficiently write code that doesn’t break. Near the end of the episode, we explore Shawn’s browser extension projects and why he has a readme file to help guide people who want to work with him. Be sure to tune in to hear more insight from Shawn on the benefits of using Elixir in the startup space.

                  Key Points From This Episode:

                  • Introducing Axle Payments CTO Shawn Vo.
                  • From investment banking to coding, hear how Shawn got into our industry.
                  • Why coding and creating content are top ways of creating value.
                  • Reading books and getting into the fundamentals; tips on how Shawn learns a language.
                  • Shawn shares details about his professional career.
                  • How Shawn grew his skills by attending coding meetups.
                  • Hear about Axle Payments’ model providing a factoring service.
                  • How Shawn discovered and fell in love with Elixir.
                  • Why Elixir has given Axle Payments their competitive advantage.
                  • Shawn reflects on his first Elixir project.
                  • The benefits of using event sourcing to build your app.
                  • Why Shawn created a readme to guide people who want to work with him.
                  • Shawn summarizes why Elixir is the perfect language for his company.
                  • Links Mentioned in Today’s Episode:

                    Shawn Vo on LinkedIn — https://www.linkedin.com/in/shawnvo/

                    Shawn Vo on Twitter — https://twitter.com/shawnvo
                    Shawn Vo on GitHub — https://github.com/voshawn
                    Shawn Vo Email — [email protected]
                    Axle Payments — https://www.axlepayments.com/
                    The Technical Cofounder Newsletter — https://technicalcofounder.substack.com/
                    Meryl Dakin — https://twitter.com/meryldakin
                    WALL-E — https://www.imdb.com/title/tt0910970/
                    Barclays Investment Bank — https://www.investmentbank.barclays.com/
                    The Climate Corporation — https://www.climate.com/
                    The Monsanto Company — https://www.cropscience.bayer.com/
                    Federal Deposit Insurance Corporation — https://www.fdic.gov/
                    Deep Learning NYC — https://www.meetup.com/Deep-Learning-NYC/
                    Baltimore AI Meetup — https://www.meetup.com/Baltimore-AI/
                    Fast.ai — https://www.fast.ai/
                    Megabus — https://www.megabus.com/
                    Greyhound — https://www.greyhound.com/
                    Techstars — https://www.techstars.com/
                    Peter Thiel — https://www.forbes.com/profile/peter-thiel/
                    WeWork — https://www.wework.com/
                    Paul Graham — http://www.paulgraham.com/
                    Y Combinator — https://www.ycombinator.com/
                    ‘The Python Paradox’ — http://www.paulgraham.com/pypar.html
                    Heroku — https://www.heroku.com/
                    Sessionizer — https://sessionize-me.herokuapp.com/
                    Hamilton — https://hamiltonmusical.com/new-york/home/
                    Slack — https://slack.com/
                    Phoenix — https://hexdocs.pm/phoenix/overview.html
                    Commanded — https://hexdocs.pm/commanded/Commanded.html
                    The Social Dilemma — https://www.imdb.com/title/tt11464826/

                    Special Guest: Shawn Vo.

                    39 min
                  • Viktória Fördős on Erlang

                    Today we sit down with Erlanger Viktória Fördős, who talks with us about Erlang and how it is used at Cisco. We open the show by finding out about Viki’s background in coding and her unorthodox entry into the field. After hearing about her experiences in her school choir and her transition into the informatics faculty, Viki talks to us about her first experiences in coding and the thrills she found in it. She then expands on the topic, revealing how she approached people to build their websites using her newfound skills in HTML and PHP. A flash-forward later, and Viki shares details about her role as an NSO Core Engineer for Cisco. After hearing how NSO serves as a network operating system, device automation platform, and orchestration engine, Viki explains why NSO is so special. She touches on fast map-based service and some of the ways she and her team implement network-wide transactions using — you guessed it — Erlang. Viki then explains Erlang, how you should approach it if you’re a newbie, and what to expect from its biggest challenges. She elaborates on tail-recursive functions and high-level vulnerabilities concerned with SSL crypto libraries, system integrity, and atom tables. Toward the end of the show, we ask Viki to tell us about her Code BEAM presentation and about her thoughts on why academia and industry should collaborate on a more regular basis. Join us today and be treated to an enriching conversation about Erlang, as well as our secret mini-feature segment!

                    Key Points From This Episode:

                    • Introducing today’s guest, Viki Fördős from Cisco.
                    • A snapshot of Viki’s unorthodox background in coding.
                    • Viki shares details about early experiences learning Basic.
                    • Hear about Viki’s first programming job out of college.
                    • Viki’s position as a core engineer for the NSO team at Cisco.
                    • Find out what the NSO team at Cisco does.
                    • Insights into the patented algorithm, “fast map.”
                    • How Viki started to use Erlang on a day-to-day basis.
                    • Ways you can start thinking in Erlang from an Elixir background.
                    • The kinds of issues Viki runs into when spawning too many processes.
                    • What Erlang has to offer that other languages cannot.
                    • Viki’s biggest challenges when she first started learning Erlang.
                    • The elevator pitch Viki uses when she encourages friends and colleagues to use Erlang.
                    • Distribution protocols and what they mean to Erlang newbies.
                    • Hear about the high-level vulnerabilities you ought to pay attention to when coding in Erlang.
                    • Introducing Christian Koch, today’s mini-feature segment guest.
                    • How Chris first got into Elixir.
                    • How Elixir is being used by platform engineers at Cars.com.
                    • Why Elixir was chosen as the end-game language to be used at Cars.com
                    • The process behind onboarding coders onto Chris’s Elixir team.
                    • Viki’s best advice to those wanting to give a Code BEAM talk.
                    • Hear about refactoring and how it works.
                    • What Viki means by, “research being consumed by industry.”
                    • Links Mentioned in Today’s Episode:

                      Viktória Fördős - https://github.com/viktoriafordos

                      Cisco — https://www.cisco.com/
                      EW20 — https://github.com/viktoriafordos/ew20 Prototype implementation of the security analysis introduced in V. Fördős: Secure Design and Verification of Erlang Systems paper
                      Christian Koch — https://www.linkedin.com/in/ckochx/
                      Cars.com — https://www.cars.com/
                      BASIC — https://en.wikipedia.org/wiki/BASIC
                      Cisco NSO — https://www.cisco.com/c/en/us/products/cloud-systems-management/network-services-orchestrator/index.html
                      Think in Erlang! - Viktória Fördős — https://www.youtube.com/watch?v=bYkOsQU2ywM
                      Erlang general server — https://erlang.org/doc/man/gen_server.html
                      Erland Reference Manual — https://erlang.org/doc/reference_manual/distributed.html
                      4 Using TLS — https://erlang.org/doc/apps/ssl/ssl_distribution.html
                      Erland System Limits — http://erlang.org/doc/efficiency_guide/advanced.html#system-limits
                      Hexdocs — https://hexdocs.pm/elixir/String.html#to_existing_atom/1
                      RefactorErl — https://plc.inf.elte.hu/erlang/
                      Pipedream on GitHub — https://github.com/PipedreamHQ/pipedream/blob/master/components/github/readme.md

                      Special Guest: Viktória Fördős.

                      48 min
                    • Simon Glenn-Gregg on Building an Election Results Prototype in Elixir

                      Today’s guest is Simon Glenn-Gregg, News Engineer at The Washington Post. He joins us to talk about using Elixir to build a prototype for a platform the news house recently implemented to visualize the results of the November 2020 elections in real-time.

                      While the job title of ‘News Engineer’ makes it seem like Simon invents news, this is not the case. He is focused on software related to publishing at The Washington Post, and in particular, has been working on building their election visualization platform for the past two years. Before the final iteration of the platform was built, the software engineering team at The Washington Post were given a period to test different technologies as an experiment to find the best fit, and Simon decided to try his hand at Elixir and Phoenix. He talks about what led him to this choice, and his experiences building out his prototype which he demonstrated on a dataset generated by the North Carolina 3rd Congressional District house race in September. Simon tells us about how the pitch went, what the team at The Washington Post was especially impressed by, and what led to the choice to use Node in the end.

                      Simon talks about the culture of openness to new technologies at The Washington Post as well as some of the limitations to their adoption. We also hear about how the final version of the visualization platform held up during the elections proper, and Simon’s plans to include Elixir in future stacks due to its amazing abilities as far as concurrency and memory. Tune in today!

                      Key Points From This Episode:

                      • What kinds of projects Simon works on at The Washington Post as a ‘news engineer’.
                      • The live updating election visualizer that Simon was working on at The Washington Post.
                      • What went into building the infrastructure for this platform and how Elixir was chosen as a candidate.
                      • A blog post about Elixir’s memory management; abilities Elixir has regarding concurrency.
                      • The first steps Simon took toward learning Elixir and Phoenix by building simple projects.
                      • Simon’s process of integrating his Elixir app into the current stack and people at The Washington Post.
                      • Testing the app on the 3rd Congressional District house race in North Carolina, and pitching to the team.
                      • Why it is hard to implement projects in new languages at The Washington Post.
                      • How the voting process went after the pitch and which project won.
                      • What the audience at the pitch loved about Elixir, and what the stumbling blocks were.
                      • The nature of working at a deadline-driven place like The Washington Post when it comes to adopting new technologies.
                      • Sources The Washington Post used to get their election data.
                      • What technologies and methods the team used to handle the size of data some election moments generated.
                      • Which parts about the election visualizer that ended up being built using Node would have been easier to do in Elixir.
                      • The other side of the coin – what made writing the app in Python and JavaScript easier.
                      • What future projects Elixir might be better suited to at The Washington Post.
                      • Simon’s background, education, and how he learned programming in previous jobs
                      • Why Simon stuck programming out and decided it was the right path for him.
                      • The need for software engineers at The Washington Post and why they are recruiting so often.
                      • A deep dive into the tech stack at The Washington Post and how they render their pages and maps.
                      • How Simon feels having reached the end of a successful project that millions of people engaged with.
                      • Future projects at The Washington Post and Simon’s hopes to incorporate more Elixir.
                      • A funny story about having to manually update the votes from rural New Hampshire into the app.
                      • Links Mentioned in Today’s Episode:

                        SmartLogic — https://smartlogic.io/

                        Simon Glenn-Gregg on LinkedIn — https://www.linkedin.com/in/simongle/
                        Simon Glenn-Gregg — http://simonglenngregg.com/
                        The Washington Post — https://www.washingtonpost.com/
                        Jason Holt on Twitter — https://twitter.com/offpol
                        ‘Elixir RAM and the Template of Doom’ — https://www.evanmiller.org/elixir-ram-and-the-template-of-doom.html
                        Erik Reyna on LinkedIn — https://www.linkedin.com/in/erikreyna/
                        Jeremy Bowers on LinkedIn — https://www.linkedin.com/in/jeremyjbowers/
                        Associated Press — https://apnews.com/
                        Edison — https://www.edisonresearch.com/
                        Whole Whale — https://www.wholewhale.com/
                        The Century Foundation — https://tcf.org/
                        Arc Publishing — https://www.arcpublishing.com/
                        Sundi Myint on Twitter — https://twitter.com/sundikhin
                        Justus Eapen — https://twitter.com/JustusEapen
                        Eric Oestrich on Twitter — https://twitter.com/ericoestrich

                        Special Guest: Simon Glenn-Gregg.

                        38 min

                      About Elixir Wizards

                      From the publisher's feed

                      Elixir Wizards is an interview-style podcast from SmartLogic featuring conversations with developers, engineers, and industry leaders about the Elixir programming language and the broader software…