dwyl / learn-phoenix-framework

Leer hoe je Phoenix Framework kunt gebruiken om plezier te beleven aan het bouwen van real-time web/mobiele apps
die snel zijn voor “eindgebruikers”, betrouwbaar,schaalbaar, onderhoudbaar en (eenvoudig) uitbreidbaar!

Waarom?

Als web/mobiele app ontwikkelaars moeten we gebruik maken van het werk dat andere (echt slimme) mensen hebben gedaan
in plaats van constant dingen “from scratch” te bouwen; dat is waarom we frameworks gebruiken om onze apps te bouwen!

Zie: “Top 10 Reasons Why Phoenix” (verderop op deze pagina!)

Er zijn veel frameworks waaruit u kunt kiezen (een paar “populaire” worden hieronder genoemd in het gedeelte “Vragen”).
Maar als we afgaan op wat “populair” is, zouden we nog steeds overal paardje (en karretje) rijden en zou er geen vooruitgang worden geboekt.

Note: alle “Waarom”-redenen voor Elixir gelden ook voor Phoenix!
check them out: https://github.com/dwyl/learn-elixir#why

Wat?

Een webapplicatieraamwerk zonder compromissen!

Ontwikkelaarsvreugde

De grootste “beperking” in elk technologieproject zijn de mensen. Een “ondernemer”/”oprichter” of “producteigenaar” kan alle goede ideeën van de wereld hebben, als hij of zij niet in staat is het idee om te zetten in realiteit, is het zinloos.

(Should I Care About) Benchmarks?

U moet natuurlijk uw eigen benchmarks uitvoeren op uw eigen hardware/cloud en weloverwogen beslissingen nemen op basis van de vereisten van uw app/product, maar …. toen we de statistieken lazen voor hoeveel gelijktijdige gebruikers een Phoenix App aankan (met live WebSocket verbindingen) waren we weggeblazen! Het betekent dat we onze real-time app(s) kunnen bouwen met 90% minder middelen.

Performance Highlights

• aanzienlijk lagere latency en request response tijd dan wat dan ook! (dankzij Erlang’s lichtgewicht processen en ultra-efficiënte netwerk/bericht afhandeling)
• 4x meer requests-per-seconde dan de equivalente Node.js (Express.js) App.
• 9x meer doorvoer dan een Python 2.7 gebaseerde app. (Blokkeren is echt klote!)
• 10x – 100x meer requests verwerkt dan Ruby-on-Rails (afhankelijk van het type app!)
• Vergelijkbare prestaties als Go op een enkele server, maar een veel eenvoudiger multi-server concurrency model, dus horizontaal schalen over meerdere datacentra (“availability zones”) is veel eenvoudiger! (Erlang beheert de middelen voor meerdere servers/processors als een enkele app “vloot” en delegeert verzoeken/verwerking naar hen over clusters/zones!)

Dit alles betekent dat u aanzienlijk minder geld uitgeeft aan hardware/cloud-infrastructuur, zodat uw app/bedrijf een concurrentievoordeel op kosten kan behalen.

Als u in de gelukkige positie bent om te overwegen iets veel beters te gebruiken voor uw volgende project, kijk dan niet verder dan Phoenix!
Lees meer: http://www.phoenixframework.org

Wie?

Veel mensen/teams/bedrijven maken al gebruik van Erlang/Elixir en Phoenix en zien fenomenale resultaten!
Onder andere: Adobe, BBC, Spotify, Pinterest, Discord (Gamer Chat App),Groupon (Fave), Lonely Planet, Brightcove, Slack …
Zie: https://github.com/doomspork/elixir-companies

Wie zou Phoenix moeten leren?

• Mensen die een eenvoudige manier willen om een app te bouwen met alle moderne gemakken van “generators”, ingebouwde database-interface (“ORM”) en eersteklas WebSockets voor “real-time” terwijl ze een legendarische betrouwbaarheid krijgen.
• Teams die de ontwikkelaarsproductiviteit of Ruby-on-Rails of Django nodig hebben, maar minder “magie” willen (d.w.z. willen begrijpen hoe alles werkt!)
• Bedrijven die 90% minder willen uitgeven aan zowel ontwikkelaars- als infrastructuurkosten, zodat u meer mensen kunt bedienen met minder middelen.

