dwyl / learn-phoenix-framework

Apprenez à utiliser Phoenix Framework pour vous amuser à construire des applications web/mobiles en temps réel
qui sont rapides pour les « utilisateurs finaux », fiables,évolutives, maintenables et (facilement) extensibles !

Pourquoi?

En tant que développeurs d’applications web/mobiles, nous devons tirer parti du travail que d’autres personnes (très intelligentes) ont fait
au lieu de construire constamment des choses « à partir de zéro » tout le temps;c’est pourquoi nous utilisons des frameworks pour construire nos applications!

Voir : « Les 10 principales raisons pour lesquelles Phoenix » (plus bas sur cette page !)

Il existe de nombreux frameworks parmi lesquels choisir(quelques uns « populaires » sont mentionnés ci-dessous dans la section « Questions »).
Mais si nous nous fions à ce qui est « populaire », nous serions encore à cheval (et à la charrette) partout et aucun progrès ne serait fait.

Note : toutes les raisons « Pourquoi « pour Elixir s’appliquent également à Phoenix !
Vérifiez-les : https://github.com/dwyl/learn-elixir#why

Quoi ?

Un framework d’application web sans compromis !

Joie du développeur

La plus grande « contrainte » dans tout projet technologique est les gens.Un « entrepreneur »/ »fondateur » ou « propriétaire de produit » peut avoir toutes les bonnes idées du monde, s’ils sont incapables de convertir l’idée en réalité, cela n’a aucun sens.

(Should I Care About) Benchmarks?

Evidemment, vous devriez exécuter vos propres benchmarks sur votre propre matériel/cloudet prendre des décisions éclairées en fonction des exigences de votre application/produit,mais …. lorsque nous avons lu les statistiques sur le nombre d’utilisateurs simultanés que Phoenix App peut gérer (avec des connexions WebSocket en direct), nous avons été époustouflés ! Cela signifie que nous pouvons construire notre (nos) application(s) en temps réel avec 90 % de ressources en moins.

Points forts de la performance

• latence et temps de réponse aux requêtes considérablement inférieurs à tout le reste ! (grâce aux processus légers d’Erlang et à la gestion ultra-efficace du réseau/des messages)
• 4 fois plus de demandes par seconde que l’application équivalente Node.js (Express.js).
• 9x plus de débit qu’une application basée sur Python 2.7. (Le blocage est vraiment nul !)
• 10x – 100x plus de requêtes traitées que Ruby-on-Rails(selon le type d’application !)
• Performances similaires à celles de Go sur un seul serveur, mais un modèle de concurrence multiserveur beaucoup plus simple, de sorte que la mise à l’échelle horizontale sur plusieurs centres de données(« zones de disponibilité ») est beaucoup plus facile ! (Erlang gère les ressources de plusieurs serveurs/processeurs comme une seule « flotte » d’applications et leur délègue les demandes/traitements à travers les clusters/zones !)

Tout cela signifie que vous dépensez considérablement moins d’argent sur l’infrastructure Hardware/Cloud, de sorte que votre application/entreprise peut obtenir un avantage concurrentiel sur le coût.

Si vous avez la chance d’envisager d’utiliser quelque chose de bien meilleur pour votre prochain projet, ne cherchez pas plus loin que Phoenix !
Lire la suite : http://www.phoenixframework.org

Qui?

De nombreuses personnes/équipes/entreprises utilisent déjà Erlang/Elixir et Phoenix et constatent des résultats phénoménaux !
Comprenant : Adobe, BBC, Spotify, Pinterest, Discord (application de chat pour joueurs),Groupon (Fave), Lonely Planet, Brightcove, Slack….
Voir : https://github.com/doomspork/elixir-companies

Qui devrait apprendre Phoenix?

• Les personnes qui veulent un moyen facile de construire une application avec toutes les commodités modernes des « générateurs », de l’interface de base de données intégrée (« ORM ») et des WebSockets de première classe pour le « temps réel » tout en obtenant une fiabilité légendaire.
• Les équipes qui ont besoin de la productivité des développeurs ou de Ruby-on-Rails ou Django,mais qui veulent moins de « magie » (c’est-à-dire qui veulent comprendre comment tout fonctionne !).
• Les entreprises qui veulent dépenser 90% de moins sur les coûts de développeurs et d’infrastructure afin que vous puissiez servir plus de gens avec moins de ressources.

Qui ne devrait PAS apprendre Phoenix?

