To give you the best possible experience, this site uses cookies. Review our Privacy Policy and Terms of Service to learn more. Got it!
Artwork

Web Development Software Development Elixir Elixirlang Phoenix Webdev SmartLogic LLC Tech Podcasting Education Web App Mobile App JavaScript Ruby On Rails Programming Code Java
Player FM - Internet Radio Done Right

79 subscribers

Web Development

Checked 5M ago
Added six years ago
Content provided by SmartLogic LLC. All podcast content including episodes, graphics, and podcast descriptions are uploaded and provided directly by SmartLogic LLC or their podcast platform partner. If you believe someone is using your copyrighted work without your permission, you can follow the process outlined here https://ppacc.player.fm/legal.

Similar to Elixir Wizards

Player FM - Podcast App
Go offline with the Player FM app!
Get it on App Store Get it on Google Play
icon Daily Deals

Elixir Wizards »
Building an Open Vehicle Control System using Elixir and Nerves with Marc, Thibault, and Loïc

54:19
 
Play
Playing
Share
 

MP3•Episode home

Fetch error

Hmmm there seems to be a problem fetching this series right now. Last successful fetch was on December 26, 2024 11:48 (5M ago)

What now? This series will be checked again in the next day. If you believe it should be working, please verify the publisher's feed link below is valid and includes actual episode links. You can contact support to request the feed be immediately fetched.

Manage episode 457594426 series 2493466
Content provided by SmartLogic LLC. All podcast content including episodes, graphics, and podcast descriptions are uploaded and provided directly by SmartLogic LLC or their podcast platform partner. If you believe someone is using your copyrighted work without your permission, you can follow the process outlined here https://ppacc.player.fm/legal.

For the Season 13 finale, Elixir Wizards Dan and Charles are joined by Spin42 Engineers Marc Lainez, Thibault Poncelet, and Loïc Vigneron to discuss their work retrofitting a 2007 VW Polo and creating an Open Vehicle Control System (OVCS). Using Elixir, Nerves, and Raspberry Pis, the team is reimagining vehicle technology to extend the lifespan of older cars and reduce waste—all while making the process approachable and open source.

The Spin42 team shares the technical details behind OVCS and how they use Elixir and Nerves to interact with the CAN bus and build a Vehicle Management System (VMS) to coordinate various vehicle components. They dive into the challenges of reverse engineering CAN messages, designing a distributed architecture with Elixir processes, and ensuring safety with fail-safe modes and emergency shutoffs.

Beyond the technical, the team discusses their motivation for the project—upgrading older vehicles with modern features to keep them on the road, building an open-source platform to share their findings with others, and above all-- to just have fun. They explore potential applications for OVCS in boats, construction equipment, and other vehicles, while reflecting on the hurdles of certifying the system for road use.

If you’ve ever wondered how Elixir and Nerves can drive innovation beyond software, this episode is packed with insights into automotive computing, hardware development, and the collaborative potential of open-source projects.

Topics Discussed in this Episode:

  • Retrofitting a 2007 VW Polo with electric engines and modern tech
  • Building an open-source Vehicle Control System (OVCS) using Elixir and Nerves
  • Leveraging Elixir to interact with the CAN bus and parse proprietary messages
  • Designing a Vehicle Management System (VMS) to coordinate vehicle components
  • Developing custom hardware for CAN communication
  • Creating a YAML-based DSL for CAN message and frame descriptions
  • Building a distributed architecture using Elixir processes
  • Ensuring safety with fail-safe modes and emergency shutoffs
  • Using Flutter and Nerves to build a custom infotainment system
  • Exploring autonomous driving features with a ROS2 bridge
  • Developing remote control functionality with a Mavlink transmitter
  • Testing OVCS features at scale with a Traxxas RC car (OVCS Mini)
  • Challenges of certifying OVCS for road use and meeting regulatory requirements
  • Encouraging community contributions to expand OVCS functionality
  • Balancing open-source projects with contract work to sustain development
  • The fun and fulfillment of experimenting with Elixir beyond traditional applications

Links mentioned:

https://www.spin42.com/
https://nerves-project.org/
Quadcopter https://github.com/Spin42/elicopter
https://github.com/linux-can/can-utils
https://docs.kernel.org/networking/can.html
https://github.com/open-vehicle-control-system/cantastic
https://github.com/commaai/opendbc
https://en.wikipedia.org/wiki/CAN_bus#CAN_FD
https://comma.ai/
https://en.wikipedia.org/wiki/CAN_FD
https://webkit.org/wpe/
https://docs.nvidia.com/jetson/archives/r35.4.1/DeveloperGuide/text/SD/WindowingSystems/WestonWayland.html
https://buildroot.org/
https://vuejs.org/
https://flutter.dev/
https://github.com/smartrent/elixir_flutter_embedder
https://www.raspberrypi.com/products/raspberry-pi-5/
The Rabbit Pickup https://www.hemmings.com/stories/value-guide-1980-83-volkswagen-pickup
https://www.expresslrs.org/software/mavlink
https://industrial-training-master.readthedocs.io/en/melodic/_source/session7/ROS1-ROS2-bridge.html
https://github.com/ros2/rcl
https://github.com/open-vehicle-control-system/traxxas
Contact Marc, Thibault, and Loïc: info@spin42.com

Special Guests: Loïc Vigneron, Marc Lainez, and Thibault Poncelet.

…   continue reading

190 episodes

#Web Development #Software Development #Elixir #Elixirlang #Phoenix #Webdev #SmartLogic LLC #Tech #Podcasting Education #Web App #Mobile App #JavaScript #Ruby On Rails #Programming #Code #Java
Artwork

Building an Open Vehicle Control System using Elixir and Nerves with Marc, Thibault, and Loïc

Elixir Wizards

79 subscribers

published

Play Playing
iconShare
 
MP3•Episode home

Fetch error

Hmmm there seems to be a problem fetching this series right now. Last successful fetch was on December 26, 2024 11:48 (5M ago)

What now? This series will be checked again in the next day. If you believe it should be working, please verify the publisher's feed link below is valid and includes actual episode links. You can contact support to request the feed be immediately fetched.

Manage episode 457594426 series 2493466
Content provided by SmartLogic LLC. All podcast content including episodes, graphics, and podcast descriptions are uploaded and provided directly by SmartLogic LLC or their podcast platform partner. If you believe someone is using your copyrighted work without your permission, you can follow the process outlined here https://ppacc.player.fm/legal.

For the Season 13 finale, Elixir Wizards Dan and Charles are joined by Spin42 Engineers Marc Lainez, Thibault Poncelet, and Loïc Vigneron to discuss their work retrofitting a 2007 VW Polo and creating an Open Vehicle Control System (OVCS). Using Elixir, Nerves, and Raspberry Pis, the team is reimagining vehicle technology to extend the lifespan of older cars and reduce waste—all while making the process approachable and open source.

The Spin42 team shares the technical details behind OVCS and how they use Elixir and Nerves to interact with the CAN bus and build a Vehicle Management System (VMS) to coordinate various vehicle components. They dive into the challenges of reverse engineering CAN messages, designing a distributed architecture with Elixir processes, and ensuring safety with fail-safe modes and emergency shutoffs.

Beyond the technical, the team discusses their motivation for the project—upgrading older vehicles with modern features to keep them on the road, building an open-source platform to share their findings with others, and above all-- to just have fun. They explore potential applications for OVCS in boats, construction equipment, and other vehicles, while reflecting on the hurdles of certifying the system for road use.

If you’ve ever wondered how Elixir and Nerves can drive innovation beyond software, this episode is packed with insights into automotive computing, hardware development, and the collaborative potential of open-source projects.

Topics Discussed in this Episode:

  • Retrofitting a 2007 VW Polo with electric engines and modern tech
  • Building an open-source Vehicle Control System (OVCS) using Elixir and Nerves
  • Leveraging Elixir to interact with the CAN bus and parse proprietary messages
  • Designing a Vehicle Management System (VMS) to coordinate vehicle components
  • Developing custom hardware for CAN communication
  • Creating a YAML-based DSL for CAN message and frame descriptions
  • Building a distributed architecture using Elixir processes
  • Ensuring safety with fail-safe modes and emergency shutoffs
  • Using Flutter and Nerves to build a custom infotainment system
  • Exploring autonomous driving features with a ROS2 bridge
  • Developing remote control functionality with a Mavlink transmitter
  • Testing OVCS features at scale with a Traxxas RC car (OVCS Mini)
  • Challenges of certifying OVCS for road use and meeting regulatory requirements
  • Encouraging community contributions to expand OVCS functionality
  • Balancing open-source projects with contract work to sustain development
  • The fun and fulfillment of experimenting with Elixir beyond traditional applications

Links mentioned:

https://www.spin42.com/
https://nerves-project.org/
Quadcopter https://github.com/Spin42/elicopter
https://github.com/linux-can/can-utils
https://docs.kernel.org/networking/can.html
https://github.com/open-vehicle-control-system/cantastic
https://github.com/commaai/opendbc
https://en.wikipedia.org/wiki/CAN_bus#CAN_FD
https://comma.ai/
https://en.wikipedia.org/wiki/CAN_FD
https://webkit.org/wpe/
https://docs.nvidia.com/jetson/archives/r35.4.1/DeveloperGuide/text/SD/WindowingSystems/WestonWayland.html
https://buildroot.org/
https://vuejs.org/
https://flutter.dev/
https://github.com/smartrent/elixir_flutter_embedder
https://www.raspberrypi.com/products/raspberry-pi-5/
The Rabbit Pickup https://www.hemmings.com/stories/value-guide-1980-83-volkswagen-pickup
https://www.expresslrs.org/software/mavlink
https://industrial-training-master.readthedocs.io/en/melodic/_source/session7/ROS1-ROS2-bridge.html
https://github.com/ros2/rcl
https://github.com/open-vehicle-control-system/traxxas
Contact Marc, Thibault, and Loïc: info@spin42.com

