dwyl / learn-phoenix-framework

Learn how to use Phoenix Framework tohave fun building real-time web/mobile apps
that are fast for “end-users”, reliable,scalable, maintainable and (easily) extensible!

Miért?

A web/mobil alkalmazások fejlesztőiként szükségünk van arra, hogy kihasználjuk a más (igazán okos) emberek által végzett munkát
ahelyett, hogy állandóan “a semmiből” építsük a dolgokat;ezért használunk keretrendszereket az alkalmazásaink építéséhez!

Lásd: “

Néhány keretrendszer közül választhatunk(néhány “népszerűt” megemlítünk az alábbiakban a “Kérdések” részben).
De ha az alapján mennénk, ami “népszerű”, akkormég mindig mindenhol lovon (és szekéren) ülnénk, és nem lenne előrelépés.

Megjegyzendő: az Elixírre vonatkozó összes “Miért “ok a Phoenixre is érvényes!
Nézd meg őket! https://github.com/dwyl/learn-elixir#why

Mi?

Egy webes alkalmazás keretrendszer kompromisszumok nélkül!

Fejlesztői öröm

A legnagyobb “korlát” minden technológiai projektben az ember.Egy “vállalkozó”/”alapító” vagy “terméktulajdonos” rendelkezhet a világ összes jó ötletével, ha nem képes az ötletet megvalósítani, az értelmetlen.

(Kell-e törődnöm a) benchmarkokkal?

Nyilvánvaló, hogy saját benchmarkokat kell futtatnia a saját hardverén/felhőjén, és megalapozott döntéseket kell hoznia az alkalmazás/termék követelményei alapján, de …. amikor elolvastuk a statisztikákat, hogy hány egyidejű felhasználót tud kezelni a Phoenix alkalmazás (élő WebSocket kapcsolatokkal), el voltunk ájulva!Ez azt jelenti, hogy 90%-kal kevesebb erőforrással építhetjük meg a valós idejű alkalmazásunkat (alkalmazásainkat).

Teljesítmény kiemelések

• jelentősen alacsonyabb késleltetés és kérési válaszidő, mint bármi más! (köszönhetően az Erlang könnyűsúlyú folyamatainak és a rendkívül hatékony hálózati/üzenetkezelésnek)
• 4x több kérés/másodperc, mint az egyenértékű Node.js (Express.js) alkalmazásnál.
• 9x nagyobb áteresztőképesség, mint egy Python 2.7 alapú alkalmazásnál. (a blokkolás tényleg szívás!)
• 10x – 100x több kérést kezel, mint a Ruby-on-Rails (az alkalmazás típusától függően!)
• Hasonló teljesítmény, mint a Go egyetlen szerveren, de sokkal egyszerűbb több szerveres párhuzamossági modell, így a horizontális skálázás több adatközpontban (“rendelkezésre állási zónák”) sokkal könnyebb! (Az Erlang a több szerver/processzor erőforrásait egyetlen alkalmazás “flottájaként” kezeli, és a kéréseket/feldolgozást a fürtök/zónák között delegálja hozzájuk!)

Mindez azt jelenti, hogy lényegesen kevesebb pénzt költ a hardver/felhő infrastruktúrára, így az alkalmazása/vállalata versenyelőnyre tehet szert a költségek terén.

Ha abban a szerencsés helyzetben van, hogy valami sokkal jobbat szeretne használni a következő projektjéhez, ne keressen tovább a Phoenixnél!
Bővebben: http://www.phoenixframework.org

Ki?

Sok ember/csapat/cég már használja az Erlang/Elixirt és a Phoenixet, és fenomenális eredményeket lát!
Egyebek között: Adobe, BBC, Spotify, Pinterest, Discord (Gamer Chat App),Groupon (Fave), Lonely Planet, Brightcove, Slack …
See: https://github.com/doomspork/elixir-companies

Kinek érdemes megtanulnia a Phoenixet?

• Azok, akik szeretnének egy egyszerű módot egy alkalmazás építésére a “generátorok”,a beépített adatbázis-felület (“ORM”) és a Firstclass WebSockets minden modern kényelmével “valós időben”, miközben legendás megbízhatóságot kapnak.
• Csapatok, akiknek szükségük van a Ruby-on-Rails vagy a Django fejlesztői termelékenységére,de kevesebb “varázslatra” vágynak (azaz meg akarják érteni, hogyan működik minden!).
• Cégek, akik 90%-kal kevesebbet akarnak költeni mind a fejlesztői, mind az infrastrukturális költségekre, hogy kevesebb erőforrással több embert tudjanak kiszolgálni.