• Toute personne qui a besoin d’utiliser le framework ou le langage « le plus populaire »(pour quelque raison que ce soit).
• Les entreprises qui ont déjà beaucoup de Java/PHP/etc. hérités et ne peuvent pas investir le temps d’apprendre/utiliser quelque chose de nouveau.
• Développeurs qui veulent la « sécurité de l’emploi » en corrigeant des bogues de code peu fiable.

Comment ?

Hypothèses / Pré-requis ?

Elixir

Vous ne pouvez pas construire une application Phoenix sans connaître Elixir.
Si vous êtes nouveau à Elixir, « star » (marque-page) thisrepo(afin que vous puissiez y revenir demain)
et ensuite allez sur:github.com/dwyl/learn-elixirapprenez elixir jusqu’à ce que vous ayez l’impression de comprendre la syntaxe,puis revenez et apprenez Phoenix !

Spécifiquement, vous devriez vous concentrer sur l’apprentissage des « bases » d’Elixir :

• types de données
• atomes
• correspondance de modèles
• maps
• définitions de fonctions
• modules

Node.js

Phoenix utilise Node.js pour compiler lesassets comme les fichiers JavaScript et CSS (en utilisant Webpack).
S’assurer simplement que vous avez Node.js installé. https://nodejs.org
Vous n’avez pas besoin de connaître Node pour utiliser Phoenix.

Installation

Si vous avez déjà appris un peu d’Elixir et installé Node.js, alors la première étape pour commencer à utiliser Phoenix est l’installation !

La documentation de Phoenix est incroyable, nous vous recommandons donc de suivre les instructions officielles d’installation de phoenix !

Vous aurez également besoin d’installer PostgreSQL, il y a un tutoriel de comment faire solinked dans le guide d’installation de Phoenix lié ci-dessus, mais vous pouvez également vérifier notre learn-postgresql repofor instructions, et soulever un problème si vous avez des problèmes !

Bien qu’une compréhension de base de JavaScript puisse être utile à certains moments, vous n’avez pas besoin de savoir comment utiliser Node pour utiliser Phoenix.

Si vous êtes curieux de savoir pourquoi ils ont choisi Brunch.io par rapport aux « alternatives »,
la réponse courte est : Simplicité & Rapidité!
Voir : http://brunch.io/docs/why-brunch
Note : Phoenix v1.4 (non publié au moment de la rédaction)utilise WebPack pour la compilation des actifs,voir : CHANGELOG.md

Suivant?

Familiarisez-vous avec le guide « Up and Running » (officiel):https://hexdocs.pm/phoenix/up_and_running.html#content

Exemples pratiques ?

Une fois que vous avez installé phoenix et suivi le guide officiel « up and running »,
revenez et essayez ces exemples conviviaux pour les débutants:

• Compteur (compteur partagé en temps réel utilisant Phoenix LiveView) :https://github.com/dwyl/phoenix-liveview-counter-tutorial
• Liste de tâches (tutoriel étape par étape montrant comment construire un clone TodoMVC entièrement fonctionnel):https://github.com/dwyl/phoenix-todo-list-tutorial
• Chat (UI/UX en temps réel utilisant WebSockets):https://github.com/dwyl/phoenix-chat-example
• Cryptage (sécurité):https://github.com/dwyl/phoenix-ecto-encryption-example
• Journal de l’application (comment stocker les données de votre application):https://github.com/dwyl/phoenix-ecto-append-only-log-example

Livre ?

Nous recommandons aux gens d’acheter (ou d’emprunter)le livre de @chrismccord : « Programming Phoenix »
voir : https://pragprog.com/book/phoenix14/programming-phoenix-1-4

Les auteurs sont individuellement impressionnants et collectivementils couvrent de manière compréhensible Phoenix comme personne d’autre ne peut le faire !Chris a créé Phoenix, José a créé Elixir et Bruce est un auteur technique ultra-expérimenté avec de nombreux livres à succès à son nom !
(c’est-à-dire que ce livre est le choix évident pour savoir comment apprendre Phoenix !)

Intro vidéo de José Valim (Créateur d’Elixir)

https://youtu.be/MD3P7Qan3pw

https://youtu.be/srtMWzyqdp8

Ressources

• Elixir vs Ruby Showdown – Phoenix vs Rails : https://littlelines.com/blog/2014/07/08/elixir-vs-ruby-showdown-phoenix-vs-rails
• Benchmark : https://github.com/mroth/phoenix-showdown

