Elixir Wizards

Today on Elixir Wizards Office Hours, SmartLogic Engineer Joel Meador joins Dan Ivovich to discuss all things background jobs.

The behind-the-scenes heroes of app performance and scalability, background jobs take center stage as we dissect their role in optimizing user experience and managing heavy-lifting tasks away from the main application flow. From syncing with external systems to processing large datasets, background jobs are pivotal to successful application management.

Dan and Joel share their perspectives on monitoring, debugging, and securing background jobs, emphasizing the need for a strategic approach to these hidden workflows.

Key topics discussed in this episode:

• The vital role of background jobs in app performance
• Optimizing user experience through background processing
• Common pitfalls: resource starvation and latency issues
• Strategies for effective monitoring and debugging of task runners and job schedulers
• Data integrity and system security in open source software
• Background job tools like Oban, Sidekiq, Resque, Cron jobs, Redis pub sub
• CPU utilization and processing speed
• Best practices for implementing background jobs
• Keeping jobs small, focused, and well-monitored
• Navigating job uniqueness, locking, and deployment orchestration
• Leveraging asynctask for asynchronous operations
• The art of continuous improvement in background job management

Links mentioned in this episode:

https://redis.io/
Oban job processing library https://hexdocs.pm/oban/Oban.html
Resque Ruby library for background jobs https://github.com/resque
Sidekiq background processing for Ruby https://github.com/sidekiq
Delayed Job priority queue system https://github.com/collectiveidea/delayed_job
RabbitMQ messaging and streaming broker https://www.rabbitmq.com/
Mnesia distributed telecommunications DBMS https://www.erlang.org/doc/man/mnesia.html
Task for Elixir https://hexdocs.pm/elixir/1.12/Task.html
ETS in-memory store for Elixir and Erlang objects https://hexdocs.pm/ets/ETS.html
Cron - https://en.wikipedia.org/wiki/Cron
Donate to Miami Indians of Indiana https://www.miamiindians.org/take-action
Joel Meador on Tumblr https://joelmeador.tumblr.com/

Special Guest: Joel Meador.

In Elixir Wizards Office Hours Episode 2, "Discovery Discoveries," SmartLogic's Project Manager Alicia Brindisi and VP of Delivery Bri LaVorgna join Elixir Wizards Sundi Myint and Owen Bickford on an exploratory journey through the discovery phase of the software development lifecycle.

This episode highlights how collaboration and communication transform the client-project team dynamic into a customized expedition. The goal of discovery is to reveal clear business goals, understand the end user, pinpoint key project objectives, and meticulously document the path forward in a Product Requirements Document (PRD).

The discussion emphasizes the importance of fostering transparency, trust, and open communication. Through a mutual exchange of ideas, we are able to create the most tailored, efficient solutions that meet the client's current goals and their vision for the future.

Key topics discussed in this episode:

• Mastering the art of tailored, collaborative discovery
• Navigating business landscapes and user experiences with empathy
• Sculpting project objectives and architectural blueprints
• Continuously capturing discoveries and refining documentation
• Striking the perfect balance between flexibility and structured processes
• Steering clear of scope creep while managing expectations
• Tapping into collective wisdom for ongoing discovery
• Building and sustaining a foundation of trust and transparency

Links mentioned in this episode:

https://smartlogic.io/
Follow SmartLogic on social media: https://twitter.com/smartlogic
Contact Bri: [email protected]
What is a PRD? https://en.wikipedia.org/wiki/Product_requirements_document

Special Guests: Alicia Brindisi and Bri LaVorgna.

The Elixir Wizards Podcast is back with Season 12 Office Hours, where we talk with the internal SmartLogic team about the stages of the software development lifecycle. For the season premiere, "Testing 1, 2, 3," Joel Meador and Charles Suggs join us to discuss the nuances of software testing.

In this episode, we discuss everything from testing philosophies to test driven development (TDD), integration, and end-user testing. Our guests share real-world experiences that highlight the benefits of thorough testing, challenges like test maintenance, and problem-solving for complex production environments.

Key topics discussed in this episode:

• How to find a balance that's cost-effective and practical while testing
• Balancing test coverage and development speed
• The importance of clear test plans and goals
• So many tests: Unit testing, integration testing, acceptance testing, penetration testing, automated vs. manual testing
• Agile vs. Waterfall methodologies
• Writing readable and maintainable tests
• Testing edge cases and unexpected scenarios
• Testing as a form of documentation and communication
• Advice for developers looking to improve testing practices
• Continuous integration and deployment

Links mentioned:

https://smartlogic.io/
Watch this episode on YouTube! youtu.be/u_nx5AIvSdc
Bob Martin “Clean Code” videos - “Uncle Bob”: http://cleancoder.com/
JUnit 5 Testing for Java and the JVM https://junit.org/junit5/
ExUnit Testing for Elixir https://hexdocs.pm/ex_unit/ExUnit.html
Code-Level Testing of Smalltalk Applications https://www.cs.ubc.ca/~murphy/st_workshop/28-7.html
Agile Manifesto https://agilemanifesto.org/
Old Man Yells at Cloud https://i.kym-cdn.com/entries/icons/original/000/019/304/old.jpg
TDD: Test Driven Development https://www.agilealliance.org/glossary/tdd/
Perl Programming Language https://www.perl.org/
Protractor Test Framework for Angular and AngularJS protractortest.org/#/
Waterfall Project Management https://business.adobe.com/blog/basics/waterfall
CodeSync Leveling up at Bleacher Report A cautionary tale - PETER HASTIE
https://www.youtube.com/watch?v=P4SzZCwB8B4
Mix ecto.dump https://hexdocs.pm/ecto_sql/Mix.Tasks.Ecto.Dump.html
Apache JMeter Load Testing in Java https://jmeter.apache.org/
Pentest Tools Collection - Penetration Testing https://github.com/arch3rPro/PentestTools
The Road to 2 Million Websocket Connections in Phoenix https://www.phoenixframework.org/blog/the-road-to-2-million-websocket-connections
Donate to Miami Indians of Indiana https://www.miamiindians.org/take-action
Joel Meador on Tumblr https://joelmeador.tumblr.com/

Special Guests: Charles Suggs and Joel Meador.

For the final episode of Elixir Wizards’ Season 11 “Branching Out from Elixir,” we’re featuring a recent discussion from the Software Unscripted podcast. In this conversation, José Valim, creator of Elixir, interviews Richard Feldman, creator of Roc. They compare notes on the process and considerations for creating a language.

This episode covers the origins of creating a language, its influences, and how goals shape the tradeoffs in programming language design. José and Richard share anecdotes from their experiences guiding the evolution of Elixir and Roc. The discussion provides an insightful look at the experimentation and learning involved in crafting new languages.

Topics discussed in this episode

• What inspires the creation of a new programming language
• Goals and use cases for a programming language
• Influences from Elm, Rust, Haskell, Go, OCaml, and more
• Tradeoffs involved in expressiveness of type systems
• Opportunistic mutation for performance gains in a functional language
• Minimum version selection for dependency resolution
• Build time considerations with type checking and monomorphization
• Design experiments and rolling back features that don’t work out
• History from the first simple interpreter to today's real programming language
• Design considerations around package management and versioning
• Participation in Advent of Code to gain new users and feedback
• Providing performance optimization tools to users in the future
• Tradeoffs involved in picking integer types and arithmetic
• Comparing floats and equality checks on dictionaries
• Using abilities to customize equality for custom types
• Ensuring availability of multiple package versions for incremental upgrades
• Treating major version bumps as separate artifacts
• Roc's focus on single-threaded performance

Links mentioned in this episode

