Elixir Wizards

On today’s episode, Elixir Wizards Owen Bickford and Dan Ivovich compare notes on building web applications with Elixir and the Phoenix Framework versus Ruby on Rails. They discuss the history of both frameworks, key differences in architecture and approach, and deciding which programming language to use when starting a project. Both Phoenix and Rails are robust frameworks that enable developers to build high-quality web apps—Phoenix leverages functional programming in Elixir and Erlang’s networking for real-time communication. Rails follows object-oriented principles and has a vast ecosystem of plug-ins. For data-heavy CRUD apps, Phoenix's immutable data pipelines provide some advantages. Developers can build great web apps with either Phoenix or Rails. Phoenix may have a slight edge for new projects based on its functional approach, built-in real-time features like LiveView, and ability to scale efficiently. But, choosing the right tech stack depends heavily on the app's specific requirements and the team's existing skills. Topics discussed in this episode: History and evolution of Phoenix Framework and Ruby on Rails Default project structure and code organization preferences in each framework Comparing object-oriented vs functional programming paradigms CRUD app development and interaction with databases Live reloading capabilities in Phoenix LiveView vs Rails Turbolinks Leveraging WebSockets for real-time UI updates Testing frameworks like RSpec, Cucumber, Wallaby, and Capybara Dependency management and size of standard libraries Scalability and distribution across nodes Readability and approachability of object-oriented code Immutability and data pipelines in functional programming Types, specs, and static analysis with Dialyzer Monkey patching in Ruby vs extensible core language in Elixir Factors to consider when choosing between frameworks Experience training new developers on Phoenix and Rails Community influences on coding styles Real-world project examples and refactoring approaches Deployment and dev ops differences Popularity and adoption curves of both frameworks Ongoing research into improving Phoenix and Rails Links Mentioned in this Episode: SmartLogic.io Dan’s LinkedIn Owen’s LinkedIn Ruby https://www.ruby-lang.org/en/ Rails https://rubyonrails.org/ Sams Teach Yourself Ruby in 21 Days Learn Ruby in 7 Days Build Your Own Ruby on Rails Web Applications Django https://github.com/django Sidekiq https://github.com/sidekiq Kafka https://kafka.apache.org/ Phoenix Framework https://www.phoenixframework.org/ Phoenix LiveView https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html#content Flask https://flask.palletsprojects.com/en/3.0.x/ WebSockets API https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API WebSocket connection for Phoenix https://github.com/phoenixframework/websock Morph Dom https://github.com/patrick-steele-idem/morphdom Turbolinks https://github.com/turbolinks Ecto https://github.com/elixir-ecto Capybara Testing Framework https://teamcapybara.github.io/capybara/ Wallaby Testing Framework https://wallabyjs.com/ Cucumber Testing Framework https://cucumber.io/ RSpec https://rspec.info/

Today on Elixir Wizards, Manuel Rubio, author of Erlang/OTP: A Concurrent World and Dan Plyukhin, creator of the UIGC Actor Garbage Collector for Akka, join host Dan Ivovich to compare notes on garbage collection in actor models. The discussion digs into the similarities and differences of actor-based garbage collection in Erlang and Akka and introduces Dan's research on how to perform garbage collection in a distributed actor system. Topics discussed: Akka is akin to Erlang actors for the JVM using Scala, with similar principles like supervision trees, messages, and clustering Erlang uses generational garbage collection and periodically copies live data to the old heap for long-lived elements Actor GC aims to determine when an actor's memory can be reclaimed automatically rather than manually killing actors Distributed actor GC is more challenging than object GC due to the distributed nature and relationships between actors across nodes Challenges include reasoning about failures like dropped messages and crashed nodes GC balance requires optimization of resource release and CPU load management Immutability helps Erlang GC, but copying data for messages impacts performance Research into distributed actor GC is still ongoing, with opportunities for improvement Fault tolerance in Erlang relies on user implementation rather than low-level guarantees Asynchronous messages in Erlang/Elixir mean references may become invalid which is similar to the distributed GC approaches in Dan's research Idempotent messaging is recommended to handle possible duplicates from failures Help your local researcher! Researchers encourage communication from practitioners on challenges and use cases Links mentioned: Erlang/OTP Volume 1: A Concurrent World by Manuel Rubio https://altenwald.com/en/book/en-erlang-i Scala https://www.scala-lang.org/ Akka Framework https://github.com/akka JVM (Java Virtual Machine) https://www.java.com/en/download/ The BEAM VM https://www.erlang.org/blog/a-brief-beam-primer/ Hadoop Framework https://hadoop.apache.org/ Pony Programming Language https://www.ponylang.io/ SLSA Programming Language https://wcl.cs.rpi.edu/salsa/#:~:text=SALSA%20 Paxos Algorithm https://en.wikipedia.org/wiki/Paxos_(computer_science) Raft library for maintaining a replicated state machine https://github.com/etcd-io/raft Dan's Website https://dplyukhin.github.io/ Dan Plyukhin on Twitter: https://twitter.com/dplyukhin Dan Plyukhin’s YouTube channel: https://m.youtube.com/@dplyukhin UIGC on GitHub https://github.com/dplyukhin/UIGC Manuel's Website https://altenwald.com/ Manuel Rubio on Twitter: https://twitter.com/MRonErlangSpecial Guests: Dan Plyukhin and Manuel Rubio.

In this episode of Elixir Wizards, Katelynn Burns, software engineer at LaunchScout, and Alexis Carpenter, senior data scientist at cars.com, join Host Dan Ivovich to discuss machine learning with Elixir, Python, SQL, and MATLAB. They compare notes on available tools, preprocessing, working with pre-trained models, and training models for specific jobs. The discussion inspires collaboration and learning across communities while revealing the foundational aspects of ML, such as understanding data and asking the right questions to solve problems effectively. Topics discussed: Using pre-trained models in Bumblebee for Elixir projects Training models using Python and SQL The importance of data preprocessing before building models Popular tools used for machine learning in different languages Getting started with ML by picking a personal project topic of interest Resources for ML aspirants, such as online courses, tutorials, and books The potential for Elixir to train more customized models in the future Similarities between ML approaches in different languages Collaboration opportunities across programming communities Choosing the right ML approach for the problem you're trying to solve Productionalizing models like fine-tuned LLM's The need for hands-on practice for learning ML skills Continued maturation of tools like Bumblebee in Elixir Katelynn's upcoming CodeBeam talk on advanced motion tracking Links mentioned in this episode https://launchscout.com/ https://www.cars.com/ Genetic Algorithms in Elixir by Sean Moriarity Machine Learning in Elixir by Sean Moriarity https://github.com/elixir-nx/bumblebee https://github.com/huggingface https://www.docker.com/products/docker-hub/ Programming with MATLAB https://elixirforum.com/ https://pypi.org/project/pyspark/ Machine Learning Course from Stanford School of Engineering Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow by Aurélien Géron Data Science for Business by Foster Provost & Tom Fawcett https://medium.com/@carscomtech https://github.com/k-burns Code Beam America March, 2024Special Guests: Alexis Carpenter and Katelynn Burns.

This week on Elixir Wizards, Connor Rigby, Software Engineer at SmartRent, and Taylor Barto, Lead Embedded Software Engineer at Eaton, join Sundi Myint to compare notes on embedded systems development with Elixir, C, C++, and Java. They discuss using Elixir and the Nerves framework for firmware projects versus more traditional choices like C. The guests ask one another questions and gain valuable insights into challenges, tooling, resources, and more across different embedded ecosystems. In this episode, the guests expand their perspectives and demystify the concept of embedded systems for engineers outside the field. This cross-language exchange of ideas and experiences inspires continued learning and collaboration between embedded software engineers using different programming languages. Topics Discussed: Defining "true embedded": using an operating system vs. bare metal programming Benefits and drawbacks of Elixir, C, C++, and Java for firmware Many embedded systems today use Java as the programming language via Java Native Interface (JNI) to interface with C/C++ code How Elixir expands the toolbox available for firmware projects Testing, tooling, workflows, and debugging across languages Elixir/Nerves features like hot code reloading and testing vs. Java alternatives Learning curves for new languages and frameworks Industry trends around established vs emerging tools Applying functional programming principles like immutability in new domains Scaling firmware updates across large connected networks Continued maturation of Nerves may bring Elixir into consideration for roles where Java is commonly used today Hardening systems for reliability in safety-critical uses Debugging differences between web development and embedded Hiring considerations for niche languages Additional skills needed for embedded engineers, such as technical writing, reading schematics, and writing test instructions Resources and recommendations for getting started with embedded systems Links Mentioned: Nerves: https://github.com/nerves-project/nerves https://nerves-project.org/ AtomVM: https://github.com/atomvm/AtomVM GRiSP: https://github.com/grisp RISC-V: https://github.com/ultraembedded/riscv https://smartrent.com/ https://www.eaton.com/us/en-us.html Zig Programming Language: https://github.com/ziglang Docker: https://github.com/docker Build a Weather Station with Elixir and Nerves by Alexander Koutmos, Bruce A. Tate, Frank Hunleth Build a Binary Clock with Elixir and Nerves by Frank Hunleth and Bruce A. Tate http://esp32.net/ https://www.nordicsemi.com/Special Guests: Connor Rigby and Taylor Barto.

In Episode 4, the Elixir Wizards are joined by Dorian Iacobescu, author of the ECSpanse ECS library for Elixir, and Daniel Luu, founder and CEO of the game development studio AKREW. The guests compare notes on backend game development using ECS, the Entity Component System approach. Akrew is currently building the multiplayer game Galactic Getaway using the Photon Unity networking framework, which employs ECS. They discuss challenges like collections of component types and persistence beyond runtime, building games for various platforms like MacOS, and handling inventory storage in a backend database. Game development is complex and has many technical hurdles, but open communication across different programming communities and game development approaches can foster collaboration, innovation, and continued learning. Topics Discussed in this Episode Dorian explains the ECSpanse ECS library and component-based architecture Dorian took inspiration for ECSpanse from the Rust library Bevy ECS and its component-based API The guests discuss popular game development platforms and languages, including C#, JavaScript, and Godot Owen and Daniel translate ECS concepts to familiar database and backend terminology for devs without game-specific experience ECSpanse uses many tools from the Elixir Erlang toolbox, including GenServers, ETS tables, tasks, queries, and Phoenix LiveView ECS challenges representing inventory collections that broke typical ECS singleton patterns AKREW is developing Galactic Getaway using the Photon Unity framework Relationships between parent and child entities in ECSpanse Persistence, serialization, and replay features to save game state Optimizing assets and code for performance on various devices Links Mentioned https://en.wikipedia.org/wiki/Entity_component_system https://iacobson.medium.com/elixir-for-fun-ecspanse-2852a7993ecd https://hexdocs.pm/ecspanse/Ecspanse.html https://bevyengine.org/learn/book/getting-started/ecs/ https://www.photonengine.com/quantum Add Galactic Getaway to your Steam Wishlist: https://store.steampowered.com/app/2012390/Galactic_Getaway/ https://godotengine.org/ https://unity.com/ https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_basics.html https://www.tiktok.com/@galacticgetaway https://docs.rs/bevy_ecs/latest/bevy_ecs/ Special Guests: Daniel Luu and Dorian Iacobescu.

This week, the Elixir Wizards are joined by Yohana Tesfazgi and Wes Bos to compare notes on the experience of learning Elixir vs. JavaScript as your first programming language. Yohana recently completed an Elixir apprenticeship, and Wes Bos is a renowned JavaScript educator with popular courses for beginner software developers. They discuss a variety of media and resources and how people with different learning styles benefit from video courses, articles, or more hands-on projects. They also discuss the current atmosphere for those looking to transition into an engineering career and how to stick out among the crowd when new to the scene. Topics Discussed in this Episode Pros and cons of learning Elixir as your first programming language Materials and resources for beginners to JavaScript and Elixir Projects and methods for learning Elixir with no prior knowledge Recommendations for sharpening and showcasing skills How to become a standout candidate for potential employers Soft skills like communication translate well from other careers to programming work Learning subsequent languages becomes more intuitive once you learn your first How to decide which library to use for a project How to build an online presence and why it’s important Open-source contributions are a way to learn from the community Ship early and often, just deploying a default Phoenix app teaches deployment skills Attend local meetups and conferences for mentoring and potential job opportunities Links Mentioned https://syntax.fm/ https://fly.io/ https://elixirschool.com/en Syntax.fm: Supper Club × How To Get Your First Dev Job With Stuart Bloxham Quinnwilton.com https://github.com/pallets/flask https://wesbos.com/courses https://beginnerjavascript.com/ Free course: https://javascript30.com/ https://pragmaticstudio.com/ https://elixircasts.io/ https://grox.io/ LiveView Mastery YouTube Channel Contact Yohana: [email protected]

