dwyl / learn-phoenix-framework

Lär dig att använda Phoenix Framework för attha kul att bygga webb-/mobilappar i realtid
som är snabba för ”slutanvändare”, tillförlitliga,skalbara, underhållbara och (lätt) utbyggbara!

Varför?

Som utvecklare av webb-/mobilappar måste vi utnyttja det arbete som andra (riktigt smarta) människor har gjort
i stället för att hela tiden bygga saker ”från grunden”; det är därför vi använder ramverk för att bygga våra appar!

Se: ”Det finns många ramverk att välja mellan (några ”populära” ramverk nämns nedan i avsnittet ”Frågor”).
Men om vi följer vad som är ”populärt” skulle vi fortfarande rida på hästar (och vagnar) överallt och inga framsteg skulle göras.

Notera: alla skäl ”Varför ”för Elixir gäller även för Phoenix!
Kontrollera dem: https://github.com/dwyl/learn-elixir#why

Vad?

En ram för webbprogram utan kompromisser!

Utvecklarglädje

Den största ”begränsningen” i alla teknikprojekt är människor.En ”entreprenör”/”grundare” eller ”produktägare” kan ha alla goda idéer i världen, men om de inte kan omvandla idén till verklighet är den meningslös.

(Bör jag bry mig om) benchmarks?

Oppenbart bör du köra dina egna benchmarks på din egen hårdvara/cloud och fatta välgrundade beslut baserat på kraven för din app/produkt, men …. när vi läste statistiken för hur många samtidiga användare Phoenix App kan hantera (med levande WebSocket-anslutningar) blev vi överväldigade!Det betyder att vi kan bygga våra realtidsappar med 90 % mindre resurser.

Prestandahöjdpunkter

• betydligt lägre latenstid och svarstid för förfrågningar än något annat! (tack vare Erlangs lätta processer och ultraeffektiva nätverks- och meddelandehantering)
• 4x fler förfrågningar per sekund än motsvarande Node.js (Express.js)-app.
• 9x mer genomströmning än en Python 2.7-baserad app. (blockering suger verkligen!)
• 10x – 100x fler begäranden än Ruby-on-Rails (beroende på typ av app!)
• Liknande prestanda som Go på en enda server, men en mycket enklare konkurrentmodell för flera servrar, så horisontell skalning över flera datacenter (”tillgänglighetszoner”) är mycket enklare! (Erlang hanterar resurserna för flera servrar/processorer som en enda app-”flotta” och delegerar förfrågningar/bearbetning till dem över kluster/zoner!)

Allt detta innebär att du spenderar betydligt mindre pengar på hårdvaru-/cloud-infrastruktur, så att din app/ ditt företag kan få en konkurrensfördel i fråga om kostnader.

Om du är i den lyckliga positionen att du överväger att använda något mycket bättre för ditt nästa projekt, behöver du inte titta längre än Phoenix!
Läs mer: http://www.phoenixframework.org

Vem?

Många människor/team/företag använder redan Erlang/Elixir och Phoenix och ser fenomenala resultat!
Inklusive: Adobe, BBC, Spotify, Pinterest, Discord (Gamer Chat App), Groupon (Fave), Lonely Planet, Brightcove, Slack …
Se: https://github.com/doomspork/elixir-companies

Vem bör lära sig Phoenix?

• Personer som vill ha ett enkelt sätt att bygga en app med alla moderna bekvämligheter som ”generatorer”, inbyggt databasgränssnitt (”ORM”) och förstklassiga WebSockets för ”realtid” samtidigt som de får en legendarisk tillförlitlighet.
• Team som behöver utvecklarens produktivitet eller Ruby-on-Rails eller Django, men vill ha mindre ”magi” (dvs. vill förstå hur allting fungerar!).
• Företag som vill spendera 90 % mindre på både utvecklar- och infrastrukturkostnader så att ni kan betjäna fler människor med mindre resurser.

Vem bör INTE lära sig Phoenix?