Software Unscripted Podcast https://feeds.resonaterecordings.com/software-unscripted
Roc Programming Language https://www.roc-lang.org/
Roc Lang on Github https://github.com/roc-lang/roc
Elm Programming Language https://elm-lang.org/
Elm in Action by Richard Feldman https://www.manning.com/books/elm-in-action
Richard Feldman on Github https://github.com/rtfeldman
Lua Programming Language https://www.lua.org/
Vimscript Guide https://google.github.io/styleguide/vimscriptfull.xml
OCaml Programming Language https://ocaml.org/
Advent of Code https://adventofcode.com/
Roc Language on Twitter https://twitter.com/roc_lang
Richard Feldman on Twitter https://twitter.com/rtfeldman
Roc Zulip Chat https://roc.zulipchat.com
Clojure Programming Language https://clojure.org/
Talk: Persistent Data Structures and Managed References by Rich Hickey https://www.youtube.com/watch?v=toD45DtVCFM
Koka Programming Language https://koka-lang.github.io/koka/doc/index.html
Flix Programming Language https://flix.dev/
Clojure Transients https://clojure.org/reference/transients
Haskell Software Transactional Memory https://wiki.haskell.org/Software_transactional_memory
Rust Traits https://doc.rust-lang.org/book/ch10-02-traits.html
CoffeeScript https://coffeescript.org/
Cargo Package Management https://doc.rust-lang.org/book/ch01-03-hello-cargo.html
Versioning in Golang https://research.swtch.com/vgo-principles

Special Guests: José Valim and Richard Feldman.

Today on Elixir Wizards, Wojtek Mach of HexPM and Amal Hussein, engineering leader and former NPM team member, join Owen Bickford to compare notes on package management in Elixir vs. JavaScript. This lively conversation covers everything from best practices for dependency management to API design, SemVer (semantic versioning), and the dark ages of web development before package managers existed.

The guests debate philosophical differences between the JavaScript and Elixir communities. They highlight the JavaScript ecosystem's maturity and identify potential areas of improvement, contrasted against Elixir’s emphasis on minimal dependencies. Both guests encourage engineers to publish packages, even small ones, as a learning opportunity.

Topics discussed in this episode:

• Leveraging community packages rather than reinventing the wheel
• Vetting packages carefully before adopting them as dependencies
• Evaluating security, performance, and bundle size when assessing packages
• Managing transitive dependencies pulled in by packages
• Why semantic versioning is difficult to consistently enforce
• Designing APIs with extensibility and backward compatibility in mind
• Using tools like deprecations to avoid breaking changes in new releases
• JavaScript’s preference for code reuse over minimization
• The Elixir community’s minimal dependencies and avoidance of tech debt
• Challenges in early package management, such as global dependency
• Learning from tools like Ruby Gems and Bundler to improve experience
• How log files provide visibility into dependency management actions
• How lock files pin dependency versions for consistency
• Publishing packages democratizes access and provides learning opportunities
• Linting to enforce standards and prevent certain bugs
• Primitive-focused packages provide flexibility over highly opinionated ones
• Suggestions for improving documentation and guides
• Benefits of collaboration between programming language communities

Links mentioned in this episode:

Node.js https://github.com/nodejs
npm JavaScript Package Manager  https://github.com/npm
JS Party Podcast https://changelog.com/jsparty
Dashbit https://dashbit.co/
HexPM Package Manager for Erlang https://hex.pm/
HTTP Client for Elixir https://github.com/wojtekmach/req
Ecto Database-Wrapper for Elixir https://github.com/elixir-ecto (Not an ORM)
XState Actor-Based State Management for JavaScript https://xstate.js.org/docs/
Supply Chain Protection for JavaScript, Python, and Go  https://socket.dev/
MixAudit https://github.com/mirego/mix_audit
NimbleTOTP Library for 2FA https://hexdocs.pm/nimble_totp/NimbleTOTP.html
Microsoft Azure https://github.com/Azure
Patch Package https://www.npmjs.com/package/patch-package
Ruby Bundler to manage Gem dependencies https://github.com/rubygems/bundler
npm-shrinkwrap https://docs.npmjs.com/cli/v10/commands/npm-shrinkwrap
SemVer Semantic Versioner for NPM https://www.npmjs.com/package/semver
Spec-ulation Keynote - Rich Hickey https://www.youtube.com/watch?v=oyLBGkS5ICk
Amal’s favorite Linter https://eslint.org/
Elixir Mint Functional HTTP Client for Elixir https://github.com/elixir-mint
Tailwind Open Source CSS Framework https://tailwindcss.com/
WebauthnComponents https://hex.pm/packages/webauthn_components

Special Guests: Amal Hussein and Wojtek Mach.

Today on Elixir Wizards, Camille Clayton, Director of Women Who Code DC, and Scott Tolinski, Co-Host of the Syntax Podcast and Creator of Level Up Tutorials, join hosts Sundi Myint and Owen Bickford to discuss tech community spaces online and IRL.

They lay out the blueprint and best practices for fostering an inclusive environment where newcomers feel comfortable and welcome to join the discussion – whether it’s an online forum, YouTube comment sections, social media platform, local meetup, or conference.

Topics discussed in this episode:

• Leaving a space open so newcomers feel empowered to join
• Celebrating small wins to maintain excitement and build confidence
• Why consistency is key to building a community with longevity
• Creating and enforcing a code of conduct to define expectations
• Finding respectful resolutions for addressing issues or complaints
• The importance of amplifying underrepresented voices in tech
• Creating content for all skill levels and adapting to a wider audience
• How remote meetups broaden the possibilities for attendance and connection
• Finding the right fit for mentorship
• Delegation to strengthen community members’ sense of ownership
• Navigating the new normal of local, in-person gatherings post-pandemic

Links mentioned in this episode:

https://www.womenwhocode.com/network/dc
https://syntax.fm/
https://levelup.video/
https://devopsdays.org/
https://github.com/sveltejs
https://github.com/womenwhocodedc
https://twitter.com/womenwhocode
https://www.remoteworkcalc.com/
https://twitter.com/WomenWhoCodeDC
https://www.meetup.com/dc-elixir/

Special Guests: Camille Clayton and Scott Tolinski.

In this episode of Elixir Wizards, Xiang Ji and Nathan Hessler join hosts Sundi Myint and Owen Bickford to compare actor model implementation in Elixir, Ruby, and Clojure.

In Elixir, the actor model is core to how the BEAM VM works, with lightweight processes communicating asynchronously via message passing. GenServers provide a common abstraction for building actors, handling messages, and maintaining internal state. In Ruby, the actor model is represented through Ractors, which currently map to OS threads.

They discuss what we can learn by comparing models, understanding tradeoffs between VMs, languages, and concurrency primitives, and how this knowledge can help us choose the best tools for a project.

Topics discussed in this episode:

• Difference between actor model and shared memory concurrency
• Isolation of actor state and communication via message passing
• BEAM VM design for high concurrency via lightweight processes
• GenServers as common abstraction for building stateful actors
• GenServer callbacks for message handling and state updates
• Agents as similar process abstraction to GenServers
• Shared state utilities like ETS for inter-process communication
• Global Interpreter Lock in older Ruby VMs
• Ractors as initial actor implementation in Ruby mapping to threads
• Planned improvements to Ruby concurrency in 3.3
• Akka implementation of actor model on JVM using thread scheduling
• Limitations of shared memory concurrency on JVM
• Project Loom bringing lightweight processes to JVM
• Building GenServer behavior in Ruby using metaprogramming
• CSP model of communication using channels in Clojure
• Differences between BEAM scheduler and thread-based VMs
• Comparing Elixir to academic languages like Haskell
• Remote and theScore are hiring!

Links mentioned in this episode:

theScore is hiring! https://www.thescore.com/
Remote is also hiring! https://remote.com/
Comparing the Actor Model and CSP with Elixir and Clojure Blog Post by Xiang Ji
Comparing the Actor model & CSP concurrency with Elixir & Clojure Xiang Ji at ElixirConf EU 2022
Clojure Programming Language https://clojure.org/
Akka https://akka.io/
Go Programming Language https://github.com/golang/go
Proto Actor for Golang https://proto.actor/
RabbitMQ Open-Source Message Broker Software  https://github.com/rabbitmq
JVM Project Loom https://github.com/openjdk/loom
Ractor for Ruby  https://docs.ruby-lang.org/en/master/ractor_md.html
Seven Concurrency Models in Seven Weeks: When Threads Unravel by Paul Butcher
Seven Languages in Seven Weeks by Bruce A. Tate
GenServer https://hexdocs.pm/elixir/1.12/GenServer.html
ets https://www.erlang.org/doc/man/ets.html
Elixir in Action by Saša Jurić
Redis https://github.com/redis/redis
Designing for Scalability with Erlang/OTP by Francesco Cesarini & Steve Vinoski
Discord Blog: Using Rust to Scale Elixir for 11 Million Concurrent Users
Xiang's website https://xiangji.me/
Feeling Good: The New Mood Therapy by David D. Burns

Special Guests: Nathan Hessler and Xiang Ji.

In this episode of Elixir Wizards, hosts Owen and Dan are joined by René Föhring, creator of Credo for Elixir, and Marc-André LaFortune, head maintainer of the RuboCop AST library for Ruby. They compare static code analysis in Ruby versus Elixir.

The conversation explores the intricacies and challenges inherent in static code analysis across object-oriented and functional programming paradigms, highlighting the unique characteristics of both Ruby and Elixir. Key topics of discussion include the ways these tools can enhance coding styles and empower developers, the delicate balance between providing guidance and enforcing rules, and the evolving future of code analysis in these languages.

Topics discussed in this episode:

• The differences and applications between static and dynamic analysis
• How Credo aims to offer flexible and educational guidance for Elixir developers
• The complexities of method identification in Ruby and its impact on static analysis
• Challenges posed by macros and dynamic code modification during compilation in Elixir
• Reducing false positives in code analysis tools to minimize developer frustration
• Promoting uniform coding practices through analysis tools
• The significance of using analysis tools with clear, specific objectives
• How coding standards can refine and improve coding styles over time
• Building analysis tools and checks through an understanding of Abstract Syntax Trees (ASTs)
• Potential advancements in the analysis of Phoenix templates and HTML in Elixir
• Contrasting approaches to managing code and comments in Elixir and Ruby ASTs
• The fine line between providing helpful guidance and imposing stylistic preferences
• Heuristics in static analysis highlight inconsistencies without mandating style
• The potential for more straightforward pattern matching in ASTs with future updates
• The importance of a gradual implementation of tool updates to maintain backward compatibility
• Creating tools that support and empower developers, rather than hinder them
• How static analysis contributes to cleaner, more maintainable codebases
• Potential future developments in the field of static code analysis
• Practical applications of using linters like Credo and RuboCop in software development

Links mentioned in this episode:

Credo https://github.com/rrrene/credo
https://hexdocs.pm/credo/overview.html
Dogma: A code style linter for Elixir https://github.com/lpil/dogma
https://github.com/rubocop/rubocop
RuboCop's AST extensions and NodePattern functionality https://github.com/rubocop/rubocop-ast
https://github.com/whitequark/parser
https://hex.pm/packages?search=credo&sort=recent_downloads
https://github.com/doorgan/sourceror
https://github.com/rrrene/credo/blob/master/lib/credo/check/readability/large_numbers.ex

Special Guests: Marc-André Lafortune and René Föhring.

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/MRonErlang

Special 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, 2024

Special 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-frameworks

Special 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/@peregrine

Special 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-2023

Special 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, 2023

Special 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/bumblebee

Special 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-ls

Special 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.html

Special 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 Security

Special 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/

Links:

• Spotify

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/jobs

Special 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/jobs

Special 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/jobs

Special 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/jobs

Special 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/survey

Special 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/survey

Special 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/survey

Special 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/witchcrafters

Special Guest: Brooklyn Zelenka.

We are always excited to have conversations about the growth of the Elixir community, and today we go truly global, welcoming Sigu Magwa to the podcast, who hails from Kenya! Sigu is currently traveling in the US and he fills us in on some of the highs and lows of his trip and why he is so excited to get home to his friends and family. From there, we get into some interesting information about Elixir Kenya and the growth of the meetup over the last couple of years. Sigu shares some insight into IoT in his country and what the general tech space is like right now over there, before opening up about his journey into programming and how he found his way into working with Elixir. We also get to talk about his company, Podii, and their first few years working with clients. Apart from all the tech talk, Sigu is kind enough to shed some light on Kenya's matatu buses, and what makes them so unique, a subject that was particularly captivating to our panel! Listeners can also expect to hear about the recent ElixirConf Africa, Sigu's thoughts on hiring young talent, and what he hopes to see in the next decade within the community. So to catch it all, be sure to listen in with us on Elixir Wizards!

Key Points From This Episode:

• Sigu's trip to the US and the sights he has been seeing in different cities.
• Some information from Sigu about the Elixir Kenya meetup and the community there.
• Sigu's experiences with IoT technology in Kenya and its adoption.
  
• The elevator pitch for Sigu's company, Podii, and its roots in training.
  
• Podii's current operation and company size and some of the projects they have worked on thus far.
• The coding language trends in Kenya; Sigu weighs in on what he has noticed.
  
• Sigu's history in the programming space and how he made his way into the world of tech.
  
• How 'matatu' buses operate in Kenya; TVs, celebrity portraits, strobe lights, and high speeds!
  
• The ElixirConf Africa that was hosted this year and Sigu's experience of being involved.
• Sigu's hopes for the Elixir community for the next ten years!
• Approaches for identifying talented young Elixir developers.
• How and where to connect with Sigu online and final remarks from our guest.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Sigu Magwa on LinkedIn — https://www.linkedin.com/in/sigu/?originalSubdomain=ke
Sigu Magwa on Twitter — https://twitter.com/s_igu
Podii — https://podiihq.com/
Nerves — https://www.nerves-project.org/platform.html
ElixirConf Africa — https://elixirconf.africa/
QuadBlockQuiz — http://quadblockquiz.org:4000/
Matatu Bus — https://www.theguardian.com/world/gallery/2018/apr/27/a-minibus-ride-like-no-other-nairobis-matatu-culture-in-pictures
Hire Junior Engineers — https://smartlogic.io/blog/hire-junior-engineers/
Teach Yourself Computer Science — https://teachyourselfcs.com/
Structure and Interpretation of Computer Programs — https://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
Elixir Wizards Discord — https://discord.com/invite/JGcqSaYf2a

Special Guest: Sigu Magwa.

Brooklin Myers is on a quest to change the perception that Elixir is difficult to get into and we are so grateful to have him as a guest on the show today. Aside from being a passionate programmer, Brooklin spends a lot of his time trying to encourage new members in the Elixir community through his Twitter account and podcast called Elixir Newbies. In this episode, we talk to Brooklin about his relationship with Elixir and its broader community, why he loves the space so much and, and why he wants to help it grow. We cover his journey into programming and how he got involved with Elixir specifically. He talks about the features of the language that he loves most and how learning Surface has allowed him to use Elixir in the same way he used to use React. Our conversation also ventures onto the subject of Dungeons and Dragons, another passion of Brooklin’s, and he tells us how learning programming is the closest he has come to fulfilling his dream of being a wizard!

Key Points From This Episode:

• Region-specific spelling and our peeves about words we easily misspell.
• Brooklin’s background in React and how Surface has helped him use Elixir in a similar way.
• Structure and testing: Why Brooklin loves Elixir and how it compares to JavaScript.
• How Brooklin got into programming and left his job selling computers.
• What led Brooklin to discover Elixir and how he realized its true potential.
• The aspect of problem-solving and continuous growth Brooklin loves about programming.
• Brooklin’s desire to help others learn and why he started the Elixir Newbie podcast.
• How to get over perfectionism: the value of remembering it is okay to fail.
• Sundi and Brooklin’s approach to taking notes and turning them into posts or tweets.
• How Brooklin handles his writing, podcasting, and other work by time-blocking.
• Brooklin’s love of Dungeons and Dragons and the improvisation of being the DM.
• Why Brooklin loves fantasy and how programming is the closest thing to real-world magic.
• The impacts of Elixir on Brooklin and how supportive the community has been to him.
• Whether Brooklin feels that learning Elixir has changed the way he codes.
• Aspects of Elixir that can improve regarding ease of access to the community.
• Final shoutouts from Brooklin and where to connect with him online.