Special Guests: Loïc Vigneron, Marc Lainez, and Thibault Poncelet.

…   continue reading

190 episodes

#Web Development #Software Development #Elixir #Elixirlang #Phoenix #Webdev #SmartLogic LLC #Tech #Podcasting Education #Web App #Mobile App #JavaScript #Ruby On Rails #Programming #Code #Java

All episodes

×
 
Artwork

1
Building an Open Vehicle Control System using Elixir and Nerves with Marc, Thibault, and Loïc 54:19

icon
54:19
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
54:19icon
 
For the Season 13 finale, Elixir Wizards Dan and Charles are joined by Spin42 Engineers Marc Lainez, Thibault Poncelet, and Loïc Vigneron to discuss their work retrofitting a 2007 VW Polo and creating an Open Vehicle Control System (OVCS). Using Elixir, Nerves, and Raspberry Pis, the team is reimagining vehicle technology to extend the lifespan of older cars and reduce waste—all while making the process approachable and open source. The Spin42 team shares the technical details behind OVCS and how they use Elixir and Nerves to interact with the CAN bus and build a Vehicle Management System (VMS) to coordinate various vehicle components. They dive into the challenges of reverse engineering CAN messages, designing a distributed architecture with Elixir processes, and ensuring safety with fail-safe modes and emergency shutoffs. Beyond the technical, the team discusses their motivation for the project—upgrading older vehicles with modern features to keep them on the road, building an open-source platform to share their findings with others, and above all-- to just have fun. They explore potential applications for OVCS in boats, construction equipment, and other vehicles, while reflecting on the hurdles of certifying the system for road use. If you’ve ever wondered how Elixir and Nerves can drive innovation beyond software, this episode is packed with insights into automotive computing, hardware development, and the collaborative potential of open-source projects. Topics Discussed in this Episode: Retrofitting a 2007 VW Polo with electric engines and modern tech Building an open-source Vehicle Control System (OVCS) using Elixir and Nerves Leveraging Elixir to interact with the CAN bus and parse proprietary messages Designing a Vehicle Management System (VMS) to coordinate vehicle components Developing custom hardware for CAN communication Creating a YAML-based DSL for CAN message and frame descriptions Building a distributed architecture using Elixir processes Ensuring safety with fail-safe modes and emergency shutoffs Using Flutter and Nerves to build a custom infotainment system Exploring autonomous driving features with a ROS2 bridge Developing remote control functionality with a Mavlink transmitter Testing OVCS features at scale with a Traxxas RC car (OVCS Mini) Challenges of certifying OVCS for road use and meeting regulatory requirements Encouraging community contributions to expand OVCS functionality Balancing open-source projects with contract work to sustain development The fun and fulfillment of experimenting with Elixir beyond traditional applications Links mentioned: https://www.spin42.com/ https://nerves-project.org/ Quadcopter https://github.com/Spin42/elicopter https://github.com/linux-can/can-utils https://docs.kernel.org/networking/can.html https://github.com/open-vehicle-control-system/cantastic https://github.com/commaai/opendbc https://en.wikipedia.org/wiki/CAN_bus#CAN_FD https://comma.ai/ https://en.wikipedia.org/wiki/CAN_FD https://webkit.org/wpe/ https://docs.nvidia.com/jetson/archives/r35.4.1/DeveloperGuide/text/SD/WindowingSystems/WestonWayland.html https://buildroot.org/ https://vuejs.org/ https://flutter.dev/ https://github.com/smartrent/elixir_flutter_embedder https://www.raspberrypi.com/products/raspberry-pi-5/ The Rabbit Pickup https://www.hemmings.com/stories/value-guide-1980-83-volkswagen-pickup https://www.expresslrs.org/software/mavlink https://industrial-training-master.readthedocs.io/en/melodic/_source/session7/ROS1-ROS2-bridge.html https://github.com/ros2/rcl https://github.com/open-vehicle-control-system/traxxas Contact Marc, Thibault, and Loïc: info@spin42.com Special Guests: Loïc Vigneron, Marc Lainez, and Thibault Poncelet.…
 
Artwork

1
Creating Horizon: Deploy Elixir Phoenix Apps on FreeBSD with Jim Freeze 44:48

icon
44:48
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
44:48icon
 
The Elixir Wizards welcome Jim Freeze, organizer of ElixirConf and creator of the Horizon library. Jim shares his journey from organizing Ruby conferences to founding and growing ElixirConf into the community cornerstone it is today. He reflects on the challenges of running a major conference, how COVID-19 shaped the event, and why the talks remain an evergreen resource for the Elixir ecosystem. We discuss Horizon, Jim’s deployment library for Elixir and Phoenix applications with Postgres on FreeBSD. Driven by a need for simplicity and cost-effectiveness, Jim explains how Horizon minimizes external dependencies while delivering fault-tolerant and streamlined setups. He compares it to tools like Fly, Terraform, and Ansible, highlighting its low cognitive load and flexibility—key benefits for developers seeking more control over their deployment environments. Jim also unpacks the broader value of understanding and customizing your deployment stack rather than relying solely on managed services. He discusses the benefits of using FreeBSD, including its stability, security, and performance advantages, as well as its robust ZFS file system. Jim emphasizes the importance of coherent deployment workflows, community collaboration, and contributions to open-source projects like Horizon. He invites listeners to explore Horizon, share feedback, and own their deployments. Topics discussed in this episode: Jim Freeze’s background organizing RubyConf and founding ElixirConf Reducing reliance on managed services and external dependencies Simplifying deployments with minimal tools and lower cognitive overhead The trade-offs of cutting-edge tools vs. stable, well-documented solutions The importance of customizing deployment tools to meet specific needs Addressing challenges with Tailwind compatibility Streamlining the FreeBSD installation process for Horizon users Community collaboration: contributing to open-source tools Jim’s vision for Horizon: PKI support, hot standby features, and serverless potential Links mentioned Nine Minutes of Elixir https://www.youtube.com/@ElixirConf https://github.com/liveview-native https://github.com/elixir-nx/nx https://2024.elixirconf.com/ https://github.com/jfreeze/horizon https://hexdocs.pm/horizon/deploying-with-horizon.html#web-cluster-topology https://kamal-deploy.org/ https://fly.io/ https://aws.amazon.com/console/ https://www.digitalocean.com/ https://cloud.google.com/ https://www.cloudflare.com/ https://www.hetzner.com/ https://www.proxmox.com/en/ https://nginx.org/ https://github.com/openzfs/zfs Zettabyte File System https://en.wikipedia.org/wiki/ZFS https://www.postgresql.org/ https://www.terraform.io/ https://www.ansible.com/ https://docs.freebsd.org/ https://www.redhat.com/ https://ubuntu.com/ https://esbuild.github.io/ Listener's Survey: https://smr.tl/EWS13 Special Guest: Jim Freeze.…
 
Artwork

1
Telemetry & Observability for Elixir Apps at Cars.com with Zack Kayser & Ethan Gunderson 42:39

icon
42:39
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
42:39icon
 
Zack Kayser and Ethan Gunderson, Software Engineers at Cars Commerce, join the Elixir Wizards to share their expertise on telemetry and observability in large-scale systems. Drawing from their experience at Cars.com—a platform handling high traffic and concurrent users—they discuss the technical and organizational challenges of scaling applications, managing microservices, and implementing effective observability practices. The conversation highlights the pivotal role observability plays in diagnosing incidents, anticipating system behavior, and asking unplanned questions of a system. Zack and Ethan explore tracing, spans, and the unique challenges introduced by LiveView deployments and WebSocket connections. They also discuss the benefits of OpenTelemetry as a vendor-agnostic instrumentation tool, the significance of Elixir’s telemetry library, and practical steps for developers starting their observability journey. Additionally, Zack and Ethan introduce their upcoming book, Instrumenting Elixir Applications, which will offer guidance on integrating telemetry and tracing into Elixir projects. Topics Discussed: Cars.com’s transition to Elixir and scaling solutions The role of observability in large-scale systems Uncovering insights by asking unplanned system questions Managing high-traffic and concurrent users with Elixir Diagnosing incidents and preventing recurrence using telemetry Balancing data collection with storage constraints Sampling strategies for large data volumes Tracing and spans in observability LiveView’s influence on deployments and WebSocket behavior Mitigating downstream effects of socket reconnections Contextual debugging for system behavior insights Observability strategies for small vs. large-scale apps OpenTelemetry for vendor-agnostic instrumentation Leveraging OpenTelemetry contrib libraries for easy setup Elixir’s telemetry library as an ecosystem cornerstone Tracing as the first step in observability Differentiating observability from business analytics Profiling with OpenTelemetry Erlang project tools The value of profiling for performance insights Making observability tools accessible and impactful for developers Links Mentioned https://www.carscommerce.inc/ https://www.cars.com/ https://hexdocs.pm/telemetry/readme.html https://kubernetes.io/ https://github.com/ninenines/cowboy https://hexdocs.pm/bandit/Bandit.html https://hexdocs.pm/broadway/Broadway.html https://hexdocs.pm/oban/Oban.html https://www.dynatrace.com/ https://www.jaegertracing.io/ https://newrelic.com/ https://www.datadoghq.com/ https://www.honeycomb.io/ https://fly.io/phoenix-files/how-phoenix-liveview-form-auto-recovery-works/ https://www.elastic.co/ https://opentelemetry.io/ https://opentelemetry.io/docs/languages/erlang/ https://opentelemetry.io/docs/concepts/signals/traces/ https://opentelemetry.io/docs/specs/otel/logs/ https://github.com/runfinch/finch https://hexdocs.pm/telemetry_metrics/Telemetry.Metrics.html https://opentelemetry.io/blog/2024/state-profiling https://www.instrumentingelixir.com/ https://prometheus.io/ https://www.datadoghq.com/dg/monitor/ts/statsd/ https://x.com/kayserzl https://github.com/zkayser https://bsky.app/profile/ethangunderson.com https://github.com/open-telemetry/opentelemetry-collector-contrib Special Guests: Ethan Gunderson and Zack Kayser.…
 