• Alla som måste använda det ”populäraste” ramverket eller språket (oavsett anledning).
• Företag som redan har mycket äldre Java/PHP/etc. och inte kan investera tid i att lära sig/använda något nytt.
• Utvecklare som vill ha ”anställningstrygghet” genom att bug-fixa opålitlig kod.

Hur?

Antaganden/förutsättningar?

Elixir

Det går inte att bygga en Phoenix-app utan att kunna Elixir.
Om du är ny i Elixir, ”star” (bookmark) this repo(så att du kan återvända till den imorgon)
och gå sedan till:github.com/dwyl/learn-elixirlär dig elixir tills du känner att du förstår syntaxen, kom sedan tillbaka och lär dig Phoenix!

Specifikt bör du fokusera på att lära dig Elixirs ”grunder”:

• typer av data
• atomer
• mönstermatchning
• mappar
• funktionsdefinitioner
• moduler

Node.js

Phoenix använder Node.js för att kompilera tillgångar som JavaScript- och CSS-filer (med hjälp av Webpack).
Du behöver bara se till att du har Node.js installerat. https://nodejs.org
Du behöver inte kunna Node för att använda Phoenix.

Installation

Om du redan har lärt dig lite Elixir och installerat Node.js, så är det första steget för att komma igång med Phoenix installationen!

Dokumentationen om Phoenix är fantastisk, så vi rekommenderar att du följer de officiella installationsinstruktionerna för Phoenix!

Du måste också installera PostgreSQL, det finns en handledning om hur man gör det i Phoenix installationsguide länkad ovan, men du kan också kolla in vår learn-postgresql repo för instruktioner, och ta upp ett problem om du har några problem!

Och även om en grundläggande förståelse för JavaScript kan vara användbar ibland, behöver du inte veta hur man använder Node för att använda Phoenix.

Om du är nyfiken på varför de valde Brunch.io framför ”alternativ”,
det korta svaret är: Enkelhet & Snabbhet!se: http://brunch.io/docs/why-brunch
Notera: Phoenix v1.4 (ej släppt i skrivande stund) använder WebPack för sammanställning av tillgångar, se: CHANGELOG.md

Nästa?

Färdiggör dig själv med guiden ”Up and Running” (officiell): https://hexdocs.pm/phoenix/up_and_running.html#content

Praktiska exempel?

När du har installerat Phoenix och följt den officiella ”up and running”-guiden,
kom tillbaka och prova dessa nybörjarvänliga exempel:

• Counter (delad räknare i realtid med hjälp av Phoenix LiveView):https://github.com/dwyl/phoenix-liveview-counter-tutorial
• Todo List (steg-för-steg-handledning som visar hur man bygger en fullt fungerande TodoMVC-klon):https://github.com/dwyl/phoenix-todo-list-tutorial
• Chat (UI/UX i realtid med hjälp av WebSockets):https://github.com/dwyl/phoenix-chat-example
• Kryptering (säkerhet):https://github.com/dwyl/phoenix-ecto-encryption-example
• Logg för appen (hur du lagrar appens data):https://github.com/dwyl/phoenix-ecto-append-only-log-example

Book?

Vi rekommenderar att folk köper (eller lånar)@chrismccords bok: ”Programming Phoenix”
se: https://pragprog.com/book/phoenix14/programming-phoenix-1-4

Författarna är individuellt imponerande och tillsammans täcker de Phoenix på ett begripligt sätt som ingen annan kan!Chris skapade Phoenix, José skapade Elixiroch Bruce är en extremt erfaren teknisk författare med många framgångsrika böcker i sitt namn!
(dvs. boken är det självklara valet för hur man lär sig Phoenix!)

Videointro av José Valim (skapare av Elixir)

https://youtu.be/MD3P7Qan3pw

https://youtu.be/srtMWzyqdp8

Resurser

• 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

Våra 10 främsta anledningar till varför Phoenix

”Phoenix ger Ruby-on-Rails produktivitet
med Erlangs samtidighet och feltolerans.”