Kinek NE tanuljon Phoenixet?

• Akinek a “legnépszerűbb” keretrendszert vagy nyelvet kell használnia (bármilyen okból).
• Cégek, akiknek már rengeteg Java/PHP/ stb. örökségük van, és nem tudnak időt áldozni valami új megtanulására/használatára.
• Developers who want “job security” bug-fixing unreliable code.

How?

Assumptions / Pre-Requisites?

Elixir

You cannot build a Phoenix App without knowledge Elixir.
Ha új vagy az Elixirben, “csillagozd” (könyvjelző) this a repo-t(hogy holnap visszatérhess rá)
és utána menj a:github.com/dwyl/learn-elixirre tanulj elixir-t, amíg úgy érzed, hogy érted a szintaxist,aztán gyere vissza és tanulj Phoenixet!

Közelebbről az Elixir “alapok” megtanulására kell koncentrálnod:

• adattípusok
• atomok
• mintaillesztés
• térképek
• függvénydefiníciók
• modulok

Node.js

Ahoenix a Node.js-t használja az olyan készletek összeállítására, mint a JavaScript és CSS fájlok (a Webpack segítségével).
Egyszerűen győződjön meg róla, hogy telepítve van a Node.js. https://nodejs.org
A Phoenix használatához nem kell ismernie a Node-ot.

Telepítés

Ha már tanult egy kis Elixir-t és telepítette a Node.js-t, akkor a Phoenix használatának megkezdéséhez az első lépés a telepítés!

A Phoenix dokumentációja csodálatos, ezért javasoljuk, hogy kövesse a hivatalos phoenix telepítési utasításokat!

A PostgreSQL-t is telepítened kell, a fentebb linkelt Phoenix telepítési útmutatóban van egy bemutató a megoldásról, de megnézheted a learn-postgresql repónkat is az utasításokért, és felvethetsz egy problémát, ha bármilyen problémád van!

Míg a JavaScript alapszintű ismerete néha hasznos lehet, a Phoenix használatához nem kell tudnod, hogyan kell használni a Node-ot.

Ha kíváncsi vagy, miért választották a Brunch.io-t az “alternatívákkal” szemben,
a rövid válasz a következő: Egyszerűség & Gyorsaság! http://brunch.io/docs/why-brunch
Megjegyzés: A Phoenix v1.4 (a cikk írásakor még nem jelent meg)WebPack-et használ az eszközök összeállításához,lásd: CHANGELOG.md

Következő?

Ismerkedj meg az “Up and Running” (hivatalos) útmutatóval:https://hexdocs.pm/phoenix/up_and_running.html#content

Gyakorlati példák?

Ha már telepítette a phoenixet és követte a hivatalos “up and running” útmutatót,
jöjjön vissza és próbálja ki ezeket a kezdőbarát példákat:

• Counter (valós idejű megosztott számláló a Phoenix LiveView használatával):https://github.com/dwyl/phoenix-liveview-counter-tutorial
• Todo List (lépésről lépésre bemutatja, hogyan készítsünk egy teljesen működőképes TodoMVC klónt):https://github.com/dwyl/phoenix-todo-list-tutorial
• Chat (valós idejű UI/UX WebSockets használatával):https://github.com/dwyl/phoenix-chat-example
• Encryption (biztonság):https://github.com/dwyl/phoenix-ecto-encryption-example
• Append-only Log (hogyan tároljuk az alkalmazás adatait):https://github.com/dwyl/phoenix-ecto-append-only-log-example

Book?

Az embereknek javasoljuk, hogy vegyék meg (vagy kölcsönözzék)@chrismccord könyvét: “Programming Phoenix”
lásd: https://pragprog.com/book/phoenix14/programming-phoenix-1-4

A szerzők külön-külön is lenyűgözőek, és együttesen úgy érthetően tárgyalják a Phoenixet, ahogy senki más nem tudja!Chris alkotta meg a Phoenixet, José az Elixirt, Bruce pedig ultra-tapasztalt technikai szerző, sok sikeres könyvvel a nevén!
(azaz: a könyv a legkézenfekvőbb választás a Phoenix megtanulására!)

José Valim (az Elixir alkotója)

https://youtu.be/MD3P7Qan3pw

https://youtu.be/srtMWzyqdp8

Források

• 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

Top 10 okunk, amiért a Phoenix

“A Phoenix a Ruby-on-Rails termelékenységét
az Erlang párhuzamosságával és hibatűrésével biztosítja.”