In today’s episode, Sundi and Owen are joined by Yordis Prieto and Stephen Chudleigh to compare notes on HTTP requests in Elixir vs. Ruby, JavaScript, Go, and Rust. They cover common pain points when working with APIs, best practices, and lessons that can be learned from other programming languages. Yordis maintains Elixir's popular Tesla HTTP client library and shares insights from building APIs and maintaining open-source projects. Stephen has experience with Rails and JavaScript, and now works primarily in Elixir. They offer perspectives on testing HTTP requests and working with different libraries. While Elixir has matured, there is room for improvement - especially around richer struct parsing from HTTP responses. The discussion highlights ongoing efforts to improve the developer experience for HTTP clients in Elixir and other ecosystems. Topics Discussed in this Episode HTTP is a protocol - but each language has different implementation methods Tesla represents requests as middleware that can be modified before sending Testing HTTP requests can be a challenge due to dependence on outside systems GraphQL, OpenAPI, and JSON API provide clear request/response formats Elixir could improve richer parsing from HTTP into structs Focus on contribution ergonomics lowers barriers for new participants Maintainers emphasize making contributions easy via templates and clear documentation APIs drive adoption of standards for client/server contracts They discuss GraphQL, JSON API, OpenAPI schemas, and other standards that provide clear request/response formats TypeScript brings types to APIs and helps to validate responses Yordis notes that Go and Rust make requests simple via tags for mapping JSON to structs Language collaboration shares strengths from different ecosystems and inspires new libraries and tools for improving the programming experience Links Mentioned Elixir-Tesla Library: https://github.com/elixir-tesla/tesla Yordis on Github: https://github.com/yordis Yordis on Twitter: https://twitter.com/alchemist_ubi Yordis on LinkedIn: https://www.linkedin.com/in/yordisprieto/ Yordis on YouTube: https://www.youtube.com/@alchemistubi Stephen on Twitter: https://twitter.com/stepchud Stephen's projects on consciousness: https://harmonicdevelopment.us Owen suggests: Http.cat HTTParty: https://github.com/jnunemaker/httparty Guardian Library: https://github.com/ueberauth/guardian Axios: https://axios-http.com/ Straw Hat Fetcher: https://github.com/straw-hat-team/nodejs-monorepo/tree/master/packages/%40straw-hat/fetcher Elixir Tesla Wiki: https://github.com/elixir-tesla/tesla/wiki HTTPoison: https://github.com/edgurgel/httpoison Tesla Testing: https://hexdocs.pm/tesla/readme.html#testing Tesla Mock: https://hexdocs.pm/tesla/Tesla.Mock.html Finch: https://hex.pm/packages/finch Mojito: https://github.com/appcues/mojito Erlang Libraries and Frameworks Working Group: https://github.com/erlef/libs-and-frameworks/ and https://erlef.org/wg/libs-and-frameworksSpecial Guests: Stephen Chudleigh and Yordis Prieto.

Hosts Dan Ivovich, Owen Bickford, and Sundi Myint kick off the 11th season of the Elixir Wizards podcast. This season’s theme is “Branching Out from Elixir,” which expands the conversation to compare notes with experts from other communities; they discuss their experiences with other languages like JavaScript, PHP, Python, Ruby, C#, Go, and Dart before and after learning Elixir. This season's conversations will illuminate how problems are solved in different languages vs. Elixir; upcoming episode topics teased include education, data processing, deployment strategies, and garbage collection; the hosts express excitement for conversations analyzing similarities and differences between communities. Topics Discussed in this Episode Season 11 branches out from Elixir to compare notes with other programming communities Sundi, Owen, and Dan introduce the season theme and their interest in exploring these conversations The hosts compare their experiences with PHP, JavaScript, Python, Ruby, C#, Go, Dart and Elixir The Wizards compare and contrast differences in their personal experience building similar things with different languages Dan dreams in Ruby and uses it for quick prototypes Comparing problem-solving approaches across languages will reframe perspectives Upcoming episodes explore data processing workflows, machine learning, and game development Pop Quiz: Who's that Pokémon... or language, or framework? Links Mentioned https://smartlogic.io/ https://codepen.io/ https://i.redd.it/0lg7979qtr511.jpg

It’s the Season 10 finale of the Elixir Wizards podcast! José Valim, Guillaume Duboc, and Giuseppe Castagna join Wizards Owen Bickford and Dan Ivovich to dive into the prospect of types in the Elixir programming language! They break down their research on set-theoretical typing and highlight their goal of creating a type system that supports as many Elixir idioms as possible while balancing simplicity and pragmatism. José, Guillaume, and Giuseppe talk about what initially sparked this project, the challenges in bringing types to Elixir, and the benefits that the Elixir community can expect from this exciting work. Guillaume's formalization and Giuseppe's "cutting-edge research" balance José's pragmatism and "Guardian of Orthodoxy" role. Decades of theory meet the needs of a living language, with open challenges like multi-process typing ahead. They come together with a shared joy of problem-solving that will accelerate Elixir's continued growth. Key Topics Discussed in this Episode: Adding type safety to Elixir through set theoretical typing How the team chose a type system that supports as many Elixir idioms as possible Balancing simplicity and pragmatism in type system design Addressing challenges like typing maps, pattern matching, and guards The tradeoffs between Dialyzer and making types part of the core language Advantages of typing for catching bugs, documentation, and tooling The differences between typing in the Gleam programming language vs. Elixir The possibility of type inference in a set-theoretic type system The history and development of set-theoretic types over 20 years Gradual typing techniques for integrating typed and untyped code How José and Giuseppe initially connected through research papers Using types as a form of "mechanized documentation" The risks and tradeoffs of choosing syntax Cheers to another decade of Elixir! A big thanks to this season’s guests and all the listeners! Links and Resources Mentioned in this Episode: Bringing Types to Elixir | Guillaume Duboc & Giuseppe Castagna | ElixirConf EU 2023 Keynote: Celebrating the 10 Years of Elixir | José Valim | ElixirConf EU 2022 OCaml industrial-strength functional programming https://ocaml.org/ ℂDuce: a language for transformation of XML documents http://www.cduce.org/ Ballerina coding language https://ballerina.io/ Luau coding language https://luau-lang.org/ Gleam type language https://gleam.run/ "The Design Principles of the Elixir Type System" by G. Castagna, G. Duboc, and J. Valim "A Gradual Type System for Elixir" by M. Cassola, A. Talagorria, A. Pardo, and M. Viera "Programming with union, intersection, and negation types", by Giuseppe Castagna "Covariance and Contravariance: a fresh look at an old issue (a primer in advanced type systems for learning functional programmers)" by Giuseppe Castagna "A reckless introduction to Hindley-Milner type inference"Special Guests: Giuseppe Castagna, Guillaume Duboc, and José Valim.

Phoenix core team members Chris McCord and Jason Stiebs join Elixir Wizards Sundi Myint and Owen Bickford the growth of Phoenix and LiveView, the latest updates, and what they're excited to see in the future. They express excitement for the possibilities of machine learning, AI, and distributed systems and how these emerging technologies will enhance the user experience of Elixir and LiveView applications in the next decade. Key Topics Discussed in this Episode: How community contributions and feedback help improve Phoenix LiveView The addition of function components, declarative assigns, HEEx, and streams Why Ecto changesets should be used as "fire and forget" data structures Excitement about machine learning and AI with libraries like NX The possibility of distributed systems and actors in the future Verifying and solving issues in the Phoenix and LiveView issue trackers Why marketing plays a part in the adoption and mindshare of Phoenix How streams provide a primitive for arbitrarily large dynamic lists Elixir VM's ability to scale to millions of connections A creative use of form inputs for associations with dynamic children Links Mentioned in this Episode: Fly Site https://fly.io/ Keynote: The Road To LiveView 1.0 by Chris McCord | ElixirConf EU 2023 Keynote: I Was Wrong About LiveView by Jason Stiebs | ElixirConf 2022 Phoenix Site https://www.phoenixframework.org/ Phoenix Github https://github.com/phoenixframework Two-Story, 10-Room Purple Martin House Blog: The Road to 2 Million Websocket Connections in Phoenix Raxx Elixir Webserver Interface https://hexdocs.pm/raxx/0.4.1/readme.html Livebook Site https://livebook.dev/ Sundi’s 6’x 6’ Phoenix painting Surface on Hex https://hex.pm/packages/surface Axon Deep Learning Framework https://hexdocs.pm/axon/Axon.html Nx Numerical Elixir https://hexdocs.pm/nx/intro-to-nx.html Phoenix PubSub https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html Jason Stiebs on Twitter https://twitter.com/peregrine Jason Stiebs on Mastodon https://merveilles.town/@peregrineSpecial Guests: Chris McCord and Jason Stiebs.

Sean Moriarity, author of Genetic Algorithms in Elixir and creator of the Axon Library, joins Elixir Wizards Sundi Myint and Bilal Hankins to discuss Elixir’s role in the future of machine learning and AI. He explains the difference between artificial intelligence, chat models, machine learning, deep learning systems, and neural networks. Large language models have great potential for code generation, education tools, streamlining workflow, and more. Deployment, development experience, and real-time processing make Elixir an ideal programming language for creating and improving machine learning tools. Key Topics Discussed in this Episode: The difference between machine learning and artificial intelligence How Axon builds on top of the Nx library for deep learning in Elixir Why logic cannot fully define characteristics that identify golden retrievers How Google Translate uses machine learning with a unified language model The difficulties in translating concepts with no direct counterpart between languages Data cleaning and labeling challenges How Sean's interest in sports betting led to exploring machine learning Why Sean's NBA betting model recommended betting $0 to maximize profit Getting started with machine learning and Elixir projects Attention mechanisms in neural networks Bias and exceptions in machine translation models How hummus preference was used to determine Sundi's Hogwarts house Sean's work on a LiveView interface for ChatGPT Why Elixir's deployment story, development experience, and real-time processing are good fits for machine learning applications Links Mentioned: Genetic Algorithms in Elixir by Sean Moriarity: https://pragprog.com/titles/smgaelixir/genetic-algorithms-in-elixir/ Axon Deep Learning in Elixir: https://seanmoriarity.com/2021/04/08/axon-deep-learning-in-elixir/ Nx Axon: https://github.com/elixir-nx/axon Sean’s Twitter: https://twitter.com/sean_moriarity Weston the Golden’s IG: https://www.instagram.com/westonthegolden_/ Sean’s Github: https://github.com/seanmor5 Bumblebee: https://github.com/elixir-nx/bumblebee Sal Khan’s TedTalk about AI in Education: https://www.ted.com/talks/sal_khan_how_ai_could_save_not_destroy_education/c Publicly Available Datasets/Intro to Machine Learning: https://www.kaggle.com/ Use code WIZARD for $100 off your ticket to Empex NYC in Brooklyn, NY on June 9, 2023 https://ti.to/empex-ny/empex-nyc-2023Special Guest: Sean Moriarity.