Wie zou Phoenix NIET moeten leren?

• Iedereen die het “meest populaire” framework of taal (om wat voor reden dan ook) moet gebruiken.
• Bedrijven die al veel legacy Java/PHP/etc.hebben en niet de tijd kunnen investeren om iets nieuws te leren/gebruiken.
• Ontwikkelaars die “baanzekerheid” willen bug-fixing onbetrouwbare code.

Hoe?

Aannames / Pre-Requisites?

Elixir

Je kunt geen Phoenix App bouwen zonder Elixir te kennen.
Als Elixir nieuw voor u is, “star” (bookmark) this repo (zodat u er morgen naar kunt terugkeren)
en ga dan naar:github.com/dwyl/learn-elixir-leer elixir tot u het gevoel heeft dat u de syntax begrijpt, kom dan terug en leer Phoenix!

Specifiek moet u zich richten op het leren van de Elixir “Basics”:

• types van data
• atomen
• pattern matching
• maps
• functiedefinities
• modules

Node.js

Phoenix gebruikt Node.js om assets zoals JavaScript en CSS bestanden te compileren (met Webpack).
Zorg er gewoon voor dat u Node.js geïnstalleerd hebt. https://nodejs.org
U hoeft Node niet te kennen om Phoenix te gebruiken.

Installatie

Als u al wat Elixir heeft geleerd en Node.js heeft geinstalleerd, dan is de eerste stap om met Phoenix aan de slag te gaan de installatie!

De Phoenix documentatie is geweldig, dus we raden aan om de officiele phoenix installatie instructies te volgen!

U moet ook PostgreSQL installeren, er is een tutorial over hoe dit te doen in de Phoenix installatie gids die hierboven is gelinkt, maar u kunt ook onze learn-postgresql repofinstructies bekijken, en een issue maken als u problemen ondervindt!

Een basiskennis van JavaScript kan soms nuttig zijn, maar je hoeft niet te weten hoe je Node moet gebruiken om Phoenix te kunnen gebruiken.

Als je nieuwsgierig bent waarom ze Brunch.io hebben verkozen boven “alternatieven”,
het korte antwoord is: Eenvoud & Snelheid! Kijk: http://brunch.io/docs/why-brunch
Note: Phoenix v1.4 (nog niet uitgebracht op het moment van schrijven) gebruikt WebPack voor het compileren van assets,zie: CHANGELOG.md

Volgende?

Wordt u vertrouwd met de “Up and Running” (officiële) gids:https://hexdocs.pm/phoenix/up_and_running.html#content

Praktische voorbeelden?

Als u Phoenix eenmaal hebt geïnstalleerd en de officiële “up-and-running” gids hebt gevolgd,
kom dan terug en probeer deze beginnersvriendelijke voorbeelden:

• Teller (realtime gedeelde teller met gebruik van Phoenix LiveView):https://github.com/dwyl/phoenix-liveview-counter-tutorial
• Todo List (stap-voor-stap tutorial die laat zien hoe je een volledig functionele TodoMVC kloon bouwt):https://github.com/dwyl/phoenix-todo-list-tutorial
• Chat (realtime UI/UX met behulp van WebSockets):https://github.com/dwyl/phoenix-chat-example
• Encryptie (beveiliging):https://github.com/dwyl/phoenix-ecto-encryption-example
• Append-only Log (hoe je de gegevens van je App opslaat):https://github.com/dwyl/phoenix-ecto-append-only-log-example

Boek?

We raden mensen aan het boek van @chrismccord te kopen (of te lenen): “Programming Phoenix”
zie: https://pragprog.com/book/phoenix14/programming-phoenix-1-4