1. Bortom alla (fantastiska) tekniska fördelar är det som lockar oss till Phoenix den stora gemenskapen av människor runt om i världen som är entusiastiska över att göra Phoenix till ett fantastiskt verktyg för att bygga webbapplikationer!
   Att ha välkomna människor som

• hjälper dig när du kör fast, tålmodigt förklarar saker
• svarar på frågor (både ”noob ”och ”avancerade”) och
• diskuterar öppet (dina) idéer till förbättringar.se: https://elixirforum.com/t/phoenix-v1-3-0-rc-0-released/3947

1. Phoenix använder programmeringsspråket Elixir vilket innebär att din app kompileras och körs på Erlang Virtual Machine ”BEAM”.
   Erlang är en stridsbeprövad, mycket feltolerant virtuell maskin som används av många telekommunikationsföretag

2. WebSockets (”kanaler”) är inbyggda i ramverket, vilket innebär att det är mycket enklare att bygga appar med kommunikation och interaktion i ”realtid” än i stort sett alla andra ramverk/plattformar (det behövs ingen tredjepartsmodul magic, allt du behöver finns redan där och är redo för dig att betjäna miljontals människor).
   Se: http://www.phoenixframework.org/docs/channels

3. Lätt asynkronisering eftersom all programmering i Phoenix (Elixir) är funktionell!Det betyder att det är väldigt enkelt att abstrahera användbar funktionalitet, som t.ex. autentisering av förfrågningar, loggning och behandling, till ”piplines” som är lättlästa för människor! (ingen tredjepartsmodul async krävs! inga ”löften”, ”generatorer” eller ”observabler” att hantera!!)

4. Säkerhet & Resilience Mindset är default.Kryptering (SSL) är enkelt i Phoenix/Elixir och både begränsning av SQL-injektion, Cross-site Scripting (XSS) och CSRF-skydd är inbyggt (aktiverat av default) vilket gör det praktiskt taget omöjligt för en ”nybörjare” programmerare att introducera denna typ av säkerhetsfel.

5. Säker kod kan inte underskattas! Vi kan skriva betydligt färre rader än i motsvarande Node.js/Java/Rails/Go-app, vilket innebär att utvecklarna är mer produktiva och att det finns mindre kod att underhålla!

6. Testbarhet tack vare funktionell programmering av alla kontrollanter!

7. Enklare driftsättning: http://www.phoenixframework.org/docs/heroku

8. Distribution utan nedtid är gratis! (återigen tack vare Erlang). Erlang klarar av att överföra ”levande/aktiva” användare från den gamla till den nya versionen av din app utan att de ens märker att den har uppgraderats/uppdaterats!

9. Inbyggd övervakning/förvaltning av din app genom Erlang supervisors innebär att du vet exakt hur din app presterar, vilka delar som har kraschat/startat om och varför! Detta är en funktion som vi betalar (mycket) för i andra ramverk och här är den gratis!!

Kan du komma på en annan anledning till varför det är fantastiskt att använda Phoenix?!
Dela gärna dina tankar i den här tråden:https://github.com/dwyl/learn-phoenix-framework/issues/13

Frågor?

Behöver jag lära mig Elixir innan jag provar/använder Phoenix?

Ja, se: https://github.com/dwyl/learn-elixir

Behöver jag kunna Erlang för att använda Elixir & Phoenix…?

Nej. Du kan börja lära dig/använda Elixir idag och anropa Erlang-funktioner när det behövs,
men du behöver inte kunna Erlangbefore du kan använda Phoenix!

Men Phoenix är inte ”Mainstream” … Ska jag/vi använda det…?

Det finns många ramverk för webbapplikationer som du/vi kan välja mellan:https://en.wikipedia.org/wiki/Comparison_of_web_frameworks
Så varför skulle någon välja ett ramverk som är skrivet i ett programmeringsspråk som inte är ”mainstream”…?

Varför använder vi inte Hapi.js längre…?