In this episode of the Elixir Wizards podcast, hosts Sundi Myint and Owen Bickford are joined by Hugo Baraúna, founder at Elixir Radar, and Lucas San Roman, senior software engineer at Felt. We dive into the future of the Elixir community, how we stay connected, and the remarkable culture that has developed over the past decade. Key highlights in this episode: The Elixir community's warm and inviting atmosphere Commitment to long-term stability and innovation in the Elixir community How projects like Nerves, Phoenix LiveView, and Livebook expand Elixir's capabilities Global connections and support among Elixirists via Slack and Discord The Elixir Radar newsletter provides up-to-date Elixir news and community developments Getting “nerd sniped” by the community Hugo Baraúna's motivation behind Elixir Radar and its impact on the tech industry Networking opportunities and relationship-building within the community Lucas San Roman's commitment to giving back with the Sourcerer Library Plans for more advanced collaboration in Livebook with the new Teams feature The potential introduction of a type system in Elixir Links mentioned in this episode: Elixir Radar: https://elixir-radar.com/ Felt: https://felt.com/ Ruby Weekly: https://rubyweekly.com/ The Elixir Discord Server: https://discord.com/invite/elixir Code Fragment: https://hexdocs.pm/elixir/Code.Fragment.html The Sourcerer Library: https://github.com/doorgan/sourceror Livebook: https://livebook.dev/ Lucas’ Blog: https://dorgan.ar/ Hugo’s Twitter: https://twitter.com/hugobarauna Elixir Radar on Twitter: https://twitter.com/elixir_radar Livebook on Twitter: https://twitter.com/livebookdev Lucas’ Twitter https://twitter.com/dorgan_ Guillaume Duboc Bringing Types to Elixir at ElixirConf EU 2023 Lucas on GitHub: https://github.com/doorgan Rooster Fighter on Easter Island Rooster Fighter at Iguazu Falls in Argentina Use code WIZARD for $100 off your ticket to Empex NYC in Brooklyn, NY on June 9, 2023Special Guests: Hugo Baraúna and Lucas San Roman.

Today on Elixir Wizards, José Valim, creator of the Elixir programming language, joins hosts Sundi Myint and Owen Bickford to discuss the future of Elixir, upcoming features, changes to the language and ecosystem, and the potential for a type system. José discusses how Elixir’s extensibility allows the ecosystem to grow with new tools and libraries, all while requiring few languages to the core language. Key Takeaways: The origin of the famous rainbow heart combo José’s hands-off approach to planning the ecosystem which allows community contribution without reliance on the core team The success and growth of the Elixir community Lessons learned in the first ten years of the language The evolution of Elixir's documentation and the role of Livebook in creating more interactive and engaging learning experiences The potential for Elixir Nx to make numerical computation, machine learning, and data science more accessible to Elixir developers Potential implementation of a gradual type system and the importance of backwards compatibility The role of the Elixir community in shaping the language's development and ecosystem, including the importance of open-source contributions Whether we’ll see Elixir 2.0 in the next decade Links mentioned in this episode: Josė Valim Keynote ElixirConf EU Bringing Elixir to Life Dashbit - https://dashbit.co/ Elixir programming language: https://elixir-lang.org/ ElixirConf: https://elixirconf.com/ ElixirForum: https://elixirforum.com/ Elixir's Logger library: https://hexdocs.pm/logger/Logger.html José's Twitter: https://twitter.com/josevalim ElixirLS (Elixir Language Server) https://github.com/elixir-lsp/elixir-ls Mermaid Charts in Livebook - https://news.livebook.dev/date/2022/1 IEx - https://hexdocs.pm/iex/1.14/IEx.html Numerical Elixir - Nx: https://hexdocs.pm/nx/getting-started.html Nerves: https://hexdocs.pm/nerves/getting-started.html Membrane: https://hexdocs.pm/membrane/getting-started.html Dialyxir: https://hexdocs.pm/dialyxir/readme.html LiveBook: https://hexdocs.pm/livebook/getting-started.html Bumblebee: https://github.com/elixir-nx/bumblebeeSpecial Guest: José Valim.

Today on Elixir Wizards, Sundi Myint and Owen Bickford are joined by Saša Jurić, distinguished developer, mentor, and author of Elixir in Action. They discuss the future of training and education in Elixir, challenges faced by new Elixir developers, Phoenix generators, peer mentorship, the emergence of types, and when it’s time to close the umbrella. Key Takeaways: The functional programming paradigm, the actor model, and concurrency Adapting to the Elixir syntax and tooling The role of community, mentorship, and continuous learning in Elixir education The pros and cons of Phoenix generators for Elixir development Customizing templates in the Phoenix priv directory to better suit individual needs The importance of understanding and adapting generated code for maintainability and proper abstractions Importance of having a clear separation between core and interface Adapting to different opinions and preferences within a development team Refactoring and restructuring code to improve quality and reduce complexity Static typing for better documentation and the limitations of dynamic code Umbrella apps vs. mix configuration and how to avoid complexity Links Mentioned in this Episode: Enter to win a copy of Elixir in Action: https://smr.tl/2023bookgiveaway Elixir in Action by Saša Jurić https://www.manning.com/books/elixir-in-action 35% discount code for book on manning.com: podexwizards20 Saša’s Website/Blog TheErlangelist.com Towards Maintainable Elixir - Saša Jurić's Medium Blog Article Series Boundary: Managing cross-module dependencies in Elixir projects Site Encrypt: Integrated Certification via Let's Encrypt for Elixir-powered sites Authentication Generator in Phoenix: https://hexdocs.pm/phoenix/mix_phx_gen_auth.html Ecto query generator for Elixir https://hexdocs.pm/ecto/Ecto.html GraphQL: Query language for APIs https://graphql.org/ Dialyxir: https://hexdocs.pm/dialyxir/readme.html Nx (Numerical Elixir) GitHub Repository: https://github.com/elixir-nx/nx ElixirLS (Elixir Language Server) GitHub Repository: https://github.com/elixir-lsp/elixir-lsSpecial Guest: Saša Jurić.

In this episode of Elixir Wizards, Owen and Dan talk to Mat Trudel, Phoenix contributor and creator of the Bandit Web Server, about the future of Phoenix, web transports, and HTTP/3. Mat explains the challenges and benefits of implementing HTTP/3 support in Phoenix. Mat provides in-depth insights into the evolution of web protocols and encourages developers to continue pushing the boundaries of web development and to contribute to the growth of the open-source community. Main topics discussed in this episode: The evolution of web protocols and how HTTP/3 is changing the landscape The challenges and benefits of implementing HTTP/3 support in Phoenix How a home AC project revealed a gap in web server testing tools and inspired Bandit how web transports like Cowboy and Ranch are used to build scalable web servers WebSock for multiplexing data over a single WebSocket connection Mat’s philosophy on naming projects and his passion for malapropisms The Bandit project and how it can help developers better understand web protocols Autobahn, a testing suite for WebSocket protocol specification conformance The importance of community involvement in open-source projects Encouragement for more people to use Bandit and report bugs Links Mentioned: SmartLogic is Hiring: https://smartlogic.io/about/jobs PagerDuty: https://www.pagerduty.com Phoenix Framework: https://www.phoenixframework.org/ Cowboy: https://ninenines.eu/docs/en/cowboy/2.9/guide/introduction/ Ranch: https://github.com/ninenines/ranch Bandit - https://hexdocs.pm/bandit/Bandit.html Autobahn: https://github.com/crossbario/autobahn-testsuite HTTP Cats: https://http.cat/ Mat Trudel at Empex 2022 A Funny Thing Happened On The Way To The Phoenix Thousand Island - https://hexdocs.pm/thousand_island/ThousandIsland.htmlSpecial Guest: Mat Trudel.

Elixir Wizards Owen Bickford and Dan Ivovich are joined by Mike Waud, Senior Software Engineer at SparkMeter, and Tony Winn, Lead Software Architect at Generac, to discuss the future of the BEAM in the electric grid, how their companies use Elixir, and the challenges they face in implementing cutting-edge technologies in an environment with a mix of old and new systems. Both guests have backgrounds in various programming languages before turning to Elixir for its functional programming capabilities, concurrency, and reliability. Elixir's portability allows it to be used in various environments, from cloud-based systems to more conservative organizations that prefer running software off the cloud. Key topics discussed in this episode: • Technology sophistication varies across different regions and industries • BEAM's reliability, concurrency, and scaling in electric grid systems • Using Elixir for caching, telemetry, and managing traffic spikes • Elixir fits well for devices due to its fault tolerance and supervision trees • Observability with telemetry hooks for understanding system performance • Traffic patterns in the grid space are often dictated by weather and human activity, requiring efficient handling • The balance between using Elixir/BEAM and other tools depending on use case • Using Elixir tools like Broadway to work with event queues and Nebulex for distributed caching • The future of the electric grid and its evolution over the next 10 years, including a shift towards more distributed energy generation • Global lessons about grid management, solar penetration, regulations, and energy storage • Prioritizing data in IoT systems and processing data at the edge of the network • Gratitude for open-source contributors in the Elixir community Links in this episode: SparkMeter: https://www.sparkmeter.io/ Generac: https://www.generac.com/ SmartLogic - https://smartlogic.io/jobs Gary Bernhardt's talk on functional core and imperative shell: https://www.destroyallsoftware.com/talks/boundaries Joe Armstrong's Erlang book: https://pragprog.com/titles/jaerlang/programming-erlang/ The Nerves podcast and documentation: https://nerves-project.org/Special Guests: Mike Waud and Tony Winn.

In today's episode, Sophie DeBenedetto emphasizes the importance of the Elixir community's commitment to education, documentation, and tools like liveBook, fostering an environment where people with varying skill levels can learn and contribute. The discussion highlights LiveView's capabilities and the role it plays in the future of Elixir, encouraging members to share knowledge and excitement for these tools through various channels. Sophie invites listeners to attend and submit their talks for the upcoming Empex conference, which aims to showcase the best in Elixir and LiveView technologies. Additionally, the group shares light-hearted moments, reminding everyone to contribute to all types of documentation and promoting an inclusive atmosphere. Key topics discussed in this episode: • Updates on the latest release of the Programming Phoenix LiveView book • The importance of community connection in Elixir conferences • The future of documentation in the Elixir ecosystem • The Elixir community's commitment to education and documentation • LiveBook as a valuable tool for learning and experimenting • Encouraging contributions across experience levels and skill sets • Importance of sharing knowledge through liveBooks, blog posts, and conference talks • Core Components in Phoenix LiveView, and modal implementation • Creating a custom component library for internal use • Reflecting on a Phoenix LiveView Project Experience • Ease of using Tailwind CSS and its benefits in web development • Advantages of LiveView in reducing complexity and speeding up project development • LiveView's potential to handle large datasets using Streams • The role of Elixir developers in the rapidly evolving AI landscape Links in this episode: Sophie DeBenedetto – https://www.linkedin.com/in/sophiedebenedetto Programming Phoenix LiveView Book – https://pragprog.com/titles/liveview/programming-phoenix-liveview Empex NYC - https://www.empex.co/new-york SmartLogic - https://smartlogic.io/jobs Phoenix LiveView documentation: https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html Live sessions and hooks: https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.Router.html#live_session/1 LiveView: https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html Tailwind CSS: https://tailwindcss.com/ Reuse Markup With Function Components and Slots LiveView Card Components With Bootstrap Building a Chat App With LiveView Streams Special Guest: Sophie DeBenedetto.

In today's episode of Elixir Wizards, Michael Lubas, founder of Paraxial.io, joins hosts Owen Bickford and Bilal Hankins to discuss security in the Elixir and Phoenix ecosystem. Lubas shares his insights on the most common security risks developers face, recent threats, and how Elixir developers can prepare for the future. Common security risks, including SQL injection and cross-site scripting, and how to mitigate these threats The importance of rate limiting and bot detection to prevent spam SMS messages Continuous security testing to maintain a secure application and avoid breaches Tools and resources available in the Elixir and Phoenix ecosystem to enhance security The Guardian library for authentication and authorization Take a drink every time someone says "bot" The difference between "bots" and AI language models The potential for evolving authentication, such as Passkeys over WebSocket How Elixir compares to other languages due to its immutability and the ability to trace user input Potion Shop, a vulnerable Phoenix application designed to test security Talking Tom, Sneaker Bots, and teenage hackers! The importance of security awareness and early planning in application development The impact of open-source software on application security How to address vulnerabilities in third-party libraries Conducting security audits and implementing security measures Links in this episode: Michael Lubas Email - [email protected] LinkedIn - https://www.linkedin.com/in/michaellubas/ Paraxial.io - https://paraxial.io/ Blog/Mailing List - https://paraxial.io/blog/index Potion Shop - https://paraxial.io/blog/potion-shop Elixir/Phoenix Security Live Coding: Preventing SQL Injection in Ecto Twitter - https://twitter.com/paraxialio LinkedIn - https://www.linkedin.com/company/paraxial-io/ GenServer Social - https://genserver.social/paraxial YouTube - https://www.youtube.com/@paraxial5874 Griffin Byatt on Sobelow: ElixirConf 2017 - Plugging the Security Holes in Your Phoenix Application Erlang Ecosystem Foundation: Security Working Group - https://erlef.org/wg/security Article by Bram - Client-Side Enforcement of LiveView SecuritySpecial Guest: Michael Lubas.