Nos 10 principales raisons pour lesquelles Phoenix

« Phoenix fournit la productivité de Ruby-on-Rails
avec la concurrence et la tolérance aux pannes d’Erlang. »

1. Au delà de tous les avantages techniques (fantastiques), ce qui nous attire dans Phoenix, c’est la grande communauté de personnes du monde entier qui sont enthousiastes à l’idée de faire de Phoenix un outil incroyable pour la création d’applications web !
   Avoir des personnes bienveillantes qui vont

• vous aider lorsque vous êtes bloqué, vous expliquer patiemment les choses
• répondre aux questions (aussi bien « noob « que « avancé ») et
• discuter ouvertement de (vos) idées d’améliorations.Voir : https://elixirforum.com/t/phoenix-v1-3-0-rc-0-released/3947

1. Phoenix utilise le langage de programmation Elixir, ce qui signifie que votre application est compilée et exécutée sur la machine virtuelle Erlang « BEAM ».
   Erlang est une machine virtuelle hautement tolérante aux pannes, testée au combat et utilisée par de nombreuses sociétés de télécommunications

2. Les web-sockets (« canaux ») sont intégrés au framework, ce qui signifie que la création d’applications avec une communication et une interaction en « temps réel » est beaucoup plus facile que pratiquement n’importe quel autre framework/plateforme !(aucun module magic tiers n’est nécessaire ! tout ce dont vous avez besoin est déjà là, prêt à servir des millions de personnes ! !!)
   voir : http://www.phoenixframework.org/docs/channels