Links Mentioned in Today’s Episode:

Brooklin Myers on Twitter — https://twitter.com/brooklinjmyers
Elixir Newbie — https://www.elixirnewbie.com/
Elixir Newbie Podcast — https://podtail.com/en/podcast/elixir-newbie/
Lost Mines of Phandelver – https://www.dicebreaker.com/games/dungeons-and-dragons-5e/deal/lost-mines-of-phandelver-adventure-free
Kealy Doyle — https://www.linkedin.com/in/kealy-doyle/
Jono Stiansen — https://twitter.com/JonoCodes
Matthew Baker — https://www.linkedin.com/in/mcbii/
Anton’s Pasta Bar — https://antonspastabar.com/
Keith Eats Everything — https://www.youtube.com/playlist?list=PL9qQXSjI-WOppp4B9x5bgsBS3993KAX2e
Surface — https://hexdocs.pm/surface/Surface.html
SmartLogic — https://smartlogic.io/

Special Guest: Brooklin Myers.

It is important to us that the Elixir community keeps thriving, and one of the best ways to ensure this is by lowering the barrier to entry as much as possible. Livebook is helping to achieve this aim, and today we are lucky enough to be joined by its developer, Jonatan Kłosko. Jonatan is a young prodigy because while he is still at college, he is working closely with José Valim at Dashbit, and he can solve a Rubik’s cube in under five seconds! After hearing about his college thesis on evolutionary algorithms using Numerical Elixir, we jump into the story of how he met José and started building Livebook. He explains that Livebook is a web application for writing interactive and collaborative code notebooks for Elixir and we hear about the many features he is building into it. From there, Jonatan describes what he loves about Elixir, and we discuss how learning functional programming changes the way we code. Tuning in, you’ll also hear about a bunch of features that make Elixir so great, how its downsides are mostly solved by its extensibility, and some of Jonatan’s other hobbies that help him keep balance in his life. Be sure to sip on some Elixir with us today!

Key Points From This Episode:

• Jonatan speaks about “speedcubing”: his hobby of quickly solving Rubik’s cubes.
• How Jonatan got into programming and where he is at in his CS degree.
• Discussing Jonatan’s Bachelor’s thesis project on evolutionary algorithms in Elixir.
• How evolutionary algorithms are a style of solving optimization problems biologically.
• Building the project using the Erlang distribution and the Numerical Elixir library.
• How Jonatan started working on the Livebook project with Dashbit.
• Thoughts on how Jonatan broke into the Elixir community and how others can do the same.
• Livebook: a code notebook application with collaborative and sequential evaluation features.
• The IEx session abilities of Livebook and how impressed Sundi was when she discovered them.
• The different use cases for Livebook and the direction Jonatan wants to take the app in.
• Jonatan’s process of learning Elixir at college and the application he built for a project.
• The pair programming features of Livebook and how to use them.
• How well-positioned Jonatan is to learn Elixir and what he loves about the language.
• The functional programming style and how it affects how people write code after learning it.
• Downsides of Elixir around immutability and typing and Jonatan’s feelings toward this.
• How Elixir is making an impact on the programming community through being user-friendly.
• Jonatan talks about his other hobbies and how he finds balance in his life.
• Hopes for the future of Elixir, resources for learning, and how to get involved in the community.
• How amazing the pipe operator is and the huge advantage it gives Elixir over JavaScript.
• Final plugs from Jonatan and how best to reach out to him online.

Links Mentioned in Today’s Episode:

Jonatan Kłosko — https://jonatanklosko.com/
Jonatan Kłosko on GitHub — https://github.com/jonatanklosko
Speedcubing — https://www.rubiks.com/en-us/speed-cubing
Erlang Ecosystem Foundation Slack — https://erlef.org/slack-invite/erlef
Numerical Elixir — https://github.com/elixir-nx
LiveView — https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html
Phoenix LiveView — https://github.com/phoenixframework/phoenix_live_view
Dashbit — https://dashbit.co/
Haskell — https://www.haskell.org/
React — https://reactjs.org/
Elixir — https://elixir-lang.org/
José Valim — https://twitter.com/josevalim
Livebook — https://dashbit.co/blog/announcing-livebook
SmartLogic — https://smartlogic.io/

Special Guest: Jonatan Kłosko.

Today on the show we are grateful to get the chance to speak with Yiming Chen from Tubi, where we hear all about how he likes to use Elixir and the contributions he has made to the community. We begin as always with Yiming's journey into programming and how he got into Elixir through his early interest in Ruby. From there, we talk about the magic of Protocols, hearing about an awesome project Yiming built using them and how this lead him to build a testing framework called Promox. In this section, we also get into how Protocols enable polymorphic logic, why they are useful for defining shared interfaces explicitly, and the differences between Promox and Mox. Our conversation today covers some general advantages of writing code in Elixir, and we explore how it has influenced Yiming’s style of programming, its efficiency thanks to concurrency, and its usefulness for building maintainable applications. Wrapping up, we hear Yiming’s thoughts about the nascent Elixir community in China and all the future possibilities for this magical language.

Key Points From This Episode:

• How Yiming got into programming by building websites using WYSIWYG tools as a child.
• Yiming’s experiences using Ruby and how that led him to learn Elixir.
• People Yiming knows that are using Elixir for personal projects and some highlights of these.
• Yiming’s project where he used Protocols to transfer files from one cloud provider to another.
• How Yiming’s Protocol project led him to create a testing framework called Promox.
• Protocols versus behaviors and how Promox differs from Mox.
• A basic description of how Protocols enable polymorphic logic in Elixir.
• Why Protocols are so useful for defining shared interfaces explicitly.
• The thing that makes Protocols in Elixir specifically attractive.
• Sundi’s talk on Mox and her thoughts on the pros and cons of using it.
• How Yiming got into using Mox through Ruby and his thoughts on it.
• The advantages of using Elixir over Ruby relating to concurrency and testing.
• Networking and software developer jobs after remote work.
• How Yiming’s ElixirConf talk went and the positive feedback he received.
• Yiming’s feelings about Test Driven Development and how closely he follows it.
• Learning Lisp in college and Yiming’s earlier experiences with functional programming.
• How small the Elixir scene in China is and thoughts about how it should grow.
• The benefits of Elixir for building maintainable applications and more.
• How Elixir has changed the way the Yiming programs.
• A model for building websites in Elixir with HTTP requests as functions.
• Final plugs from Yiming about the need for developers at Tubi!

Links Mentioned in Today’s Episode:

Yiming Chen on Twitter — https://twitter.com/dsdshcym?lang=en
tubi.tv — https://tubitv.com/
Quinn Wilton — https://twitter.com/wilton_quinn
Promox — https://giters.com/dsdshcym/promox
Sundi Myint: Stunt Doubles | Testing with Mox, Elixir Conf 2021 — https://youtu.be/qMScnpGhu4E
Yiming Chen - Promox: Roles, Protocols, and Mocks — https://youtu.be/Df81LbdRd0A
‘Mocks and explicit contracts’ — https://dashbit.co/blog/mocks-and-explicit-contracts
Programming Phoenix — https://www.amazon.com/Programming-Phoenix-Productive-Reliable-Fast/dp/1680501453
Why Elixir Matters A Genealogy of Functional Programming - OsaGaius — https://youtu.be/X2u0bBqhRKE
SmartLogic — https://smartlogic.io/

Special Guest: Yiming Chen.