In this episode of Elixir Wizards, Cory O'Daniel, CEO of Massdriver, talks with Sundi and Owen about the role of DevOps in the future of Elixir programming. They discuss the advantages of using Elixir for cloud infrastructure and the challenges of securing cloud systems. They elaborate on their hopes for the future, including processes and automation to streamline operations so programmers can spend more time doing what they love … writing software! Major topics of discussion in the episode: Cory’s ideal ratio of hot sauce to honey (recommended for chicken) Why this episode was renamed “how Cory almost killed his dad." The history of deployment with Elixir and Erlang The benefits of using Kubernetes to deploy Elixir applications The future of Elixir DevOps and Massdriver's role in solving related problems Benefits of reducing the operational burden for developers Whether Elixir is a good fit for Kubernetes How DevOps has changed over the last 10 years. The confusion about what DevOps actually means The idea of "engineers doing everything" is not sustainable A future where engineers don't need to know much about DevOps, and can focus on writing code Minimizing the operational burden for developers Monolithic application vs. microservices Why Massdriver does not use Webhooks to update configurations Security, access to source code, and potential source leaks The idea of multi-cloud, site-wide outage, and cloud agnosticism Hybrid cloud vs true multi-cloud Standardizing methods of packaging and deploying applications in the future Links mentioned in this episode: SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic Massdriver — https://www.massdriver.cloud/ State of Production Survey (with Sweet Raffle Prizes) — https://blog.massdriver.cloud/surveys/state-of-production-2023/ $5000 Massdriver Credit — https://www.massdriver.cloud/partners/elixir-wizards Elephant in the Cloud Blog Post — https://startups.microsoft.com/blog/elephant-in-the-cloud/ RIAK — https://github.com/basho/riak Otel — https://hexdocs.pm/ Terraform — https://hexdocs.pm/terraform/Terraform.html DigitalOcean — https://www.digitalocean.com/ Heroku — https://www.heroku.com/ Linode — https://www.linode.com/ Docker — https://www.docker.com/ Kubernetes — https://kubernetes.io/ Webhooks — https://hexdocs.pm/elixir_plaid/webhooks.html GitOps — https://hexdocs.pm/git_ops/readme.html Helm — https://helm.sh/docs/Special Guest: Cory O'Daniel.

It’s the season 10 premiere of the Elixir Wizards podcast! Sundi Myint, Owen Bickford, and Dan Ivovich kick off the season with a spirited conversation about what they hope to see in the future of the Elixir programming language, experiences that inform their predictions, and excitement for this season’s lineup of guests. They touch on how Elixir has evolved in the previous ten years and how the range of use cases has expanded beyond web development. The hosts introduce the season 10 theme: The Next Ten Years of Elixir Dan explains his initial hesitation and how he was ultimately won over by the language Owen talks about functional programming and why Elixir piqued his interest Sundi compares Elixir to other languages she’s worked with and why she thinks it’s more intuitive and readable Sundi talks about her recent experience using Flutter for mobile application development The hosts express excitement about the various ways Elixir is currently being used and its potential for growth The Wizards express interest in hearing from guests this season to gain more perspective They discuss Phoenix, LiveView, documentation, Flutter, Dart, and resources available to the Elixir community, and the benefits of being fluent in different programming languages Owen suggests that Elixir and Phoenix are optimal for projects with limited resources and leaner teams They highlight the importance of building resource-efficient apps that work well on low-powered devices Dan expresses his desire to embrace types more but acknowledges that a first-party typing system is unlikely The speakers discuss how Elixir has made complex tasks more accessible through features like LiveView, Phoenix Presence, WebSockets, Pub/Sub, Nerves, and ML libraries They express excitement about the possibilities for the future of Elixir Links mentioned in this episode: SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic Axon – https://hexdocs.pm/axon/Axon.html Bumblebee – https://hex.pm/packages/bumblebee HEEx – https://hexdocs.pm/phoenix_live_view/assigns-eex.html Phoenix LiveView – https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html Numerical Elixir – https://hexdocs.pm/nx/intro-to-nx.html Hugging Face – https://huggingface.co/docs Flutter – https://docs.flutter.dev/ Dart – https://dart.dev/ Broadway – https://hexdocs.pm/broadway/Broadway.html Phoenix Presence – https://hexdocs.pm/phoenix/Phoenix.Presence.html Nerves – https://hexdocs.pm/nerves/getting-started.html WebSocket – https://hexdocs.pm/web_socket/readme.html

Elixir Wizards Season 9 is coming to an end! In the season finale, hosts Sundi, Bilal, Owen, and Dan reflect on the guests and highlights that made this season unforgettable. We thank you for joining us as we parsed the particulars and can't wait to reconnect next season for more insightful conversations! *Please remember to take our LISTENER SURVEY so we can come back bigger and better for Season 10 – Coming in early 2023!! * SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic

Today on Elixir Wizards, Marcelo Dominguez, co-founder at Mimiquate, joins us to parse the particulars of command query responsibility segregation (CQRS). Mimiquate is a specialized team of developers providing solutions for their clients with Elixir, Ruby on Rails, and Ember. Tune in to learn the benefits and potential applications of CQRS. *Please remember to take our LISTENER SURVEY so we can come back bigger and better for Season 10 – Coming in early 2023!! * The Wizards catch up with Marcelo and hear about ElixirConf Uruguay and Advent of Code 2022 Marcelo and the hosts run through their experience with CQRS and event sourcing The definition of CQRS What is the elevator pitch for CQRS Marcelo distinguishes between database writes and reads What are some limitations of the CRUD pattern How to know whether your application will benefit from the CQRS pattern What tools are in the Elixir ecosystem for implementing CQRS How to quickly recover from outages within a mature CQRS application How multi-node distribution impact CQRS architecture Links Mentioned in Today’s Episode: Eventsourcing and CQRS in Elixir CQRS Pattern (Microsoft) Commanded (Hex Docs) Advent of Code Marcelo’s Advent of Code Gist for Day 1 Marcelo Dominguez on LinkedIn — https://uy.linkedin.com/in/marpo60 Marcelo Dominguez on Twitter — https://twitter.com/marpo60 Marcelo Dominguez on GitHub – https://github.com/marpo60 Mimiquate – https://www.mimiquate.com/ SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic

Today on Elixir Wizards, Chris Miller, software engineer at Corvus Insurance, joins us again for an in-depth discussion on the different approaches to programming. We dive into the conception and origin of new languages and how they evolve to solve new problems over time. *Please remember to take our LISTENER SURVEY so we can come back bigger and better for Season 10 – Coming in early 2023!! * Key Points From This Episode: The hosts catch up with Chris and learn a bit about Corvus Insurance What excites Chris about programming language and new ways of thinking Chris' fascination with all different types of languages from Chinese to Greek to C++ We get a refresher on the concept of Domain Specific Language What DSL is being used for certains problems in the domain at Corvus Insurance Why a coder should care about the crafting of a programming language We discuss why all coders don't only write assembly code Chris breaks down how he has attempted to write his own programming language We learn some inside tips on how stay within the abstract boundary when building a domain How Chris' experience with multiple coding languages has influenced his work in Elixir What the advantage of knowing multiple languages is Links Mentioned in Today’s Episode: Corvus Insurance on Twitter — https://twitter.com/CorvusInsurance Corvus Insurance -- https://www.corvusinsurance.com/ SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic

Today on Elixir Wizards, we speak with two great minds in the Elixir community: Frank Hunleth from SmartRent and Joe Martin from Company Six. Join us to parse the particulars of Nerves, from production and terminology, to stacks, customization, and how they function. *Please remember to take our LISTENER SURVEY so we can come back bigger and better for Season 10 – Coming in early 2023!! * Key Points From This Episode: How both Frank & Joe became interested in Elixir We learn what nerves is currently being used for in production How Nerves is being utilized within farming and energy companies What the elevator pitch for nerves would be How well nerves play with pre-existing embedded projects in other languages, especially when having to coexist within a system How much can a user customize nerves What is Buildroot and the functions that it serves Frank explains how there are two worlds: elixir world & nerves systems Joe and Frank let us know what they are most excited about in the near future of nerves and Elixir Links Mentioned in Today’s Episode: LISTENER SURVEY – https://smr.tl/survey2022 Nerves Livebook – https://github.com/livebook-dev/nerves_livebook Frank Hunleth on LinkedIn — https://www.linkedin.com/in/fhunleth/ Frank Hunleth on Twitter — https://twitter.com/fhunleth Frank Hunleth on GitHub -- https://github.com/fhunleth Joe Martin on LinkedIn — https://www.linkedin.com/in/joseph-martin-265861b2/ Joe Martin on GitHub – http://github.com/josephmartin09 SmartRent -- https://smartrent.com/ Company Six – https://www.co6.com/ SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic

Today on Elixir Wizards, we chat with Jenny Bramble. Jenny is the Director of Quality Engineering at Papa, a platform that connects older adults and low-income families with companionship and a helping hand with daily tasks. Tune in to learn more about Jenny's experience with testing and team collaboration at Papa. Key Points From This Episode: Jenny tells us about her journey to learning Elixir (for 8 years now!) We learn about the 24 talks that Jenny has done as a keynote speaker The breakdown of her talk this year at Elixir Conf on upgrades How Jenny got in to writing tests after going to college for computer science What goes into developer handoff and how that varies depending on the company and team The connection and importance between customer service and empathy What it's like to work in Quality Engineering and Testing at Papa What is testing? She provides helpful tips of things that tend to be caught up by QA during code reviews Jenny has a course on management for Test Automation coming out in 2023! Links Mentioned in Today’s Episode: Jenny Bramble on LinkedIn — https://www.linkedin.com/in/jennybramble/ Jenny Bramble on Twitter — https://twitter.com/jennydoesthings Jenny Bramble on GitHub -- https://github.com/jennydoesthings Papa -- https://www.papa.com/ SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic

We are excited to have SmartLogic's own Harper Atlas as our guest on Elixir Wizards today! Harper, a product designer at SmartLogic (and cat lady at home), joins us on this episode to parse the particulars of the Tailwind framework from a designer's perspective. Join us to gain insights from our first non-engineer guest in this spirited conversation with Harper! Key Points From This Episode: We learn about Harper’s journey into the UX field Harper breaks down her day-to-day life as a product designer at SmartLogic What the difference between FigMa and FigJam is The good & bad sides of Tailwind What goes into developer handoff and how that varies depending on the company and team The importance of finding common language and bridging the gap between developer island and design island within a developer handoff The features that Harper doesn’t like about Tailwind How Tailwind has started to feel like the Baader-Meinhof Phenomenon Harper gives developers some advice on how to be more helpful to designers while working in a Tailwind space Links Mentioned in Today’s Episode: Harper Atlas on LinkedIn — https://www.linkedin.com/in/harper-atlas Harper Atlas on Twitter — https://twitter.com/harperatlas SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic

Today on the show we’re excited to have Theo Harris here to discuss Onboarding Into Elixir. Theo is a technical consultant working for Alembic in Sydney, Australia. He is currently working on a project utilizing Elixir and Phoenix LiveView. Tune in today to learn more about Onboarding Into Elixir, from our guest Theo Harris! Key Points From This Episode: A brief breakdown of today’s topic and introduction to our special guest, Theo Harris Theo lets us in on his current hot tech take We discuss accessibility tips and tricks Theo gives us the run down on Alembic and what they do at their company We find out whether or not Theo has a pet dinosaur We learn of the technical challenges that Theo has faced as an Elixir Engineer The breakdown of the onboarding process at Alembic Theo gives advice to beginners on how to learn Elixir/Phoenix Links Mentioned in Today’s Episode: Theo Harris on Twitter — https://twitter.com/dino_coder Theo Harris on GitHub — https://github.com/Theosaurus-Rexv Theo Harris on LinkedIn — https://www.linkedin.com/in/theo-harris-coder/ Alembic — https://alembic.com.au/ SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic

On today’s episode of Elixir Wizards, Ashley Smith and Kenneth Moy from Bowery Farming join us to dive into the particulars of Oban. Ashley has been working as a software engineer for 3 years with full-stack experience working mainly on web applications and now works in elixir at Bowery Farming. Kenneth is a software engineer at Bowery Farming with 3 years of elixir experience. Tune in today to learn more about Oban from today’s special guests, Ashley & Kenneth! Key Points From This Episode: A brief breakdown of today’s topic and introduction to our special guests, Ashley & Kenneth We get the inside scoop of what happens behind the scenes at Bowery Farms and how they use elixir What is Oban and how does it compare to other languages Why one would use Oban rather than something like Broadway How Oban is useful at Bowery Farms Ashley & Kenneth explain why they are not “over” Ecto.Multi just yet We hear about their working experience at Bowery, some days are remote, some days are at the office, and some days are at the farm where they get to see their work come to life Links Mentioned in Today’s Episode: Ashley Smith on GitHub — https://github.com/asmith1 Ashley Smith on LinkedIn — https://www.linkedin.com/in/ashley-smith-951802126/ Kenneth Moy on Twitter — https://mobile.twitter.com/chehitskenniexd Kenneth Moy on GitHub — https://github.com/chehitskenniexd Kenneth Moy on LinkedIn — https://www.linkedin.com/in/kenneth-moy/ Bowery Farms — https://boweryfarming.com SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic

Today we welcome Jason Stiebs to the podcast to talk about all things LiveView and how he was originally wrong about LiveView in the beginning. Jason is the founder at Rokkincat, and a core contributor to Phoenix. Jason loves finding solutions to complex problems and mentoring young engineers. Tune in today to learn more about LiveView from today’s special guest, Jason Stiebs! Key Points From This Episode: A brief breakdown of today’s topic and introduction to our special guest, Jason Stiebs A summary of Jason’s talk at ElixirConf on why he initially was wrong about LiveView How Jason became a Phoenix core team member What is stopping LiveView from being 1.0 Is there something that would make LiveView ‘complete’ How to decide to use LiveView over an SPA framework Do you know if there are any folks out there putting together tooling for LiveView? Thinking like Chrome devtools, performance monitoring, etc. What tools can we use to compare our LiveView performance to non LV performance? What Jason's thoughts about a time traveling feature for LiveView like what React / Redux has What some featuresare from other frameworks that Jason would like to see in LiveView one day How often Jason sees mixed LV and non LV projects We hear about what's next in terms of features for functional components Links Mentioned in Today’s Episode: Jason Stiebs on Twitter — https://twitter.com/peregrine Jason Stiebs on GitHub — https://github.com/jeregrine Jason Stiebs on LinkedIn — https://www.linkedin.com/in/jasonstiebs/ Jason Stiebs Email Address – [email protected] RokkinCat — https://rokkincat.com/ SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic

This week the Thinking Elixir Podcast is taking over Elixir Wizards! Mark & David from Thinking Elixir are here today to parse the particulars of Ecto Queries! Mark Ericksen is an Elixir Specialist at Fly.io and host of Thinking Elixir. David Bernheisel is a Senior Software Engineer at Bitfo and host of Thinking Elixir. Tune in today to learn more about Ecto Queries from today’s special guests, Mark Ericksen and David Bernheisel! Key Points From This Episode: A brief breakdown of today’s topic and introduction to our special guests, Mark & David The hosts catch up with Mark & David and learn about David’s new book Ecto In Production Dave Lucia is mentioned once again, can we go one episode without talking about him? Find out how long David & Mark have been working in databases We get the breakdown of what an Ecto Query is There is a discussion around schema migrations vs data migrations and how to avoid common pain points Learn what resources are available for learning Ecto We find out what the pin operator is and when it is used What an extensive query is and how to optimize queries We learn about fun edge cases that we’ve bumped into while working with Ecto The ins and outs of Ecto dump and Ecto load ”Ecto is a whole wide world of information. You think you know a lot and then you realize you don't. Nope, I'm almost just as dumb as I was five years ago about SQL and Ecto. Nope, it evolves. It gets deep.” - Mark Ericksen Links Mentioned in Today’s Episode: Mark Ericksen on Twitter — https://twitter.com/brainlid Mark Ericksen on LinkedIn — https://www.linkedin.com/in/mark-ericksen-66397417/ David Bernheisel on Twitter – https://twitter.com/bernheisel David Bernheisel on GitHub – https://github.com/dbernheisel David Bernheisel on LinkedIn – https://www.linkedin.com/in/bernheisel/ Thinking Elixir Podcast https://podcast.thinkingelixir.com/ SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic Use The Index, Luke! https://use-the-index-luke.com/ Postgresql Tutorial https://www.postgresqltutorial.com/ Postgresql subqueries https://stackoverflow.com/questions/3004887/how-to-do-a-postgresql-subquery-in-select-clause-with-join-in-from-clause-like-s https://www.w3resource.com/sql/subqueries/understanding-sql-subqueries.php Fly Blog: Safe Ecto Migrations https://fly.io/phoenix-files/safe-ecto-migrations/ Crunchy Data Developer Tutorials https://www.crunchydata.com/developers/tutorials Crunchy Data Postgres Tips https://www.crunchydata.com/postgres-tips Ecto in Production https://www.ectoinproduction.com/ SQL Join Illustration https://commons.wikimedia.org/wiki/File:SQLJoins.svg SQL Join Illustration https://i.stack.imgur.com/UI25E.jpg

Today on Elixir Wizards we are joined by Tyler Young to explore the particulars of Geo Mapping, the process of turning data into maps. Tyler is a Senior Software Developer at Felt, the world’s first collaborative mapping tool built for anyone to make a beautiful map in minutes. Tune in today to learn more about Geo Mapping from today’s special guest, Tyler Young! Key Points From This Episode: A brief breakdown of today’s topic and introduction to our special guest, Tyler Young We discover Tyler’s background and how he started working in Elixir, as well as how he got into the map business because of his love for Elixir We learn about GIS and its history as a system/standard/protocol, and how someone can study GIS Find out how mapping is helpful in more ways than just for directions, including climate changes, vacation planning, and more Tyler breaks down the common technologies and toolkits for programming with maps The specific tools that Felt is using to ingest map data and build the interactive maps What common problems arise when developing with maps Tyler teaches the Elixir Wizards about his tried and true way of decision making with “The McDonald’s option” _ **Links Mentioned in Today’s Episode: Tyler Young on Twitter — https://twitter.com/TylerAYoung Tyler Young on GitHub — https://github.com/s3cur3 Tyler Young on LinkedIn — https://www.linkedin.com/in/tyler-young-dev/ Felt — https://felt.com/about SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic

Season 9 is in full swing and we are so excited to welcome Kate Rezentes today to dive into the particulars of GenServers. Kate is a Junior Software Developer at Simplebet, a B2B product development company using machine learning and real-time technology to make every moment of every sporting event a betting opportunity. Tune in today to learn more from today’s special guest, Kate Rezentes! Key Points From This Episode: A brief breakdown of today’s topic and introduction to our special guest, Kate Rezentes We learn about Kate’s background and her long history with programming We discuss how many conferences she’s attended and why ElixirConf has been her favorite (thus far) Find out how Kate landed a job while attending ElixirConf How GenServers as a subject came to be We get an inside look at Kate’s working experience at Simplebet and her experience as a Junior Engineer in the industry so far What cases in particular cause the need for a GenServer We discuss where GenServers would be appropriate to use and why The ins and outs of ‘handle calls’ and ‘callbacks’ The process of testing a GenServer and data storage_ **Links Mentioned in Today’s Episode:* Kate Rezentes on Twitter — https://twitter.com/rezkate Kate Rezentes on GitHub — https://github.com/KateRezentes Kate Rezentes on LinkedIn — https://www.linkedin.com/in/kfrezent/ Simplebet — https://simplebet.io/ SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic

Welcome to our first episode of Season 9 Elixir Wizards, Parsing the Particulars. A show focused on conversations with software developers from around the world on the Elixir language and other modern web technologies. Today, we are joined by Dave Lucia, Chief Technology Officer at Bitfo, a cryptocurrency media company building educational content for people who are interested in cryptocurrency. Dave is active in the Elixir community and in the past has spoken at Code BEAM SF, ElixirConf, RabbitMQ Summit, and has written several blog posts which can be found at davelucia.com. In today’s episode we find out more about Dave’s professional background and dive into the particulars of observability. Tune in today to learn more from today’s special guest, Dave Lucia! Key Points From This Episode: A brief breakdown of today’s topic and introduction to our special guest, Dave Lucia We find out about Bitfo and what services they offer We discuss Dave’s blog post on observability Find out how Dave wrote the blog post because he saw a gap at his company How Sundi proofread Dave’s blog post and realized her lack of knowledge on observability The most common mistake teams or engineers make when it comes to observability We peel back the layers on what telemetry is What the difference between telemetry and OpenTelemetry is How to choose which tool is right when it comes to better observability *The breakdown of the uses for observability telemetry *When and why would we use OpenTelemtry vs basic observability *What languages Dave started in before he was working in Elixir *How Elixir lends better for observability *Where to start if you want to implement basic observability for someone who has no experience with it *Dave answers the question, “can you go too far with observability?” *We discuss Livebook and what exciting things it will bring for the future *Most importantly, Dave explains why pineapples are important to him **Links Mentioned in Today’s Episode: Dave’s blog post on Observability: https://davelucia.com/blog/observing-elixir-with-lightstep Dave Lucia on Twitter — https://twitter.com/davydog187 Dave Lucia on GitHub — https://github.com/davydog187 Dave Lucia on LinkedIn — https://www.linkedin.com/in/david-lucia-a395441b/ Bitfo — https://www.bitfo.com/ SmartLogic — https://smartlogic.io/

Hey everyone, Season 9 of Elixir Wizards is back! This season's theme is Parsing the Particulars, where we dive into particular subjects with our guests. Your returning hosts this season are Sundi, Owen and Dan! And we are excited to announce that we have a new host joining the show - Bilal Hankins! Bilal is a Software Developer at SmartLogic and is super excited to join us this season. Some of this season's guests include Dave Lucia, CTO at Bitfo, Tyler Young, Senior Software Developer at Felt, and Kate Rezentes, Junior Developer at SimpleBet. Can't wait to see you there! SmartLogic — https://smartlogic.io/ SmartLogic on Twitter — https://twitter.com/smartlogic SmartLogic on LinkedIn — https://www.linkedin.com/company/smartlogic-io/ SmartLogic on Facebook — https://www.facebook.com/smartlogic/ Bilal Hankins on LinkedIn — https://www.linkedin.com/in/hankins-bilal/ Sundi Myint on LinkedIn — https://www.linkedin.com/in/sundimyint/ Owen Bickford on LinkedIn — https://www.linkedin.com/in/owen-bickford-8b6b1523a/

It’s the season finale show! Can you believe it? Join us this week as Sundi, Owen, and Dan take a look back at this season of Elixir Wizards! You’ll hear their discussion about favorite moments over the season and learn about this season’s theme and its origin, and what they learned throughout the season. Enjoy and we hope to see you back for Season 9! Key Points From This Episode: Reflection on the guests experiences with all different types of language How the team landed on the theme of Elixir in a Polyglot Environment Having expectation of guests vs how the conversation turned out The discovery that environment influences the strength of the code that is being written We dig deeper into the flexibility of all of these companies How the hosts enjoyed the dream language combination answers from guests We hear about the teams experience with their first in-person recording Hearing about guests personal experiences and projects vs just their at-work experience We find out what birds do when they’re excited in a tree Flutter as a solution for building mobile applications The hosts likes, dislikes, experience with Flutter and the difference it brings to the table We reflect on a guest applying gamification The hosts discuss the guests range of experience, from a year to decades in the field, and how many different perspectives were shown with different backgrounds A recurring theme of the guests: structuring teams to fit the needs of the company - recurring theme Hearing about products and projects guests are working on Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ SmartLogic on Twitter — https://twitter.com/smartlogic SmartLogic on LinkedIn — https://www.linkedin.com/company/smartlogic-io/ SmartLogic on Facebook — https://www.facebook.com/smartlogic/ Dan Ivovich on LinkedIn — https://www.linkedin.com/in/divovich/ Sundi Myint on LinkedIn — https://www.linkedin.com/in/sundimyint/