1. A (fantasztikus) technikai előnyökön túl, ami vonz minket a Phoenixhez, az a nagyszerű közösség, akik világszerte izgatottak, hogy a Phoenixet egy csodálatos eszközzé tegyék a webes alkalmazások építéséhez!
   Hívogató emberek, akik

• segítenek, ha elakadsz, türelmesen elmagyarázzák a dolgokat
• válaszolnak a kérdésekre (mind a “noob”-ok, mind a “haladók” számára) és
• nyíltan megvitatják a (te) fejlesztési ötleteidet.lásd: https://elixirforum.com/t/phoenix-v1-3-0-rc-0-released/3947

1. A Phoenix az Elixir programozási nyelvet használja, ami azt jelenti, hogy az alkalmazásodat az Erlang virtuális gépen “BEAM” fordítják és futtatják.
   Az Erlang egy harcban kipróbált, nagy hibatűrésű VM, amelyet számos távközlési vállalat használ

2. A webSockets (“csatornák”) be vannak építve a keretrendszerbe, ami azt jelenti, hogy a “valós idejű” kommunikációval és interakcióval rendelkező alkalmazások építése sokkal egyszerűbb, mint gyakorlatilag bármely más keretrendszer/platform!(nincs szükség harmadik féltől származó magic modulra! minden, amire szükséged van, már készen áll, hogy emberek millióit szolgáld ki!!).
   lásd: http://www.phoenixframework.org/docs/channels

3. Egyszerű aszinkronizálás, mert a Phoenixben (Elixir) minden programozás funkcionális!Ez azt jelenti, hogy nagyon egyszerű absztrahálni a hasznos funkciókat, mint a kérések hitelesítése, naplózás és feldolgozás “pipline”-okba, amelyek könnyen ember által olvashatóak! (nincs szükség harmadik féltől származó async modulra! nem kell “ígéreteket”, “generátorokat” vagy “megfigyelőket” kezelni!!)

4. Biztonság & A rugalmassági gondolkodásmód a default.A titkosítás (SSL) egyszerű a Phoenix/Elixirben ésaz SQL injection,Cross-site Scripting (XSS)és CSRF védelem egyaránt beépített (a default által engedélyezett), így gyakorlatilag lehetetlen egy “kezdő” programozó számára, hogy ilyen típusú biztonsági hibát vezessen be.

5. A precíz kódot nem lehet alábecsülni! Sokkal kevesebb sort írhatunk, mint az egyenértékű Node.js/Java/Rails/Go alkalmazásban, ez azt jelenti, hogy a fejlesztők produktívabbak és kevesebb a karbantartandó kód!

6. Tesztelhetőség az összes vezérlő funkcionális programozásának köszönhetően!

7. Egyszerű telepítés: http://www.phoenixframework.org/docs/heroku

8. Nulla leállási idejű telepítés ingyenes! (ismét az Erlang miatt). Az Erlang kezeli az “élő/aktív” felhasználók átállását az alkalmazásod régi verziójáról az új verziójára anélkül, hogy észrevennék, hogy frissítés/frissítés történt!!!

9. Az alkalmazásod beépített monitorozása/menedzselése az Erlang felügyelőkön keresztül azt jelenti, hogy pontosan tudod, hogyan teljesít az alkalmazásod, mely részek törtek/indultak újra és miért! Ez egy olyan funkció, amiért más keretrendszerekben (sokat) fizetünk, itt pedig ingyenes!!!

Még egy okot tudsz mondani, amiért a Phoenix használata fantasztikus?!
Kérem, ossza meg gondolatait ebben a témában:https://github.com/dwyl/learn-phoenix-framework/issues/13

Kérdések?

Meg kell tanulnom az Elixirt, mielőtt kipróbálom/használom a Phoenixet?

Igen. ld: https://github.com/dwyl/learn-elixir

Kell-e ismernem az Erlangot az Elixir & Phoenix használatához…?

Nem. Elkezdheted ma tanulni/használni az Elixirt és szükség esetén hívhatod az Erlang függvényeket,
de nem kell ismerned az Erlangotbefore használhatod a Phoenixet!

De a Phoenix nem “Mainstream” … Használjam/használjuk…?

Egy csomó webalkalmazási keretrendszer közül választhatsz/választhatunk:https://en.wikipedia.org/wiki/Comparison_of_web_frameworks
Miért választana valaki egy olyan programozási nyelven írt keretrendszert, ami nem “mainstream”…?

Miért nem használjuk már a Hapi.js-t…?

Ez téves információ. Még mindig használjuk a Hapi.js-t számos olyan projektben, ahol ez megfelelő.
Ez számos ügyfélprojektet és belső dwyl alkalmazásokat/eszközöket foglal magában.