Today we are joined by programmer, professor, educator, and podcaster, Adolfo Neto! We have a fascinating conversation that continues our exploration of the theme of the impact of Elixir, hearing from Adolfo about his early attraction to computers and computer science, the decision to study the subject, and how this led to a life in education and academia. We also talk about growing up in Brazil and how geography influenced his career trajectory, before getting into some of the main outlets that Adolfo uses to share information on functional programming. He also comments on what he loves about Elixir, why learning it can improve any programmer's skills, and much more. One of Adolfo's main goals with his podcasts and YouTube channel is the diversification of the computer science field, and to bring the subject to a wider audience that may not always consider it an option to pursue. Towards the end of our chat, our guest shares some thoughts on useful resources to check out, and his desire to help the Elixir community to continue to grow!

Key Points From This Episode:

• Opening remarks and rants from Adolfo regarding Livebook!
• Adolfo's route into teaching and how he became a university professor.
• Information on Adolfo's Ph.D. program which he completed at the University of São Paulo.
• The initial impetus to study computer science; what drew Adolfo to the field.
• Adolfo's YouTube channels and the subjects he covers for his audience.
  
• The course that Adolfo offers on Elixir to students all over the world!
• How Adolfo found and learned about functional programming.
• Adolfo's thoughts on the benefits of different functional programming languages.
• The main goals that Adolfo has for his functional programming classes.
• Adolfo's own forays into podcasting, and what drew him to the medium!
• Experiences in the South; Adolfo's early days studying the US.
• Recommended resources for learning Elixir; the books and sites that Adolfo uses.
• Adolfo's hopes for Elixir to keep growing and why he prefers functional programming.
• How to connect with Adolfo online and make use of some of his amazing content!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Adolfo Neto on Twitter — https://twitter.com/adolfont
Adolfo Neto on YouTube — https://www.youtube.com/c/AdolfoNeto
Livebook — https://livebook.dev/#install
Fly.io — https://fly.io/
BASIC — https://en.wikipedia.org/wiki/BASIC
ML (programming language) — https://en.wikipedia.org/wiki/ML_(programming_language)
Emílias on Twitter — https://twitter.com/emilias_utfpr
Elixir em Foco on Twitter — https://twitter.com/elixiremfoco
Seven Languages in Seven Weeks — https://www.amazon.com/Seven-Languages-Weeks-Programming-Programmers/dp/193435659X
Clojure — https://clojure.org/
Laurie Williams — https://collaboration.csc.ncsu.edu/laurie/
Saša Jurić — https://www.theerlangelist.com/
Brujo Benavides on LinkedIn — https://www.linkedin.com/in/elbrujohalcon?originalSubdomain=es
Elixir School — https://elixirschool.com/en/
Exercism Elixir Track — https://exercism.org/tracks/elixir
Exercism Erlang Track — https://exercism.org/tracks/erlang

Special Guest: Adolfo Neto.

As we continue this season of the podcast, focusing on the impact of Elixir, we are joined by Florian Kraft, all the way from Berlin, Germany! Florian works as a software engineer at Contentful, and has a number of exciting open-source projects that he is currently involved with. In our fun conversation with Florian, we get to hear about the events that led up to him becoming interested in computers and working with software, and why he maintains a light-hearted attitude when talking about his expertise. We also get to hear from our guest about his thoughts on a few other languages, and why learning new languages is a great way to constantly improve your work in the languages you already know! Florian talks about what drew him to Elixir and the community and also shares some of his reflections from this year's virtual Elixir Wizards conference. Towards the end of our chat, Florian tells us about his work with AdoptOSS and Mimicry, which you can currently find on GitHub, both of which we are quite excited about! So to hear it all from Florian and our usual suspects, be sure to listen in!

Key Points From This Episode:

• Florian's interesting route into the world of software engineering.
• How Florian views his experiences and skills as a software engineer.
• Florian's thoughts on Haskell and some of the best resources for learning about it.
• The languages that Florian uses in his work at Contentful.
• Experiences entering into the Elixir community and the colleague who introduced him to the language!
• Life in Germany and Berlin; thoughts on the seasons, and the general culture.
• Florian's experiences at this year's Elixir Wizards conference; warming to virtual events.
• Staying active in the Elixir community and Florian's honest confessions about the time he puts in.
• Features that Florian misses and wishes for when working in Elixir.
• Immutability and pattern matching: Florian's favorite parts of Elixir!
• Some of the open-source Elixir projects that Florian is currently working on.
• The video games that Florian has most enjoyed recently and some of his all-time favorites!
  
• Where to find and connect with Florian and his exciting projects!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Florian Kraft — github.com/FlorianK
Contentful — https://www.contentful.com/
Exercism — https://exercism.org/
Adoptoposs — https://adoptoposs.org
Adoptoposs Github — https://github.com/adoptoposs/adoptoposs
Mimicry — https://github.com/mimicry-tech/mimicry
Learn You a Haskell for Great Good — https://www.amazon.com/Learn-You-Haskell-Great-Good/dp/1593272839
Haskell — https://www.haskell.org/
Prolog — https://www.cpp.edu/~jrfisher/www/prolog_tutorial/pt_framer.html
Learn You Some Erlang for Great Good — https://www.amazon.com/Learn-Some-Erlang-Great-Good/dp/1593274351
Elixir in Action, Second Edition — https://www.manning.com/books/elixir-in-action-second-edition
Gleam — https://gleam.run/
Autobutler — https://autobutler.co.uk
Squid Game — https://www.rottentomatoes.com/tv/squid_game
Oktoberfest — https://www.imdb.com/title/tt10244612/
Toucan — https://www.toucan.events/
The Binding of Isaac — https://store.steampowered.com/app/113200/The_Binding_of_Isaac/
Zelda — https://www.zelda.com/
Doom — https://bethesda.net/en/game/doom
Defragmenting C Drive — http://hultbergs.org/defrag/

Special Guest: Florian Kraft.

Today’s guest is Angel Jose, a Software Engineer Manager at Cars.com with a passion for product and the customer experience. Angel played a key role in completely re-platforming Cars.com via Elixir, Phoenix, and other open source tooling, and his former adventures in the blockchain space include working with ETH, EOS, and general distributed tooling. In today’s episode, we discuss Cars.com's decision to migrate to an entirely Elixir-based system, rebuilding the data model from scratch, redesigning all of the user interfaces, and what that meant for the team that Angel was tasked with leading, as well as how the Elixir system functions at such incredible scale, with Cars.com receiving more than a million visitors daily! We touch on Angel’s approach to onboarding new engineers, how Elixir impacts this process, and the broader impact Elixir has on the community as a whole, as well as what he hopes to see from the community in the future, so make sure not to miss this awesome conversation about adopting Elixir with Angel Jose!

Key Points From This Episode:

• Hot takes, rants, and obsessions: Angel’s best and worst taco experiences.
• Why Angel won’t be at ElixirConf 2021 and the story of how he began programming in Elixir.
• The process of finding a job in software engineering after completing an online bootcamp.
• Angel’s experience of navigating the freedom that comes with being an engineer.
• Find out how Angel got involved in re-platforming Cars.com, one of the original dot coms.
• Get a glimpse into the make up of the engineering team at Cars.com.
• How the pandemic impacted not only Angel’s deadlines but the car industry as a whole.
• The ETL pipeline of different data points that makes up Cars.com and Auto.com.
• Angel shares his opinion of LiveView and what he has learned about using it at scale.
• Advice for those adopting new technology: make sure there are enough resources out there.
• Where Angel believes his team would be without Elixir and what they are looking forward to.
• Some of the tangible benefits Cars.com has seen from flipping the switch to Elixir.
• How Angel approaches onboarding new engineers by providing them with resources and integrating learning into their day-to-day.
• The importance of celebrating small wins and fostering feelings of accomplishment.
• Angel on how Elixir impacts onboarding and new engineers; more simplicity, less magic.
• How Elixir has impacted the programming community and what Angel hopes to see in future.
• Taco happy hour, conference food, making the most of each meal, remote work, and more!
• What Angel has learned from working remotely, particularly from a social perspective.
• Angel shares his dream car after working at Cars.com and moving to Colorado.