Artwork

1
Scaling the Daylite Apple-Native CRM Using Elixir with AJ 52:21

icon
52:21
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
52:21icon
 
AJ (Alykhan Jetha), CEO and CTO of Marketcircle, joins the Elixir Wizards to share his experience building and evolving Daylite, their award-winning CRM and business productivity app for Apple users. He details his experiences as a self-taught programmer and how Marketcircle has navigated pivots, challenges, and opportunities since its founding in 1999. AJ explains why they migrated Daylite’s backend to Elixir, focusing on their sync engine, which demands high concurrency and fault tolerance. He highlights how Elixir has improved performance, reduced cloud costs, and simplified development with its approachable syntax and productive workflows. The conversation also touches on the technical hurdles of deploying native apps for Apple devices and the potential for integrating new technologies like LiveView Native to streamline cross-platform development. For technical founders, AJ emphasizes the importance of leveraging your strengths (“superpowers”), staying deeply connected to the development process, and finding stability in tools like Elixir amidst a rapidly evolving tech ecosystem. He also shares Marketcircle’s roadmap for migrating more customers to Elixir-powered systems and explores the potential for new features in their native apps. Tune in for insights on building resilient systems, navigating technical and business challenges, and how Elixir is shaping Marketcircle’s future. Topics discussed in this episode: AJ’s journey as a self-taught programmer and entrepreneur Marketcircle’s evolution since 1999 and lessons from their pivots Daylite’s growth as a flagship product for Apple users Migrating to Elixir for high concurrency and fault tolerance How Elixir improved performance and reduced cloud costs The simplicity of Elixir and its impact on developer onboarding Challenges in managing a growing microservices architecture Insights into deploying native apps for the Apple ecosystem Exploring LiveView Native for future cross-platform development Advice for technical founders: leveraging your superpowers Staying connected to development to maintain system understanding The role of Elixir in improving development efficiency and stability Planning gradual customer migrations to an Elixir-powered backend Potential new features for Daylite’s native apps Benefits of collaboration with the Elixir community #ElixirMullet -- native app in the front, Elixir in the back Navigating a rapidly evolving tech ecosystem as a founder Leveraging Elixir to future-proof Marketcircle’s systems Balancing technical and business priorities in a startup environment AJ’s thoughts on the future of Elixir in powering business tools Links mentioned: https://www.marketcircle.com/ Daylite.app https://www.nextcomputers.org/ https://www.digitalocean.com/ Python Async https://docs.python.org/3/library/asyncio.html https://github.com/sinatra/sinatra https://github.com/dependabot https://kafka.apache.org/ https://www.djangoproject.com/ https://github.com/socketry/falcon https://github.com/puma/puma https://www.swift.org/blog/announcing-swift-6/ https://en.wikipedia.org/wiki/Async/await https://www.ffmpeg.org/ https://www.sqlite.org/ https://github.com/commanded/commanded https://pragprog.com/titles/khpes/real-world-event-sourcing/ https://en.wikipedia.org/wiki/Ship_of_Theseus https://reactnative.dev/ https://www.electronjs.org/ https://en.wikipedia.org/wiki/WebOS https://www.linkedin.com/in/alykhanjetha/ https://bsky.app/profile/ajetha.bsky.social Special Guest: Alykhan Jetha.…
 
Artwork

1
Creating the Castmagic AI-Powered Content Workflow Platform with Justin Tormey 35:40

icon
35:40
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
35:40icon
 
Justin Tormey, co-founder of Castmagic, joins the Elixir Wizards to discuss building an AI-powered content creation app. Castmagic repurposes audio and video into social media posts, blog articles, newsletters, and more. The tech stack leverages OpenAI and Anthropic LLMs with Elixir as the coordination layer and Phoenix LiveView powering the front end. Justin dives into the technical details of Castmagic, including the integration of JavaScript libraries like ProseMirror and TipTap through LiveSvelte, as well as enabling real-time collaboration with CRDTs and YDoc. He shares the benefits and challenges of using Elixir for rapid development, as well as the trade-offs between custom code and off-the-shelf solutions. The conversation also covers Justin’s entrepreneurial journey, highlighting the advantages of bootstrapping over venture capital, the importance of acquiring early customers, and creative marketing strategies like affiliate programs and software marketplaces. Whether you're an Elixirist exploring machine learning or an aspiring tech founder, tune in to learn more about AI with Elixir, navigating startup challenges, and turning ideas into impactful software. Topics discussed in this episode: Building Castmagic to generate content from audio and video for creators Using AI services like OpenAI and Anthropic for transcription and workflows Elixir as the coordination layer for complex processes Rapid UI development with Phoenix LiveView Integrating rich text editing libraries through LiveSvelte Enabling collaborative editing with CRDTs and YDoc Balancing offline functionality with cloud-based AI tools Challenges of working with external AI services Exploring the future of multimodal AI in product development Bootstrapping vs. venture capital: benefits and challenges Strategies for finding distribution channels and early adopters Creative approaches to marketing, including affiliates and marketplaces Balancing engineering efforts with customer and business needs Practical advice for navigating the early stages of a startup Links mentioned: https://www.castmagic.io/ https://pragprog.com/titles/jaerlang2/programming-erlang-2nd-edition/ https://www.blockchain.com/ https://fly.io/ https://hexdocs.pm/live_svelte/readme.html https://github.com/woutdp/live_svelte https://prosemirror.net/ https://tiptap.dev/ https://docs.yjs.dev/api/y.doc https://hexdocs.pm/polymorphic_embed/readme.html https://github.com/elixir-nx/nx https://github.com/elixir-nx/tokenizers https://github.com/thmsmlr/instructor_ex https://openai.com/ https://www.anthropic.com/ https://getoban.pro/ https://github.com/wojtekmach/req https://ollama.com/ https://x.com/j_tormey Special Guest: Justin Tormey.…
 
Artwork

1
Creating the Standd AI-Native Due Diligence Platform with Stephen Solka 48:44

icon
48:44
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
48:44icon
 
Stephen Solka, CTO and co-founder of Standd.io, joins Elixir Wizards Owen and Charles to share the journey of building an AI-native deal intelligence and due diligence platform. Designed to streamline document analysis and text generation for venture capital firms, Standd.io leverages large language models and AI tools to address key customer pain points in document workflows. Stephen explains how Elixir and Phoenix LiveView enabled rapid UI iteration and seamless integration between the front-end and back-end. The conversation also explores the human side of startup life. Stephen reflects on balancing tech debt with customer demands, the value of accelerators in building networks and securing funding, and the challenges of pricing in early-stage startups. He emphasizes the importance of validating ideas with potential customers and learning from the hurdles of growing a business. Tune in for insights on leveraging AI in Elixir, solving real-world problems, and navigating the journey from concept to company. Topics discussed in this episode: The journey from self-taught programmer to CTO The perks of Phoenix LiveView for rapid UI development Integrating front-end and back-end technologies AI tools for code generation How early adopters balance functionality with product polish Validating ideas and understanding customer needs The impact of accelerators on networking and fundraising Approaches to managing pricing strategies for startups Balancing technical debt with feature development The role of telemetry and error reporting in product development Creating collaborative and supportive tech communities Educating users on AI’s capabilities and limitations The broader implications of AI tools across industries Links Mentioned Contact Stephen & Julie at Standd: founders@standd.io https://www.standd.io/ https://www.digitalocean.com/community/tutorials/gangs-of-four-gof-design-patterns https://www.thriftbooks.com/w/code-complete_steve-mcconnell/248753/item/15057346/ https://aws.amazon.com/sagemaker/ https://www.anthropic.com/ https://getoban.pro/ https://kubernetes.io/ https://www.apollographql.com/ https://aws.amazon.com/startups/accelerators https://accelerate.techstars.com/ https://aider.chat/ https://github.com/Aider-AI/aider https://neovim.io/ https://ui.shadcn.com/ https://tailwindui.com/ https://www.ycombinator.com/ https://www.thriftbooks.com/w/close-to-the-machine-technophilia-and-its-discontents_ellen-ullman/392556 Special Guest: Stephen Solka.…
 
Artwork

1
Creating the WebAuthn Components Library for Phoenix LiveView Apps with Owen Bickford 57:32

icon
57:32
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
57:32icon
 