De auteurs zijn individueel indrukwekkend en gezamenlijk behandelen ze Phoenix zoals niemand anders dat kan! Chris heeft Phoenix gemaakt, José heeft Elixir gemaakt en Bruce is een zeer ervaren technisch auteur met vele succesvolle boeken op zijn naam!
(Dat wil zeggen: het boek is de voor de hand liggende keuze voor hoe Phoenix te leren!

Video Intro door José Valim (Schepper van Elixir)

https://youtu.be/MD3P7Qan3pw

https://youtu.be/srtMWzyqdp8

Resources

• 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

Onze Top 10 Redenen waarom Phoenix

“Phoenix biedt de productiviteit van Ruby-on-Rails
met de concurrency en fouttolerantie van Erlang.”

1. Naast alle (fantastische) technische voordelen, is wat ons aantrekt in Phoenix de geweldige community van mensen over de hele wereld die enthousiast zijn om van Phoenix een geweldige tool te maken voor het bouwen van webapps!
   Goede mensen die je

• helpen als je vastloopt, geduldig dingen
• uitleggen, vragen beantwoorden (zowel “noob “als “gevorderd”) en
• openlijk (jouw) ideeën voor verbeteringen bespreken.zie: https://elixirforum.com/t/phoenix-v1-3-0-rc-0-released/3947

1. Phoenix gebruikt de programmeertaal Elixir, wat betekent dat uw app wordt gecompileerd en uitgevoerd op de Erlang Virtual Machine “BEAM”.
   Erlang is een beproefde, uiterst fouttolerante VM die door veel telecommunicatiebedrijven wordt gebruikt

2. WebSockets (“channels”) zijn in het framework ingebouwd, wat betekent dat het bouwen van apps met “real-time” communicatie en interactie veel eenvoudiger is dan vrijwel elk ander framework/platform! (geen magic-module van derden nodig! alles wat je nodig hebt is er al, klaar om miljoenen mensen van dienst te zijn!!)
   zie: http://www.phoenixframework.org/docs/channels

3. Eenvoudige asynchronisatie omdat alle programmering in Phoenix (Elixir) Functioneel is! Dit betekent dat het heel eenvoudig is om nuttige functionaliteit zoals authenticatie van verzoeken, logging en verwerking te abstraheren in “piplines” die gemakkelijk leesbaar zijn voor mensen! (geen async module van derden vereist! geen “beloften”, “generatoren” of “observeerbaarheden” om te beheren!)

4. Veiligheid & is de default Resilience Mindset.Encryptie (SSL) is eenvoudig in Phoenix/Elixir en zowel mitigatie van SQL-injectie, Cross-site Scripting (XSS) en CSRF-bescherming zijn ingebouwd (mogelijk gemaakt door default), dus het is vrijwel onmogelijk voor een “beginnende” programmeur om dit soort beveiligingsfouten te introduceren.

5. Concise Code kan niet worden onderschat! We kunnen veel minder regels schrijven dan in een equivalente Node.js/Java/Rails/Go-app, wat betekent dat ontwikkelaars productiever zijn en er minder code hoeft te worden onderhouden.

6. Testbaarheid dankzij functionele programmering van alle controllers.

7. Eenvoudige implementatie: http://www.phoenixframework.org/docs/heroku

8. Zero-downtime Deployment is gratis! (opnieuw vanwege Erlang). Erlang beheert de overgang van “live/actieve” gebruikers van de oude naar de nieuwe versie van uw app zonder dat ze zelfs maar merken dat de app is geüpgraded/geüpdatet!

9. Ingebouwde monitoring/beheer van uw app via Erlang supervisors betekent dat u precies weet hoe uw app presteert, welke onderdelen zijn gecrasht/opgestart en waarom! Dit is een functie waar we in andere frameworks (veel) voor betalen en hier is het gratis!

Kunt u nog een reden bedenken waarom het gebruik van Phoenix geweldig is?!
Deel uw mening in deze thread:https://github.com/dwyl/learn-phoenix-framework/issues/13

Vragen?

Moet ik Elixir leren voordat ik Phoenix probeer/gebruik?

Ja. Zie: https://github.com/dwyl/learn-elixir

Moet ik Erlang kennen om Elixir & Phoenix te gebruiken…?

Nee. U kunt vandaag beginnen met het leren/gebruiken van Elixir en Erlang-functies aanroepen wanneer dat nodig is,
maar u hoeft Erlang niet te kennenbefore u kunt Phoenix gebruiken!

Maar Phoenix is niet “Mainstream” … Moet ik/we het gebruiken…?

Er zijn vele web applicatie frameworks waaruit u/we kunnen kiezen:https://en.wikipedia.org/wiki/Comparison_of_web_frameworks
Dus waarom zou iemand een framework kiezen dat geschreven is in een programmeertaal die niet “mainstream” is…?

Waarom gebruiken we Hapi.js niet meer…?

Dit is misleidende informatie. We gebruiken Hapi.js nog steeds voor een aantal projecten waar dat zinvol is.
Dit omvat diverse client projecten en interne dwyl apps/tools.

We hebben besloten om Phoenix te gebruiken voor onze nieuwe projecten om deze simpele redenen:

• Elixir is een mooiere taal dan JavaScript.#LessIsMore #LessButBetter #SmallIsBeautiful #SyntaxMatters
• JS kan functioneel zijn, terwijl Elixir (altijd) Functioneel is! Het onderscheid maakt het verschil!
  Met “functioneel” programmeren, zijn de programma’s een stuk makkelijker om over na te denken terwijl je ze schrijft/onderhoudt!
• Elixir gebruikt de Erlang VM die veel efficiënter/krachtiger is dan “V8”
• De Erlang VM schaalt veel makkelijker naar multi-core multi-server multi-data-center dan Node.js
  (of vrijwel al het andere wat dat betreft!!)

Voor onze nieuwe projecten hebben we multi-data-center fouttolerantie nodig!
we krijgen dat “gratis” door Erlang -> Elixir -> Phoenix te gebruiken!!

Naar onze mening is Hapi.js nog steeds “het beste” Node.js framework en we zullen continue het blijven gebruiken en aanbevelen
aan mensen die eenvoudige apps nodig hebben die schaalbaar en eenvoudig te onderhouden zijn.
zie: https://github.com/dwyl/learn-hapi

Ook gebruiken we nog steeds JavaScript voor al onze AWS Lambda Micro-Services, dat zal niet veranderen.
Ze zijn eenvoudig, efficiënt en schalen echt goed!
zie: https://github.com/dwyl/learn-aws-lambda

Wat is er “fout” aan het gebruik van Rails of Django?

De oorspronkelijke “productieve” webframeworks waren “Ruby-on-Rails” en “Django” (python) in 2005!
(We hebben ze allebei gebruikt tijdens onze “reis” en kunnen spreken over de voordelen van elk van hen).

Er is “niets mis” met het gebruik van Rails of Django.
Wij denken dat er nog genoeg use-cases zijn voor beide frameworks.
We weten alleen dat het (veel) eenvoudiger is om “real-time” te bouwen
met Phoenix omdat “Channels” (WebSockets) zijn ingebouwd,
en de Elixir/Erlang concurrency is een heel ander ballgame!
Erlang (en dus Phoenix) kan miljoenen gelijktijdige gebruikers op een enkele server aan,
waar een Rails/Django server er maar een paar duizend aan kan (op zijn best!)
als je app maar een paar duizend mensen tegelijk bedient, dan zit je goed!

Wij vinden het geweldig dat Erlang gebruik maakt van “lighweight long-lived” processen,
wat betekent dat we miljoenen (IoT) apparaten kunnen aansluiten …Voor IoT is Erlang (onbetwistbaar) het Antwoord!
Voor eenvoudigere web apps waar je maar een paar gebruikers per dag verwacht, zijn Rails/Django nog steeds levensvatbaar.

Maar waarom compromissen sluiten als het niet hoeft?
Als je een Tesla kunt krijgen voor de “prijs” van een Ford Focus, waarom zou je dat dan niet doen?!?
Waarom genoegen nemen met goed als je makkelijk het beste kunt hebben/gebruiken?

Maar GitHub gebruikt nog steeds Rails … GitHub is toch “schaalbaar”?

Ja, GitHub gebruikt nog steeds Rails voor hun Web App/Site.
Maar vraag een van de kernteams van GitHub of ze (als ze de kans kregen om opnieuw te beginnen) Rails zouden kiezen om GitHub in 2017 te bouwen, en kijk eens hoeveel van hen “ja, natuurlijk” zeggen (met een strak gezicht…)!

Ook doet GitHub op de achtergrond veel dingen om Rails schaalbaar te maken.
En veel van hun nieuwere (client-side) functies zijn geschreven in JavaScript!zie: https://github.com/github

Bottom line is: alles kan schaalbaar worden gemaakt met behulp van “DevOps”,
maar Phoenix is schaalbaar gemaakt door defaultomdat Erlang (is) uitgevonden (om) schaalbaar te maken!

Waarom zou je Go NIET gebruiken?

“Er zijn twee soorten programmeertalen – de talen die niemand gebruikt en de talen waar iedereen over zeurt” ~ Bjarne Stroustrup(bedenker van C++)

Go is erg populair. Grotendeels dankzij het feit dat Google het “sponsort”.
Het was bedoeld om C++ en Java binnen Google te vereenvoudigen (vervangen)…
en voor het grootste deel, is het geslaagd!

We houden echt van Go. Het was onze “nummer twee” keuze toen we besloten welke programmeertaal
(na Elixir) in onze “post JS stack”…De beslissing om elixir te gebruiken in plaats van iets else was gemakkelijk:

• Elixir is functioneel (veel eenvoudiger te lezen/schrijven/onderhouden/uitbreiden)
• Elixir functies componeren op een echt elegante manier als “plugs”/”pipelines”
• Gegevens zijn onveranderlijk, waardoor de toestand van de applicatie voorspelbaar is (geen gissingen!
• Types zijn dynamisch en worden afgeleid (je hoeft ze niet handmatig aan te geven), maar er zijn regels die de zaken vereenvoudigen en de compiler controleert ze en geeft een passende waarschuwing.
• Erlang maakt gedistribueerde apps veel gemakkelijker en ons plan is om IoT-systemen te bouwen die inhouden dat vele (miljoenen) apparaten worden verbonden met persistente verbindingen, Erlang is hiervoor gemaakt!
• Phoenix bevat veel nuttige dingen out-of-the-box, waaronder een aantal beveiligingsfuncties waar de meeste mensen niet eens aan zullen denken.

Verder lezen:

• Waarom Go niet goed is: http://yager.io/programming/go.html
• Go Web Frameworks: https://medium.com/code-zen/why-i-don-t-use-go-web-frameworks-1087e1facfa4
• Waarom iedereen Go haat: https://npf.io/2014/10/why-everyone-hates-go/(click-bait titel, enkele geldige punten…)
• Discussie: https://www.reddit.com/r/elixir/comments/3c8yfz/how_does_go_compare_to_elixir

(`hulp gezocht` bij het uitbreiden van dit antwoord…)

Waarom geen Scala + Play Framework gebruiken…?

Als je al gewend bent om Java te schrijven of te deployen naar de JVM, is het Play Framework een uitstekende keuze: https://www.playframework.com
Scala is een goede programmeertaal en iedereen zou het moeten leren! https://www.scala-lang.org/what-is-scala.html

We hebben Play een paar keer gebruikt (voordat we Node.js gingen gebruiken) en vonden het erg leuk!
Maar Scala is een “gootsteen” (multi-paradigma) programmeertaal die mensen in staat stelt om “alles van Java” te gebruiken …
Wij denken dat Scala’s “Java Interoperability” betekent dat het “te gemakkelijk” is om complexiteit in je codebase toe te laten. Specifiek “OOP Mutation” …

Waarom gebruiken wij (DWYL) “Play” niet meer voor nieuwe projecten? Ten eerste zijn we een paar jaar geleden overgestapt op Hapi.js (Node.js) omdat het meer “lichtgewicht” was en ons in staat stelde kleine programma’s te schrijven die slechts een paar Megs RAM gebruikten (waar onze Play-apps erg veel bronnen gebruikten.

Samenvatting van “redenen” voor Phoenix in plaats van Play:

• We blijven erbij dat Play/Scala nog steeds veel geldige use-cases heeft.
• Elixir is veel eenvoudiger dan Scala.
• De Erlang VM is veel beter in concurrency dan de JVM.
• We vinden het geweldig dat alle gegevens in Elixir onveranderlijk zijn.
• We vinden het geweldig hoe weinig resources het kost om een Phoenix-app te draaien (bijv. op een Raspberry Pi!!!

Wij denken gewoon dat voor ons project(en) Erlang’s Concurrency model beter werkt en Functionele code die Immutable data transformeert is makkelijker te testen en te onderhouden.

Als u bewijs heeft dat “Scala eenvoudiger is” dan zouden we dat graag van u horen!
Vertel het ons: https://github.com/dwyl/learn-phoenix-web-development/issues

Waarom niet Haskell?

Als u zo van Functioneel Programmeren (FP) houdt, waarom dan niet Haskell?

Stel gerust meer vragen: https://github.com/dwyl/learn-phoenix-framework/issues