Learn how to use Phoenix Framework to
have fun building real-time web/mobile apps
that are fast for "end-users", reliable,
scalable, maintainable and (easily) extensible!
As web/mobile app developers we need to leverage
the work that other (really smart) people have done
instead of constantly building things "from scratch" all the time;
that is why we use frameworks to build our apps!
See: "Top 10 Reasons Why Phoenix" (further down this page!)
There are many frameworks to choose from
(a few "popular" ones are mentioned below
in the "Questions" section).
But if we go by what is "popular" we would
still be riding horses (and carts) everywhere
and no progress would be made.
Note: all the reasons "Why" for Elixir also apply to Phoenix!
check them out: https://github.com/dwyl/learn-elixir#why
A web application framework without compromise!
The biggest "constraint" in any technology project is people. An "Entrepreneur"/"Founder" or "Product Owner" can have all the good ideas in the world, if they are unable to convert idea into reality, it's meaningless.
Obviously, you should run your own benchmarks on your own hardware/cloud and make informed decisions based on the requirements of your app/product, but ... when we read the stats for how many concurrent users a Phoenix App can handle (with live WebSocket connections) we were blown away! It means we can build our real-time app(s) with 90% fewer resources.
All of this means that you spend considerably less money on Hardware/Cloud infrastructure so your app/company can gain a competitive advantage on cost.
If you are in the fortunate position to be considering using something way better for your next project, look no further than Phoenix!
Read more: http://www.phoenixframework.org
Many people/teams/companies are already
using Erlang/Elixir and Phoenix and seeing phenomenal results!
Including: Adobe, BBC, Spotify, Pinterest, Discord (Gamer Chat App),
Groupon (Fave), Lonely Planet, Brightcove, Slack ...
See: https://github.com/doomspork/elixir-companies
You cannot build a Phoenix App without knowing Elixir.
If you are new to Elixir, "star" (bookmark) this
repo
(so you can return to it tomorrow)
and then go to:
github.com/dwyl/learn-elixir
learn elixir until you feel like you understand the syntax,
then come back and learn Phoenix!
Specifically you should focus on learning the Elixir "Basics":
Phoenix uses Node.js to compile
assets like JavaScript and CSS files (using Webpack).
Simply ensure you have Node.js installed. https://nodejs.org
You don't need to know Node to use Phoenix.
If you've already learned some Elixir and installed Node.js, then the first step to getting started with Phoenix is installation!
The Phoenix documentation is amazing, so we recommend following the official phoenix installation instructions!
You'll also need to install PostgreSQL, there is a tutorial of how to do so
linked in the Phoenix installation guide linked above, but you can also check
out our learn-postgresql
repo
for instructions, and raise an issue if you have any trouble!
While a basic understanding of JavaScript can be useful at times, you don't need to know how to use Node to use Phoenix.
If you're curious why they chose Brunch.io over "alternatives",
the short answer is: Simplicity & Speed! see: http://brunch.io/docs/why-brunch
Note: Phoenix v1.4 (unreleased at the time of writing) uses WebPack for asset compilation, see: CHANGELOG.md
Familiarize yourself with the "Up and Running" (official) guide: https://hexdocs.pm/phoenix/up_and_running.html#content
Once you have phoenix installed
and followed the official "up and running" guide,
come back and try these beginner-friendly examples:
We recommend that people buy (or borrow)
@chrismccord's book:
"Programming Phoenix"
see: https://pragprog.com/book/phoenix14/programming-phoenix-1-4
The authors are individually impressive and collectively
they comprehenisively cover Phoenix like nobody else can!
Chris created Phoenix, José created Elixir
and Bruce is ultra-experienced technical author
with many successful books to his name!
(i.e: the book is the obvious choice for how to learn Phoenix!)
"Phoenix provides the productivity of Ruby-on-Rails
with the concurrency and fault-tolerance of Erlang."
Beyond all the (fantastic) technical benefits,
what attracts us to Phoenix is the Great Community
of people around the world who are excited about making Phoenix
an amazing tool for building web apps!
Having welcomming people who will
Phoenix uses the Elixir programming language which means your
app is compiled and run on the Erlang Virtual Machine "BEAM".
Erlang is a battle-tested highly fault-tolerant VM used by
many telecommunications companies
WebSockets ("channels") are built-in to the framework
which means building apps with "real-time" communication and interaction
is much easier than virtually any other framework/platform!
(no third-party magic
module needed! everything you need is
already there ready for you to serve millions of people!!)
see: http://www.phoenixframework.org/docs/channels
Easy asyncrhonisity because all programming
in Phoenix (Elixir) is Functional!
This means it's really simple to abstract useful functionality
like request authentication, logging and processing into "piplines"
that are easily human-readable! (no third-party async
module required! no "promises", "generators" or "observables" to managed!!)
Security & Resilience Mindset is the default
.
Encryption (SSL) is easy in Phoenix/Elixir and
both mitigation of SQL injection,
Cross-site Scripting (XSS)
and CSRF protection are built-in (enabled by default
) so
it's virtually impossible for a "novice" programmer
to introduce this type of security bug.
Concise Code cannot be understated! We can write way fewer lines than in the equivalent Node.js/Java/Rails/Go app, this means developers are more productive and there is less code to maintain!
Testability due to functional programming of all controllers!
Easy Deployment: https://hexdocs.pm/phoenix/heroku.html
Zero-downtime Deployment is free! (again because of Erlang). Erlang manages transitioning "live/active" users from the old to new version of your app without them even noticing that it was upgraded/updated!!
Built-in Monitoring/Managment of your app through Erlang supervisors mean that you know exactly how your app is performing, what parts have crashed/restarted and why! This is a feature we pay (a lot) for in other frameworks and here it's free!!
Can you think of another reason
why using Phoenix is awesome?!
Please Share your thoughts in this thread:
https://github.com/dwyl/learn-phoenix-framework/issues/13
before
trying/using Phoenix?Yes. See: https://github.com/dwyl/learn-elixir
No. You can start learning/using Elixir today and
call Erlang functions when required,
but you don't need to know Erlang
before
you can use Phoenix!
There are many web application frameworks you/we can choose from:
https://en.wikipedia.org/wiki/Comparison_of_web_frameworks
So why would anyone select a framework written in a programming language
that is not "mainstream"...?
This is missinformation. We are still using Hapi.js
for a number of projects where it is appropriate.
This includes several client projects and internal dwyl apps/tools.
We decided to use Phoenix for our new projects for these simple reasons:
#LessIsMore
#LessButBetter
#SmallIsBeautiful
#SyntaxMatters
For our new projects we need multi-data-center fault-tolerance!
we get that "for free" by using Erlang -> Elixir -> Phoenix!!
In our opinion Hapi.js is still "the best" Node.js framework and
we will continue
to use and recommend it
to people that need simple apps that scale and are easy to maintain.
see: https://github.com/dwyl/learn-hapi
Also we still use JavaScript for all our AWS Lambda Micro-Services,
that is not going to change.
They are simple, efficient and
scale really well!
see: https://github.com/dwyl/learn-aws-lambda
The original "productive" web frameworks
were "Ruby-on-Rails" and "Django" (python) back in 2005!
(We used both of these for periods in our "journey" and
can speak on the advantages of each of them!)
There is "nothing wrong" with using Rails or Django.
We think there are still plenty of use-cases for both frameworks.
We just know that it's (a lot) easier to build "real-time"
with Phoenix because "Channels" (WebSockets) are baked in,
and the Elixir/Erlang concurrency is a whole different ballgame!
Erlang (and thus Phoenix) can handle millions of concurrent users on a single server,
whereas a Rails/Django server can only handle a few thousand (at best!)
if your app is only serving a few thousand people at once, then you're fine!!
We love the fact that Erlang uses "lighweight long-lived" processes,
which means we can connect millions of (IoT) devices ...
For IoT Erlang is (unquestionably) the Answer!
For simpler web apps where you only expect a few users per day,
Rails/Django are still viable.
But why compromise if you don't have to?
If you can have a Tesla for the "price" of a Ford Focus,
why wouldn't you?!?
Why settle for good when you can easily have/use the best?
Yes, GitHub is still using Rails for their Web App/Site.
But ask any of the core team at GitHub if (given the chance to start over)
they would chose Rails
to build GitHub in 2017, and see how many of them say "yes, of course"
(with a straight face...)!
Also, GitHub does a lot of things to Scale Rails in the background.
And many of their newer (client-side) features are written in JavaScript!
see: https://github.com/github
Bottom line is: anything can be made to scale using "DevOps",
but Phoenix is made to scale bydefault
because Erlang (was) invented (to) scale!
"There are two kinds of programming languages - those that nobody uses and those that everybody's bitching about" ~ Bjarne Stroustrup (creator of
C++
)
Go is very popular. Largely due to the fact that Google "sponsors" it.
It was meant to simplify (replace) C++
and Java inside Google ...
and for the most part, it has succeeded!
We really like Go. It was our "number two" choice when deciding
what programming language
(after Elixir) in our "post JS stack"...
The decision to use elixir
instead of anything else
was easy:
Further Reading:
help wanted
expanding this answer...)Play
Framework instead...?If you are already used to writing Java or deploying to the JVM,
the Play Framework is a superb choice: https://www.playframework.com
Scala is a good programming language and everyone should learn it!
https://www.scala-lang.org/what-is-scala.html
We have used Play a few times (before we adopted Node.js) and really liked it!
But Scala is a "kitchen sink" (multi-paradigm) programming language that allows people to use "all of Java" ...
We think Scala's "Java Interoperability" means it's "too easy" to allow complexity into your codebase. Specifically "OOP Mutation" ...
So why aren't we (DWYL) using "Play" for new projects any more? Firstly, we transitioned to Hapi.js (Node.js) a few years ago because it was more "lightweight" and allowed us to write tiny programs that used only a few Megs of RAM (where our Play apps were very resource-hungry..! have you ever tried running a Scala app on a "basic" laptop like a Chromebook...?)
Summary of "reasons" for Phoenix instead of Play:
We just think that for our project(s) Erlang's Concurrency model works better and Functional code transforming Immutable data is easier to test and maintain.
If you have evidence that "Scala is Simpler"
we would love to hear from you!
Tell us: https://github.com/dwyl/learn-phoenix-web-development/issues
If you like Functional Programming (FP) so much, why not use Haskell?