Today on Elixir Wizards, Owen Bickford, fellow Wizard and creator of the WebauthnComponents library, joins us to talk about building passwordless authentication for Phoenix LiveView applications. Owen walks us through the evolution of authentication—touching on everything from plain text passwords to multi-factor setups—and explains the security flaws and user experience issues each method presents. He describes passkeys, a solution based on the WebAuthn API, which improves security and ease of use. The conversation covers cross-device support for passkeys, the role of password managers in keeping credentials synced, and ideas for enhancing WebauthnComponents, like supporting multiple passkeys per account. Owen invites listeners to contribute to the library’s development on GitHub and emphasizes the role passkeys play in improving app security and user experience. Topics discussed in this episode: Passkeys and the shift toward passwordless authentication WebAuthn API and its role in secure login systems Creating the WebauthnComponents library for Phoenix LiveView History of authentication from basic passwords to multi-factor approaches Security gaps and user experience challenges with traditional methods Asymmetric cryptography’s impact on secure logins Hardware-based credential storage and generation with Trusted Platform Modules Structure and components of the WebAuthn library: dependencies, LiveViews, and Ecto schemas Live components for real-time server-browser interactions Passkeys as a primary or secondary authentication method Key business considerations when choosing authentication methods Cross-device support for passkeys and credential syncing Strategies for passkey recovery if devices are lost Ensuring secure access in unattended environments Elixir’s ecosystem advantages for building authentication systems Simplifying JavaScript complexity within Elixir projects Future-proofing WebAuthn Components for seamless updates Using Igniter to enhance customization and refactoring Developer-friendly tools for secure authentication Inviting community contributions on GitHub and the Elixir forum Plans for telemetry and performance tracking Why adopting passkeys is a win for app security and user experience Links mentioned: https://github.com/liveshowy/webauthn_components https://en.wikipedia.org/wiki/Salt_(cryptography) https://en.wikipedia.org/wiki/Rainbow_table https://en.wikipedia.org/wiki/Multi-factor_authentication https://oauth.net/2/ https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API https://www.w3.org/TR/webauthn-3/ https://www.microsoft.com/en-us/windows/tips/windows-hello https://trustedcomputinggroup.org/resource/trusted-platform-module-tpm-summary/ https://hexdocs.pm/phoenix/mix_phx_gen_auth.html https://en.wikipedia.org/wiki/Public-key_cryptography SSH Protocol (Secure Shell) https://en.wikipedia.org/wiki/Secure_Shell https://www.yubico.com/products/yubikey-5-overview/ https://fidoalliance.org/how-fido-works/ https://1password.com/ https://keepassxc.org/ https://hexdocs.pm/ecto_ulid/Ecto.ULID.html https://en.wikipedia.org/wiki/Universally_unique_identifier https://hexdocs.pm/ecto/Ecto.Schema.html https://hexdocs.pm/sourceror/ https://github.com/ash-project/igniter Forum thread: https://elixirforum.com/t/webauthnlivecomponent-passwordless-auth-for-liveview-apps/49941…
 
Artwork

1
Creating a Terrestrial Telescope using Nerves & LiveView with Lucas Sifoni 49:56

icon
49:56
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
49:56icon
 
Today on Elixir Wizards, indie developer Lucas Sifoni shares his experience prototyping a remote-controlled terrestrial telescope using Elixir, Nerves, Rust, and various hardware components. Lucas explains the basic components of a telescope, the challenges he faced during the development process, and the benefits of using Elixir and Nerves for hardware projects. Lucas emphasizes the importance of simulating hardware components and testing assumptions before working with physical devices, as well as the value of literate programming and executable blog posts for documenting and sharing the process. Lucas encourages listeners to explore Nerves and build their own hardware projects. He also gives a shout-out to the Nerves core team for their incredible work. Topics discussed in this episode: Challenges in optimizing wiring and PCB design for the prototype Benefits of Elixir and Nerves for hardware projects Communicating with Arduinos using serial connections and pattern matching Leveraging binary pattern matching and construction in Elixir for hardware Balancing educational value and real-world usability Learning CID software and parametric design for 3D printing components Growing interest in Nerves and hardware projects within the Elixir community Simulating hardware components and testing assumptions before physical implementation Literate programming and executable blog posts for documenting hardware projects Using Elixir's interoperability with Rust for performance-critical tasks Elixir's low fragmentation and high-quality libraries for various domains Potential for using Livebook in hardware projects, with some limitations Encouraging listeners to explore Nerves and build their own hardware projects Links mentioned https://lucassifoni.info/ https://www.rust-lang.org/ https://go.dev/ https://lisp-lang.org/ https://ubuntu.com/ https://hexdocs.pm/iex/IEx.html https://nerves-project.org/ https://lucassifoni.info/blog/prototyping-elixir-telescope-code-beam/ https://github.com/Lucassifoni/oiseaux https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html https://www.raspberrypi.com/ https://mangopi.org/ https://store.arduino.cc/products/arduino-nano https://elixir-circuits.github.io/ https://www.erlang.org/doc/apps/runtime_tools/scheduler.html Binary pattern matching in Elixir with PNG parsing example https://zohaib.me/binary-pattern-matching-in-elixir/ Lucas’ Code Beam Talk: https://www.youtube.com/watch?v=q7bleFzA11c https://github.com/membraneframework-labs https://github.com/talklittle/ffmpex https://studio.blender.org/training/3d-printing/ https://www.autodesk.com/products/fusion-360/personal https://en.wikipedia.org/wiki/Parametric_design https://www.exem.fr/ https://www.kikk.be/exhibitions/collectif-lab212-nicolas-guichard-beatrice-lartigue/ https://livebook.dev/ https://github.com/elixir-nx/bumblebee https://github.com/rusterlium/rustlerhttps://www.youtube.com/watch?v=q7bleFzA11c Special Guest: Lucas Sifoni.…
 
Artwork

1
Creating a Local-First Offline-Enabled LiveView PWA with Tony Dang 48:18

icon
48:18
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
48:18icon
 
Today in the Creator’s Lab, Tony Dang joins Elixir Wizards Sundi Myint and Owen Bickford to break down his journey of creating a local-first, offline-ready to-do app using Phoenix LiveView, Svelte, and CRDTs (Conflict-free Replicated Data Types). Tony explains why offline functionality matters and how this feature can transform various apps. He shares insights on different libraries, algorithms, and techniques for building local-first experiences and highlights the advantages of Elixir and Phoenix LiveView. Tony also shares his go-to tools, like Inertia.js for connecting Phoenix backends with JavaScript frontends, and favorite Elixir packages like Oban, Joken, and Hammer, offering a toolkit for anyone building powerful, adaptable applications. Topics discussed in this episode: Tony Dang's background from mechanical engineer to web developer Building an offline-enabled to-do app with Phoenix LiveView and Svelte CRDTs: Conflict-free Replicated Data Types for merging changes offline How to make a LiveView app work offline Sending full state updates vs. incremental updates for performance optimization Inspiring others through open-source projects and community contributions Learning vanilla Phoenix and Channels to understand LiveView better Handling stale CSRF tokens when reconnecting to a LiveView app offline Exploring service workers and browser APIs for managing offline connectivity Balancing the use of JavaScript and Elixir in web development Fostering a supportive and inspiring Elixir community Links mentioned: Working in Elevators: How to build an offline-enabled, real-time todo app w/ LiveView, Svelte, & Yjs Tony’s Twitter: https://x.com/tonydangblog https://liveview-svelte-pwa.fly.dev/ https://github.com/tonydangblog/liveview-svelte-pwa CRDT: https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type PWA: https://en.wikipedia.org/wiki/Progressive_web_app https://github.com/josevalim/sync https://github.com/sveltejs/svelte https://github.com/woutdp/live_svelte https://github.com/yjs/yjs https://github.com/satoren/y_ex https://github.com/y-crdt/y-crdt https://linear.app/ https://github.com/automerge/automerge https://hexdocs.pm/phoenix/1.4.0-rc.1/presence.html Vaxine, the Rich CRDT Database for ElixirPhoenix Apps | James Arthur | Code BEAM America 2022 https://github.com/electric-sql/vaxine Hybrid Logical Clocks https://muratbuffalo.blogspot.com/2014/07/hybrid-logical-clocks.html https://en.wikipedia.org/wiki/256_(number) CSRF Tokens in LiveView https://hexdocs.pm/phoenixliveview/Phoenix.LiveView.html#getconnectparams/1 https://hexdocs.pm/phoenix/channels.html Authentication with Passkeys Talk by Tony https://www.meetup.com/dc-elixir/ https://github.com/rails/rails https://github.com/facebook/react-native https://github.com/vuejs https://github.com/laravel/laravel https://hexdocs.pm/phoenixliveview/js-interop.html https://github.com/inertiajs https://github.com/inertiajs/inertia-phoenix https://savvycal.com/ https://github.com/wojtekmach/req https://github.com/oban-bg/oban https://github.com/joken-elixir/joken https://github.com/ExHammer/hammer Special Guest: Tony Dang.…
 
Artwork

1
Creating VintageCell: Nerves, PCBs, and GenStateMachine with Bryan Green 28:58

icon
28:58
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
28:58icon
 