This week on Elixir Wizards we’re joined by Nathan Retta, Senior Software Engineer from Android at DoorDash. We learn about Nathan’s background; his experience having a degree in Chemical Engineering and working in Oil and Gas for 6 years. Nathan then wrote an Android app in 2016 and soon after became a mobile developer -- the rest is history. He is currently based in Denver, Colorado, and our host Owen has met him prior through the Denver Elixir virtual meet up. Join us today for this conversation between Owen, Dan and Nathan as we learn about Nathan’s experience leading up to his current position at Android for DoorDash and how he is using Elixir in his side projects.

Welcome to this week’s episode of Elixir Wizards, with our special guest, Cara Mitchell of Pepsi Co. Today we speak with Cara about her career journey that led to her living in the lower East Side of New York City. Cara has been working in the software engineering field for over 20 years and currently works at PepsiCo on their in-house eCommerce platform built with Elixir. Over the years, she's worked on systems that range from embedded firmware to large distributed systems running on thousands of machines. She enjoys working in a number of programming languages and refuses to pick a favorite. Today we learn about Cara’s unique experience as a college dropout turned self-made software engineer and how PepsiCo is working in Elixir on a global scale with an inside look at the goings on at PepsiCo. Tune in today to learn more from today’s special guest, Cara Mitchell!

Joining us today on Elixir Wizards is Catalina Astengo, Staff Software Engineer at Nav Inc. We chat with Catalina about how she went from working as a process engineer in a mine to a software engineer in beautiful Salt Lake City. In today’s show we find out more about Catalina’s professional background, how and why she started taking Ruby courses while working at a mine in southern Utah, how she fell in love with Salt Lake City and what it looked like transitioning to a new profession. We learn about the ins & outs of Nav and their team roles, as well as how they keep up with all of the languages that they are using including Elixir, Ruby, Go and JS. Tune in today to learn more from today’s special guest, Catalina Astengo! Key Points From This Episode: A brief breakdown of today’s topic and introduction to our special guest, Catalina Astengo. What it was like working in a small town in a mine in southern Utah What a process engineer is and what the job title entails What prompted the switch from process engineering to software engineering What Nav does as a company Catalina gives us a rundown of her professional career. Is this the most Polyglot stack we have encountered this season!? The ins & outs at Nav and their teams roles How Nav uses Elixir on a daily basis How Nav keeps up to date on all of the languages they are using Concerns about using multiple languages on the backend Context switching between languages How Nav decided to use Golang and why she prefers Elixir Where Nav is based and where they are hiring How Catalina and her team made a home movie production of Beetlejuice We review Elixir Conf 2020 and takeaways that Catalina had from the conference How Nav uses GRPC RP vs GRPC - what’s the difference? Protobuf for validation schemes across GPS Ways to validate event payloads by using the Graph QL We discuss our experience with management vs. coding Owens penguin discovery about Catalina on the Nav website Links Mentioned in Today’s Episode: Catalina Astengo on Twitter — https://twitter.com/catalinaastengo Catalina Astengo on GitHub — https://github.com/castengo Catalina Astengo on LinkedIn — https://www.linkedin.com/in/catalinaastengo/ Blog Post on Graph QL Schema Validation – https://www.infoq.com/news/2022/05/graphql-schema-validation/ Nav Careers — https://www.nav.com/ SmartLogic — https://smartlogic.io/ SmartLogic on Twitter — https://twitter.com/smartlogic SmartLogic on LinkedIn — https://www.linkedin.com/company/smartlogic-io/ SmartLogic on Facebook — https://www.facebook.com/smartlogic/ Sundi Myint on LinkedIn — https://www.linkedin.com/in/sundimyint/

Welcome to another episode of Elixir Wizards, a show focused on conversations with software developers from around the world on the Elixir language and other modern web technologies. In today’s episode, we speak with Meks McClure, a Full Stack Software Engineer with an unconventional background in Biology and Philosophy. Meks found their passion for programming after building a website for a Mexican non-profit, Permanencia Voluntaria, using wix.com. Seeing people use the website and how it helped the community inspired Meks to pursue a career in programming. They are currently based at NewAperio, a software development company, as a Junior Developer. In today’s show we find out more about Meks’s professional background, NewAperio and the services they offer, more about their unconventional training background, challenges transitioning to a new career path, the importance of effective communication in the workplace, the significance of Pride Month, Meks’s very cool desk setup, and much more! Tune in today to learn more from today’s special guest, Meks McClure! Key Points From This Episode: A brief breakdown of today’s topic and introduction to our special guest, Meks McClure. We find out about NewAperio and what services they offer. How long Meks has been based at NewAperio. Find out what the NewAperio tradition is for people celebrating their work anniversary. A light-hearted discussion about singing Happy Birthday to colleagues. Meks gives us a rundown of their professional career. We find out more about Meks’s non-traditional programming background. How long they have been using Elixir for and how they initially got started in it. The lessons they learned from their Flatiron and Elixir development experience. What was most difficult transitioning from working Ruby to Elixir. Keeping a balance between learning and meeting productivity targets. The moment when Meks felt like they were making good progress transitioning. Some advice they have for people learning Elixir. Other projects that Meks is currently working on and programming languages used. How boot camp is different from real-world situations, in terms of programming. We find out about Meks’s current Star Wars obsession. The importance of finding enjoyment outside of work. Meks shares their personal journey to becoming the person they are today. A conversation about the importance of Pride Month and keeping an open mind. A highlight of some communication challenges that come with remote working. Why empathetic and effective communication is essential in the workplace. We reflect on some recent networking opportunities and conferences. The approach at NewAperio to networking and conferences. Details about Meks’ desk setup and why it is called the ‘Moon Lander’. More about their desk setup: keycap preferences. How learning Elixir changed the way Meks thinks about programming in general. Meks explains their approach to writing code. What their ultimate combination of programming languages are. What opportunities or weaknesses that a polyglot environment can introduce. *Links Mentioned in Today’s Episode: * Meks McClure on Twitter — https://twitter.com/mmcclure0100 Meks McClure on GitHub — https://github.com/MMcClure11 Meks McClure on LinkedIn — https://www.linkedin.com/in/meksmcclure/ NewAperio — https://newaperio.com/ SmartLogic — https://smartlogic.io/ Sundi Myint on Twitter — https://twitter.com/sundikhin Owen Bickford on Twitter — https://twitter.com/owenbickford/ SmartLogic — https://smartlogic.io Moon Lander — https://www.zsa.io/moonlander/ Difficult Conversations — https://www.penguinrandomhouse.com/books/331191/difficult-conversations-by-douglas-stone-bruce-patton-and-sheila-heen-foreword-by-roger-fisher/ Kailh Speed Silver (Linear) Mechanical Switch Kit — https://www.amazon.com/Silver-Linear-Mechanical-EVGA-Keyboard/dp/B09N9BXW7Z Special Guest: Meks McClure.

A superpower of software development is teaching our code to teach us what’s happening. This is observability, and it’s why Jessica Kerr works at Honeycomb, where she is a Developer Advocate. After twenty years as a developer, Jess sees software as a significant force in the world. As a symmathecist in the medium of code, she views development teams as learning systems made of both people and software. She believes that, if we allow the software to teach us, it becomes a better teammate and, if this process makes us into systems thinkers, we can be better people in the world! Today, Jess compares the way we work in teams to game design and we find out what she means by observability and how it can serve everybody on a team. She elaborates on the remarkable agency that software developers have and how the languages they use can empower them, especially when they aren’t having specific architecture imposed on them! We also touch on what being a polyglot means to Jess, the value of working with rather then against complexity, and what Jess means when she says a software team is the perfect example of a symmathesy, plus so much more, so make sure to tune in today for this fascinating conversation with Jessica Kerr! *Key Points From This Episode: * Jess starts by drawing an interesting comparison between teamwork and game design. Insight into her journey as a developer and how she was introduced to Elixir. Discover Jess’ connection to Elixir iteratees via Jose Valim! Her role at Honeycomb, the languages she uses, and what she means by observability. Why Jess believes that developers have agency and enormous power. Why the best language to use is the one that you and your team know best. The value of standardizing the platform rather than trying to dictate the language. How observability reveals connections and acts as one tool that serves everybody. Congressive versus ingressive behavior as per Dr. Eugenia Cheng. What being a polyglot means to Jess: accepting that others don’t think just like you do and actively learning from them. Working skillfully within complexity rather than trying to eliminate it. How people gain exposure to different languages at Honeycomb. The importance of understanding what architecture is being imposed on you. Jess’ favorite talk on symmathesy and why a software team in particular is a symmathesy. Opportunities and/or weaknesses that being in a polyglot environment can introduce. Ways you can connect with Jess and even sign up for a 30-minute chat with her! *Links Mentioned in Today’s Episode: * Jessica Kerr — https://jessitron.com/ Jessica Kerr on LinkedIn — https://www.linkedin.com/in/jessicakerr/ Jessica Kerr on Twitter — https://twitter.com/jessitron Honeycomb — https://www.honeycomb.io/ Schedule a Call with Jess — honeycomb.io/office-hours Games: Agency As Art — https://objectionable.net/games-agency-as-art/ OpenTelemetry — https://opentelemetry.io/ Matthew Skelton — https://blog.matthewskelton.net/ Team Topologies — https://teamtopologies.com/ QCon — https://plus.qconferences.com/ Keynote: ’The Language is the Least of It’ — https://youtu.be/nvV-4040xXI Dr Eugenia Cheng — http://eugeniacheng.com/ x + y — https://www.basicbooks.com/titles/eugenia-cheng/x-y/9781541646513/ 'Backend for frontend (BFF) pattern’ — https://medium.com/mobilepeople/backend-for-frontend-pattern-why-you-need-to-know-it-46f94ce420b0 Abstract syntax tree — https://en.wikipedia.org/wiki/Abstract_syntax_tree Keynote: ‘Collective Problem Solving in Music, Science, Art, and Software’ — https://jessitron.com/2019/11/05/keynote-collective-problem-solving-in-music-science-art-and-software/ SmartLogic — https://smartlogic.io/ Special Guest: Jessica Kerr.

Welcome back to another episode of Elixir Wizards. Today, we chat with Digit, a talented software engineer currently based at SmartRent. He became aware of the company when he started trying to modify his smart home and realized what was behind the software. Digit works on building applications within the SmartRent suite of tools using the Nerves ecosystem. Although fairly new at SmartRent, Digit loves the powerful applications of the software they are developing. In today’s show we find out more about the work Digit is currently involved with at SmartRent and what they have in store for the future. We also discuss the pros and cons of living in a smart home, the different languages that Digit uses, what makes developing a game so challenging, Using Elixir for building DSLs to generate content for Unity, what Digit’s opinion is of Burrito, and much more! For all this and more, be sure to tune in today! Key Points From This Episode: Introduction to today’s show and brief catch-up of what everyone has been up to. We find out what talks at the conference Digit is most looking forward to. What OTP stands for: hint, it is not ‘Open Telephony Platform.’ A brief discussion about the advantages of a one-day conference. We find out who all the people are that are going to give talks at EMPEX. Digit shares what it has been like working at SmartRent. We find out how Digit landed the job at SmartRent. Breakdown of what SmartRent is in terms of the high level. We get some insider knowledge of the next-generation technology at SmartRent. Rundown of what Flutter is and the advantages of using it. Discussion about the pros and cons of living in a smart home. Find out what the best smart thermostat is, according to Digit. The different programming languages that Digit is currently working in. Digit explains the type of WebSocket support available in Flutter. Background about Digit’s experience in game development. What makes finishing developing a game so difficult. The language stack used to develop games. Using Elixir for building DSLs to generate content for Unity. Digit gives listeners an overview of Burrito. The advantages of using Burrito for cross-platform with no internet connection. Examples of real-world applications using Burrito. Other applications for Elixir outside of web application development. We get some insider information about a new Elixir-based project in the works. A rundown of the security applications using Macaroons. The power that passwordless authentication has to offer. We end the show with some takeaways from Digit for listeners. Links Mentioned in Today’s Episode: Digit — https://puppy.surf Digit on GitHub — https://github.com/doawoo Digit on Twitter — https://twitter.com/doawoo SmartRent — https://smartrent.com SmartLogic — https://smartlogic.io/ Sundi Myint on Twitter — https://twitter.com/sundikhin/ Owen Bickford on Twitter — https://twitter.com/owenbickford/ EMPEX — https://www.empex.co Flutter — https://flutter.dev/Special Guest: Digit.

