Elixir Wizards

Elixir Wizards

By SmartLogic LLCTechnologyEducationHow To
Download on the App Store

Elixir Wizards episodes

  • Scaling and The Growth Curve with Francesco Cesarini

    Joining us for this episode of Elixir Wizards is the vastly experienced and well-traveled Francesco Cesarini! Francesco is the founder of Erlang Solutions and we are so lucky to have him here on the show to talk about his personal and professional journey, and take this great season of shows on the magic of the BEAM even further. Francesco takes us through his early interactions with computers and coding and the events that led to his decision to study computer science, before diving into his move to Sweden, and subsequently the UK, and how this all resulted in the founding of his company. Our guest touches on some helpful lessons he learned around marketing and branding, particularly related to the name of the company and we also discuss how the company grew in stages over the years. From there, the conversation turns to Francesco's work on conferences, and his commitment to this important feature of the community. We talk about the benefits of virtual conferences, what to look forward to, and the team that Francesco works with when organizing. To finish off this segment, our guest gives a few recommended resources and comments on Erlang syntax too! For today's mini-feature we welcome Jeffery Utter who works as a Senior Software Developer at Bleacher Report, so make sure to tune in to catch it all!

    Key Points From This Episode:

    • Francesco's route into coding from an early age and first forays into studying computer science.
    • The first job that Francesco had out of college: an exciting internship at Ericsson.
    • How Francesco founded Erlang Solutions after leaving Sweden and moving to London.
    • The big growth steps that happened over the years as Erlang Solutions developed.
    • Francesco's evolving mindset during this growth period and his attitude towards scaling the company.
    • The current size of the company and the offices that are spread all over the world!
    • Virtual conferences, more connectivity, and the benefits of getting involved in the community.
    • The planning process for conferences and the size of the team that put them together.
    • The growth curve for Erlang Solutions over the years and the main drivers in the process.
    • Examples from the explanatory videos that Francesco produced to help people understand Erlang.
    • Francesco's feelings about Erlang syntax and the misconceptions about its difficulty.
    • Recommendations of helpful resources to aid the learning curve.
    • Getting involved with Erlang Solutions and connecting with Francesco and his team!
    • Jeffery Utter from Bleacher Report joins us to briefly talk about his journey with Elixir.
    • The time that Jeffery spent working at Communication Service for the Deaf prior to Bleacher Report.
    • Some updates on the growth and evolution of Bleacher Report and what they offer users.
    • How Elixir is used at Bleacher Report and its succession of Ruby at the company.
    • Jeffery's alternate career paths and qualifications in music and education!
    • Links Mentioned in Today’s Episode:

      SmartLogic — https://smartlogic.io/

      Elixir Conference — http://smr.tl/conf-podcast
      Francesco Cesarini on Twitter — https://twitter.com/FrancescoC
      Joe Armstrong — https://codersatwork.com/joe-armstrong.html
      Erlang Solutions — https://www.erlang-solutions.com/
      Erlang Programming Language - Computerphile — https://www.youtube.com/watch?v=SOqQVoVai6s
      Chalmers University of Technology — https://www.chalmers.se/en/Pages/default.aspx
      Erlang & Elixir Developers | Careers at Erlang Solutions — https://www.erlang-solutions.com/careers/
      Code BEAM V SF 2021 — https://codesync.global/conferences/code-beam-sf-2021/.
      RabbitMQ Summit— https://rabbitmqsummit.com/
      Languages, and about languages, on the BEAM — https://github.com/llaisdy/beam_languages
      Lambda Days 2021 — https://www.lambdadays.org/lambdadays2021
      Code Mesh — https://codesync.global/conferences/code-mesh-ldn
      Erlang Master Classes University of Kent — https://www.cs.kent.ac.uk/ErlangMasterClasses/
      Professor Simon Thompson — https://www.kent.ac.uk/computing/people/3164/thompson-simon
      Designing for Scalability with Erlang/OTP — https://www.oreilly.com/library/view/designing-for-scalability/9781449361556/
      Erlang Programming — https://www.oreilly.com/library/view/erlang-programming/9780596803940/
      Jeffery Utter — https://www.linkedin.com/in/jeffutter
      Bleacher Report — https://bleacherreport.com/
      Communication Service for the Deaf — https://www.csd.org/
      Gallaudet University — https://www.gallaudet.edu/

      47 min
    • Bringing the Magic of Math into Programming with Chris Miller

      Today we have some extra BEAM magic for all of you! Joining us on the show is Chris Miller, who currently works as an Associate Software Engineer at Corvus Insurance. We get into a great conversation with Chris about his history with programming, his long-held interest in mathematics, and how he is trying to bring these two worlds closer together through his work. Chris weighs in with some very important expert perspectives on a range of subjects, from monads and monoids to Vim and Emacs, before we get into the different avenues of Chris' work. Along with an old college friend, Chris runs the informative YouTube Channel, Coding Cave, helps other coders through mentorship and tutoring, and is also multilingual, speaking Mandarin, Spanish, German, and English! We get some illumination on interesting and important concepts such as Turing completeness, programming language theory, and more, all delivered with an accessibility that belies the high level of the material. So for all this, plus our bonus mini-segment with Semsee employee, Sidney Leatherwood, at the end, be sure to listen in today!

      Key Points From This Episode:

      • The story behind Chris' Twitter handle and his admiration for Leonhard Euler!
      • How Chris is bringing his love of math into his programming work.
      • A crash course on monads and monoids!
      • Chris' teaching and tutoring work and his aim of bringing fun examples into learning.
      • The YouTube channel that Chris runs with an old friend, called Coding Cave.
      • Chris' take on the Vim versus Emacs debate.
      • How Chris learned to program from his father, and his return to it during college.
      • Unpacking programming language theory and the idea of Turing completeness.
      • Chris clears up the difference between computer science and mathematics.
      • Reasons that Chris enjoys working in Elixir compared with other languages.
      • Chris' goals for his YouTube channel and his hopes to spread advanced education.
      • Magic and languages; a programming language theory perspective.
      • Chris' day job as a software engineer at Corvus Insurance using Elixir and Elm.
      • The array of languages that Chris can speak; Mandarin, German, and Spanish.
      • The process of language acquisition and Chris' methods for learning.
      • Why Chris believes starting with the function is the best way to learn a new programming language.
      • The aspects of Elixir and the BEAM that have Chris the most excited at the moment!
      • This week's mini-feature with Sidney Leatherwood and his use of Elixir in production.
      • The comparative rating service that Semsee offers their customers.
      • Hiring in Elixir currently; perks, challenges, and resources in the space.
      • Links Mentioned in Today’s Episode:

        SmartLogic — https://smartlogic.io/

        Chris Miller on Twitter — https://twitter.com/blackeuler
        Elixir Wizard Conference — http://smr.tl/conf-podcast
        Leonhard Euler — https://en.wikipedia.org/wiki/Leonhard_Euler
        Curry–Howard Correspondence — https://en.wikipedia.org/wiki/Curry%E2%80%93Howard_correspondence
        Haskell — https://www.haskell.org/
        Brooklyn Zelenka — https://medium.com/@expede
        Coding Cave — https://www.youtube.com/channel/UCwIO8jv71cbOyEwJdrYov_g
        Conversations with the Creator: José Valim — https://www.youtube.com/watch?v=BXpoKKkqAX4
        Functor — https://en.wikipedia.org/wiki/Functor
        Spacemacs: Emacs advanced Kit focused on Evil — https://www.spacemacs.org/
        hlissner/doom-emacs — https://github.com/hlissner/doom-emacs
        Turing Completeness — https://en.wikipedia.org/wiki/Turing_completeness
        Cal Newport — https://www.calnewport.com/
        Boolean Algebra — https://en.wikipedia.org/wiki/Boolean_algebra
        Clojure — https://clojure.org/
        Corvus Insurance — https://www.corvusinsurance.com/
        APL — https://en.wikipedia.org/wiki/APL_(programming_language)
        Gleam - https://gleam.run/
        Sidney Leatherwood on LinkedIn — https://www.linkedin.com/in/leather-s
        Semsee — https://semsee.com/

        Special Guest: Chris Miller.

        55 min
      • The Controlled Magic of Oban with Parker and Shannon Selbert

        While there is magic to be found in many frameworks, having too much going on under the hood without you being able to control it is not for everybody. Today we invite Parker and Shannon Selbert to speak about their dynamic partnership and the ‘controlled magic’ of their tool Oban. Together Parker and Shannon founded Soren, where they help clients with established web apps stabilize, scale, and ‘add schmancy features’. Their tool Oban is a persistent background job processor written in Elixir whose differentiating feature revolves around keeping jobs after they're processed. We dive right in with Parker and Shannon hearing about how they got into programming before they talk about Oban and what sets it apart. Next up we get into how our guests navigate their personal relationship and professional partnership and they weigh in on homeschooling kids, writing new features, and the necessary life skills for handling Oban user support. Moving onto the topic of the BEAM, we explore the unique type of magic it offers and how this plays into some of the cooler features of Oban such as being able to cancel jobs. Our guests talk about some of the kinks they still need to work out of their tool and we wrap up our conversation on the pro version of Oban and how successful it has been. As always we close today’s show off with our mini-interview, this time with Joe Peck from Spreedly!

        Key Points From This Episode:

        • The illicit stories behind how Parker and Shannon got into tech.
        • Understanding Oban, a persistent background job processor written in Elixir.
        • How Oban is different from other job processors like Sidekiq.
        • The great partnership our guests have and the story behind Soren.
        • How Parker and Shannon differentiate their personal and professional life.
        • The approach Parker and Shannon take to handling Oban user support.
        • Perspectives on the magic of homeschooling, relationships, and Oban!
        • Different kinds of magic provided by different frameworks and why Elixir magic is the best.
        • How Parker and Shannon got interested in Erlang, BEAM, and Elixir.
        • The best part about maintaining an open-source project.
        • The story behind getting a global concurrency lock on handling batches.
        • Added features that come with upgrading to the pro version of Oban.
        • Canceling a job on Oban and the role the BEAM plays in allowing this.
        • Writing documentation for Oban and our guest’s plans to make video tutorials.
        • The shift in digital learning more towards video tutorials.
        • Perspectives on whether we have arrived at a golden age in computing yet.
        • Challenges around implementing seamless horizontal scaling in Oban.
        • Making a living and working on Oban; advantages of setting up a pro version.
        • Our mini-interview with Joe Peck where we explore his journey with Elixir.
        • Links Mentioned in Today’s Episode:

          Elixir Wizards |> Conference — https://smr.tl/conf-podcast

          SmartLogic — https://smartlogic.io/
          Soren on Twitter — https://twitter.com/sorentwo?lang=en
          Soren — https://sorentwo.com/
          Parker Selbert on GitHub — https://github.com/sorentwo
          Shannon Selbert on GitHub — https://github.com/sorenone
          Oban — https://github.com/sorentwo/oban
          Sidekiq — https://sidekiq.org/
          Lawnmower Man — https://www.imdb.com/title/tt0104692/
          Soren Kierkegaard — https://www.britannica.com/biography/Soren-Kierkegaard
          Ender's Game — https://www.amazon.com/Enders-Ender-Quintet-Orson-Scott/dp/0812550706
          Joe Peck — https://peckyeah.com/
          Spreedly — https://www.spreedly.com/

          Special Guests: Parker Selbert and Shannon Selbert.

          51 min
        • The Right Amount of Magic with Erik Person

          Today we are joined by the Vice President of Engineering at Corvus Insurance, Erik Person! Erik continues our journey into the magic of the BEAM, our season-long theme for the Elixir Wizards Podcast, and we get to hear all about Erik's path in programming, his relationship with Elixir, and his utilization of the BEAM. Growing up in a family involved in computer science, and an early affinity for technology made the choice of what to study at college a straightforward one for Erik. He tells us about his life during and after those school years, touching on his first job and the important milestones leading up to his current position at Corvus. We talk about his early feelings for Elixir and why it appealed to him almost immediately before discussing different languages on the BEAM and his love of types! Our guest also shares some of the bigger challenges he has encountered working in Elixir and touches on the issue of scaling effectively. In this episode, we also air a mini-feature with SmartLogic's very own Stephanie Vizzi, talking about her work at the company, relationship with Elixir, and more! So for all this, plus a lot in between, be sure to tune in!

          Key Points From This Episode:

          • Erik's family ties to computer science and his path leading into programming.
          • The first job that Erik landed in programming and his current role at Corvus Insurance.
          • The BEAM at Corvus and the general architecture of the company's technology.
          • Erik's first encounters and learnings with Elixir and the questions it answered for him immediately.
          • The learning curve for languages on The BEAM; Erik's own journey to understanding.
          • Erik's preference for types and his wish for their inclusion on Elixir!
          • Lisp on The BEAM; Erik unpacks his perspectives and the blog post he wrote on the subject.
          • Getting to grips with abstract forms and how these terms operate in Erlang and Elixir.
          • The challenges that Erik experienced parsing and manipulating the code in Elixir.
          • Erik weighs in on BEAM magic; appreciating the magic that is possible with Elixir and Elm.
          • Perspectives on scaling on Elm and Elixir as an application grows rapidly.
          • How Erik and his team typically use contexts and service-oriented architecture.
          • Challenges with compile times during the process of scaling of the application.
          • Excitement about the progressive steps in the data science component of Corvus.
          • How Erik applied his skills to his passion for playing blackjack by creating a card-counting application.
          • The remote meeting hardware device that Erik built as a pandemic side-project!
          • This week's community mini-feature! Looking at how Stephanie Vizzi got into and uses Elixir.
          • Links Mentioned in Today’s Episode:

            SmartLogic — https://smartlogic.io/

            Erik Person on LinkedIn — https://www.linkedin.com/in/erik-person-a9368bb
            VirtualBox — https://www.virtualbox.org/
            Tunnelblick — https://tunnelblick.net/
            Corvus Insurance — https://www.corvusinsurance.com/
            Corvus Job Openings — https://boards.greenhouse.io/corvusinsurance/
            Clojure — https://clojure.org/
            Saša Jurić — https://github.com/sasa1977
            LFE — https://lfe.io/
            Elm — https://elm-lang.org/
            Robert Virding — https://codesync.global/speaker/robert-virding/
            The Erlang Rationale — https://elixirforum.com/t/the-erlang-rationale-by-robert-virding-pdf/35313
            Paul Graham — http://www.paulgraham.com/
            Hackers and Painters — https://www.amazon.com/Hackers-Painters-Big-Ideas-Computer/dp/1449389554
            Myers Briggs — https://www.myersbriggs.org/my-mbti-personality-type/mbti-basics/
            Chris McCord — http://chrismccord.com/
            Mix Xref — https://hexdocs.pm/mix/Mix.Tasks.Xref.html
            Gleam — https://gleam.run/
            Leex — http://erlang.org/doc/man/leex.html
            GNU Bison - The Yacc-compatible Parser Generator — https://www.gnu.org/software/bison/manual/
            YACC — https://www.geeksforgeeks.org/introduction-to-yacc/
            Stephanie Vizzi on LinkedIn — https://www.linkedin.com/in/stephanie-vizzi-b1158996

            Special Guests: Erik Person and Stephanie Vizzi.

            1 hr 1 min
          • Robert Virding on the Roots of Erlang

            Welcome to a brand-spanking-new season of Elixir Wizards! This time around we will be focussing on the magic of the BEAM, so get ready for an exciting journey into new territories filled with mystery and power! To kick things off in this inaugural episode we are joined by a true legend in the space of Erlang, Elixir, and the BEAM. Robert Virding is one of the three founding members of Erlang, and his unrivaled intimacy with the language and its related subjects is truly inspiring and informative. We feel like we could fill many more episodes just hearing Robert unpack the history he has been involved in, but we do manage to cover a lot in this show, touching on Robert's career arcs, the other founders of Erlang, the connection to Ericsson and the bridge to Elixir, as well as much more. Robert also shares some insight into the BEAM and the idea of a virtual machine, broaching these sometimes misunderstood concepts with simplicity and clarity. We talk about magic, hurdles, best practices, and the future of community, with Robert sharing his experiences working on Erlog, LFE, and much more. Make sure to join us for this episode and stay tuned for the rest of another great season!

            Key Points From This Episode:

            • Robert's description of the Erlang Rationale document and why it was important to create it.
            • Background information on the founding three members of Erlang and how they came together.
            • Training and early career as a computer scientist; Robert's background before Ericsson.
            • The roots of the Erlang name, and how Robert first came across and connected with it.
            • The simplest definition of the BEAM, Bogdan’s Erlang Abstract Machine!
            • Unpacking the application of a virtual machine and the connection between Erlang and BEAM.
            • Information on Core Erlang and how it works within the compiler.
            • LFE or Lisp-Flavored Erlang and the decisions that were made to keep it straightforward.
            • Hurdles to learning Erlang and Robert's thoughts on getting over these.
            • Weighing the usefulness of 'magic' and the caution with which Robert approaches it.
            • Best practices for Erlang and Elixir according to Robert; the biggest shifts necessary for success.
            • Robert's first feelings about the arrival of Elixir and the questions it raised for him.
            • The motivation behind Robert's work on Erlog!
            • Reflections on the Erlang movies that Ericsson produced and their evolution over time!
            • The future of Erlang, its community, and the need for continued and increased collaboration.
            • Why Robert wants to put more parentheses back in the mix!
            • Links Mentioned in Today’s Episode:

              SmartLogic - https://smartlogic.io/

              Robert Virding - https://codesync.global/speaker/robert-virding/
              Robert Viriding on Twitter - https://twitter.com/rvirding?lang=en
              The Erlang Rationale - https://elixirforum.com/t/the-erlang-rationale-by-robert-virding-pdf/35313
              Prolog - https://www.swi-prolog.org/
              Ericsson - https://www.ericsson.com/
              Joe Armstrong - https://www.theguardian.com/education/2019/may/08/joe-armstrong-obituary
              Mike Williams - https://codesync.global/speaker/mike-williams/
              Fortran - https://fortran-lang.org/
              Pascal - http://www.pascal-programming.info/index.php
              VAX - https://www.computerhope.com/jargon/v/vax.htm
              Franz Lisp - https://franz.com/products/allegro-common-lisp/acl_prolog.lhtml
              Agner Krarup Erlang - https://mathshistory.st-andrews.ac.uk/Biographies/Erlang/
              LFE - https://lfe.io/
              Erlang The Abstract Format - https://erlang.org/doc/apps/erts/absform.html
              Core Erlang - https://blog.erlang.org/core-erlang-by-example/
              Erlog - https://github.com/rvirding/erlog
              Lua in Erlang - https://github.com/rvirding/luerl
              Erlang: The Movie - https://elixirforum.com/t/erlang-the-movie/440
              Monty Python - http://www.montypython.com/
              Erlang Ecosystem Foundation - https://erlef.org/
              A first look at the JIT - https://blog.erlang.org/a-first-look-at-the-jit/
              Lisp Cycles - https://xkcd.com/297/
              Creative Assembly - https://www.creative-assembly.com/
              Total War - https://www.totalwar.com/
              World of Warcraft - https://worldofwarcraft.com/en-us/

              Special Guest: Robert Virding.

              50 min
            • Adopting Elixir Finale with Sean Lewis, Anna Neyzberg, and René Föhring

              Season 5 ends with a bang as we welcome back Sean Lewis, Anna Neyzber, and René Föhring onto the show to share their journey on getting their companies and teams to adopt Elixir. We open our conversation with each guest sharing their first experiences with Elixir. After chatting about the changes that they’ve seen in the Elixir ecosystem, we explore Elixir’s benefits and how they’ve persuaded companies to make the Elixir leap. From zero downtime deployment to arguing for Elixir’s ability to solve immediate problems, we touch on the most convincing reasons for stakeholders to adopt Elixir. Following this, we unpack common Elixir criticisms before looking at the importance of hiring developers for their aptitude as well as for their skill set. Later, we discuss what we most appreciate about Elixir, with each guest sharing a story from producing an Elixir app. We round off an insightful episode by talking about Elixir accessibility and the top ways to train entry-level programmers. Join us as we wrap up this season for a last deep-dive on adopting Elixir.

              Key Points From This Episode:

              • We introduce today’s panel, featuring Sean Lewis, Anna Neyzberg, and René Föhring.
              • Hear how each guest discovered Elixir and what they’ve seen change in the ecosystem.
              • Exploring our guests' first Elixir projects.
              • The intersections between Elixir and cryptocurrency.
              • How to persuade company stakeholders to adopt Elixir.
              • Why choosing a language for scalability often isn’t as important as its immediate benefits.
              • Unpacking common criticisms of Elixir adoption.
              • How a culture of learning can push your company in the right direction.
              • Anecdotes on getting companies to adopt Elixir.
              • We touch on the benefits of using Elixir.
              • Each guest reflects on their experiences producing and maintaining Elixir apps.
              • How our guests are currently using Elixir.
              • Using Credo to train new Elixir developers.
              • Advice on making Elixir accessible to entry-level coders.
              • Links Mentioned in Today’s Episode:

                SmartLogic — https://smartlogic.io/

                Elixir Wizards Discord — https://smr.tl/wizards-discord
                Elixir Wizards Email — [email protected]
                Elixir Wizards Conference — https://smartlogic.io/about/community/elixir-wizards-conference/
                Anna Neyzberg on LinkedIn — https://www.linkedin.com/in/anna-neyzberg-93545316/
                Anna Neyzberg on Twitter — https://twitter.com/ANeyzb
                Sean Lewis on LinkedIn— https://www.linkedin.com/in/sean-lewis-40375077/
                René Föhring on Twitter — https://twitter.com/rrrene
                René Föhring — https://rrrene.org/
                ElixirBridge — http://elixirbridge.org/
                Carbon Five — https://www.carbonfive.com/
                Genesis Block — https://genesisblock.com/
                Genesis Block Jobs — https://genesisblock.com/jobs
                Credo on GitHub — https://github.com/rrrene/credo/
                ElixirConf 2018 — https://elixirconf.com/2018
                Ethereumex — https://hex.pm/packages/ethereumex
                Mana — https://github.com/mana-ethereum/mana
                Robinhood — https://robinhood.com/us/en/
                Slack — https://slack.com/
                PagerDuty — https://www.pagerduty.com/
                Alexandra Episode — https://smartlogic.io/podcast/elixir-wizards/s5e10-chakeres/
                Turing — https://turing.io/
                Weedmaps — https://weedmaps.com/
                Nav Inc. — https://www.nav.com/
                ElixirStatus — https://elixirstatus.com/
                Divvy — https://getdivvy.com/
                Matt Mills — https://github.com/photomattmills
                Factorio — https://factorio.com/
                Dyson Sphere Program — https://store.steampowered.com/app/1366540/Dyson_Sphere_Program/

                Special Guests: Anna Neyzberg, René Föhring, and Sean Lewis.

                1 hr 2 min
              • Jenn Gamble on Data Science, Machine Learning, and Elixir

                The fields of data science and machine learning are moving ever faster. Jenn Gamble has her finger on the pulse and has become an industry expert with a wealth of experience to her name. As today’s guest, she dives into these rich and often complex topics, and she helps us boil them down into palatable nuggets of knowledge. We start off by asking Jenn about her current role at Very, and she tells us about the nature of her team and the things they’re able to achieve. She touches on what the language markups look like for a data science team, before moving onto her experiences in machine learning and data science. Delving deeper, Jenn tells us why it is not a necessity to have a master’s in data science, and why you can be well enough equipped in other senses to become proficient in the area. Later on, she reveals the differences between Elixir models and data science models. Following these detailed explanations, she furnishes listener’s minds with informative comments on relating the foundations of machine learning to IoT, using priori knowledge to add nuance to your machine learning, and how she envisions the future of data science. Join us today and be sure to get all this, and much more!

                Key Points From This Episode:

                • Introducing today’s guest, Jenn Gamble.
                • Jenn tells us about Very, an IoT engineering firm.
                • Hear about the data science team at Very.
                • We learn more on what the language markup looks like for a data science team.
                • Jenn’s experience in learning machine learning and data science.
                • Hear her five-year plan while doing her masters.
                • We ask if it’s necessary to have a master’s degree to be well-equipped in data science.
                • The difference between an Elixir model and a data science model.
                • Jenn elaborates on weights and intuitive algorithms.
                • Dealing with N-dimensional matrices.
                • Relating the foundations of machine learning to IoT.
                • Ways to start building up an intuition around what the most fundamental abstractions are.
                • Using priori knowledge to add nuance to your machine learning.
                • How Jenn envisions the future of data science.
                • Hear about tensors and vectors.
                • Jenn tells us about her keynote experience at ElixirConf 2020.
                • Links Mentioned in Today’s Episode:

                  SmartLogic — https://smartlogic.io/

                  Elixir Wizards Discord — https://smr.tl/wizards-discord
                  Elixir Wizards Email — [email protected]
                  Jenn Gamble on Twitter – https://twitter.com/jennpgamble
                  Jenn Gamble on LinkedIn – https://www.linkedin.com/in/jenn-gamble/
                  ElixirConf 2020 - Keynote - Jenn Gamble – https://www.youtube.com/watch?v=btIvtN9ws_I&ab_channel=ElixirConf
                  IoT – https://www.verypossible.com/careers
                  Very – https://jobs.lever.co/verypossible
                  MathWorks – https://www.mathworks.com/products/matlab.html
                  Cassie Kozykrov – https://kozyrkov.medium.com/
                  Linear regression – http://www.stat.yale.edu/Courses/1997-98/101/linreg.htm
                  Pythagorean theorem – https://www.mathplanet.com/education/pre-algebra/right-triangles-and-algebra/the-pythagorean-theorem
                  Quadratic equation – https://www.mathsisfun.com/algebra/quadratic-equation.html
                  A priori and a posteriori – https://iep.utm.edu/apriori/
                  Tensor – https://mathworld.wolfram.com/Tensor.html
                  Vector (mathematics and physics) – https://mathinsight.org/vector_introduction
                  Coursera – https://www.coursera.org/learn/ai-for-everyone

                  Special Guest: Jenn Gamble.

                  48 min
                • John Mertens on Adopting Elixir at Change.org

                  Many organizations take an incremental approach when adopting Elixir, preferring to pick up its nuances by using it to work on non-essential projects. But not Change.org. Today we speak with Change.org Director of Engineering John Mertens about how his company adopted Elixir to create a business-critical app that handles over a billion emails per month. From building webpages on GeoCities to working as an IT intern at an Iowan prison, we open our conversation by exploring John’s coding background. After chatting about his first Elixir project, we dive into Change.org’s process in adopting Elixir. As John shares his insights into successfully integrating Elixir into your tech stack, he highlights the benefits provided by the language. Later, John discusses the advantages of event-driven architecture and how this structure makes it easier for teams to access and analyze data, while also making it easier to add product features. We wrap up this episode with John highlighting his user-centered approach to coding. Join us to hear John’s lessons on making the leap and adopting Elixir in large organizations.

                  Key Points From This Episode:

                  • John shares details about his role at Change.org.
                  • The story behind John and Change’s Elixir adoption.
                  • Hear about John’s coding journey.
                  • How John made an Elixir app based on spotting San Francisco tram carriages.
                  • Insights into the massive project that Change built using Elixir.
                  • Why Elixir is taking over Change’s back-end tech stack.
                  • Using Elixir to build reliable event-based architecture.
                  • Exploring event-driven architecture from the perspective of Change’s system.
                  • John makes a compelling case for event-driven architecture.
                  • How Change hires for Elixir roles.
                  • Change’s process in training their staff to code in Elixir.
                  • John talks about his user-centred approach to design.
                  • Links Mentioned in Today’s Episode:

                    SmartLogic — https://smartlogic.io/

                    Elixir Wizards Discord — https://smr.tl/wizards-discord
                    Elixir Wizards Email — [email protected]
                    John Mertens — https://www.mertonium.com/about
                    John Mertens on Twitter — https://twitter.com/mertonium
                    John Mertens on GitHub — https://github.com/mertonium
                    Change.org — https://www.change.org/
                    Change.org Careers — https://careers.change.org/
                    José Valim — https://twitter.com/josevalim
                    GenStage and Flow - José Valim (Lambda Days 2017) — https://www.youtube.com/watch?v=XPlXNUXmcgE
                    Dashbit — https://dashbit.co/
                    Hacker News — https://thehackernews.com/
                    Paul Graham — https://twitter.com/paulg/
                    Nim — https://nim-lang.org/
                    Pony — https://www.ponylang.io/
                    Grax.io — https://www.grax.com/
                    Logo — https://el.media.mit.edu/logo-foundation/what_is_logo/logo_programming.html
                    Nerves — https://www.nerves-project.org/
                    Flow — https://hexdocs.pm/flow/Flow.html
                    ElixirConf EU — https://www.elixirconf.eu/
                    Martin Fowler — https://martinfowler.com/
                    ‘The Log: What every software engineer should know about real-time data's unifying abstraction’ — https://engineering.linkedin.com/distributed-systems/log-what-every-software-engineer-should-know-about-real-time-datas-unifying
                    Salesforce Marketing Cloud — https://www.salesforce.com/eu/products/marketing-cloud/overview/
                    ‘Delivering social change with Elixir at Change.org’ — https://elixir-lang.org/blog/2020/10/27/delivering-social-change-with-elixir-at-change.org/
                    Code for America — https://www.codeforamerica.org/

                    Special Guest: John Mertens.

                    44 min
                  • Sophie DeBenedetto on Programming Phoenix LiveView

                    As users increasingly demand interactivity from their web experiences, Phoenix LiveView is becoming the dominant way of writing interactive Elixir applications without a loss to reliability. Today we welcome back an old friend of the show and GitHub engineer Sophie DeBenedetto to talk about her upcoming book, Programming Phoenix LiveView. We open our conversation with Sophie by hearing about her work at GitHub, as well as what we can expect from the Code BEAM V conference. As she doesn’t always get to use Elixir at her job, Sophie then discusses how coders can sharpen their Elixir skills when not at work. After exploring how companies can begin adopting Elixir through event-driven design, we dive into Sophie’s book. She unpacks the value of LiveView when building efficient web applications before touching on how her book can best help people to learn LiveView. We ask Sophie how intertwined the future of Elixir is to the success of LiveView and how this might impact Phoenix. Her answers highlight LiveView’s role in pushing Elixir adoption while also making Elixir easier to learn. We wrap up our discussion by chatting about the challenges of technical writing and Sophie’s experience working with the wonderful Pragmatic Programmers publishing house. Tune in to hear more insights into programming LiveView; if you believe the hype, it’s “one of the most important new frameworks of our generation.”

                    Key Points From This Episode:

                    • We catch up with guest Sophie DeBenedetto and hear about the Code BEAM V conference.
                    • Sophie shares her feelings on coding in Go.
                    • How Sophie engages with Elixir when it’s not a key part of her day job.
                    • What Flatiron School did to work towards Elixir adoption.
                    • Exploring the concept of event-driven design.
                    • Insights into the eventing system used at GitHub.
                    • Sophie talks about her experience as an engineering manager.
                    • Why Sophie transitioned from being a manager to being an individual contributor.
                    • How work-from-home has impacted meeting expectations.
                    • Hear the elevator pitch for Sophie’s upcoming book.
                    • Thoughts on how beginner-friendly Elixir is as a language.
                    • Whether Phoenix LiveView is the future of Elixir.
                    • How the attention placed on LiveView limits access to Phoenix resources and tutorials.
                    • We ask Sophie if LiveView will make it easier or more difficult to learn Elixir.
                    • Advice on writing technical books and the writing support offered by Pragmatic Programmers.
                    • Links Mentioned in Today’s Episode:

                      SmartLogic — https://smartlogic.io/

                      Elixir Wizards Discord — https://smr.tl/wizards-discord
                      Elixir Wizards Email — [email protected]
                      Sophie DeBenedetto — http://sophiedebenedetto.nyc/
                      Sophie DeBenedetto on LinkedIn — https://www.linkedin.com/in/sophiedebenedetto/
                      Sophie DeBenedetto on Twitter — https://twitter.com/sm_debenedetto
                      Programming Phoenix LiveView — https://www.pragprog.com/titles/liveview/programming-phoenix-liveview/
                      Beam Radio — https://www.beamrad.io/
                      Code BEAM V — https://codesync.global/conferences/code-beam-sto/
                      Bruce Tate — https://twitter.com/redrapids
                      José Valim — https://twitter.com/josevalim
                      Nx — https://dashbit.co/blog/nx-numerical-elixir-is-now-publicly-available
                      Alex Koutmos — https://twitter.com/akoutmos
                      EMPEX — https://empex.co/nyc.html
                      Flatiron School — https://flatironschool.com/
                      ‘What is the difference between Event Driven and Event Sourcing?’ — https://softwareengineering.stackexchange.com/questions/385375/what-is-the-difference-between-event-driven-and-event-sourcing
                      Chris Keithley — https://twitter.com/chriskeathley
                      GitHub — https://github.com/
                      Steven Nuñez — https://twitter.com/_StevenNunez
                      ‘Shipping Greenfield Elixir in a Legacy World’ — https://codesync.global/conferences/code-beam-v-america-2021/training/#145shipping-greenfield-elixir-in-a-legacy-world
                      Ruby on Rails Tutorial: Learn Web Development with Rails — https://www.amazon.com/Ruby-Rails-Tutorial-Addison-Wesley-Professional-ebook/dp/B01N779HKK
                      Toran Billups — https://twitter.com/toranb
                      The Pragmatic Programmers — https://pragprog.com/
                      Chris McCord — https://twitter.com/chris_mccord/
                      Dave Thomas — https://twitter.com/pragdave/
                      Andy Hunt — https://twitter.com/PragmaticAndy/
                      Zenni — https://www.zennioptical.com/
                      Warby Parker — https://www.warbyparker.com/

                      Special Guest: Sophie DeBenedetto.

                      49 min
                    • Shaun Robinson and Toran Billups on Using Elixir to Empower Online Learning

                      With the prevalence of at-home learning, teachers have to compete for student attention against numerous screen-based activities. Today we speak with engineering lead Shaun Robinson and Elixir developer Toran Billups about how Legends of Learning helps educators make their classrooms fun, engaging, and productive through their curriculum-based games. After chatting about Legends’ mission to empower teachers, we talk with Toran about how he landed a job there. He then shares his insights into securing Elixir jobs, touching on the importance of networking and building a portfolio of Elixir projects. We discuss why Elixir became Legends’ language of choice before exploring their process in adopting Elixir. Reflecting on their early server structure, Shaun explains their process of refactoring from their old code base into an Elixir monolith. Responding to a previous episode, where frustrations were shared about coding in LiveView, Toran talks about its advantages, despite its issues as a new technology. Later, Shaun and Toran dive into what you can do to help your company adopt Elixir. We wrap up another incredible conversation by asking our guests about their favorite Legend of Learning games. Tune in to hear more about Legend of Learning’s Elixir journey and how they’re using it to create dynamic learning environments.

                      Key Points From This Episode:

                      • Exploring the mission and work of the Legends of Learning startup.
                      • Shaun and Toran share details about their backgrounds.
                      • Why building a van home is so similar to building software.
                      • Hear about Toran’s podcast on the human side of programming.
                      • Shaun talks about the time when he sold his Twitter and GitHub handle.
                      • What Toran did to land his first Elixir job.
                      • Why Legends of Learning decided to adopt Elixir.
                      • Insights into Legends of Learning’s early server architecture.
                      • Toran unpacks Legend’s hiring process.
                      • Why Shaun’s engineering team consists of remote workers.
                      • Toran shares the virtues of coding in LiveView.
                      • What Shaun did to refactor their old code base into an Elixir monolith.
                      • The process that Legends underwent when adopting Elixir.
                      • Advice on finding an Elixir role and adopting Elixir in your company.
                      • Hear about Shaun and Toran’s favorite Legend of Learning games.
                      • Links Mentioned in Today’s Episode:

                        SmartLogic — https://smartlogic.io/

                        Elixir Wizards Email — [email protected]
                        Shaun Robinson on LinkedIn — https://www.linkedin.com/in/shaun1010/
                        Toran Billups on Twitter — https://twitter.com/toranb
                        Toran Billups on LinkedIn — https://www.linkedin.com/in/toranb/
                        Legends of Learning — https://www.legendsoflearning.com/
                        Vadim Polikov — https://www.linkedin.com/in/vadim-polikov/
                        Kris Van Houghton — https://twitter.com/krivaten
                        Dave Gardner — https://www.linkedin.com/in/davegardner01/
                        Legends of Learning Careers — https://www.legendsoflearning.com/interested-game-developer/
                        Legends of Learning API Docs — https://docs.legendsoflearning.com/
                        Elixir Match on GitHub — https://github.com/toranb/elixir-match
                        Chris McCord — http://chrismccord.com/
                        Grox.io — https://grox.io/
                        Bruce Tate — https://www.linkedin.com/in/bruce-tate/
                        Postgraphile on GitHub — https://github.com/graphile/postgraphile
                        Martin Fowler — https://martinfowler.com/
                        The Strangler Application — https://martinfowler.com/bliki/StranglerFigApplication.html
                        Timescale — https://www.timescale.com/
                        ‘TimescaleDB 2.0 is now Generally Available’ — https://blog.timescale.com/blog/timescaledb-2-0-is-now-generally-available/
                        Sun, Moon & Stars: Patterns of Apparent Motion on Legends of Learning — https://www.legendsoflearning.com/learning-objectives/the-sun-moon-and-stars-patterns-of-apparent-motion/
                        Magic the Gathering — https://magic.wizards.com/en
                        Legends of Learning Awakening — https://www.legendsoflearning.com/blog/homework-and-test-prep-math-and-science-game/
                        Hour of Code — https://hourofcode.com/
                        Owl Pro — https://owllabs.com/products/meeting-owl-pro

                        Correction: In an earlier version of this episode, the host mis-spoke and mis-named the guests' company name in the outro; that error has been corrected as of 2021-02-25 3:52PM ET.

                        Special Guests: Shaun Robinson and Toran Billups.

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