Today on Elixir Wizards, Bryan Green shares how he transformed a vintage 1930s rotary phone into a fully functional cell phone using Elixir, Nerves, and a mix of hardware components. Bryan shares the highs and lows of his project, from decoding rotary dial clicks to troubleshooting hardware issues with LED outputs. He explains why Nerves was the perfect fit for this project, offering SSH access, over-the-air updates, and remote debugging. You’ll also hear how Elixir’s concurrency model helped him manage hardware inputs and outputs efficiently using GenStateMachine and Genservers. Elixir and Nerves really shine when modeling real-world systems. Bryan dives into how he used a finite state machine to track the phone’s states and handled inputs from the rotary dial and hook switch via GPIO. For hardware enthusiasts, Bryan’s advice is to embrace this “golden age” of DIY electronics. Whether you're experienced with embedded systems or just curious on where to start, Bryan's VintageCell can inspire you to tinker with a hardware engineering project. Key topics discussed in this episode: Advantages of functional programming and immutability in Elixir Building hardware projects using Adafruit components Why Nerves was the best choice for the VintageCell project Interpreting rotary dial clicks using GPIO and circuits.gpio Troubleshooting hardware issues with LED diagnostics Challenges in optimizing wiring and PCB design Benefits of Nerves: SSH access, OTA updates, and remote debugging Modeling real-world systems with Elixir and Nerves Implementing a finite state machine with GenStateMachine Managing input with Genservers for rotary dial and hook switch Leveraging community resources like Discord, Elixir Slack, and forums Practical advice for keeping hardware projects on track Potential applications from SMS servers to home automation Links mentioned: Vintage Cellphone: Bridging the Past and Future with Elixir Seven Languages in Seven Weeks https://pragprog.com/titles/btlang/seven-languages-in-seven-weeks/ Seven More Languages https://pragprog.com/titles/7lang/seven-more-languages-in-seven-weeks/ Node.js https://github.com/nodejs https://nerves-project.org/ https://www.arduino.cc/ Adafruit Circuit Playground https://www.adafruit.com/category/965 Adafruit 3D Printed Star Trek Communicator https://learn.adafruit.com/3d-printed-star-trek-communicator Adafruit FONA 3G Cellular + GPS Breakout https://learn.adafruit.com/adafruit-fona-3g-cellular-gps-breakout/overview https://github.com/elixir-circuits/circuits_gpio Nerves SSH https://hex.pm/packages/nerves_ssh OTA (over-the-air) Updates with NervesHub https://www.nerves-hub.org/ https://github.com/kicad Waveshare 4G Hat for Raspberry Pi https://www.waveshare.com/sim7600e-h-4g-hat.htm https://hexdocs.pm/gen_state_machine/GenStateMachine.html https://hexdocs.pm/elixir/GenServer.html https://www.sparkfun.com/ https://www.digikey.com/ USB-C Gadget Mode with Nerves https://github.com/nerves-project/nerves_system_rpi4/issues/18 https://livebook.dev/ https://codestorm.me/ https://github.com/codestorm1/vintage_cell/ Special Guest: Bryan Green.…
 
Artwork

1
Creating the Igniter Code Generation Framework with Zach Daniel 52:55

icon
52:55
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
52:55icon
 
To kick off Elixir Wizards Season 13, The Creator's Lab, we're joined by Zach Daniel, the creator of Igniter and the Ash framework. Zach joins hosts Owen Bickford and Charles Suggs to discuss the mechanics and aspirations of his latest brainchild, Igniter—a code generation and project patching framework designed to revolutionize the Elixir development experience. Igniter isn’t just about generating code; it’s about generating smarter code. By leveraging tools like Sourcerer and Rewrite, Igniter allows developers to modify source code and batch updates by directly interacting with Elixir's AST instead of regex patching. This approach streamlines new project setup and package installations and enhances overall workflow. They also discuss the strategic implications of Igniter for the broader Elixir community. Zach hopes Igniter will foster a more interconnected and efficient ecosystem that attracts new developers to Elixir and caters to the evolving needs of seasoned Elixir engineers. Topics discussed in this episode: Advanced package installation and code generation improve the developer experience Scripting and staging techniques streamline project updates Innovative methods for smoother installation processes in Elixir packages High-level tools apply direct patches to source code Progressive feature additions simplify the mix phx.new experience Chaining installers and composing tasks for more efficient project setup Continuous improvement in developer experiences to boost Elixir adoption Encourage listeners to collaborate by sharing code generation patterns Introduction of a new mix task aimed at removing the "unless" keyword in preparation for Elixir 1.18 You can learn more in the upcoming book "Building Web Applications with Ash Framework" by Zach and Rebecca Links mentioned: https://smartlogic.io/ https://alembic.com.au/blog/igniter-rethinking-code-generation-with-project-patching https://hexdocs.pm/igniter/readme.html https://github.com/ash-project/igniter https://www.zachdaniel.dev/p/serialization-is-the-secret https://www.zachdaniel.dev/p/welcome-to-my-substack https://ash-hq.org/ https://hexdocs.pm/sourceror/readme.html https://smartlogic.io/podcast/elixir-wizards/s10-e09-hugo-lucas-future-of-elixir-community/ https://github.com/hrzndhrn/rewrite https://github.com/zachdaniel https://github.com/liveshowy/webauthn_components https://hexdocs.pm/elixir/Regex.html https://github.com/msaraiva/vscode-surface https://github.com/swoosh/swoosh https://github.com/erlef/oidcc https://alembic.com.au/ https://www.zachdaniel.dev/ Special Guest: Zach Daniel.…
 
Artwork

1
Elixir Wizards X Thinking Elixir ElixirConf 2024 Hype-isode 59:50

icon
59:50
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
59:50icon
 
The Elixir Wizards and Thinking Elixir podcasts join forces to bring you a special hype-isode for ElixirConf 2024 in Orlando, Florida. Hosts Owen, Sundi, David, and Mark discuss their favorite moments from past conferences and offer a sneak peek into what this year's event has in store. From insightful training classes to thought-provoking talks on topics like LiveView, data processing, Nerves, and machine learning—there's something for every Elixirist and Elixir-curious software developer. In this episode, we share tips on making the most of the conference, whether you're there to network, learn, or just soak in the community vibes. Want to attend ElixirConf in Orlando from August 27th-30th, 2024? Use code ELIXIRPODCAST at checkout to get a $50 discount on your tickets here: https://ti.to/elixirconf/2024 Key topics discussed in this episode: Favorite moments and experiences from previous ElixirConf events How to network and make the most of your conference attendance Training classes and talks we're looking forward to this year Keynotes from prominent Elixir community figures Chris McCord's keynote: TBD (Could it be a LiveView 1.0 announcement?!) Benefits of attending ElixirConf: learning, networking, community immersion Virtual attendance options for those unable to attend in person Early bird ticket prices and special discount code "ELIXIRPODCAST" for $50 off Why you should step out of your comfort zone and engage with others Passion and energy of Elixir community members at ElixirConf Mentorship opportunities: connect with experienced Elixir developers Exploring Orlando attractions during ElixirConf 2024 downtime An invitation to join us at ElixirConf 2024 and immerse yourself in the Elixir community Links mentioned: https://2024.elixirconf.com/ https://hexdocs.pm/ecto/Ecto.html https://fly.io/ https://brainlid.org/ https://github.com/brainlid/ https://www.meetup.com/austin-elixir/ https://grox.io/ https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html https://opentelemetry.io/docs/languages/erlang/ https://ash-hq.org/ https://alembic.com.au/ Functional IoT with Elixir and Nerves - Justin Schneck | Craft 2019 https://docs.nerves-hub.org/ https://nerves-project.org/ https://getoban.pro/ https://hexdocs.pm/broadway/Broadway.html https://developer.farm.bot/v15/docs/farmbot-os.html Leaving Everything Behind For Elixir - Theo’s video Phoenix LiveView Is Making Me Reconsider React... - Theo’s other video Podcast: Thinking Elixir 206: BeamOps - DevOps on the BEAM Special Guests: David Bernheisel and Mark Ericksen.…
 
Artwork

1
"The Past is Your Teacher" with Alicia Brindisi and Bri LaVorgna 32:56

icon
32:56
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
32:56icon
 
It’s the season finale of Elixir Wizards Office Hours! SmartLogic’s Project Manager Alicia Brindisi and VP of Delivery Bri LaVorgna join host Dan to delve into the agile ceremony of retrospectives. They explore the vital role of retrospectives in Agile project management and unveil practical strategies for enhancing their effectiveness. Alicia and Bri break down the elements of a successful retrospective. They cover everything from meticulous preparation to facilitation techniques, and how to choose the best format for fostering open dialogue and actionable results. Learn how to navigate common obstacles and guide discussions toward productive, solution-focused outcomes. Throughout the episode, they emphasize the transformative potential of retrospectives within the Agile framework, portraying them not just as a procedural activity, but as a catalyst for continuous team growth and project success. Key topics discussed in this episode: Mastering the full potential of retrospectives in Agile environments Best practices for effective preparation and facilitation Choosing the right format to suit your team's dynamics Strategies for overcoming typical challenges during retrospectives Techniques for addressing and resolving interpersonal conflicts constructively The critical importance of valuing each team member’s perspective Practical advice on applying insights from retrospectives to enact organizational changes Tailoring and refining retrospectives to meet your team’s unique requirements Links mentioned: SmartLogic https://smartlogic.io/ SmartLogic LinkedIn https://www.linkedin.com/company/smartlogic-io Contact Bri Bri@smartlogic.io Retrium Retrospectives for Scrum & Agile Teams https://www.retrium.com/ 4Ls Retrospective Template https://www.retrium.com/retrospective-techniques/4ls Start Stop Continue Retrospective https://www.retrium.com/retrospective-techniques/start-stop-continue Sailboat Retrospective https://www.retrium.com/retrospective-techniques/sailboat Starfish Retrospective https://www.retrium.com/retrospective-techniques/starfish ClickUp Project Management Platform https://clickup.com/teams/project-management Asana Task Manager http://www.asana.com Jira Project Management Tool https://www.atlassian.com/software/jira Special Guests: Alicia Brindisi and Bri LaVorgna.…
 