Links Mentioned in Today’s Episode:

Angel Jose on LinkedIn — https://www.linkedin.com/in/ajose01/
Angel Jose on Twitter — https://twitter.com/ajose01
Cars.com — https://www.cars.com/
Cars.com Careers — https://www.cars.com/careers/
Elixir Conf — https://2021.elixirconf.com/
Elixir Slack — https://elixir-slackin.herokuapp.com/
General Assembly — https://generalassemb.ly/
SmartLogic — https://smartlogic.io/

Special Guest: Angel Jose.

As we kick off our new, seventh season of the Elixir Wizards podcast, we wanted to introduce our theme of the impact of Elixir by having a simple chat between our panel and foregoing our usual guest format. As fans of podcasts ourselves, we always like to get to know some of the personalities behind the voices, so we decided to take this opportunity to do just that, with Alex, Sundi, and Eric! So to hear a little about what to expect in the coming weeks of the show, what the teams have been up to recently, both professionally and beyond, and to just enjoy a quick hangout with some friendly voices, make sure you tune into this launchisode!

Key Points From This Episode:

• What our team has been up to recently: new projects, the apprentice program, and more.
• Reflections on this iteration of the apprentice program and differences from 2018.
  
• The recent ElixirConf and how our panel was involved in the event.
• Inside information that is shared at conferences and learning about the world!
• Avoiding the pressure to always do more while engaging in the community.
• Noting the impact that Elixir has had on each of us, and how we write code respectively.
• Proactive learning and career growth; looking forward to the new season exploring these subjects!
• Staying focused on what's important, getting rest, and pursuing passions.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Aino — https://github.com/oestrich/aino
Aino Read Me — https://ainoweb.dev/readme.html
King Tooth — https://www.instagram.com/kingtooth_pug/
SmartLogic Apprenticeship Program — https://smartlogic.io/about/community/apprentice/
SmartLogic Welcomes Two New Developer Apprentices to the Team! — https://smartlogic.io/blog/2021apprentices/
Elixir Conf — https://2021.elixirconf.com/
Culttt — https://www.culttt.com/
Shrek — https://www.rottentomatoes.com/m/shrek
Kangaroo Jack — https://www.rottentomatoes.com/m/kangaroo_jack
Korn — https://www.kornofficial.com/
Flutter — https://flutter.dev/docs/resources/books
Lonestar Elixir — https://lonestarelixir.com/

We have reached the final episode of our season, and as we wrap up our exploration of BEAM magic, we are joined by Amos King, whose tweet was the inspiration behind this season's focus! We've had such a great time this season and hope that our listeners have enjoyed it as much as we have, and gained something in the process. Our conversation with Amos jumps around from exploring his experiences during the last year and a half, to the journey he has been on with his company, Binary Noggin, life as a CEO, and much more! We delve into some thoughts from our guest about the relationship between magic and understanding and also talk a little about this year's upcoming ElixirConf, where Amos will be speaking. Amos also shares how learning a new language can help the coding you do in languages you already know, and tells an interesting story about how he turned a long commute into a superpower! So stay tuned for Season 7, coming to you soon, and thank you for sticking with us this long!

Key Points From This Episode:

• Looking forward to this year's ElixirConf and the hope that it will proceed.
• Amos' return to the office after three months of working from home.
• A little about Binary Noggin and the different size clients they work with.
• The inspiration behind the company name and the transition from side work to a full-time gig.
• Amos' experiences as a CEO during the pandemic and the surprising growth at Binary Noggin.
• How Amos inspired the BEAM Magic theme for this season and his thoughts on understanding.
• Amos' experiences of speaking at conferences and the possibility of presenting about magic.
  
• Some details on Amos' talk this year at ElixirConf.
• How Amos was introduced to Elixir through Erlang and the things that made him love it!
• The impact that learning new languages can have on your work in general.
• How an extremely long commute early in Amos' career served him in unexpected ways.

Links Mentioned in Today’s Episode:

SmartLogic Jobs — https://smartlogic.io/about/jobs
Amos King on Twitter — https://twitter.com/adkron
Binary Noggin — https://binarynoggin.com/
Binary Noggin Careers — https://binarynoggin.com/about-us/#careers
Binary Noggin Email — [email protected]
DirtyInformation — http://dirtyinformation.com/
Elixir Outlaws — https://elixiroutlaws.com/
Wallaby — https://github.com/elixir-wallaby/wallaby
Testing Elixir — https://www.goodreads.com/book/show/54156353-testing-elixir

Special Guest: Amos King.

This episode serves as a round-up of some of the special mini-features we have recorded throughout Season 6, where we'll hear from Tyler Clemens, Elom Amouzou, Elise Navarro, and Jeremy Neal about their work and experiences with Elixir. Our first segment is with Tyler, who is a software developer at Jackpocket, where he explains what he is currently busy with and how the company is offering access to the lottery in more safe and convenient ways. We then move on to Elom, who talks about transitioning from a life in public education, and what prompted him to learn functional programming. Elise, who works at Zingeroo, takes us through her relatively new career, why she is so excited about Elixir, and the interesting work that is being done at her company to educate the public about the stock market. Lastly, Jeremy talks to us about the socially conscious agenda at Clover Food Lab, his personal interests in cooking and baking, and how he came to work with Elixir. All of our guests share helpful resources for learning, and reflections on their time working within Elixir - make sure to join us to catch all this good stuff!

Key Points From This Episode:

• Tyler's path into software engineering and the first language he learned.
• What Jackpocket offers its customers and how Elixir is used within the company.
• Tyler's thoughts on the perks and challenges associated with engineering with Elixir.
  
• The most helpful resources that Tyler uses when in need: Elixir Slack, books, and Elixir School!
• Onboarding and training in Elixir and the biggest challenges presented in this area.
• Tyler's passion for photography and imagining an alternative career path in this direction.
• Elom's first programming language and the subsequent transition into Elixir.
• How Elom moved into working in programming from his roots in education.
• Elom's perspective on the positives associated with adopting Elixir early on.
• Resource recommendations from Elom for early-stage developers.
• Considering the pros and cons of the small intimate Elixir community and its future.
• Elom's ideal alternative career path and favorite book!
• Elise's beginnings in programming and her move from a career in digital media.
• Comparing Elixir with other languages; Elise weighs in with her experiences.
• What Zingeroo does and how they use Elixir to make the stock market more accessible through the app.
• The benefits of using Elixir for a real-time app like Zingeroo.
• The resources that have been most valuable to Elise since joining the community.
• Elise's alternative career path, and her passion for teaching Pilates.
  
• Jeremy's educational and professional path into software engineering and working with Elixir.
• How Jeremy has been using LiveView in his work to get a functional UI up and running.
• What Clover Food Lab does and how Elixir is used at the company and online store.
• Jeremy's thoughts on a different career and why he would love to be a baker!

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Tyler Clemens — https://www.linkedin.com/in/tylerclemens
Jackpocket — https://jackpocket.com/
Elixir in Action — https://www.goodreads.com/book/show/38732242-elixir-in-action
Elixir School — https://elixirschool.com/
Turing School — https://turing.edu/
Pragmatic Bookshelf — https://pragprog.com/
Code Flow Thinking Elixir — https://thinkingelixir.com/available-courses/code-flow/
Frantz Fanon — https://www.britannica.com/biography/Frantz-Fanon
Peau Noire, Masques Blancs — https://www.amazon.com/Peau-Noire-Masques-Blancs-French/dp/2020006014
Elise Navarro — https://www.linkedin.com/in/elise-navarro
Zingeroo — https://zingeroo.com/
Jeremy Neal — https://www.linkedin.com/in/jeremy-neal-59ba8b82
Clover Food Lab — https://www.cloverfoodlab.com/