Joining us in conversation today is Nathan Willson all the way from Tokyo, Japan. Listeners will learn about the polyglot landscape he works in from Japan, why he believes knowing a language, and mastering it, are two different things, and what his first foray into coding looked like. We touch on the necessary evil of MIDI plugins, and Nathan introduces listeners to GEMS, how you can use it, and what he has done to make it accessible across the globe. We talk latency issues, curbing the potential for abuse, and choosing to make an app open source, before delving into Nathan’s other projects outside of GEMS, including the Elixir app, Biddy, that he built with five friends, When to Chat, and much more. Thanks for tuning in to hear from today’s inspiring guest. Key Points From This Episode: An introduction to today’s guest, Nathan Willson, his Canadian-Japanese history, his obsession with Elixir, and his musical experimental app, GEMS. The polyglot environment in which he works which is Japanese and English. Why knowing a language and mastering a language are such different things. His first foray into coding via Reaper’s plugins. Why he considers MIDI to be a necessary evil. What GEMS, or Globally Editable Matrix Sequencer, is, and how it works. How Phoenix or Elixir can facilitate the use of GEMS anywhere in the world, at the same time. How he has approached the problem of the potential for abuse. Relative and absolute latency and how that impacts user experience between countries. Nathan’s other projects outside of GEMS, including the Elixir app, Biddy, and TreeLib. The app, When to Chat, that Nathan has built. Where he picked up his design skills with a background in back-end engineering. Why he prefers BandCamp to Spotify as a music listener. How his knowledge of Elixir has helped him to code Ruby better. An invitation from Nathan to reach out with what you are working on. Links Mentioned in Today’s Episode: Tone.js — https://tonejs.github.io/ BandCamp — https://bandcamp.com/ Nathan Wilson — https://nathanwillson.com/ Nathan Willson on Twitter — https://twitter.com/nathanwillson Nathan Willson on Instagram — https://www.instagram.com/nahtanw/ GEMS — https://gems.nathanwillson.com/ What is Max? | Cycling ‘74 — https://cycling74.com/products/max When to Chat —https://whentochat.co/ SmartLogic — https://smartlogic.io/ Special Guest: Nathan Willson.

This week we are joined by Sanne Kalkman, former teacher turned software engineer. Currently, Sanne works at CodeSandbox, where she's one of two Elixir developers responsible for the backend. When she's not coding, you'll probably find her either 25 browser tabs deep into a new CS topic, learning yet another new hobby, or behind her sewing machine, all of which we dive into in today’s episode! Tuning in, you’ll discover which languages Sanne is proficient in and why she doesn’t consider herself a polyglot; gain some insight into CodeSandbox Projects, a more collaborative rewrite of CodeSandbox from the ground up; and get a sneak peek into Sanne’s upcoming keynote address at Code BEAM Europe in May 2022, which tackles how to help juniors succeed in your organization. We also touch on garbage collection in Elixir, cute avatars, the intersection of code and sewing, and much, much more, so make sure not to miss this fun and insightful conversation with coder and crafter, Sanne Kalkman! Key Points From This Episode: What it’s like living in the Netherlands, Sanne’s favorite TV show, and more. An introduction to Sanne, how she found herself in tech, and her role at CodeSandbox. The first language she entered the professional coding space with: Elixir, of course! How she thinks about JavaScript now that she is proficient in another language like Elixir. Learn more about CodeSandbox Projects and how it fosters live collaboration. How the CodeSandbox app is broken down into Elixir, TypeScript, and Rust. Why Sanne views CodeSandbox as a polyglot environment, but she isn’t a polyglot herself. Find out why she prefers to stick with Elixir in her personal capacity. Code BEAM Europe 2022 and some highlights from Sanne’s upcoming keynote address. Top tips for helping juniors succeed at your organization; model asking questions. The TLDR summary of garbage collection in Elixir from Sanne’s 2020 Code BEAM Talk. Cute avatars over headshots, Sanne’s crafty hobbies, side projects, and more! Some of the cool work taking place at the intersection of code and sewing. Opportunities at CodeSandbox to dive into different codebases and learn different things. Final plugs, mentions, and where to connect with Sanne! Links Mentioned in Today’s Episode: Sanne Kalkman on LinkedIn — https://www.linkedin.com/in/sannekalkman/ Sanne Kalkman on GitHub — https://github.com/sannek/sketch Sanne Kalkman on Twitter — https://twitter.com/sannekalkman CodeSandbox — https://codesandbox.io/ Our Flag Means Death — https://www.hbomax.com/series/urn:hbo:series:GYf3LzwJV98JifQEAAAAO Walibi Amusement Park — https://www.walibi.com/ Code BEAM Europe 2022 — https://codesync.global/conferences/code-beam-sto-2022/ Sanne Kalkman: ’Who Takes Out Your Trash’ (Code BEAM V 2020) — https://youtu.be/OSdaXNQ0xhQ Covatar — https://covatar.com/ FreeSewing — https://freesewing.org/ SmartLogic — https://smartlogic.io/ SmartLogic Jobs — https://smartlogic.io/jobsSpecial Guest: Sanne Kalkman.

This double guest episode features Cassidy Williams, Head of Developer Experience and Education and Tobi Pfeiffer, Staff Engineer from Remote. This fast growing Elixir company provides HR support to clients who are hiring internationally. In this fascinating fast-paced conversation Cassidy and Tobi discuss how Remote works, the explosive growth it has seen and what Cassidy and Tobi have most enjoyed in their time there. Also, we learn more about Cassidy's content creation projects, why Tobi's handle is PragTob, and the strangest laws they have come across when working internationally. We also learn about Cassidy's love of mechanical keyboards and about Tobi's adorable pet rabbits. We wrap up the episode with some great book recommendations and what's upcoming at Remote. Key Points From This Episode: Welcome to Cassidy Williams (Head of Developer Experience and Education) and Tobi Pfeiffer (Staff Engineer) at Remote. Why Cassidy recommends the app Centered for achieving flow state. How different types of music affect everyone’s concentration while coding. Getting to know Tobi: Rails Girls community member, wearer of green and keyboard player. Who Cassidy is: a dweeb who likes memes and how she found the world of coding. What Remote is and how it works. How Tobi came up with the handle PragTob! The explosive growth Remote has seen, and how they stay on top of it. What's coming on the open-source front of Remote. The challenges Remote faces when employing people from different countries. The strangest laws Tobi and Cassidy have come across internationally. Why Cassidy enjoyed the well-practiced onboarding aspects of Remote, and the company values Tobi most appreciates. Tobi’s secret role in the formation of Remote! The people Tobi and Cassidy see moving into Elixir and which skills benefit them the most. Why Tobi's GitHub picture has a rabbit and his favorite game. Cassidy’s passion for mechanical keyboards! Book club recommendations: the books you should be looking out for, and why! Links Mentioned in Today’s Episode: Cassidy Williams on LinkedIn — https://www.linkedin.com/in/cassidoo/ Cassidy Williams on TikTok — https://www.tiktok.com/@cassidoo Cassidy Williams’ Newsletter — https://cassidoo.co/newsletter/ Tobi Pfeiffer on LinkedIn — https://www.linkedin.com/in/tobiaspfeiffer Tobi Pfeiffer on GitHub — https://github.com/pragtob Remote — https://remote.com/ Remote GitHub — https://github.com/remoteoss Centered — https://www.centered.app/ Benchee — https://elixirschool.com/en/lessons/misc/benchee SimpleCov — https://github.com/simplecov-ruby Rails Girls Berlin — http://railsgirls.com/berlin The Agile Samurai: How Agile Masters Deliver Great Software — https://www.amazon.com/Agile-Samurai-Software-Pragmatic-Programmers Netlify — https://www.netlify.com/ Devs for Ukraine — https://www.devsforukraine.io/ Jose Valim — https://www.linkedin.com/in/josevalim Marcelo Lebre — https://www.linkedin.com/in/marcelolebre RubyConf — https://rubyconf.org/ Rust — https://rust.facepunch.com/ Go — https://go.dev/ Node.js — https://nodejs.org/en/ React — https://reactjs.org/ Astro — https://astro.build/ Supabase — https://supabase.com/ Thea 2: The Shattering — https://store.steampowered.com/app/606230/Thea_2_The_Shattering Mechanical Keyboard — https://en.wikipedia.org/wiki/Model_M_keyboard QMK Firmware — https://docs.qmk.fm/#/ Brandon Sanderson — https://www.brandonsanderson.com/ Dark Matter — https://www.amazon.com/Dark-Matter-Novel-Blake-Crouch SmartLogic — https://smartlogic.io/ SmartLogic Jobs — https://smartlogic.io/about/jobsSpecial Guests: Cassidy Williams and Tobi Pfeiffer.