Artwork

1
"So You've Been Hired" with Emma Whamond and Micaela Cunha 46:06

icon
46:06
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
46:06icon
 
In Office Hours Episode 10, SmartLogic’s newest developers, Emma Whamond and Micaela Cunha, join Elixir Wizard Owen Bickford to discuss their onboarding experiences, joining a new engineering team, and navigating an unfamiliar codebase. They share tips and challenges on learning new programming languages like Ruby and Elixir while ramping up for active client projects. Emma and Micaela emphasize the value of starting with tests and seeking guidance from teammates when diving into unfamiliar projects. Our guests provide valuable guidance for anyone navigating the transition into a new software development team, highlighting the importance of collaboration, continuous learning, and community support in the tech industry. Key topics discussed in this episode: What to expect when joining a new engineering team Navigating existing codebases as a new hire in Elixir and Ruby Applying previous work experience to software development The importance of tests and team communication in unfamiliar projects Learning Ruby as a C++ and JavaScript developer Differences between dynamic and static typing Building team camaraderie and intentionality in remote work environments The steep learning curve of the onboarding process, including documentation, codebases, and client meetings Relying on teammates for guidance and overcoming the fear of asking too many questions Updating documentation within project repositories Learning team dynamics and identifying domain experts for targeted assistance Domain-specific knowledge: being a senior developer in one language vs. another Building friendships and connections within local tech communities The welcoming and supportive nature of the tech industry for newcomers Links mentioned: Elixir Programming Language https://elixir-lang.org/ Ruby on Rails https://www.ruby-lang.org/en/ Ruby Koans - Learn Ruby language, syntax, structure https://www.rubykoans.com/ Elixir Language Learning Exercises (Elixir Koans) https://github.com/elixirkoans/elixir-koans The PETAL Stack in Elixir https://thinkingelixir.com/petal-stack-in-elixir/ Alpine JS Lightweight JavaScript Framework https://alpinejs.dev/ Phoenix LiveView https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html WebAuthn Components passwordless authentication to LiveView applications https://github.com/liveshowy/webauthn_components Gleam functional language for building type-safe, scalable systems https://gleam.run/ The Future of Types in Elixir with José Valim, Guillaume Duboc, and Giuseppe Castagna https://smartlogic.io/podcast/elixir-wizards/s10-e12-jose-guillaume-giuseppe-types-elixir/ Git-Blame https://git-scm.com/docs/git-blame nix store https://nixos.org/manual/nix/stable/command-ref/nix-store Code and Coffee https://codeandcoffee.org/ Special Guests: Emma Whamond and Micaela Cunha.…
 
Artwork

1
"From Inspiration to Execution" with Camber Griffin 45:03

icon
45:03
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
45:03icon
 
In Episode 9 of Elixir Wizards Office Hours, we dive into task writing and backlog grooming, transforming ideas from the discovery phase into actionable tickets. Join SmartLogic Developer Camber Griffin and hosts Dan Ivovich and Owen Bickford as they explore the intricacies of task writing, ticket grooming, estimation, and backlog management in the software development lifecycle. They emphasize crafting clear, detailed tickets that act as comprehensive guides for development teams. A well-written ticket does more than outline what needs to be built—it facilitates collaboration by including entry points, linking to essential documentation, defining acceptance criteria, detailing QA steps, and identifying potential risks and future hurdles. Key topics discussed in this episode: Crafting actionable development tickets from inspiration Achieving the optimal level of detail in tickets Tailoring ticket content for developers, QA, and stakeholders Standardizing ticket format with templates Structurally breaking down tasks into manageable sections Ensuring flexibility in implementation while maintaining clear specifications Proactively discussing architectural and design approaches Incorporating related documentation within tickets Clarifying acceptance criteria and QA procedures Accurately estimating task effort and complexity Collaboratively grooming tasks with cross-functional teams Adjusting tickets to evolving requirements Strategically planning for uncertainties and out-of-scope concerns Managing and versioning ongoing documentation Keeping the backlog clean, prioritized, and relevant Mapping dependencies among interconnected tasks Links mentioned: Jira Work Management https://www.atlassian.com/software/jira ClickUp Project Management Platform https://clickup.com/teams/project-management GitHub Projects https://docs.github.com/en/issues/planning-and-tracking-with-projects Zube Agile Project Management https://zube.io/ Pivotal Tracker Agile Project Management Tool https://www.pivotaltracker.com/ Trak Portfolio Management System https://pd-trak.com/ ClearCase Software Configuration Mgmt www.ibm.com/products/devops-code-clearcase Oban Job Processing in Elixir https://github.com/sorentwo/oban Special Guest: Camber Griffin.…
 
Artwork

1
"DevOps: From Code to Cloud" with Dan Ivovich 43:43

icon
43:43
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
43:43icon
 
In Elixir Wizards Office Hours Episode 8, hosts Sundi Myint and Owen Bickford lead an engaging Q&A session with co-host Dan Ivovich, diving deep into the nuances of DevOps. Drawing from his extensive experience, Dan navigates topics from the early days before Docker to managing diverse polyglot environments and optimizing observability. This episode offers insights for developers of all levels looking to sharpen their DevOps skills. Explore the realms of Docker, containerization, DevOps workflows, and the deployment intricacies of Elixir applications. Key topics discussed in this episode: Understanding DevOps and starting points for beginners Best practices for deploying applications to the cloud Using Docker for containerization Managing multiple programming environments with microservices Strategies for geographic distribution and ensuring redundancy Localization considerations involving latency and device specs Using Prometheus and OpenTelemetry for observability Adjusting scaling based on application metrics Approaching failure scenarios, including database migrations and managing dependencies Tackling challenges in monitoring setups and alert configurations Implementing incremental, zero-downtime deployment strategies The intricacies of hot code upgrades and effective state management Recommended learning paths, including Linux and CI/CD workflows Tools for visualizing system health and monitoring Identifying actionable metrics and setting effective alerts Links mentioned: Ansible open source IT automation engine https://www.ansible.com/ Wikimedia engine https://doc.wikimedia.org/ Drupal content management software https://www.drupal.org/ Capistrano remote server automation and deployment https://capistranorb.com/ Docker https://www.docker.com/ Circle CI CI/CD Tool https://circleci.com/ DNS Cluster https://hex.pm/packages/dns_cluster ElixirConf 2023 Chris McCord Phoenix Field Notes https://youtu.be/Ckgl9KO4E4M Nerves https://nerves-project.org/ Oban job processing in Elixir https://getoban.pro/ Sidekiq background jobs for Ruby https://sidekiq.org/ Prometheus https://prometheus.io/ PromEx https://hexdocs.pm/prom_ex/PromEx.html GitHub Actions - Setup BEAM: https://github.com/erlef/setup-beam Jenkins open source automation server https://www.jenkins.io/ DataDog Cloud Monitoring https://www.datadoghq.com/…
 
Artwork

1
"Printing is Ugly" with Joel Meador and Charles Suggs 47:03

icon
47:03
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
47:03icon
 
In Episode 7 of Elixir Wizards Office Hours, SmartLogic Engineers Joel Meador and Charles Suggs join host Owen Bickford to tackle the often tricky task of adding print functionality to web applications. They discuss their recent experiences with browser-based printing and the hurdles of cross-browser compatibility, consistent styling, and dynamic content generation, such as headers and footers. The trio delves into the limitations of current printing capabilities in browsers, the potential of server-side PDF generation, and the necessity of juggling separate templates for web and print. They also consider accessibility for printed content and the demands of delivering high-fidelity, pixel-perfect prints. Throughout the episode, Joel, Charles, and Owen offer up practical advice for developers grappling with similar issues, emphasizing the need for thorough research, proactive problem-solving, and the exploration of both in-browser and external PDF generation solutions. Key topics discussed in this episode: Real-world experiences with software project printing Navigating the limitations of browser-based printing Ensuring cross-browser compatibility and consistent layout Generating dynamic content for print versions Exploring server-side PDF generation and its advantages Balancing design consistency across web and print formats Addressing accessibility in printed outputs Overcoming the unique challenges of high-accuracy printing requirements Practical tips for researching and implementing printing solutions Handling complex data presentations like tables in print Evaluating the pros and cons of different printing APIs Understanding the distinction between web viewing and printing needs Innovating with mixed content in PDF generation Learning from past printing challenges and planning for future improvements Links mentioned: CSS3 https://css3.com/ WeasyPrint https://github.com/Kozea/WeasyPrint WebKit https://webkit.org/ Pdf.js https://github.com/mozilla/pdf.js YesLogic Prince 15 https://www.princexml.com/ PrintXML https://gist.github.com/craiga/2934093 PDF/A https://en.wikipedia.org/wiki/PDF/A The PDF/A Family of Archiving Standards https://www.pdflib.com/pdf-knowledge-base/pdfa/the-pdfa-standards/ PDF/X https://en.wikipedia.org/wiki/PDF/X Microsoft Encarta https://en.wikipedia.org/wiki/Encarta Special Guests: Charles Suggs and Joel Meador.…
 
Artwork

1
"Keeping it Fresh" with Bilal Hankins and Anna Dorigo 36:00

icon
36:00
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
36:00icon
 
