Web Development Frameworks: Elixir and Phoenix vs. Ruby on Rails with Owen Bickford & Dan Ivovich
Elixir Wizards
Introduction
The hosts introduce themselves and discuss their background in customer service and transitioning into coding professionally. They also talk about their involvement with PHP and how they started working with Elixir.
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/
Remember Everything You Learn from Podcasts
