Elixir Wizards is an interview-format podcast, focused on engineers who use the Elixir programming language. Initially launched in early 2019, each season focuses on a specific topic or topics, with each interview focusing on the guest's experience and opinions on the topic. Elixir Wizards is hosted by Eric Oestrich and Sundi Myint of SmartLogic, a dev shop that’s been building custom software since 2005 and running Elixir applications in production since 2015. Learn more about how SmartLogic uses Phoenix and Elixir. (https://smartlogic.io/phoenix-and-elixir?utm_source=podcast)
Similar Podcasts
Elixir Outlaws
Elixir Outlaws is an informal discussion about interesting things happening in Elixir. Our goal is to capture the spirit of a conference hallway discussion in a podcast.
Flutter 101 Podcast
Weekly podcast focusing on software development with Flutter and Dart. Hosted by Vince Varga.
Remote Ruby
Three Rubyists having conversations and interviewing others about Ruby and web development.
Dr Jim Freeze on Hiring, Training, and Functional Programming – Working with Elixir
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 (https://www.smartlogic.com) Dr. Jim Freeze on Twitter (https://twitter.com/jimfreeze) ElixirConf (https://elixirconf.com/events) Sophie DeBenedetto (http://sophiedebenedetto.nyc/) Elixir Radar (https://elixirnation.io/references/elixir-radar-weekly-newsletter-on-elixir) Phoenix In Action (https://www.amazon.com/Phoenix-Action-Geoffrey-Lessel/dp/1617295043) Geoffrey Lessel (http://www.apple.com) Saša Jurić (https://codesync.global/speaker/sasa-juric/) Sandi Metz (https://www.sandimetz.com) Special Guest: Dr. Jim Freeze.
Season 3 Trailer
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.
Season Two Wrap
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/empirestrikesback
Dave Lucia on Rustler – Elixir Internals
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 — dave@simplebet.io 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/compiler Special Guest: Dave Lucia.
Eric Oestrich on ExVenture – Elixir Internals
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. (https://smr.tl/2Hyslu8)
Sophie DeBenedetto on Excrypt and Railway – Elixir Internals
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/2019 Special Guest: Sophie DeBenedetto.
Shanti Chellaram on Pri-Queue and raft_erl – Elixir Internals
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 rafterl, 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 rafterl, 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 rafterl — https://github.com/shantiii/rafterl 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.
Michał Muskała on Ecto and jason – Elixir Internals
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.
Todd Resudek on Hex – Elixir Internals
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.
Chris Keathley on Wallaby and Raft – Elixir Internals
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.
René Föhring on Credo – Elixir Internals
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. (https://smr.tl/2Hyslu8) Special Guest: René Föhring.
Meryl Dakin on Token Alchemist – Elixir Internals
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. (https://smr.tl/2Hyslu8) Special Guest: Meryl Dakin.
Paul Schoenfelder on Distillery – Elixir Internals
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. (https://smr.tl/2Hyslu8) Special Guest: Paul Schoenfelder.
Bryan Joseph on ElixirScript – Elixir Internals
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. (https://smr.tl/2Hyslu8) Special Guest: Bryan Joseph.
Brooklyn Zelenka on Witchcraft - Elixir Internals
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 — hello@brooklynzelenka.com 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. (https://smr.tl/2Hyslu8) Special Guest: Brooklyn Zelenka.