#Phoenix
35 notas · última:
Out-of-the-box Elixir telemetry with Phoenix
The article explains Phoenix’s built-in telemetry, how metrics are defined in telemetry.ex, how events feed multiple metrics, and how clustered Elixir lets the dashboard attach to other nodes.
Elixir Makes You Make Good Decisions
The author argues that Elixir, Phoenix, Ecto, and the BEAM helped screen.garden make cleaner architecture, easier authorization, faster file sync, and tests that are pleasant to write.
A love letter to React
The text says that React influenced LiveView and Phoenix by showing a model of reactive components, colocation between markup and code, HTML-aware components, and diff optimizations on the server and the client.
Did contexts kill Phoenix?
Argues that Phoenix's contexts layer, meant to enforce domain-driven boundaries, raised the barrier to entry enough to slow the framework's adoption relative to Rails.
Enhancing Your Elixir Codebase with Gleam
The article shows how to add Gleam to an Elixir/Phoenix project, move core enrollment logic into Gleam, call it from Elixir, and extend the setup to handle a waitlist.
How I Stopped Worrying and Started Loving the Umbrella – TAGBASE
The author explains why Tagbase moved from separate Node.js and Elixir apps to an Elixir umbrella app, focusing on shared code, clearer boundaries, faster local development, and safer separation between portal and back office.
Why you should use Ash?
The chapter argues that Ash is worth learning because it centralizes domain logic, reduces duplication, and helps teams manage growing complexity, onboarding, and long-term maintenance.
Setup VSCode for Elixir Dev
The page recommends a VS Code setup for Elixir and Phoenix development: ElixirLS and Phoenix Framework as must-have extensions, Elixir Test as a helpful add-on, and Tailwind CSS IntelliSense for Tailwind users.
Is LiveView Overhyped?
The author argues LiveView is heavily promoted but not technically overhyped. He frames it as a useful, well-chosen trade-off for many web apps, while noting limits around offline use, latency, connectivity, and fallback behavior.
Optimizing for Free Hosting — Elixir Deployments
The article lays out a single-server Phoenix deployment on free Google Cloud hardware, using raw Linux tools, Nginx, systemd, releases, and a bash script to achieve simple, low-cost, zero-downtime deploys.
How to Deploy a Phoenix App to Gigalixir in 20 Minutes
Shows the basic steps to create a Phoenix app, adjust production config for Gigalixir, set buildpacks, create a database, and push the app to the host.
Elixir Phoenix App deployed into a Load Balanced DigitalOcean setup
The post walks through deploying a Phoenix app on DigitalOcean with Postgres, HAProxy, and two Phoenix nodes, stressing Erlang clustering, release-based deployment, and the limits of PaaS for this setup.
Supervising multiple GenServer processes
The post refactors a single board monitor into one GenServer per board, supervised by a module-based Supervisor, so a failure in one board does not wipe the state of the others.
Implementing Video Chat in a Phoenix Application with WebRTC
The post explains how to add video chat to a Phoenix app by using Phoenix channels to exchange signaling data, then creating a direct WebRTC peer connection with local and remote video streams.
Writing Acceptance tests in Phoenix
The post shows how to write acceptance tests in Phoenix with Hound, from setup and an IntegrationCase to form interactions, while noting the runtime cost of these tests.
Phoenix, to the basics and beyond.
The post outlines a short set of Phoenix topics beyond the default generators: editor setup, model definitions, custom primary keys and validators, and a Repository-based approach with macros.
What I learned migrating a Rails app to Elixir/Phoenix
The migration favors small functions, explicit composition, and Phoenix idioms over Rails patterns. It also shows where the ecosystem is thinner and where custom integrations or rewrites are needed.
Phoenix: The difference between web and lib
Phoenix has two code locations, `web` and `lib`. The key difference is that `web` is hot reloaded on each request, while `lib` is suited to state that lives beyond a request lifecycle.
Test-Driven APIs with Phoenix and Elixir
The tutorial uses TDD to build a Phoenix API for listing movies, adding dependencies, routes, a controller, a view, and a model while showing how each test failure guides the next change.
The Obligatory “Flame War” Phoenix vs Node.js
The post compares Node.js and Phoenix with simple Siege benchmarks, showing Node doing fine on I/O-bound requests but collapsing when each request blocks for one second, while Phoenix keeps handling the load.
Building an API Facade with Elixir
The post describes building a lightweight API serializer facade in Elixir and Phoenix, using pattern matching, guard clauses, and macros to keep serialization format-agnostic and DRY.
Ex Pusher Lite - Part 1: Phoenix Channels and Rails apps
The post shows a Rails chat built with Pusher, then starts replacing Pusher with a Phoenix server that receives POSTs from Rails and broadcasts them over WebSockets.
Sharing Functions Between Phoenix Controllers
The post explains how Phoenix controllers share imports through web/web.ex, how use MyApp.Web, :controller expands __using__/3, and how adding an import there makes helper functions available to all controllers.
What makes Elixir so attractive for some developers?
The post collects other developers’ reasons for liking Elixir, especially performance, concurrency, fault tolerance, metaprogramming, tooling, and Phoenix for real-time and distributed systems.
Internationalization using Gettext in the Phoenix framework
The post explains i18n and l10n in Phoenix 1.1, shows why Linguist was unwieldy, and walks through using Gettext, .pot and .po files, and a locale-switching plug.
Creating a Todo Application using the Phoenix Framework and Ember.js
The tutorial shows how to build a todo app with Phoenix and Elixir on the server, PostgreSQL for storage, and Ember on the client, then connect both apps through REST, CORS, and JSON key changes.
Phoenix: Templates Are Just Functions
The post explains that Phoenix templates are compiled into render functions injected into views, which made the author understand how `@conn` and pattern matching work during rendering.
CORS in Phoenix
Explains why SPAs need a backend, how Phoenix serves as a JSON API, what CORS is, and how Phoenix plugs can add CORS headers while handling pre-flight OPTIONS requests.
Phoenix & WebSockets
The thread says Phoenix could not support raw WebSockets directly at the time, because its websocket support for Channels was tied to a private Cowboy API. The recommended path was Plug dispatch options with a raw Cowboy websocket handler.
Why I’m betting on Elixir
The author argues that Elixir and Phoenix keep Ruby on Rails’ focus on developer happiness while adding fault tolerance, concurrency, speed, and a strong ecosystem backed by Erlang.
Doubts about layers and application's organization
A thread about how to organize Elixir code with Phoenix and Ecto. José Valim and others advise delaying architecture decisions, avoiding premature optimization, and separating database queries into explicit query modules.
How to work with multiple Channels in Phoenix?
The thread asks whether user info can be shared across Phoenix topics through the socket struct. Chris McCord says the client must join each topic, while socket params and channel params can carry shared data.
Compile issues with Elixir/Phoenix in a Docker container
A Phoenix project compiled in Docker breaks after container restarts because Hex registry data in ~/.hex is not preserved, causing deps like plug to disappear from _build/dev/lib until deps are fetched again.
Build and test a blazing fast JSON API with Phoenix, an Elixir framework
The article shows how to build a Phoenix JSON API for contacts, starting with a test, then adding an Ecto model, migration, route, controller, and view until the test passes.
Elixir vs Ruby Showdown - Phoenix vs Rails
The post compares Phoenix and Rails on the same routed, rendered request and reports much higher throughput for Phoenix, with lower CPU load and steadier latency in localhost and Heroku benchmarks.