Today’s guest is Devon Estes, who leads the third-party integration team at Remote, a company that uses technology to make it easier for other companies to hire remote employees (not contractors, actual employees) from over 100 countries across the world. Prior to working at Remote (which he loves, as you'll hear today), Devon was a freelancer and avid public speaker, and some of his talks from many years ago are still relevant today. In this conversation, Devon explains why functional programming is easier to use than any other programming type, and how the only thing holding you back from becoming a master is your desire to learn! Key Points From This Episode: Guest host Dan Ivovich explains what prompted him to come up with the theme for this season; Elixir in a Polyglot Environment. A brief rundown of Devon’s daily life. Content that Devon covers in the talks that he gives these days. Devon explains what his role at Remote (where he has worked since November 2021) involves. A challenge that Devon has noticed other people facing when learning Elixir. An overview of what Remote does, and the specific area that Devon’s team focuses on. Functional programming versus object-oriented programming. Devon shares an example of the power of Elixir. The importance of libraries in making Elixir a viable language for data scientists. Devon’s thoughts on mutation testing. Why Devon doesn’t do a lot of open-source work anymore. How Remote has grown over the past year and a half. One of the things that Devon loves about working at Remote. Links Mentioned in Today’s Episode: Devon Estes on Twitter — https://twitter.com/devoncestes Devon Estes — https://devonestes.com/ Refactoring Elixir — https://www.youtube.com/watch?v=tJJMrtJEK1A Going Multi-Node with ExUnit— https://www.youtube.com/watch?v=elC_8PhWRTg Designing Elixir Systems with OTP — https://www.goodreads.com/book/show/45159167-designing-elixir-systems-with-otp ElixirConf EU — https://www.elixirconf.eu/ Remote — http://remote.com/ SmartLogic — https://smartlogic.io/ Jobs at SmartLogic — https://smartlogic.io/jobsSpecial Guest: Devon Estes.

Welcome to the new season of Elixir Wizards: Elixir in a Polyglot Environment. To get things going on this exciting and intriguing subject we are very happy to welcome Miguel Cobá! Miguel currently works at Shore, and he gives us some great insight into the part that Elixir plays at the company (alongside other languages), and how this suits his particulars skillset and vision. In this season, we want to consider important questions about reaching beyond the confines of the Elixir community, and how we can all learn from each other. Miguel is such a perfect guest to open this conversation, as he is fascinated by the way Elixir can fit into a network of knowledge and its deployment into other areas. In today's chat, we also get into the early days of Miguel's interest in programming, and how it took starting a job for him to really start learning. So, to hear all this and more, and to get a taste of a great season to come, be sure to tune in! Key Points From This Episode: Miguel's perspective on the importance of using Elixir alongside other languages. The languages that Miguel has worked in, and currently uses. A look at the path that Miguel took into programming and the first language he used! Turning an interest into a career; Miguel's biggest periods of learning. Background and motivations for Miguel's book, 100 Elixir Tips. The book that Miguel wrote that aims to help developers to write their own books! Constant learning and the passion that Miguel has for sharing this process with others through writing. Miguel shares some surprising parts of deployment in other languages. The combinations of languages that Miguel prefers. An explanation of Elixir's strength for background or asynchronous tasks. Why Miguel values the attitude above different language skills in a programmer. Unpacking how Elixir fits into the polyglot environment at Shore. How Miguel feels about community building and the usefulness of Twitter. Miguel compares his favorite parts of Elixir and the things he feels it is missing. Where to find and connect with Miguel online! Links Mentioned in Today’s Episode: 100 Elixir Tips — https://store.miguelcoba.com/l/100elixirtips Deploying Elixir — https://blog.miguelcoba.com/deploying-elixir-ebook Miguel Cobá on Twitter https://twitter.com/MiguelCoba_ Elm — https://elm-lang.org/ Miguel Cobá Blog https://blog.miguelcoba.com/ Gumroad — https://gumroad.com/ Hashnotes — https://www.hashnotes.app/ Shore — https://www.shore.com/en/ SmartLogic — https://smartlogic.io/ Jobs at SmartLogic – https://smartlogic.io/jobsSpecial Guest: Miguel Cobá.

Welcome to the Season 7 finale! Today, we are joined by Todd Resudek, Staff Engineer at Jackpocket, to reflect on the past season and speak about the impact of Elixir, as well as a variety of other topics almost entirely unrelated to programming! Todd is a reformed graphic designer that got his start in web development 15 years ago. He has made a career in front-end development, PHP, Rails, and Elixir. He is also a member of the Hex core team and, in his spare time, he tinkers with hardware projects. In today’s episode of Elixir Wizards, you’ll learn more about the 2022 EMPEX Elixir Mountain event that Todd is co-organizing, the formula for anticipating how many people will turn up at your event, and what trains have to do with the history of timezones. We also touch on Todd’s hopes for the future of Elixir, how Elixir has impacted him, both personally and professionally, and why he recommends learning Elixir as a backup language, plus so much more! Tune in today for a fun discussion with Todd Resudek! ** Key Points From This Episode:** The hilarious and sometimes tragic mispronunciation of our names. Learn more about the 2022 EMPEX Elixir Mountain event that Todd is co-organizing. Todd shares a bit about his background and his allegiance to Wisconsin football. We discuss the formula for how many people to expect at your meetup (or wedding). Some interesting history on timezones and how they relate to trains. Dune memes, roller skating, a qualifier for couple skates, and more. Todd shares his favorite Elixir Wizards episode from Season 7: Brooklyn Zelenka. How Todd learned Elixir when he first started working at Weedmaps. Why he suggests learning Elixir as a ‘backup language’ rather than a primary one. His biggest hope for the future of Elixir: an even more diverse, welcoming community. How a functional programming language like Elixir has impacted the way Todd works. The personal impact the Elixir community has had for Todd by enabling new connections. Find out why Alex’s dog, Bean, loved the test kitchen at their previous workplace. Eric and Alex share how the impact of Elixir has changed for them throughout this season. What all our children, human and animal, had for breakfast. Links Mentioned in Today’s Episode: Todd Resudek on LinkedIn — https://www.linkedin.com/in/toddresudek/ Todd Resudek on Twitter — https://twitter.com/sprsmpl Todd Resudek on GitHub — https://github.com/supersimple Todd Resudek — https://supersimple.org/ Jackpocket — https://jackpocket.com/ EMPEX Conference — https://www.empex.co/ EMPEX MTN 2022 — https://www.empex.co/mtn Alex’s Favorite Dune Meme — https://i.kym-cdn.com/photos/images/facebook/002/234/162/d96 ‘Brooklyn Zelenka and The Exciting World of Edge Computing’ — https://smartlogic.io/podcast/elixir-wizards/s7e9-zelenka/ Toucan — https://www.toucan.events Elixir Wizards |> Conference — https://smartlogic.io/about/community/elixir-wizards-conference/ SmartLogic — https://smartlogic.io/ Audience Survey -- https://smr.tl/surveySpecial Guest: Todd Resudek.

This week we welcome Arthi Radhakrishnan back to the show to discuss how Elixir and her career more broadly have shaped her perspectives on learning. Arthi first got into programming as a child growing up in the Bay Area, constantly exposed to tech and tech culture. She remembers building websites using GeoCities in high school and learning about data structures and OOP in Java while in college before transitioning to Elixir during her current position as a backend engineer at Community. We hear about what made her learning so enjoyable, the biggest paradigm shifts she needed to make, and she talks about the value of mentorship, pair programming, and working at a company that encourages learning on the job. In today’s show, we also explore a realization that Arthi has come to at the end of her first decade as a software engineer: that effective learning requires a big dose of self-compassion. So, for all this and more, be sure to tune in today! Key Points From This Episode: Introducing Arthi and the work she does as a backend engineer for Community. What it was like growing up in the Bay Area and how Arthi got into programming. Going from building websites with GeoCities in high school to building a compiler in college. The big role that Java and OOP played in Arthi’s experience of programming fundamentals. Arthi’s experience of learning Elixir and having to shift away from an OOP paradigm. Where Arthi is in her journey of learning Elixir and why she enjoys it so much. How compelling it is to learn on the job and the value of companies that allow for this. The impact that company culture has on job experiences and career trajectories. Summer internships Arthi did in college and how they shaped her career goals. Finding time to do personal learning and why Advent of Code is so helpful. Why setting low expectations for yourself is a helpful paradigm for learning. Exercising self-compassion while learning and how Arthi’s learning approach has evolved. Why Arthi is so grateful that she has gotten to learn Elixir at Community specifically. What good mentorship looks like to Arthi and why she loves pair programming. How learning Elixir and the past 10 years have shaped Arthi’s sense of her needs. Arthi’s thoughts on how Elixir will evolve in the next 10 years. Links Mentioned in Today’s Episode: Arthi Radhakrishnan — https://www.linkedin.com/in/arthiradhakrishnan/ Community — https://www.community.com/ Advent of Code — https://adventofcode.com/ SmartLogic — https://smartlogic.io/ Audience Survey -- https://smr.tl/surveySpecial Guest: Arthi Radhakrishnan.

Today we welcome software engineer Meryl Dakin to the show, who is currently employed by Knock. Meryl is here to help us continue our exploration of this season's theme of the impact of Elixir, and we get to hear about all how it has impacted her professional and personal life! Our guest talks about her journey through the world of development and the different positions she has held before her current role. We also get into her recent stint as the emcee of ElixirConf alongside our other friend Sophie DeBenedetto! We talk about learning through teaching, encouraging more questions, and why Elixir has had such a positive impact on Meryl's approach to code more generally. Big takeaways from today's conversation include the way that learning a new language can alter one's career in multiple and unexpected ways, why the Elixir community can feel so safe and supportive, and who might get the most benefit from being exposed to Elixir at the right time. So, to hear it all from Meryl and our usual cast of characters, be sure to listen in! Key Points From This Episode: A quick update on Meryl and what she has been busy with lately. Meryl's experiences emceeing the recent ElixirConf! Unpacking what Knock does and who the company serves. How Elixir has been used at Knock and the great experience Meryl has had building with it. Meryl's learning curve with Elixir and the biggest developments in the space from her perspective. The most common advice that Meryl would offer to junior engineers! Why teaching is often the best route to further learning; Meryl's reflections on her presentations. The importance of asking questions and speaking up when you do not understand. How Elixir shifted Meryl's way of thinking about programming: cleaner code and encapsulation. The different kinds of developers that might benefit from being introduced to Elixir. Thoughts on making Elixir more visible to the right people in the larger community. The personal impacts that Elixir has had on Meryl's life: meeting great people and finding an engaging and supportive community. When to consider using Knock and the initial offer for new clients. Where to go to find out more about Knock and whether it might be right for you! Meryl shares her biggest hopes and dreams for the future of the Elixir community. Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ Meryl Dakin on Twitter — https://twitter.com/meryldakin ElixirConf — https://www.elixirconf.com/ Netflix Christmas Universe — https://collider.com/netflix-christmas-universe-how-movies-connect-explained/ Flatiron School — https://flatironschool.com/ Frame.io — https://www.frame.io/ Knock — https://knock.app/ Knock on Twitter — https://twitter.com/knockdotcom Knock Changelog — https://knock.app/changelog Sophie DeBenedetto — https://www.amazon.com/Books-Sophie-DeBenedetto/s?rh=n%3A283155%2Cp_27%3ASophie+DeBenedetto The Flutter Apprentice Book — https://www.raywenderlich.com/books/flutter-apprentice/v1.0.ea2 EMPEX — https://www.empex.co/mtn Programming Phoenix LiveView — https://pragprog.com/titles/liveview/programming-phoenix-liveview/ Twilio — https://www.twilio.com/ Audience Survey -- https://smr.tl/surveySpecial Guest: Meryl Dakin.

We are very excited to welcome Brooklyn Zelenka back to the podcast to talk about her work at Fission and the ever-expanding frontier of edge computing! Brooklyn is a co-founder and CTO at Fission and she gives us some insight into the focus of the company's applied research. We hear from our guest about the projects she has been most excited about recently and she even talks about her newfound passion for fermentation! She does a great job of explaining why edge computing is potentially so revolutionary and some of the hurdles that are yet to be overcome on the way to reaching this potential. We discuss security and trust, tech equity, broad adoption, and much more before getting into some more Elixir-focused questions. Our guest shares how Elixir and functional programming have inspired her in different ways, as well as her perspective on some of the weaknesses of Elixir. At the end of our chat, Brooklyn gives some great resource recommendations for anyone wanting to learn more about edge computing, so make sure to stay tuned for that! Key Points From This Episode: What Brooklyn has been keeping busy with recently. A little about Fission and what their research focuses on. Tech and societal trends through the pandemic and Brooklyn's new interest in fermentation. Brooklyn unpacks the main mission of edge computing and some of the biggest challenges. Decisions around what is localized and what is stored remotely in edge computing. Addressing the issue of trust and safeguarding against data breaches. The influence of functional programming in Brooklyn's work on edge applications. Some information on Brooklyn's talk at ElixirConf this year titled 'The Jump to Hyperspace.' Our guest explains the concept of antientropy and its associated techniques. Thoughts on the problem of tech equity and how this might be tackled. Gaining popular trust for new technologies and their inevitable faults. Brooklyn's feelings about Haskell, and the inspiration she takes from it into her work with Elixir. The impact that Elixir has on Brooklyn's work in a broader sense. The route that Brooklyn took into the functional programming world. Brooklyn weighs in on the questions of Elixir's downsides. Resources recommendations for anyone looking to get more acquainted with work in edge computing. Where to find and connect with Brooklyn online! Links Mentioned in Today’s Episode: SmartLogic — https://smartlogic.io/ Brooklyn Zelenka — https://twitter.com/expede?lang=en Fission — https://fission.codes/ Brooklyn Zelenka at ElixirConf 2021— https://www.youtube.com/watch?v=ogOEEKWxevo Designing Data-Intensive Applications — https://www.bookmall.co.za/products/designing-data-intensive-applications?gclid=Cj0KCQiA2ZCOBhDiARIsAMRfv9ITE1sFKIIcSwK6EGR04aW2RrFZphwrvDQxZekyhuPbEyuqKt6Td8QaApPqEALw_wcB Brooklyn's Tepache Fermentation Recipe — https://ipfs.io/ipfs/bafybeiawn23o6prk4kdhv4cpbfylzr5g2fr22umhvbshf4rlksfrgjzpga/p/Tepache.pdf Witchcraft Suite of Libraries in Haskell/Elixir — https://hexdocs.pm/witchcraft/readme.html Proto School — https://proto.school/ Fission Discord — https://discord.gg/zAQBDEq Fission Discourse — https://talk.fission.codes/ Fission on Luma — https://lu.ma/community/com-XuESjPQQHjh43pc FissionCodes Twitter — https://twitter.com/FISSIONcodes Witchcraft Suite — https://github.com/witchcraftersSpecial Guest: Brooklyn Zelenka.