Az új projektjeinkhez a következő egyszerű okok miatt döntöttünk a Phoenix használata mellett:

• Az Elixir szebb nyelv, mint a JavaScript.#LessIsMore #LessButBetter #SmallIsBeautiful #SyntaxMatters
• A JS lehet funkcionális, míg az Elixir (mindig) funkcionális!A különbség mindent megváltoztat!
  A “funkcionális” programozással,a programokat sokkal könnyebb átgondolni írás/fenntartás közben!
• Az Elixir az Erlang VM-et használja, ami sokkal hatékonyabb/erősebb, mint a “V8”
• Az Erlang VM sokkal könnyebben skálázódik többmagos, többszerveres, több adatközpontra, mint a Node.js
  (vagy nagyjából bármi más!!)

Az új projektjeinkhez multi-data-center hibatűrésre van szükségünk!
ezt “ingyen” megkapjuk az Erlang -> Elixir -> Phoenix használatával!!!

Véleményünk szerint a Hapi.js még mindig a “legjobb” Node.js keretrendszer és mi continue használni fogjuk és ajánljuk
azoknak, akiknek egyszerű, skálázható és könnyen karbantartható alkalmazásokra van szükségük.
lásd: https://github.com/dwyl/learn-hapi

Még mindig JavaScriptet használunk az összes AWS Lambda mikroszolgáltatásunkhoz,ez nem fog változni.
Egyszerűek, hatékonyak és nagyon jól skálázódnak!
lásd: https://github.com/dwyl/learn-aws-lambda

Mi a “baj” a Rails vagy a Django használatával?

Az eredeti “produktív” webes keretrendszerek a “Ruby-on-Rails” és a “Django” (python) voltak 2005-ben!
(Mindkettőt használtuk “utazásunk” során, és mindkettő előnyeiről tudunk beszélni!).

Nincs “semmi baj” a Rails vagy a Django használatával.
Úgy gondoljuk, hogy még mindig rengeteg felhasználási lehetőség van mindkét keretrendszer számára.
Mi csak azt tudjuk, hogy (sokkal) könnyebb “valós idejű”
készíteni a Phoenix-szel, mert a “Channels” (WebSockets) be van építve,
és az Elixir/Erlang párhuzamosság egy teljesen más labdajáték!
Az Erlang (és így a Phoenix) több millió egyidejű felhasználót tud kezelni egyetlen szerveren,
míg egy Rails/Django szerver csak néhány ezer embert tud kezelni (a legjobb esetben!)
ha az alkalmazásod csak néhány ezer embert szolgál ki egyszerre, akkor rendben vagy!!

Azt szeretjük, hogy az Erlang “könnyűsúlyú, hosszú életű” folyamatokat használ,
ami azt jelenti, hogy (IoT) eszközök millióit tudjuk összekapcsolni …Az IoT számára az Erlang (megkérdőjelezhetetlenül) a Válasz!
Egyszerűbb webes alkalmazásokhoz, ahol csak néhány felhasználóra számítunk naponta, a Rails/Django még mindig életképes.

De miért kössünk kompromisszumot, ha nem muszáj?
Ha egy Ford Focus “áráért” kaphatsz egy Teslát,miért ne tennéd?!!?
Miért elégedj meg a jóval, ha könnyen a legjobbat kaphatod/használhatod?

De a GitHub még mindig a Rails-t használja … Biztos, hogy a GitHub “skálázható”?

Igen, a GitHub még mindig a Rails-t használja a webes alkalmazásához/oldalához.
De kérdezd meg a GitHub alapcsapatának bármelyik tagját, hogy (ha újrakezdhetnék) a Rails
-t választanák-e a GitHub építéséhez 2017-ben, és nézd meg, hányan mondják közülük, hogy “igen, persze” (rezzenéstelen arccal…)!

A GitHub sok mindent csinál a háttérben a Rails skálázása érdekében.
És sok újabb (kliensoldali) funkciójukat JavaScriptben írják!ld: https://github.com/github

A lényeg: bármi skálázható a “DevOps” segítségével,
de a Phoenix skálázható defaultmert az Erlang (volt) feltalálva (skálázásra)!

Miért NEM használjuk a Go-t?

“Kétféle programozási nyelv van – azok, amelyeket senki sem használ, és azok, amelyeket mindenki nyavalyog” ~ Bjarne Stroustrup(creator of C++)

A Go nagyon népszerű. Nagyrészt annak köszönhetően, hogy a Google “szponzorálja”.
Az volt a célja, hogy egyszerűsítse (helyettesítse) a C++ és a Java-t a Google …
és nagyrészt sikerült is!

