Elixir Wizards

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

Key Points From This Episode:

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

Links Mentioned in Today’s Episode:

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

Special Guest: Steve Domin.

We talk with developers from the team here at SmartLogic about our current practices on deploying Elixir and Phoenix in production.

Dan Ivovich - Director of Development Operations @ SmartLogic

Learn more about how SmartLogic uses Phoenix and Elixir.

00:00 - Fade In

00:30 - Introductions to Eric, Dan and SmartLogic

Dan Ivovich - Director of Development Operations @ SmartLogic

Eric Oestrich - Developer, Elixir Lead @ SmartLogic

Justus Eapen - Full stack developer @ SmartLogic

Introduced to Elixir by an old colleague.

1:20 - What Elixir projects do you have in production?

Several client projects in production. Several Mobile Apps with APIs powered by Phoenix and Elixir.

Baltimore Water Taxi.

A digital marketplace.

And more!

1:57 - Advantages and disadvantages to using Elixir.

We made the switch when a colleague was stoked about Functional Programming and introduced us to Elixir. We were won over by the performance and rich feature sets, OTP, etc.

2:43 - Where are we hosting our Elixir Apps?

• Heroku
• AWS
• Linode
• Digital Ocean

6:20Deployment process, tools, scripting

• Ansible - for underlying VPS’s, servers, and more recently deployment itself. (Similar to Capistrano).
  
• Distillery
  
• Mix.release

7:18 - Zero Downtime Deployments

• Old school load balancers and rolling restarts

7:46 - What are the performance metrics like? Comparatively.

• Ruby ends up with memory leaks. That doesn’t happen with Elixir.
• Memory utilization is flat and low no matter what.
• “Phenomenal response times”

8:54 - How does Eric think about clustered applications in Elixir?

• Going Multi Node (https://www.youtube.com/watch?v=lCUKQnkjajo)
• Pg2 - process groups
• Mnesia distributed database (beware!)
• “Just sending messages to pids because Erlang is great”
• Swarm / Horde

12:40 - How do we handle background tasks?

• Started with verk
• Recently becoming more comfortable with spinning up GenServers
• “The language itself is built to be concurrent.”

15:06 What libraries are we using in prod?

• First thing: You don’t need a whole lot because the language is so well designed.
• Phoenix - web framework
• Ecto - sort of an ORM
• Distillery - for releases
• Bamboo - for sending emails
• Quantum - for task scheduling
• Timex - for dates and times, and timezones
• Cachex - for caching

18:20- What third party integrations have we attempted

• Stripe
• Square
• Twilio
• Mindbody

Always building our own clients. Using HTTPoison

19:58Has Elixir ever saved the day in production?

It’s saved many days by PREVENTING ISSUES. Systems are architected for reliability and fault-tolerance.

21:48 - Where do supervision trees come from? What is OTP?

• OTP is an Erlang standard lib
• Includes supervision trees, genservers, ETS, and a lot of stuff we don’t even know about!
• gen_tcp
• Mnesia
• dets

23:43- Tips for devs considering running elixir in production.

• Jump in and read the docs
• Understand how systems boot, distillery releases, config providers, etc.
• “Good server monitoring hygiene”
• “DIVE IN!” 19:54 Outro

Learn more about how SmartLogic uses Phoenix and Elixir.

Special Guest: Dan Ivo...

We’re excited to announce our season two topic, Elixir Internals. In this season we talk with developers behind some of the most popular Elixir libraries, including Witchcraft, ElixirScript, Distillery, Ecto, and more!

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.

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.