In Office Hours Episode 6, SmartLogic Developers Anna Dorigo and Bilal Hankins join Elixir Wizards Sundi and Dan to discuss their experiences maintaining a decade-old Ruby on Rails codebase. They delve into the critical importance of deeply understanding the codebase, keeping dependencies current, and adapting to the original application's evolving priorities and design choices. The conversation spans a range of topics, including accessibility, testing, monitoring, and the challenges of deploying database migrations in production environments. The guests share effective strategies for sustaining and enhancing older codebases, such as employing automated tools, performing code audits, and adhering to clean coding principles. Key topics discussed in this episode: Grasping the legacy codebase and its historical context Overcoming accessibility issues in older applications Safe dependency management and upgrades The effects of application scaling on database performance The critical role of comprehensive test suites in legacy systems Using tools like Sentry for error tracking and performance monitoring The benefits of automated security and dependency scans Juggling client needs with budget constraints Local simulation techniques for large datasets The value of iterative code reviews and maintaining clean code Utilizing git history for contextual understanding Onboarding strategies for legacy projects Removing obsolete code and avoiding "magic numbers" Importance of descriptive naming for better code clarity Leveraging a rich repository of example code for learning and reference Proactive code audits to anticipate issues Managing pull request sizes for smoother reviews Communicating effectively about upgrades and potential impacts Strategies for handling large databases efficiently Ensuring thorough test coverage Keeping open lines of communication with clients regarding ongoing maintenance Links mentioned: COBOL programming language https://developer.ibm.com/languages/cobol/ Ruby on Rails https://rubyonrails.org/ ARIA Rules (Accessible Rich Internet Applications) https://www.w3.org/TR/using-aria/ Shawn Vo on Elixir as a Competitive Advantage https://smartlogic.io/podcast/elixir-wizards/s5e5-vo/ Bundler Audit Ruby Gem https://rubygems.org/gems/bundler-audit/ Sentry application monitoring and error tracking software https://sentry.io/ Dependabot Github automated dependency updates Mix hex.audit https://hexdocs.pm/hex/Mx.Tasks.Hex.Audit.html Git Blame https://git-scm.com/docs/git-blame Cow hoof trimming videos - The Hoof GP on YouTube (TW graphic imagery) Special Guests: Anna Dorigo and Bilal Hankins.…
 
Artwork

1
"Saga of a Gnarly Report" with Owen and Dan 50:21

icon
50:21
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
50:21icon
 
In today's episode, Elixir Wizards Owen and Dan delve into the complexities of building advanced reporting features within software applications. They share personal insights and challenges encountered while developing reporting solutions for user-generated data, leveraging both Elixir/Phoenix and Ruby on Rails. The discussion zeroes in on crucial data modeling and architectural decisions that enhance reporting efficiency and flexibility. Owen and Dan explore tactics like materialized views, event sourcing, and database triggers to optimize data handling while being mindful of UX elements like progress indicators and background job management. They share insights on leveraging the Elixir/Beam ecosystem’s strengths—like concurrency and streamlined deployment—to tackle common reporting, caching, and integration challenges. The episode highlights the impact of reporting features across all aspects of a software application’s design and architecture. Key topics discussed in this episode: Reporting on assessment data, survey results, and user metrics Differences between reporting and performance/error monitoring Implementing reporting in Elixir/Phoenix vs. Ruby on Rails Displaying reports in web, printable, PDF, SVG, and CSV formats Challenges of generating PDFs for large data sets Streaming CSV data directly to the client Handling long-running report generation tasks Providing progress indicators and user notifications Strategies for canceling or abandoning incomplete reports Tradeoffs of pre-calculating report data vs. real-time generation Materializing views and denormalizing data for reporting Exploring event sourcing patterns for reporting needs Using database triggers and stored procedures for reporting Balancing data structure optimization for reports vs. day-to-day usage Caching report data for faster retrieval and rendering Charting and visualization integration in reporting systems Links mentioned: Prometheus monitoring system & time series database https://prometheus.io/ Thinking Elixir "FLAME with Chris McCord" https://podcast.thinkingelixir.com/181 Phoenix LiveView Uploads https://hexdocs.pm/phoenix/file_uploads.html https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.UploadWriter.html Postgrex PostgreSQL driver for Elixir https://hexdocs.pm/postgrex/Postgrex.html Ecto https://hexdocs.pm/ecto/Ecto.html Heroku cloud application platform https://www.heroku.com/ Elixir Wizards S9E12 Marcelo Dominguez on Command and Query Responsibility Segregation https://smartlogic.io/podcast/elixir-wizards/s9-e12-marcelo-dominguez-cqrs/ Commanded Elixir CQRS/ES applications https://github.com/commanded/commanded Tailwind CSS Framework https://github.com/tailwindlabs Memcached https://memcached.org/ Redis https://redis.io/ Oban https://hexdocs.pm/oban/Oban.html ETS https://hexdocs.pm/ets/ETS.html Capistrano remote server automation and deployment tool https://capistranorb.com/…
 
Artwork

1
"Whose Tailwind is it Anyway?" with Ava Slivkoff 48:17

icon
48:17
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
48:17icon
 
In Elixir Wizards Office Hours Episode 4, SmartLogic Product Designer Ava Slivkoff joins hosts Sundi Myint and Owen Bickford to discuss the product designer's role in software development. Ava shares her experience navigating client expectations, software design principles, and technical constraints. They explore the integration of design and development workflows and how designers and engineers can collaborate to meet a project's specific needs. The conversation emphasizes the value of cross-functional teams and the synergy that can arise when all team members work in harmony to bring a product to life. Key concepts discussed in the episode: The broad scope of the designer role in web app development The value of an MVP in the iterative software design process Challenges of aligning client expectations with design best practices Pros and cons of leveraging pre-built Tailwind CSS styled components Trends and evolution in web design aesthetics and patterns Leveraging open-source design systems like Tailwind UI Balancing technical constraints with design aspirations Communication and trust-building between designers and engineers Workflows for design handoffs and feedback loops Importance of user flows and mapping the product experience Challenges around the implementation of complex UI elements Benefits of regular design review meetings and syncs Fostering empathy and collaboration across disciplines Links mentioned Figma Dev Mode https://www.figma.com/dev-mode/ Tailwind CSS utility-first CSS framework https://tailwindcss.com/ Tailwind UI https://tailwindui.com/ https://devinai.ai/ Special Guest: Ava Slivkoff.…
 
Artwork

1
"You've Got a Job to Do" with Joel Meador 44:26

icon
44:26
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
44:26icon
 
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.…
 
Artwork

1
"Discovery Discoveries" with Alicia Brindisi and Bri LaVorgna 43:26

icon
43:26
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
43:26icon
 
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: bri@smartlogic.io What is a PRD? https://en.wikipedia.org/wiki/Product_requirements_document Special Guests: Alicia Brindisi and Bri LaVorgna.…
 
Artwork

1
"Testing 1, 2, 3" with Joel Meador and Charles Suggs 45:40

icon
45:40
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
45:40icon
 
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.…
 
Artwork

1
Creating a Language: Elixir vs. Roc with José Valim and Richard Feldman (Elixir Wizards X Software Unscripted Podcast) 1:09:04

icon
1:09:04
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
1:09:04icon
 
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.…
 
Artwork

1
Package Management in Elixir vs. JavaScript with Wojtek Mach & Amal Hussein 54:06

icon
54:06
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
54:06icon
 
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.…
 
Artwork

1
Communities in Tech with Camille Clayton & Scott Tolinski 48:19

icon
48:19
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
48:19icon
 
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.…
 
Artwork

1
Actor Model and Concurrent Processing in Elixir vs. Clojure and Ruby with Xiang Ji & Nathan Hessler 47:57

icon
47:57
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
47:57icon
 
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.…
 
Artwork

1
Static Code Analysis in Elixir vs. Ruby with René Föhring & Marc-André Lafortune 46:02

icon
46:02
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
46:02icon
 
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.…
 
Artwork

1
Web Development Frameworks: Elixir and Phoenix vs. Ruby on Rails with Owen Bickford & Dan Ivovich 41:41

icon
41:41
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
41:41icon
 
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/…
 
Artwork

1
Garbage Collection in Erlang vs JVM/Akka with Manuel Rubio & Dan Plyukhin 44:08

icon
44:08
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
44:08icon
 
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.…
 
Artwork

1
Machine Learning in Elixir vs. Python, SQL, and Matlab with Katelynn Burns & Alexis Carpenter 31:19

icon
31:19
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
31:19icon
 
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.…
 
Artwork

1
Embedded Systems in Elixir vs. C, C++, and Java with Connor Rigby & Taylor Barto 46:30

icon
46:30
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
46:30icon
 
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.…
 
Artwork

1
ECS / Game Development with Elixir vs. Python, JavaScript, React with Dorian Iacobescu & Daniel Luu 41:08

icon
41:08
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
41:08icon
 
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.…
 
Artwork

1
Learning a Language: Elixir vs. JavaScript with Yohana Tesfazgi & Wes Bos 42:14

icon
42:14
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
42:14icon
 
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: yytesfazgi@gmail.com…
 
Artwork

1
HTTP Requests in Elixir vs. JavaScript with Yordis Prieto & Stephen Chudleigh 50:29

icon
50:29
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
50:29icon
 
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.…
 
Artwork

1
Season 11 Kickoff: The Hosts Discuss Branching Out from Elixir to Compare Notes 32:21

icon
32:21
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
32:21icon
 
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…
 
Artwork