Nekünk nagyon tetszik a Go. Ez volt a “második számú” választásunk, amikor eldöntöttük, hogy milyen programozási nyelvet
(az Elixir után) válasszunk a “post JS stack”-ben…A döntés, hogy elixir használjuk bármi else helyett, könnyű volt:

• Elixir funkcionális (sokkal egyszerűbb olvasni/írni/fenntartani/kibővíteni)
• Elixir függvények igazán elegáns módon állnak össze “dugók”/”pipelines”-ként
• Az adatok megváltoztathatatlanok, ami kiszámíthatóvá teszi az alkalmazás állapotát (nincs találgatás!).)
• A típusok dinamikusak és kikövetkeztethetők (nem kell kézzel deklarálni őket)de vannak szabályok, amelyek egyszerűsítik a dolgokat, és a fordító ellenőrzi őket, megfelelő figyelmeztetést adva.
• Az Erlang sokkal könnyebbé teszi az elosztott alkalmazásokat, és a tervünk az, hogy IoT rendszereket építünk, ami sok (millió) eszköz összekapcsolását jelenti tartós kapcsolatokkal, az Erlang erre készült!
• A Phoenix sok hasznos dolgot tartalmaz out-of-the box, beleértve számos biztonsági funkciót, amire a legtöbb ember nem is gondol.

További olvasmányok:

• Miért nem jó a Go: http://yager.io/programming/go.html
• Go Web Frameworks: https://medium.com/code-zen/why-i-don-t-use-go-web-frameworks-1087e1facfa4
• Miért utálja mindenki a Go-t: https://npf.io/2014/10/why-everyone-hates-go/(click-bait cím, néhány érvényes pont…)
• Discussion: https://www.reddit.com/r/elixir/comments/3c8yfz/how_does_go_compare_to_elixir

(`Segítséget kérünk` a válasz kibővítéséhez…)

Miért NEM használjuk inkább a Scala + Play Framework-et…?

Ha már hozzászoktál a Java íráshoz vagy a JVM-re való telepítéshez,a Play Framework egy kiváló választás: https://www.playframework.com
A Scala egy jó programozási nyelv, és mindenkinek meg kellene tanulnia!https://www.scala-lang.org/what-is-scala.html

Párszor használtuk a Play-t (mielőtt átvettük a Node.js-t)és nagyon tetszett!
De a Scala egy “konyhai mosogató” (multiparadigmás)programozási nyelv, amely lehetővé teszi, hogy az emberek “az egész Java-t” …
Mi úgy gondoljuk, hogy a Scala “Java interoperabilitása” azt jelenti, hogy “túl könnyű” beengedni a komplexitást a kódbázisodba. Specifikusan az “OOP mutáció” …

Miért nem használjuk (DWYL) többé a “Play”-t az új projektekhez?Először is, néhány évvel ezelőtt áttértünk a Hapi.js-re (Node.js), mert az “könnyebb” volt és lehetővé tette, hogy apró programokat írjunk, amelyek csak néhány mega RAM-ot használtak (míg a Play alkalmazások nagyon erőforrás-igényesek voltak)..!Próbáltál már valaha Scala alkalmazást futtatni egy “egyszerű” laptopon, például egy Chromebookon…?)

Az “okok” összefoglalása a Phoenix helyett a Play helyett:

• Fenntartjuk, hogy a Play/Scala még mindig rengeteg érvényes felhasználási esettel rendelkezik.
• Az Elixir sokkal egyszerűbb, mint a Scala.
• Az Erlang VM sokkal jobb az egyidejűségben, mint a JVM.
• Azt szeretjük, hogy az Elixirben minden adat megváltoztathatatlan.
• Azt szeretjük, hogy milyen kevés erőforrás kell egy Phoenix alkalmazás futtatásához (pl. egy Raspberry Pi-n!!!).)

Egyszerűen úgy gondoljuk, hogy a mi projektünk(ek)hez az Erlang párhuzamossági modellje jobban működik, és a funkcionális kódot átalakító, megváltoztathatatlan adatokat könnyebb tesztelni és karbantartani.

Ha van bizonyítékod arra, hogy “a Scala egyszerűbb “szívesen hallanánk rólad!
Mondja el nekünk! https://github.com/dwyl/learn-phoenix-web-development/issues

Miért nem használja a Haskellt?

Ha annyira szereti a funkcionális programozást (FP), miért nem használja a Haskellt?

Kérjük, tegyen fel további kérdéseket: https://github.com/dwyl/learn-phoenix-framework/issues