Det här är missinformation. Vi använder fortfarande Hapi.js för ett antal projekt där det är lämpligt.
Detta inkluderar flera klientprojekt och interna dwyl-appar/verktyg.

Vi bestämde oss för att använda Phoenix för våra nya projekt av dessa enkla skäl:

• Elixir är ett trevligare språk än JavaScript.#LessIsMore #LessButBetter #SmallIsBeautiful #SyntaxMatters
• JS kan vara funktionellt, medan Elixir (alltid) är funktionellt!Skillnaden gör all skillnad!
  Med ”funktionell” programmering är programmen mycket lättare att tänka på medan du skriver/underhåller dem!
• Elixir använder Erlang VM som är mycket effektivare/kraftigare än ”V8”
• Erlang VM skalar mycket lättare till flera kärnor, flera servrar, flera datacenter än Node.js
  (eller i stort sett allt annat för den delen!!)

För våra nya projekt behöver vi feltolerans för flera datacenter!
Vi får det ”gratis” genom att använda Erlang -> Elixir -> Phoenix!!

Vi anser att Hapi.js fortfarande är ”det bästa” Node.js ramverket och vi kommer continue att använda det och rekommendera det
till människor som behöver enkla appar som skalas och är lätta att underhålla.
Se: https://github.com/dwyl/learn-hapi

Och vi använder fortfarande JavaScript för alla våra AWS Lambda-mikrotjänster, vilket inte kommer att förändras.
De är enkla, effektiva och skalar riktigt bra!
Se: https://github.com/dwyl/learn-aws-lambda

Vad är ”fel” med att använda Rails eller Django?

De ursprungliga ”produktiva” webbramverken var ”Ruby-on-Rails” och ”Django” (python) redan 2005!
(Vi använde båda dessa under perioder i vår ”resa” och kan tala om fördelarna med var och en av dem!)

Det är ”inget fel” med att använda Rails eller Django.
Vi anser att det fortfarande finns gott om användningsområden för båda ramverken.
Vi vet bara att det är (mycket) lättare att bygga ”realtid”
med Phoenix eftersom ”Channels” (WebSockets) är inbyggda,
och Elixir/Erlang-konkurrens är en helt annan sak!
Erlang (och därmed Phoenix) kan hantera flera miljoner samtidiga användare på en enda server,
då en Rails/Django-server bara kan hantera några tusen (i bästa fall!)
Om din app bara betjänar några tusen personer samtidigt, så går det bra!!

Vi älskar det faktum att Erlang använder ”lättviktiga långlivade” processer,
vilket innebär att vi kan ansluta miljontals (IoT) enheter …För IoT är Erlang (utan tvekan) svaret!
För enklare webbapplikationer där du bara förväntar dig några få användare per dag är Rails/Django fortfarande gångbara.

Men varför kompromissa om du inte måste?
Om du kan få en Tesla till ”priset” av en Ford Focus, varför skulle du inte göra det?!?
Varför nöja sig med bra när man lätt kan ha/använda det bästa?

Men GitHub använder fortfarande Rails … GitHub är väl ”skalbar”?

Ja, GitHub använder fortfarande Rails för sin webbapplikation/webbplats.
Men fråga någon i GitHubs kärngrupp om de (om de fick chansen att börja om från början) skulle välja Rails
för att bygga GitHub 2017, och se hur många av dem som säger ”ja, naturligtvis” (med ett rakt ansikte…)!

GitHub gör också en hel del saker för att skala Rails i bakgrunden.
Och många av deras nyare funktioner (på klientsidan) är skrivna i JavaScript!se: https://github.com/github

Slutsatsen är: allt kan skalas med hjälp av ”DevOps”,
men Phoenix skalas av defaultför att Erlang (uppfanns) för att skalas!

Varför INTE använda Go?

”Det finns två typer av programmeringsspråk – de som ingen använder och de som alla klagar på” ~ Bjarne Stroustrup(skapare av C++)