1
José Valim, Guillaume Duboc, and Giuseppe Castagna on the Future of Types in Elixir 48:32

icon
48:32
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
48:32icon
 
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.…
 
Artwork

1
Chris McCord and Jason Stiebs on the Future of Phoenix 58:12

icon
58:12
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
58:12icon
 
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.…
 
Artwork

1
Sean Moriarity on the Future of Machine Learning with Elixir 47:18

icon
47:18
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
47:18icon
 
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.…
 
Artwork

1
Hugo Baraúna & Lucas San Roman on the Future of the Elixir Community 50:48

icon
50:48
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
50:48icon
 
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.…
 
Artwork

1
José Valim on the Future of the Elixir Ecosystem 43:57

icon
43:57
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
43:57icon
 
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.…
 
Artwork

1
Saša Jurić on The Future of Training & Education in Elixir 46:27

icon
46:27
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
46:27icon
 
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ć.…
 
Artwork

1
Mat Trudel on the Future of Phoenix and Web Transports 48:05

icon
48:05
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
48:05icon
 
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.…
 
Artwork

1
Mike Waud and Tony Winn on the Future of Elixir on the Grid 42:41

icon
42:41
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
42:41icon
 
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.…
 
Artwork

1
Sophie DeBenedetto on the Future of Elixir and LiveView 51:08

icon
51:08
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
51:08icon
 
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.…
 
Artwork

1
Michael Lubas on the Future of Elixir Security 40:30

icon
40:30
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
40:30icon
 
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 - michael@paraxial.io 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.…
 
Artwork

1
Cory O'Daniel and the Future of DevOps in Elixir Programming 45:45

icon
45:45
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
45:45icon
 
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.…
 
Artwork

1
Season 10 Kickoff: The Hosts Discuss The Future of Elixir 41:48

icon
41:48
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
41:48icon
 
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…
 
Artwork

1
That's a Wrap: Season 9 Finale with Sundi, Bilal, Owen & Dan! 36:53

icon
36:53
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
36:53icon
 
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…
 
Artwork

1
Marcelo Dominguez on Command and Query Responsibility Segregation 44:12

icon
44:12
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
44:12icon
 
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…
 
Artwork

1
Chris Miller on Crafting a Programming Language 42:55

icon
42:55
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
42:55icon
 
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…
 
Artwork

1
Frank Hunleth and Joe Martin on the Particulars of Nerves 45:13

icon
45:13
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
45:13icon
 
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…
 
Artwork

1
Jenny Bramble on Testing and Collaboration at Papa 46:15

icon
46:15
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
46:15icon
 
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…
 
Artwork

1
Harper Atlas on Tailwind From the Perspective of a Designer 39:54

icon
39:54
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
39:54icon
 
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…
 
Artwork

1
Theo Harris on Onboarding into Elixir at Alembic 39:55

icon
39:55
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
39:55icon
 
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…
 
Artwork

1
Ashley Smith & Kenneth Moy from Bowery Farming on Oban 38:30

icon
38:30
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
38:30icon
 
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…
 
Artwork

1
Jason Stiebs on LiveView at RokkinCat 49:53

icon
49:53
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
49:53icon
 
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 – jason@rokkincat.com RokkinCat — https://rokkincat.com/ SmartLogic — https://smartlogic.io/ SmartLogic Twitter — https://twitter.com/smartlogic…
 
Artwork

1
Mark & David from Thinking Elixir on Ecto Queries 53:35

icon
53:35
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
53:35icon
 
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…
 
Artwork

1
Tyler Young on Geo Mapping at Felt 36:59

icon
36:59
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
36:59icon
 
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…
 
Artwork

1
Kate Rezentes on GenServers at Simplebet 48:07

icon
48:07
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
48:07icon
 
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…
 
Artwork

1
Dave Lucia on Observability at Bitfo 51:35

icon
51:35
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
51:35icon
 
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…
 
Artwork

1
We're baaaack! Season 9 Teaser 1:07

icon
1:07
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
1:07icon
 
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/…
 
Artwork

1
Looking back on Season 8 with Sundi, Owen & Dan 38:23

icon
38:23
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
38:23icon
 
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/…
 
Artwork

1
Nathan Retta on Engineering in Android at DoorDash 29:11

icon
29:11
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
29:11icon
 
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.…
 
Artwork

1
Cara Mitchell on Internal In-house eCommerce 44:41

icon
44:41
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
44:41icon
 
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!…
 
Artwork

1
Catalina Astengo on The Many Languages of Nav 42:48

icon
42:48
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
42:48icon
 
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/…
 
Artwork

1
Meks McClure on Communication, Diversity, and Ergonomics 45:35

icon
45:35
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
45:35icon
 
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.…
 
Artwork

1
Jessica Kerr on Systems Thinking for Developers 43:42

icon
43:42
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
43:42icon
 
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.…
 
Artwork

1
Digit on Smart Homes, EMPEX, and Cross-platform Development 42:58

icon
42:58
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
42:58icon
 
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.…
 
Artwork

1
Nathan Willson on the Polyglot Landscape in Japan 45:20

icon
45:20
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
45:20icon
 
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.…
 
Artwork

1
Sanne Kalkman on Coding, Crafting, and Collaboration 43:31

icon
43:31
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
43:31icon
 
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.…
 
Artwork

1
Cassidy Williams and Tobi Pfeiffer on Elixir Programming at Remote 1:00:36

icon
1:00:36
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
1:00:36icon
 
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.…
 
Artwork

1
Devon Estes on The Power of Functional Programming 48:07

icon
48:07
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
48:07icon
 
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.…
 
Artwork

1
Miguel Cobá on Deploying in Elixir and Other Languages 48:47

icon
48:47
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
48:47icon
 
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á.…
 
Artwork

1
Todd Resudek on the Impact of Elixir 56:55

icon
56:55
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
56:55icon
 
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.…
 
Artwork

1
Arthi Radhakrishnan on the Value of Collaborative Learning for Software Engineers 45:33

icon
45:33
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
45:33icon
 
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.…
 
Artwork

1
Meryl Dakin on Changing Lanes and Switching Gears With Elixir 51:20

icon
51:20
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
51:20icon
 
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.…
 
Artwork

1
Brooklyn Zelenka and The Exciting World of Edge Computing 46:05

icon
46:05
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
46:05icon
 
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.…
 
Artwork

1
Sigu Magwa on the Elixir Community in Kenya 50:42

icon
50:42
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
50:42icon
 
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.…
 
Artwork

1
Casting Spells with Brooklin Myers 56:10

icon
56:10
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
56:10icon
 
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.…
 
Artwork

1
Speedcubing and Building Livebook with Jonatan Kłosko 45:17

icon
45:17
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
45:17icon
 
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.…
 
Artwork

1
Protocols in Elixir with Yiming Chen 42:11

icon
42:11
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
42:11icon
 
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.…
 
Artwork

1
Learning and Teaching Functional Programming with Adolfo Neto 47:53

icon
47:53
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
47:53icon
 
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.…
 
Artwork

1
The Benefits of Consistently Growing Your Toolset with Florian Kraft 48:52

icon
48:52
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
48:52icon
 
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.…
 
Artwork

1
Re-Platforming One of the Original Dot Coms in Elixir with Angel Jose 47:57

icon
47:57
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
47:57icon
 
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.…
 
Artwork

1
The Impact of Elixir Launchisode 58:47

icon
58:47
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
58:47icon
 
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/…
 
Artwork

1
Wrapping up BEAM Magic with Amos King 57:56

icon
57:56
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
57:56icon
 
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 — contact@binarynoggin.com 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.…
 
Artwork

1
Mini-Feature Extravaganza featuring Tyler Clemens, Elom Amouzou, Elise Navarro, and Jeremy Neal 38:30

icon
38:30
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
38:30icon
 
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.…
 
Artwork

1
Delving Deeper into Magic with Quinn Wilton 44:54

icon
44:54
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
44:54icon
 
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.…
 
Artwork

1
The Bridge Between Elixir and Zig with Isaac Yonemoto 46:34

icon
46:34
icon
iconicon Play Later
iconicon Play Later
iconicon Lists
iconicon Liked
46:34icon
 
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.…
 
Loading …

Welcome to Player FM!

Player FM is scanning the web for high-quality podcasts for you to enjoy right now. It's the best podcast app and works on Android, iPhone, and the web. Signup to sync subscriptions across devices.

 

icon Daily Deals
icon Daily Deals
icon Daily Deals

Similar to Elixir Wizards

Listen to 500+ topics
Player FM - Podcast App
Go offline with the Player FM app!
Get it on App Store Get it on Google Play

Quick Reference Guide

Top Podcasts
The Bill Simmons Podcast
PTI
First Take
Marketplace
Comedy of the Week
The Bugle
How Did This Get Made?
Doug Loves Movies
Planet Money
TED Talks Daily
NBC Nightly News with Lester Holt
The World This Hour
Daily Boost Motivation and Coaching
Radiolab
Science Friday
This American Life
Criminal
Sword and Scale
In The Dark
Player FM logo
Help/FAQ | Upgrade | Advertise
Arts|Business|Comedy|Economics|Entertainment|News|Politics|Religion
Science|Soccer|Sports|Storytelling|Technology|True Crime
Copyright 2025 | Sitemap | Privacy Policy | Terms of Service | | Copyright
Episode being played series thumbnail
icon icon
/

View Player FM in...
Player FM
Browser
Chrome
Safari
Firefox
Listen to this show while you explore
Play