Special Guests: Elise Navarro, Jeremy Neal, and Tyler Clemens.

Joining us on the show today is Quinn Wilton, and we have a wonderful conversation with our guest about her journey with Elixir, unusual path into programming, and her wide appreciation for different languages! We start off looking at the time Quinn spent at Waterloo University and what separates the Canadian ethos around computer science. From there, we turn to Quinn's early work in programming, the first proper job that she stepped into, and the immediate affinity she felt for working in Elixir. We also talk a bit about the interesting research that Quinn has been conducting privately, tracking and plotting the path of Erlang over the decades, while also reflecting on the skill of academic reading. We spend some necessary time hearing from Quinn about the BEAM and what BEAM magic means to her, before hearing about her website, love of Twitter, other languages that currently have her excited, and the avenues she is most lit up about exploring in the future! Listen in to hear it all, as we continue this journey!

Key Points From This Episode:

• Quinn's reflections on her education in Canada, and differences to the American approach to computer science.
• Reasons that Quinn wanted to pursue a career in programming
  
• The first jobs that Quinn landed as a programmer; creating a Roblox game and tracking malware.
• How Quinn was introduced to Elixir and the immediate love she felt for the language.
• The recent work that Quinn has been busy with researching and tracing the history of Erlang.
• Experiences of reading academic papers and what sets it apart from other formats.
• The inspiration behind Quinn's website and her affinity for Twitter's format.
• Quinn's favorite characteristics of the BEAM: the debugging possibilities.
• The project that Quinn worked on using Gleam on the BEAM and her enjoyment of its simplicity.
• Some possible areas, outlined by Joe Armstrong, that Quinn is excited to explore in the near future.
• Quinn's huge appreciation for different programming languages and her fascination with Strand.
• Encouragement from Quinn to dive into reading intimidating research papers.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/jobs
Quinn Wilton — https://quinnwilton.com/
Quinn Wilton on Twitter — https://twitter.com/wilton_quinn
Quinn Wilton on GitHub — https://github.com/QuinnWilton
University of Waterloo — https://uwaterloo.ca/
Roblox — https://www.roblox.com/
Lookout — https://www.lookout.com/
Clint Gibler — https://clintgibler.com/
Gleam — https://gleam.run/
Joe Armstrong — https://www.theguardian.com/education/2019/may/08/joe-armstrong-obituary
'Getting Erlang to talk to the outside world' — https://www.researchgate.net/publication/2549678_Getting_Erlang_to_talk_to_the_outside_world
Universal Binary Format — https://github.com/ubf/ubf
CLU — https://en.wikipedia.org/wiki/CLU_(programming_language)
Strand — https://en.wikipedia.org/wiki/Strand_(programming_language)

Special Guest: Quinn Wilton.

While NIFs provide a great way to interface with native code in the BEAM machine, the process can also be rather error-prone. Thankfully, since Isaac Yonemoto built Zigler, things have become a lot simpler, and he joins us today to talk about how. Isaac is an Elixir developer with a background in biotech and we kick off the discussion by hearing about his journey into programming and some of the ways that he has combined it with science. From there we hear more about the different languages Isaac has worked in and why he fell in love with Elixir, where he talks about its encouragement of test-driven development and how this has made him a better programmer. We dive right into the contributions Isaac is making to the Elixir community next, and he starts off by talking about Zigler. He explains how Zigler provides a bridge between Zig and Elixir that makes it far easier to build NIFs. We hear a bunch of the other cool possibilities that Zigler offers to Elixir as well, including its ability to make debugging easier by appending the Zig stack trace to the Elixir one. After hearing Isaac’s opinion of magic in Elixir, we close today's show off with a few of the other projects he is working on, contributions that are bound to make the world of Elixir even more exciting!

Key Points From This Episode:

• Isaac’s early exposure to programming and how he got started in tech.
• The education Isaac had in the sciences and his experience in the biotech sphere.
• Difficulties with installing Ruby and how this led to Isaac learning Elixir.
• Support for asynchronous testing and the reasons why Isaac finds joy in Elixir.
• The emphasis on test-driven development in Elixir and how this has made Isaac a better programmer.
• Isaac’s experiences with Zig and the similarities between it and Elixir.
• How NIFs allow C code in Elixir and what it is like debugging them.
• Isaac’s Zigler project and how it provides integration between Elixir and Zig making it easy to build NIFs.
• Cross-compiling C using Zig and why Isaac built a disassembler.
• Aspects of the BEAM that make it harder to write NIFs in Elixir than in Julia.
• Isaac’s opinion of magic in programming and how it should always be comprehensible.
• Final plugs from Isaac: where to find Zigler, and some upcoming projects.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Isaac Yonemoto on Twitter — https://twitter.com/DNAutics
Isaac Yonemoto on GitHub — https://github.com/ityonemo
Isaac Yonemoto on YouTube — https://www.youtube.com/channel/UCarZZW7eavljSdGRQx9kkSA
Selectrix — https://github.com/ityonemo/selectrix
Mavis — https://github.com/ityonemo/mavis
Chiaroscuro - https://github.com/ityonemo/chiaroscuro
Zigler - https://hexdocs.pm/zigler/Zig.html
Zigler on GitHub — https://github.com/ityonemo/zigler
Julia — https://julialang.org/
Testing Elixir with Jeffrey Matthias and Andrea Leopardi — https://smartlogic.io/podcast/elixir-wizards/s6e6-matthias-leopardi/

Special Guest: Isaac Yonemoto.

Today we are so excited to share a conversation with Maxim Fedorov, who is the Core Infrastructure Lead at communications giant, WhatsApp! In our chat, Maxim offers such interesting insight and wisdom from a long career in the space, focusing on Erlang and why he views it as such a powerful language for the work at WhatsApp. We also get some backstory from Maxim, looking at his first experiences with computers, his educational background, and some of the work he did leading up to his current position. Our guest does a great job of sharing his thoughts on what he sees as a lack of magic within the Erlang language, why he prefers this, and how the company has managed to scale in such a major way over the past years. We also deal with some more general questions, weighing functional languages against object-oriented ones, useful resource recommendations, and a whole lot more! We finish off this episode with a mini-interview with David Hardwick, who is the current Vice President of Engineering at STORD, so make sure to stay tuned until the end for that!

Key Points From This Episode:

• The beginnings of Maxim's interest in computer science and software development.
• How Maxim transitioned into the network security field.
• Maxim's experience with timezones and how this is approached for an app like WhatsApp.
• Thoughts on why WhatsApp is so popular outside of the United States.
• How Erlang is used at WhatsApp to power messaging.
• Probable reasons that Erlang was selected as the language for WhatsApp.
• Outages and downtime; what constitutes a serious issue for WhatsApp user experience.
• The massive growth that WhatsApp has seen and how their approach to scaling has evolved.
• Characteristics of Erlang that make it so well suited to WhatsApp's needs; simplicity and reliability.
• Maxim's perspective on the issues around programmer education and their results.
  
• Functional languages versus object-oriented programming; Maxim's thoughts on strengths and weaknesses.
• Why Maxim views Erlang as not containing or performing anything magical.
• Maxim's recommendations for resources when getting started in Erlang!
• Looking back at Maxim's experiences of tertiary education and the thesis he produced.
• The scaling of the WhatsApp server; the project that Maxim is most proud of!
• Maxim's love for motorcycles and bicycles and how these grew out of initial conveniences.
  