Go är mycket populärt. Till stor del på grund av att Google ”sponsrar” det.
Det var tänkt att förenkla (ersätta) C++ och Java i Google …
och för det mesta har det lyckats!

Vi gillar verkligen Go. Det var vårt ”andrahandsval” när vi bestämde oss för vilket programmeringsspråk
(efter Elixir) i vår ”post JS stack” …Beslutet att använda elixir istället för något else var enkelt:

• Elixir är funktionellt (mycket enklare att läsa/skriva/underhålla/utöka)
• Elixir-funktioner komponeras på ett riktigt elegant sätt som ”pluggar”/”pipelines”
• Data är oföränderliga vilket gör applikationstillståndet förutsägbart (ingen gissning!
• Typer är dynamiska och härledda (inget behov av att manuellt deklarera dem)men det finns regler som förenklar saker och ting och kompilatorn kontrollerar dem och ger en lämplig varning.
• Erlang gör distribuerade applikationer mycket enklare och vår plan är att bygga IoT-system som kommer att innebära att man kopplar ihop många (miljontals) enheter med persistenta anslutningar, Erlang är gjord för detta!
• Phoenix innehåller många användbara saker utanför boxen, inklusive flera säkerhetsfunktioner som de flesta inte ens tänker på.

Fördjupad läsning:

• Varför Go inte är bra: http://yager.io/programming/go.html
• Go Web Frameworks: http://yager.io/programming/go.html
• Go Web Frameworks: https://medium.com/code-zen/why-i-don-t-use-go-web-frameworks-1087e1facfa4
• Varför alla hatar Go: https://npf.io/2014/10/why-everyone-hates-go/(titel som lockar, men några giltiga punkter…)
• Diskussion: https://www.reddit.com/r/elixir/comments/3c8yfz/how_does_go_compare_to_elixir

(`help wanted` expanding this answer…)

Varför INTE använda Scala + Play Framework istället…?

Om du redan är van vid att skriva Java eller distribuera till JVM är Play Framework ett utmärkt val: https://www.playframework.com
Scala är ett bra programmeringsspråk och alla borde lära sig det!https://www.scala-lang.org/what-is-scala.html

Vi har använt Play några gånger (innan vi valde Node.js)och gillade det verkligen!
Men Scala är ett programmeringsspråk med flera paradigm som gör det möjligt att använda ”hela Java” …
Vi tror att Scalas ”Java Interoperability” innebär att det är ”för lätt” att tillåta komplexitet i din kodbas. Specifikt ”OOP-mutation” …

Så varför använder vi (DWYL) inte ”Play” för nya projekt längre?För det första övergick vi till Hapi.js (Node.js) för några år sedan för att det var mer ”lättviktigt” och gjorde det möjligt för oss att skriva små program som bara använde några få megs RAM-minne (där våra Play-applikationer var mycket resurskrävande)..!har du någonsin provat att köra en Scala-app på en ”enkel” bärbar dator som en Chromebook…?)

Sammanfattning av ”skälen” för Phoenix istället för Play:

• Vi vidhåller att Play/Scala fortfarande har gott om giltiga användningsområden.
• Elixir är mycket enklare än Scala.
• Erlang VM är mycket bättre på samtidighet än JVM.
• Vi älskar det faktum att alla data är oföränderliga i Elixir.
• Vi älskar hur få resurser som krävs för att köra en Phoenix-app (t.ex. på en Raspberry Pi!!!).)

Vi tycker bara att för våra projekt fungerar Erlangs Concurrency-modell bättre och funktionell kod som omvandlar Immutable data är lättare att testa och underhålla.

Om du har bevis för att ”Scala är enklare” vill vi gärna höra från dig!
Berätta för oss: https://github.com/dwyl/learn-phoenix-web-development/issues

Varför inte använda Haskell?

Om du gillar funktionell programmering (FP) så mycket, varför inte använda Haskell?

Ställ fler frågor: https://github.com/dwyl/learn-phoenix-framework/issues