3. Asynchronisation facile car toute la programmation dans Phoenix (Elixir) est fonctionnelle !Cela signifie qu’il est vraiment simple d’abstraire des fonctionnalités utiles comme l’authentification des demandes, la journalisation et le traitement dans des « piplines « qui sont facilement lisibles par l’homme ! (aucun async module tiers requis ! pas de « promesses », de « générateurs » ou d' »observables » à gérer ! !)

4. Sécurité & L’état d’esprit de résilience est le default.Le cryptage (SSL) est facile dans Phoenix/Elixir et les deux atténuations de l’injection SQL, du Cross-site Scripting (XSS) et de la protection CSRF sont intégrées (activées par default), donc il est pratiquement impossible pour un programmeur « novice » d’introduire ce type de bogue de sécurité.

5. Code concis ne peut pas être sous-estimé ! Nous pouvons écrire beaucoup moins de lignes que dans l’application Node.js/Java/Rails/Go équivalente, cela signifie que les développeurs sont plus productifs et qu’il y a moins de code à maintenir !

6. Testabilité en raison de la programmation fonctionnelle de tous les contrôleurs !

7. Déploiement facile : http://www.phoenixframework.org/docs/heroku

8. Le déploiement zéro temps mort est gratuit ! (encore une fois grâce à Erlang). Erlang gère la transition des utilisateurs « vivants/actifs » de l’ancienne à la nouvelle version de votre application sans qu’ils ne remarquent même pas qu’elle a été mise à niveau/mise à jour !

9. Surveillance/gestion intégrée de votre application par le biais de superviseurs Erlang signifient que vous savez exactement comment votre application fonctionne, quelles parties ont planté/redémarré et pourquoi ! C’est une fonctionnalité pour laquelle nous payons (beaucoup) dans d’autres frameworks et ici elle est gratuite !

Pouvez-vous penser à une autre raisonpour laquelle utiliser Phoenix est génial ? !
Veuillez partager vos pensées dans ce fil de discussion:https://github.com/dwyl/learn-phoenix-framework/issues/13

Questions?

Dois-je apprendre Elixir avant d’essayer/utiliser Phoenix?

Oui. Voyez : https://github.com/dwyl/learn-elixir

Dois-je connaître Erlang pour utiliser Elixir & Phoenix… ?

Non. Vous pouvez commencer à apprendre/utiliser Elixir aujourd’hui et appeler des fonctions Erlang lorsque cela est nécessaire,
mais vous n’avez pas besoin de connaître Erlangbefore vous pouvez utiliser Phoenix!

Mais Phoenix n’est pas « Mainstream » …. Devrais-je/nous l’utiliser…?

Il existe de nombreux frameworks d’application web parmi lesquels vous/nous pouvons choisir:https://en.wikipedia.org/wiki/Comparison_of_web_frameworks
Alors pourquoi quelqu’un choisirait un framework écrit dans un langage de programmationqui n’est pas « grand public »…?

Pourquoi n’utilisons-nous plus Hapi.js…?

C’est de la désinformation. Nous utilisons encore Hapi.jspour un certain nombre de projets où il est approprié.
Cela inclut plusieurs projets clients et des apps/outils internes dwyl.

Nous avons décidé d’utiliser Phoenix pour nos nouveaux projets pour ces simples raisons :

• Elixir est un langage plus agréable que JavaScript.#LessIsMore #LessButBetter #SmallIsBeautiful #SyntaxMatters
• JS peut être fonctionnel, alors qu’Elixir est (toujours) Fonctionnel !La distinction fait toute la différence !
  Avec la programmation « fonctionnelle », les programmes sont beaucoup plus faciles à penser pendant que vous les écrivez/maintenez !
• Elixir utilise la VM Erlang qui est beaucoup plus efficace/puissante que « V8 »
• La VM Erlang évolue beaucoup plus facilement vers les multi-cœurs multi-serveurs multi-centre de données que Node.js
  (ou à peu près tout le reste d’ailleurs !)

Pour nos nouveaux projets, nous avons besoin d’une tolérance aux pannes multi-centre de données !
nous l’obtenons « gratuitement » en utilisant Erlang -> Elixir -> Phoenix !!

À notre avis, Hapi.js est toujours « le meilleur » framework Node.js et nous continuel’utiliserons et le recommanderons
aux personnes qui ont besoin d’applications simples qui évoluent et sont faciles à maintenir.
Voir : https://github.com/dwyl/learn-hapi

De plus, nous utilisons toujours JavaScript pour tous nos micro-services AWS Lambda, cela ne va pas changer.
Ils sont simples, efficaces et s’échelonnent vraiment bien !
Voir : https://github.com/dwyl/learn-aws-lambda

Qu’est-ce qui est « mauvais » d’utiliser Rails ou Django?

Les cadres web « productifs » originaux étaient « Ruby-on-Rails » et « Django » (python) en 2005 !
(Nous avons utilisé les deux pendant des périodes dans notre « voyage » et pouvons parler des avantages de chacun d’eux !).

Il n’y a « rien de mal » à utiliser Rails ou Django.
Nous pensons qu’il y a encore beaucoup de cas d’utilisation pour les deux frameworks.
Nous savons juste qu’il est (beaucoup) plus facile de construire en « temps réel »
avec Phoenix parce que les « Canaux » (WebSockets) sont intégrés,
et la concurrence Elixir/Erlang est un tout autre jeu de balle !
Erlang (et donc Phoenix) peut gérer des millions d’utilisateurs simultanés sur un seul serveur,
alors qu’un serveur Rails/Django ne peut en gérer que quelques milliers (au mieux !)
si votre application ne sert que quelques milliers de personnes à la fois, alors vous êtes bien !!

Nous aimons le fait qu’Erlang utilise des processus « légers à longue durée de vie »,
ce qui signifie que nous pouvons connecter des millions de dispositifs (IoT)…Pour l’IoT, Erlang est (incontestablement) la réponse !
Pour des applications web plus simples où vous n’attendez que quelques utilisateurs par jour,Rails/Django sont encore viables.

Mais pourquoi faire des compromis si vous n’avez pas à le faire ?
Si vous pouvez avoir une Tesla pour le « prix » d’une Ford Focus, pourquoi ne le feriez-vous pas ? !?
Pourquoi se contenter du bon quand on peut facilement avoir/utiliser le meilleur ?

Mais GitHub utilise toujours Rails …. GitHub est sûrement « évolutif »?

Oui, GitHub utilise toujours Rails pour son application/site Web.
Mais demandez à n’importe quel membre de l’équipe centrale de GitHub si (étant donné la chance de recommencer) ils choisiraient Rails
pour construire GitHub en 2017, et voyez combien d’entre eux répondent « oui, bien sûr »(avec un visage impassible…)!

De plus, GitHub fait beaucoup de choses pour faire évoluer Rails en arrière-plan.
Et beaucoup de leurs fonctionnalités plus récentes (côté client) sont écrites en JavaScript !voir : https://github.com/github

La ligne de fond est : tout peut être mis à l’échelle en utilisant « DevOps »,
mais Phoenix est mis à l’échelle par defaultparce que Erlang (a été) inventé (pour) l’échelle!

Pourquoi ne pas utiliser Go ?

« Il y a deux sortes de langages de programmation – ceux que personne n’utilise et ceux dont tout le monde râle » ~ Bjarne Stroustrup(créateur de C++)

Go est très populaire. En grande partie grâce au fait que Google le « sponsorise ».
Il était destiné à simplifier (remplacer) C++ et Java à l’intérieur de Google….
et pour la plupart, il a réussi !

Nous aimons vraiment Go. C’était notre choix  » numéro deux  » lorsque nous avons décidé quel langage de programmation
(après Elixir) dans notre  » pile post JS « ….La décision d’utiliser elixir au lieu de tout else a été facile:

• Elixir est fonctionnel (beaucoup plus simple à lire/écrire/maintenir/extendre)
• Les fonctions Elixir se composent d’une manière vraiment élégante comme des « plugs »/ »pipelines »
• Les données sont immuables ce qui rend l’état de l’application prévisible (pas de devinette !)
• Les types sont dynamiques et inférés (pas besoin de les déclarer manuellement)mais il existe des règles qui simplifient les choses et le compilateur les vérifieen donnant un avertissement approprié.
• Erlang rend les applications distribuées beaucoup plus faciles et notre plan est de construire des systèmesIoT qui signifieront la connexion de nombreux (millions) appareilsavec des connexions persistantes, Erlang a été fait pour cela !
• Phoenix inclut de nombreuses choses utiles hors de la boîte, y compris plusieurs fonctionnalités de sécurité auxquelles la plupart des gens ne penseront même pas.

Lecture complémentaire:

• Pourquoi Go n’est pas bon : http://yager.io/programming/go.html
• Cadres Web Go : https://medium.com/code-zen/why-i-don-t-use-go-web-frameworks-1087e1facfa4
• Pourquoi tout le monde déteste Go : https://npf.io/2014/10/why-everyone-hates-go/(titre click-bait, quelques points valables…)
• Discussion : https://www.reddit.com/r/elixir/comments/3c8yfz/how_does_go_compare_to_elixir

(`help wanted` élargissant cette réponse…)

Pourquoi ne pas utiliser Scala + Play Framework à la place…?

Si vous êtes déjà habitué à écrire du Java ou à déployer sur la JVM, le Play Framework est un superbe choix : https://www.playframework.com
Scala est un bon langage de programmation et tout le monde devrait l’apprendre!https://www.scala-lang.org/what-is-scala.html

Nous avons utilisé Play quelques fois (avant d’adopter Node.js)et l’avons vraiment apprécié !
Mais Scala est un langage de programmation « kitchen sink » (multi-paradigme)qui permet aux gens d’utiliser « tout Java »….
Nous pensons que l' »interopérabilité Java » de Scala signifie qu’il est « trop facile » de permettre la complexité dans votre base de code. Nous pensons que l' »interopérabilité Java » de Scala signifie qu’il est « trop facile » d’autoriser la complexité dans votre base de code.

Alors pourquoi nous (DWYL) n’utilisons plus « Play » pour les nouveaux projets ? Tout d’abord, nous avons fait la transition vers Hapi.js (Node.js) il y a quelques années parce qu’il était plus « léger » et nous a permis d’écrire de minuscules programmes qui n’utilisaient que quelques mégas de RAM (là où nos applications Play étaient très gourmandes en ressources..!avez-vous déjà essayé d’exécuter une application Scala sur un ordinateur portable « de base » comme un Chromebook… ?)

Résumé des « raisons » pour Phoenix au lieu de Play:

• Nous maintenons que Play/Scala a encore beaucoup de cas d’utilisation valables.
• Elixir est beaucoup plus simple que Scala.
• La VM Erlang est bien meilleure à la concurrence que la JVM.
• Nous aimons le fait que toutes les données sont immuables en Elixir.
• Nous aimons le peu de ressources nécessaires pour exécuter une application Phoenix(par exemple sur un Raspberry Pi !!).)

Nous pensons simplement que pour notre ou nos projets, le modèle de Concurrence d’Erlang fonctionne mieux et le code fonctionnel transformant des données immuablesest plus facile à tester et à maintenir.

Si vous avez des preuves que « Scala est plus simple « nous aimerions les entendre !
Dites-nous : https://github.com/dwyl/learn-phoenix-web-development/issues

Pourquoi ne pas utiliser Haskell?

Si vous aimez tant la programmation fonctionnelle (FP), pourquoi ne pas utiliser Haskell?

S’il vous plaît, posez plus de questions : https://github.com/dwyl/learn-phoenix-framework/issues