• Today's mini-feature interview with David Hardwick, VP of Engineering at STORD.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Maxim Fedorov: https://au.linkedin.com/in/maxim-fedorov-14a570b
Electronika MK-61 — https://en.wikipedia.org/wiki/Elektronika_MK-52
Brian Acton — https://www.forbes.com/profile/brian-acton/
Learn You Some Erlang — https://learnyousomeerlang.com/
Adopting Erlang — https://github.com/adoptingerlang
Joe Armstrong Thesis — https://erlang.org/download/armstrong_thesis_2003.pdf
The BEAM Book— https://github.com/happi/theBeamBook
ejabberd — https://www.ejabberd.im/
Will Cathcart Tweet — https://twitter.com/wcathcart/status/1385253969522413568
Clarke's three laws — https://en.wikipedia.org/wiki/Clarke%27s_three_laws
Lukas Larson — https://twitter.com/garazdawi
Erlang OTP — https://github.com/erlang/otp/blob/master/lib/kernel/src/pg.erl
David Hardwick — https://www.linkedin.com/in/davidhardwick
STORD — https://www.stord.com/
BetterCloud — http://www.bettercloud.com/

Special Guest: Maxim Fedorov.

Some of you may recognize Chelsea Troy from her popular blog of the same name or as a keynote speaker for the March 2021 Code BEAM conference. Chelsea is an instructor in the Master's Program in Computer Science at the University of Chicago and currently works as a staff software engineer at Mozilla, where she specializes in machine learning and backend systems. In our conversation with Chelsea, we discuss some of the unique aspects of coding as a career. Chelsea outlines how programming can be more accessible than other careers because it doesn't have the same financial burden when it comes to education. She also emphasizes the importance of allowing a more diverse range of people access to the field and unpacks the type of person the internet was originally built for, explaining how it had favored privileged affluent individuals from the Bay Area. We hear from Chelsea about how she became a programmer out of a desire for job security rather than passion and why she believes it’s so important to have a broader representation of different narratives when it comes to careers in programming and coding. Later Chelsea shares the story of how she became an educator and why she is so passionate about teaching. For all this and much more, join us today!

Key Points From This Episode:

• Introducing today’s guest Chelsea Troy
• Why Chelsea believes it’s important to privilege multiple narratives of why people choose to pursue programming as a career.
• There is less of a financial burden with becoming a programmer than other higher-paying professions.
• The benefits of a diverse group of people having access to programming as a career.
• What first prompted Chelsea to start her blog and how her goals for it have changed over time.
• Why Chelsea struggles to give advice on how to market a blog.
• How being able to draw parallels between different coding languages has strengthened Chelsea’s teaching and writing pursuits.
• Why Chelsea is so enthusiastic about teaching.
• How teaching allows Chelsea to have a more meaningful impact in the field of tech.
• How Chelsea prioritizes which jobs and clients to pursue as a consultant.
• How having two parents who taught for living influenced Chelsea’s passion for teaching.
• Chelsea shares how she earned her position at Chicago University, despite expecting not to.
• The challenges and benefits of teaching remotely.
• The pros and cons of functional languages versus object-oriented languages.
• How students tend to react to learning functional languages versus object-oriented languages.
• Mini-feature segment: hear from Rosemary about how she became a software engineer.
• How Rosemary built websites as a side hustle while studying English.
• Rosemary shares how she transitioned from working with Java and Blu-ray discs to doing back-end web development and writing in Elixir.
• How RentPath, the company Rosemary is currently working for, is transitioning from Ruby to Elixir.
• An outline of RentPath and what they do.
• Rosemary’s many hobbies and pursuits, including wildlife photography.

Links Mentioned in Today’s Episode:

Chelsea Troy on Twitter — https://twitter.com/HeyChelseaTroy
Chelsea Troy on LinkedIn — https://www.linkedin.com/in/chelseatroy/
Chelsea Troy Blog — https://chelseatroy.com/
Upcoming Code BEAM Conferences — https://codesync.global/
Chelsea Troy on Youtube — https://www.youtube.com/channel/UCIwpdjmSUJmqJ8HwvIGNqig
Ruby — https://www.ruby-lang.org/en/
Mozilla — mozilla.org/en-US/
Pocket — https://getpocket.com/
Rosemary Ledesma — https://www.linkedin.com/in/rosemary-ledesma-b6198717/
RentPath — https://www.rentpath.com/
RedFin — https://www.redfin.com/

Special Guest: Chelsea Troy.

While we can think of many reasons why we love Elixir, the community could always benefit from a more lively conversation around testing. It was with this in mind that Jeffrey Matthias and Andrea Leopardi decided to write Testing Elixir, and today they join us on the show to share some of the insights to be found in their new book. Our guests start by sketching out the main reasons why they decided to write a book of this nature before speaking to the process of writing it collaboratively from their respective homes in Italy and the US. Andrea and Jeffrey speak about the challenges of finding a middle ground between their unique styles to come up with a unified testing method. The conversation then takes a deep dive into the weeds of testing in Elixir and we hear our guests' perspectives on the most appropriate situations to use async true, Mox, Ecto Sandbox, and other techniques. We wrap up our interview with a question about what Andrea and Jeffrey would most like people to take away from their book where they express the hope that it can act as a springboard for further conversation about best practices for testing in Elixir and more. As always, we close the show off with our mini-interview, this time talking to Tracey Onim from Podii.

Key Points From This Episode:

• Why Jeffrey and Andrea wrote their book and how they pitched it to the publisher.
• How the feedback Andrea and Jeffrey got while writing the book shaped its content.
• What writing the book was like considering its authors live in different countries.
• How our guests came up with a unified testing method when each had their own style.
• Stories about testing mistakes and the funny situations they led to.
• Discussing the HBO integration test email and how it was responded to and dealt with.
• The issue of developers not using async true enough and how to get better at it.
• When to use async true, Ecto Sandbox, and Mox.
• Why our guests use Mox, when the best times to use it are, and how it shapes your thinking.
• Exploring the relationship between test driven development and using the program.
• What can go wrong if you rely purely on tests to test out your code.
• The main takeaways our guests hope can be found in their book.
• Final plugs from Jeffrey and Andrea and where to find them online.
• A quick interview where we learn more about Tracey Onim from Podii.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Jeffrey Matthias on Twitter — https://twitter.com/idlehands
Andrea Leopardi — https://andrealeopardi.com/
Andrea Leopardi on Twitter — https://twitter.com/whatyouhide
Andrea Leopardi on GitHub — https://github.com/whatyouhide/corsica
Testing Elixir — http://testingelixir.com/
Testing Elixir — https://pragprog.com/titles/lmelixir/testing-elixir/
Testing Elixir — https://www.target.com/p/testing-elixir-by-andrea-leopardi-jeffrey-matthias-paperback/-/A-83072057#lnk=sametab
Testing Elixir on Twitter — https://twitter.com/testingelixir
Publish with The Pragmatic Bookshelf — https://pragprog.com/become-an-author/
Ecto.Adapters.SQL.Sandbox — https://hexdocs.pm/ecto_sql/Ecto.Adapters.SQL.Sandbox.html
Mox — https://hexdocs.pm/mox/Mox.html
Command Line Options — https://hexdocs.pm/mix/1.12/Mix.Tasks.Test.html#module-command-line-options
Mocks and Explicit Contracts — http://blog.plataformatec.com.br/2015/10/mocks-and-explicit-contracts/
bypass — https://github.com/PSPDFKit-labs/bypass
Test-Driven Development with Phoenix — https://www.tddphoenix.com/
Tracey Onim — https://www.linkedin.com/in/tracey-onim-420b3316a?originalSubdomain=ke
Podii — https://www.apollo.io/companies/Podii/5c1df0e8f651257261ddc16a?chart=count

Special Guests: Andrea Leopardi and Jeffrey Matthias.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guest: Chris Miller.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guests: Parker Selbert and Shannon Selbert.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guests: Erik Person and Stephanie Vizzi.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guest: Robert Virding.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

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

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guest: Jenn Gamble.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guest: John Mertens.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guest: Sophie DeBenedetto.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

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

Special Guests: Shaun Robinson and Toran Billups.

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

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

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

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guest: Brian Howenstein.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guest: Yair Flicker.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guest: Alexandra Chakeres.

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

Key Points From This Episode:

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

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

Special Guests: Jake Heinz and Matt Nowack.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guest: Jason Axelson.

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guest: Steve Domin.

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

Key Points From This Episode:

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