ugrás a tartalomhoz

Tiszta kód - Node.js

webproghu · 2015. Jan. 8. (Cs), 18.30
Sziasztok,

volt már alkalmam némi ismerettséget kötni a Node.js-el, alapvetően kisebb alkalmazások írására nagyon szeretem használni. Viszont most gondolkodunk egy nagyobb projekt Node.js-ben való megvalósításán, ezzel kapcsolatban lenne egy kérdésem:
lehet Node.js-ben (Javascriptben) szép, tiszta, külön fájlokban szervezett kódot írni?

Előre is köszönök minden építő jellegű hozzászólást, segítséget!
 
1

Természetesen.Miért ne

Chriksz · 2015. Jan. 8. (Cs), 23.46
Természetesen.
Miért ne lehetne? Minden adott hozzá.
Pl. itt van egy frame work a Paypaltól. Mi tesztelésre jasmine-t használunk, igaz csak front end oldalon (angular). De egy alap express is szerintem ad annyi kezdőlökést, hogy onnan már nem nehéz tiszta kódot írni.
2

Nem a framework-okről van

webproghu · 2015. Jan. 9. (P), 14.19
Nem a framework-okről van szó, abból én is ismerek jópárat.
De ez a module exports-os dolog nagyon nem tetszik, ha valamit külön fájlba akarsz kirakni.
3

Pedig pont ez az egyik

spapp · 2015. Jan. 9. (P), 14.45
Pedig pont ez az egyik eszköze annak, hogy szépen felépített, külön fájlokba, modulokba rendezd a kódot.
Ezt nézd át: modules

Az eredeti kérdéshez:

Ha homogén kódminőségű alkalmazást akarsz, akkor ne sajnáld az időt, és ne használj külső modulokat. Sajnos sok fellelhető modul, nem igazán "tiszta kód"-ra épül. Kezdetben nagy lendületet tud adni a projektnek, de mikor a teljesítmény teszteknél derül ki, hogy jelentős, 20-30%-os, teljesítmény csökkenés róható fel neki az nagyon drága tud lenni.
7

Pedig pont ez az egyik

webproghu · 2015. Jan. 10. (Szo), 11.44
Pedig pont ez az egyik eszköze annak, hogy szépen felépített, külön fájlokba, modulokba rendezd a kódot.


Akkor feltennék pár kérdést:
- mi van akkor ha nem akarom egy modul összes osztályát egy fájlba beleírni? (ne legyen már egy modul 30 osztállyal 5000 sor egy fájlban) Minden egyes fájlt tele kell szemetelnem a module.exports-al, ami ráadásul megtévesztő is, mert az valójában nem egy modul hanem egy osztály (objektum).
- a modelljeim és controllereimet is szemeteljem tele module.exports-al? Szintén nem modulok. Vagy rakjam őket egy fájlba? Nem túl szép.
- tegyük fel van egy modell, megcsinálom modulként, más húsz osztályban van még használva. Mindenhova be kell require-znem? Mi lesz ha megváltozik a neve? Át kell írni kézzel mind a húsz helyen?

Ez minden, csak nem szépen felépített.

Ezt nézd át: modules


Három éve programozok Node.js-ben, ismerem a modulokat. :) Viszont én még mindig nem látom, hogy alkalmas lenne _szépen felépített_ nagyobb alkalmazások megírására, úgy, hogy egy karbantartható, mások számára is egyszerűen értelmezhető kód legyen a végeredmény.
8

tegyük fel van egy modell,

Chriksz · 2015. Jan. 10. (Szo), 15.27
tegyük fel van egy modell, megcsinálom modulként, más húsz osztályban van még használva. Mindenhova be kell require-znem? Mi lesz ha megváltozik a neve? Át kell írni kézzel mind a húsz helyen?


Mégis mi korlátoz abban téged, hogy írj vagy használj egy DI frameworkot?
9

- mi van akkor ha nem akarom

Poetro · 2015. Jan. 11. (V), 11.13
- mi van akkor ha nem akarom egy modul összes osztályát egy fájlba beleírni? (ne legyen már egy modul 30 osztállyal 5000 sor egy fájlban) Minden egyes fájlt tele kell szemetelnem a module.exports-al, ami ráadásul megtévesztő is, mert az valójában nem egy modul hanem egy osztály (objektum).

Mindegyik osztályát kirakod külön modulba, a modulod könyvtárába.- a modelljeim és
controllereimet is szemeteljem tele module.exports-al? Szintén nem modulok. Vagy rakjam őket egy fájlba? Nem túl szép.

Más nyelvekben is teleszemeteled. Nem tudom, ez mit változtat.
- tegyük fel van egy modell, megcsinálom modulként, más húsz osztályban van még használva. Mindenhova be kell require-znem? Mi lesz ha megváltozik a neve? Át kell írni kézzel mind a húsz helyen?

Igen, ahogy más nyelvekben is.
Mesélj egy nyelvről, amiben jobban van megvalósítva a fenti pár probléma!
10

Máshol nem tudom, mi a

pythonozok · 2015. Jan. 11. (V), 11.39
Máshol nem tudom, mi a helyzet, pythonban valami dependency injectionre emlékeztető megoldással elérhető(nek tűnik), hogy csak a controllerbe kelljen importálni a modellt és a view-t, bár engem kifejezetten zavar, hogy olyan objektumot használjak, aminek a definíciója nincs importálva.
Demo talán holnap, ha nem leszek lusta, mint általában.
11

Mindegyik osztályát kirakod

webproghu · 2015. Jan. 11. (V), 16.19
Mindegyik osztályát kirakod külön modulba, a modulod könyvtárába.


Na ez az, egy osztály mióta egy modul?

Más nyelvekben is teleszemeteled. Nem tudom, ez mit változtat.


Nem, más nyelveken csinálok egy osztályt egy fájlba, és onnantól kezdve fantasztikusan működik a dolog. Nem kell azt még külön egy modulként is definiálnom.

Igen, ahogy más nyelvekben is.
Mesélj egy nyelvről, amiben jobban van megvalósítva a fenti pár probléma!


Nem, más nyelveken nem kell egy osztályt egy külön modulként is definiálnom, nem kell külön behúznom egy másik fájlban, ezzel kvázi belehardcodeolnom a fájl nevét (más nyelveknél van ugye autoloader). Ruby, PHP, Java, csak pár nyelv, ahol jobban van megvalósítva a probléma.
12

Na ez az, egy osztály mióta

MadBence · 2015. Jan. 11. (V), 17.22
Na ez az, egy osztály mióta egy modul?

A CommonJS szemantikájában egy modul az, amit kiexportálsz. Ez lehet egyetlen függvény (konstruktor vagy valami más), több függvény (~több osztály, vagy statikus függvények, mint pl az underscore esetében). Modul bármi lehet, akár egy tömb is. A lényeg, hogy valami olyasmi, ami újrafelhasználható.
13

Hogy egy programozási

spapp · 2015. Jan. 12. (H), 10.39
Hogy egy programozási környezet által a programozó számára biztosított nyelvi eszközök jók-e vagy rosszak-e az szubjektív. Hogy ezeket egy programozó használja-e és éppen hogyan az megint szubjektív. Erről szerintem meddő vitatkozni.

Az eredeti kérdésedre még mindig az a válaszom, hogy nodejs-ben (és Javascript-ben is) lehet szép, tiszta, külön fájlokban szervezett kódot írni. Ehhez jól kell ismerni a nodejs-t a javascritet, mvc, tervezési mintákat, ..., és még sok minden mást. Ja és a legfontosabb: legyen idő tervezésre stb. Ne kutyafuttában kelljen dolgozni.

Gondolom ezekkel nem mondtam semmi újat. Ezeket bármelyik programozási nyelvről el elehet mondani.

Az, hogy a nodejs lehetne-e jobb, biztosíthatna kifinomultabb eszközöket, arra viszont egyértelmű igen választ adnék. No, de melyik programnyelvről nem tudnánk ezt mondani?...

Eddigi hozzászólásaidból arra következtetek, hogy kétségeid vannak az felől, hogy azt a nagyobb projektet nodejs-ben meg lehet-e valósítani. Ez esetben viszont érdemes elgondolkodni más alternatívákon. Lehet éppen a java lenne a legalkalmasabb. (A java egyébként biztosan veri teljesítményben a nodejs-t)
14

a nagyobb projektet

Poetro · 2015. Jan. 12. (H), 11.04
a nagyobb projektet nodejs-ben meg lehet-e valósítani

Valószínűleg akkor mélyebb architekturális ismeretek szükségesek, esetleg el kell vonatkoztatni a korábbi módszerektől, és egy radikálisan különbözőt kell megvalósítani, ami jobban illik az adott programozási nyelvhez. Nem véletlen, hogy több JavaScript és Node.js konferencián is ezek a témák, és úgy tűnik a Microservices lehet az egyik befutó architektúra nagyobb projektek esetén (és nem csak Node.js projektek esetén).
17

egy radikálisan különbözőt

Hidvégi Gábor · 2015. Jan. 16. (P), 10.36
egy radikálisan különbözőt kell megvalósítani, ami jobban illik az adott programozási nyelvhez
Most akkor mi vagyunk a nyelvért, vagy a nyelv van miértünk, hogy minél egyszerűbben megoldhassuk a feladatainkat?
18

Nem a csavarhúzó hibája, ha

bamegakapa · 2015. Jan. 16. (P), 11.18
Nem a csavarhúzó hibája, ha úgy akarod fogni, mint a kalapácsot, mert te ahhoz szoktál. Mindennek megvan a technikája.
19

Egyik sem

Poetro · 2015. Jan. 16. (P), 11.18
A legtöbb nyelv kínál több megoldást is, hogy ugyanazt a feladatot megoldd. PHP esetén bevezették az OOP-t, hogy segítsék az embereket. Te még sem vagy boldog vele.
Minden nyelv más feladatokra használható ideálisan, illetve máshogy illik őket használni. Haskell-ben is írhatnál Windows-os asztali alkalmazásokat, de még sem teszik, mert nem igazán alkalmas a feladatra.

Még szerencse, hogy van választék, hogy melyik feladatra, melyik nyelvet használja az ember.
20

Nem jók a példáid. Az egy

Hidvégi Gábor · 2015. Jan. 16. (P), 12.00
Nem jók a példáid. Az egy dolog, hogy az OOP-vel problémáim vannak, de a PHP-ben szerencsére van lehetőség procedurális programozásra, így mindenre használhatom nyugodtan.

A node.js-ben viszont van pár olyan hozott kötöttség (vagy incidental complexity), ami rád kényszerít egy bizonyos stílust. Az egyik ilyen a callback-es programozás. Egy átlagos programozási nyelvben megszokott, hogy használható a következő formula: valtozo = fuggveny(parameterek);. Node alatt, ha a függvény IO-zik, akkor ez ebben a formában nem oldható meg (azaz elképzelhető, hogy már létezik rá valami, de itt jön be a következő probléma, hogy mi van, ha az általad használt külső modulok nem, akkor ugyanott vagy, ahol a part szakad).

A másik ilyen, amit webproghu is felvet, hogy nincs a megszokott include-olásra beépített lehetőség, ami minden normális nyelvben ott van, csak modulokat tudsz betölteni. A különböző kerülő megoldások nem játszanak.
21

Az egy dolog, hogy az OOP-vel

Poetro · 2015. Jan. 16. (P), 12.10
Az egy dolog, hogy az OOP-vel problémáim vannak, de a PHP-ben szerencsére van lehetőség procedurális programozásra

Az egy dolog, hogy egyes embereknek problémái vannak az aszinkron programozással, de szerencsére vannak más nyelvek is, amikben ez nem probléma (vagy csak nem veszik figyelembe).

megszokott include-olásra beépített lehetőség

Tudsz példát hozni erre, ami nem PHP?

Szerintem a modul eléggé egyértelmű kódfelbontási alap. Van egy modulom, az implementál valamit, és ad egy interface-t, amivel használhatom, ami minden esetben egy objektum. Mivel a függvények is objektumok, ezáltal lehet egy konstruktor is.

A különböző kerülő megoldások nem játszanak.

Ezzel nem értem, mire akarsz célozni. Milyen kerülő megoldások?
23

Lásd 11-es hozzászólás.

Hidvégi Gábor · 2015. Jan. 16. (P), 12.37
25

Nem értem

Poetro · 2015. Jan. 16. (P), 12.45
Továbbra sem értem. Egy fájlba rakhatsz egy prototípust, és akkor csak azt exportálod (mivel a nyelv nem támogat hagyományos értelemben vett osztályokat, ne is várjuk tőle, hogy úgy működjön, ahogy más nyelvek ebben a tekintetben.). Ez más nyelvekben is működik. Ugyanakkor több osztályt is deklarálhatsz egy modulban. Erre is van példa más nyelvekben.
Java-ban nincs autoloader igazából, ott a fordító valósítja meg a fájlok behúzását az import-ok alapján (amik ugye hardcode-oltak).
PHP-ban csak pár éve van működő autoloader, és az sem tökéletes, ahogy hallottam.
Egyébként a fájl nevét modulok esetén más nyelvekben is be kell hardecode-olni, még tudtommal Python esetében is.
26

Lásd 7-es hozzászólás Go-ban

Hidvégi Gábor · 2015. Jan. 16. (P), 13.01
Lásd 7-es hozzászólás

Go-ban például egy modul egy könyvtárat jelent, abból beinclude-olja a fájlokat, amikben akár külön osztályok lehetnek.
27

Modul

Poetro · 2015. Jan. 16. (P), 13.08
Azt, hogy egy nyelvben mást jelent a modul, mint egy másikban, szerintem ne rójuk fel a nyelv hibájának. C-ben is mást jelent a tömb, mint például PHP-ban, vagy Python-ban, vagy Haskell-ban.
40

"PHP-ban csak pár éve van

webproghu · 2015. Jan. 16. (P), 14.29
"PHP-ban csak pár éve van működő autoloader"

11 éve :)

"és az sem tökéletes, ahogy hallottam"

Hallani sok dolgot lehet. :) PHP-val 9 éve foglalkozom, munkahelyen 6 éve fejlesztőként, abból 1 éve vezető fejlesztőként. Eddig sem nekem, sem bármelyik munkatársamnak nem volt gondja az autoloaderrel.

De visszakanyarodva a fő témához:
bár lehetőséget ad rá a Node.js (Javascript), hogy több osztályt (objektumot) egy fájlba írjak (bár aki valaha is foglalkozott tiszta kóddal, az tudja, hogy ez ejnye bejnye), de tegyük fel, hogy én szeretnék megmaradni a szép, áttekinthető egy osztály egy fájl koncepciónál. Maga az osztály ad kifelé egy interfészt, publikus adattagokkal és metódusokkal, ez az OOP egyik lényegi eleme is. Innentől kezdve nekem mi a francért kell még teleszemetelnem az osztályom kódját egy ilyen module exports-os dologgal? Ráadásul még egyszer meg kell adnom, hogy az adott modul/fájl/osztály milyen interfészt nyújt kifelé.
Továbbá ha olyan perverz vágyaim lennének, hogy csinálok egy tényleges (több osztályt összefoglaló modult), akkor lényegében lesz egy modulom, amin belül lesz sok másik modulom, amik valójában osztályok, nem is modulok.

Ne érts félre, nem elvakult támadásba kezdtem a Node.js-el szemben, vagy bárminemű hitvitát szeretnék generálni. De én nem látom azt, hogy ez szép és tiszta lenne. Az is lehet, hogy tévedek, vagy csak nincs még elég tapasztalatom vele. De cáfold meg kérlek a fenti gondolatmenetemet, hogy ezt nem így kell csinálni. Nagyon örülnék neki, mert már nagyon szívesen átnyargalnék Node-ra, de ez a modulos dolog minden, de nem átlátható és/vagy szép.
41

"Szerintem a modul eléggé

webproghu · 2015. Jan. 16. (P), 14.33
"Szerintem a modul eléggé egyértelmű kódfelbontási alap. Van egy modulom, az implementál valamit, és ad egy interface-t, amivel használhatom, ami minden esetben egy objektum. "

Tehát az objektum is ad kifelé egy jól definiált interface-t, ami ugye az OOP egyik alapja, és még a modul is? Ez szép?
22

Az aszinkron működésnek

MadBence · 2015. Jan. 16. (P), 12.22
Az aszinkron működésnek megvan az oka, ezt már kismilliószor előkerült itt: mivel egy futtató folyamatod van, így nem használhatsz blokkoló hívásokat, hiszen azzal a többi beérkező kérést is blokkolnád. PHP-nál ezzel nem foglalkozol, mert az őt futtató webszerver elintézi, hogy minden kérés saját szálat kap (nem vagyok vele tisztában, de gondolom valami threadpool megoldást használ), így nyugodtan blokkolhat. A hátrány, hogy erősen limitálva van így a párhuzamos kérések száma, mert egy szál elég nagy (memória) overheaddel rendelkezik. Az aszinkron működés egy tervezői döntés volt, ha neked nem tetszik, akkor nyilván nem fogod használni, de ettől még nem eredendően rossz megoldás.

Az include problémát nem értem, a node a CommonJS szintaktikát használja modulok definiálására, a require pedig .js vagy .json fájlokat tud betölteni, amik lehetnek abszolút/relatív útvonalak (/path/to/file vagy ./path/to/file), core modulok (http, net, stb.) vagy ha ezek közül egyik sem, akkor megpróbálja megkeresni a ./node_modules könyvtárban, ha ott nincs, akkor egy szinttel feljebb a ../node_modules-ben (egészen a gyökérig). Ezek nem kerülő megoldások.

Kíváncsi leszek mi fog történni, ha stabil lesz a v8 module implementációja, eddig ehhez sajnos mindenféle transpilereket kellett használni:

import foo from 'bar;
24

Az aszinkron működés egy

Hidvégi Gábor · 2015. Jan. 16. (P), 12.44
Az aszinkron működés egy tervezői döntés volt
Nem, ez egy incidental complexity. A javascript szabvány szerint egyszálú, ezt valósítja meg a V8, a node.js kitalálója, Ryan Dahl pedig ezt választotta a nyelv alapjául. Ezzel jött, hogy eseményalapú lesz az egész.

A hátrány, hogy erősen limitálva van így a párhuzamos kérések száma
A node-ben is limitálva van, annyi lesz, amennyit az adott processzor ki tud szolgálni. Ha ez nem elég, akkor használhatsz thread kezelést ott is, ami átkerülhet a másik processzorra, de akkor pontosan ugyanott vagy, ahol a part szakad.

mert egy szál elég nagy (memória) overheaddel rendelkezik
Ez megoldásfüggő, pont a héten olvastam utána dolgoknak. Ahol fork()-ot használnak az új folyamat indítására, ott nagy lehet a memóriafoglalás, ugyanis forkoláskor lemásolják az addigi program teljes memóriáját. Ahol szálkezelést (thread) használnak, az jóval olcsóbb, mivel memóriát nem másolnak, az közös (és itt jön be a bonyolítás, hogy lockolni kell, szóval ez az ár). Márpedig a modern Apache például már szálakkal dolgozik.
28

Nem, ez egy incidental

MadBence · 2015. Jan. 16. (P), 13.12
Nem, ez egy incidental complexity. A javascript szabvány szerint egyszálú, ezt valósítja meg a V8, a node.js kitalálója, Ryan Dahl pedig ezt választotta a nyelv alapjául. Ezzel jött, hogy eseményalapú lesz az egész.
Ez nem valami feketemágia, pl. a GUI rendszerek mind a mai napig így működnek, ott sem sikerült jobbat kitalálni.

A node-ben is limitálva van, annyi lesz, amennyit az adott processzor ki tud szolgálni.
Azért elég nagy a különbség. Nagyságrendileg egy apache párszáz párhuzamos kérésig bírja (igaziból attól függ mennyi memóriát tolsz alá), node-ban akár egymillió párhuzamos kapcsolat is lehet (ami sejteti, hogy valós felhasználásnál sem kellene pár tízezer kapcsolat alatt megtorpannia).

Minden kéréshez egy processzt elindítani (helló CGI!)... Manapság ezt maximum megmosolyogná az ember. Minden kéréshez saját szál indítása (pl. a php apache modul) szintén elég pazarló: egyrészt egy thread indítása nagyon lassú (le kell foglalni a stacket, rendszerhívással regisztrálni kell a szálat, stb), másrészt sok memóriát foglal (az én laptopomon egy szálnak 8MB-os stackje van). A lassú indításon lehet segíteni a threadpoolokkal (ahogy én tudom az apache is valami ilyesmit csinál mod_php címszó alatt), amikor előre elindítunk valahány szálat, és a beérkező kéréseket ezek szolgálják ki.
Az aszinkron működés gyakorlatilag ingyen van, a háttérszálak elvégzik a rendszerhívásokat, az eseményhurok pedig tud pörögni.
30

pl. a GUI rendszerek mind a

Hidvégi Gábor · 2015. Jan. 16. (P), 13.30
pl. a GUI rendszerek mind a mai napig így működnek
Igen, csak itt nem GUI-ról van szó, ahol természetes, hogy események történnek, és azok között idő telik el (billentyűleütés, egérkattintás stb.), viszont a node.js egy szerveroldali programozási nyelv. A szerveroldali kérések legalábbis általában úgy szoktak történni, hogy jön a kérés, a szerver dolgozik (lefuttat n darab utasítást), majd visszaad egy választ.

node-ban akár egymillió párhuzamos kapcsolat is lehet
Igen, de hogy ebből mennyit szolgál ki, arról nem szól a fáma. Egy másik írásban is erről van szó, ott egy kérés nagyjából negyven bájtot ad vissza, és megjegyzik, hogy amikor húszezer párhuzamos kérést indítottak el, csak tizenhétezret tudott kiszolgálni a rendszer.

Minden kéréshez egy processzt elindítani (helló CGI!)... Manapság ezt maximum megmosolyogná az ember.
Nyilván. Mégis elég népszerű az Apache, és sokszor tesznek Apache-ot node.js elé, szóval érdemes ezeken is elgondolkozni.
34

A szerveroldali kérések

MadBence · 2015. Jan. 16. (P), 14.05
A szerveroldali kérések legalábbis általában úgy szoktak történni, hogy jön a kérés, a szerver dolgozik (lefuttat n darab utasítást), majd visszaad egy választ.
Ha izoláltan nézel egy http kérést, akkor igen. A valóságban ez úgy működik, hogy érkezik egy kérés, te elkezded kiszolgálni, végrehajtasz egy adatbázisműveletet, érkezik egy másik kérés, azt is elkezded kiszolgálni, azzal is indítasz egy adatbázis műveletet, az első adatbázisművelet visszatér, válaszolsz a kliensnek, a második adatbázisművelet visszatér, a másik kliensnek is válaszolsz. És ez csak 2 kérés volt, 1-1 adatbázisművelettel.
Igen, de hogy ebből mennyit szolgál ki, arról nem szól a fáma. Egy másik írásban is erről van szó, ott egy kérés nagyjából negyven bájtot ad vissza, és megjegyzik, hogy amikor húszezer párhuzamos kérést indítottak el, csak tizenhétezret tudott kiszolgálni a rendszer.
Mivel a bejegyzésből nem derül ki, hogy ez miért volt, így nem tudom neked megmondani, hogy ez a node, a socket.io vagy esetleg az operációs rendszer hibája (ulimit -n) miatt volt.
Mégis elég népszerű az Apache, és sokszor tesznek Apache-ot node.js elé
Ettől az apache kiszolgálási modellje nem fog megváltozni... (bár úgy tudom, már támogatja az eseményalapú feldolgozást is, amivel gondolom az nginx-hez hasonló működésre képes)
29

A javascript szabvány szerint

Chriksz · 2015. Jan. 16. (P), 13.26
A javascript szabvány szerint egyszálú


Melyik szabvány ez? Az alap ECMAscript? Meg tudnád mutatni hol van ez leírva? Vagy a w3c JS API-ra gondolsz? Akkor mi van a web workers-szel?
31

Web Worker

Poetro · 2015. Jan. 16. (P), 13.36
A Web Worker egy DOM API, ergó nem része az ECMAScript-nek. És az ECMAScript egyébként sem említ szálakat, így mondhatjuk róla, hogy egyszálú.
32

Persze, hogy nem része. Ezért

Chriksz · 2015. Jan. 16. (P), 13.46
Persze, hogy nem része. Ezért kérdeztem külön. És igen, nem említ. Tehát mondhatjuk azt is, hogy több szálú. Tudtommal nincs semmi olyan nyelvi sajátosság, ami meggátolná, hogy több szálú legyen. Az, hogy több vagy egy szálú, az a futattó környezet sajátossága, nem a nyelvé.
33

Tudtommal nincs semmi olyan

Poetro · 2015. Jan. 16. (P), 13.50
Tudtommal nincs semmi olyan nyelvi sajátosság, ami meggátolná, hogy több szálú legyen.

Csak annyi, hogy nincs mód újabb szálak nyitására, és semelyik függvény sem szál-biztonságos (és nem is lehet nyelvi eszközökkel azzá tenni).
35

Csak annyi, hogy nincs mód

Chriksz · 2015. Jan. 16. (P), 14.05
Csak annyi, hogy nincs mód újabb szálak nyitására
De van. Pl. Web workers.

Milyen nyelvi elemekre gondolsz? Egyedül az async / await jut eszembe C#-ból, de előtte is alkalmas volt többszálú programozásra, vagy nem?
37

Mutex, szemafor, stb. Az

MadBence · 2015. Jan. 16. (P), 14.10
Mutex, szemafor, stb. Az async/await pont azért kell, mert egyszálú a működés.
38

Web workers

Poetro · 2015. Jan. 16. (P), 14.21
De a Web workers nem a nyelv része, még csak nem is a JavaScript része, hanem a DOM része.
Többszálú működéshez kell módszer amivel szálakat tudsz létrehozni. C/C++ esetén eléred a OS-t, annak meghívhatod függvényeit, hogy új processzeket, szálakat nyiss. Ugyanez nem létezik JavaScript esetén.
42

Nem is mondtam, hogy a nyelv

Chriksz · 2015. Jan. 16. (P), 14.50
Nem is mondtam, hogy a nyelv része, csak azt, hogy a nyelvnek van olyan futtatókörnyezete ahol lehet új szálat nyitni.

C/C++ esetén eléred a OS-t, annak meghívhatod függvényeit

Ez is pont ugyan annyira nyelvi elem, mint a web workers.

Mutex is csak egy algoritmus. Onnantól kezdve, hogy egy nyelv turing teljes. Azt valósítasz meg benne, amit akarsz.
43

Mutex is csak egy algoritmus.

BlaZe · 2015. Jan. 16. (P), 14.57
Mutex is csak egy algoritmus. Onnantól kezdve, hogy egy nyelv turing teljes. Azt valósítasz meg benne, amit akarsz.
Hát ennél azért lényegesen összetettebb a dolog. A processzor ad utasításokat a többszálú programok helyességének biztosítására (memory barrierek, atomi műveletek pl). Ha ezt egy nyelv, fordító nem támogatja, akkor a fejed tetejére is állhatsz, akkor se tudsz benne thread-safe kódot írni.
45

Javascript, mint nyelv, ugyan

Chriksz · 2015. Jan. 16. (P), 15.34
Javascript, mint nyelv, ugyan úgy képes shell parancsokat küldeni, sőt akár konkrét gépi kódot a procinak. Ezek nem a nyelv, annak alapvető elemeinek kérdése. Hanem a hozzátartozó futtatókörnyezeté. Ezért nem tér ki egy nyelvi specifikáció sem, hogy többszálú, mert ha kitérne, azt is fel kéne sorolni, hogy igen, képes bubble sortra, képes láncolt listára, stb.
46

Nem azt mondtam, hogy

BlaZe · 2015. Jan. 16. (P), 16.41
Nem azt mondtam, hogy többszálú egy nyelv, hanem hogy nyelvi eszközökkel is támogatja a többszálú programozást. Az, hogy tudsz rendszerhívásokat csinálni, nem ezt jelenti. Pláne nem, ha ezt gépi kódú utasításokkal teszed. A mai modern nyelvek már egyre inkább definiálnak ún. memory modelt, aminek fontos része, hogy egy változó értéke milyen feltételek mellett látható egy másik szálon. Gondolj pl a register allocated változókra. Egy

int x = 1; 

Thread1:
while (x==1);

Thread2:
x=2;
kód vajon ki fog lépni a ciklusból? Mire számítasz, ha a nyelv specifikációja nem egyértelműsíti valahogy ezt az esetet? És itt még az sem igaz, hogy ez a nyelv implementációjának a feladata, mert a fenti kódot impementációtól függetlenül helyesre és determinisztikusra kell tudnod csinálni. Adott esetben még kernel primitívek hívása se feltétlenül segít.
64

Nem az volt a célom az

Chriksz · 2015. Feb. 14. (Szo), 16.45
Nem az volt a célom az elmondottakkal, hogy bizonygassam, hogy a JS a legjobb választás multi threadingre; csak annyi, hogy abszolút alkalmas rá, lévén turing-teljes. C vagy JS éppen ugyanannyira alkalmas teljes memóriaképek pakolgatására: semennyire. Ezeket assembly könyvtárak hívogatásával oldjuk meg.

A fenti példádban ált. egy sima változót közös memóriában máshol is az állítja be, aki éppen hozzáfér, de némi tervezéssel, szemaforok nélkül is simán megoldható a helyzet, mondjuk valamilyen busy waiting-gel(Pl. Peterson-algoritmus).

Továbbá 'nyelvi szinten' sem vagy teljesen elveszve, pl. web workers-nél pontosan le van írva mi történik a memóriaképpel.
65

Továbbá 'nyelvi szinten' sem

Poetro · 2015. Feb. 14. (Szo), 19.23
Továbbá 'nyelvi szinten' sem vagy teljesen elveszve, pl. web workers-nél pontosan le van írva mi történik a memóriaképpel.

Csak a web workers nem része a JavaScriptnek, hanem az egy böngészőbeli API, és a böngésző oldja meg a többszálúságot, vagy busy waiting-et.
67

Ezért raktam zárójelbe.

Chriksz · 2015. Feb. 15. (V), 00.26
Ezért raktam idézőjelbe. Amikor blokkolsz, azzal primitíveket hívsz meg, amit nyugodtan hozzácsaphatsz könyvtár formájában, c#-ban, c-ben, PHP-ban is tök ugyanezt csinálod. Ergo nincs sok dolga a nyelvvel vagy kijelenthetjük azt, hogy egyedül az assembly többszálú.

Elmondom nagy vonalakban, hogy én hogyan látom ezt az egészet. Van két lehetőség: vagy te kezeled a szálak processzoridejét vagy a kernel. Ha az első a helyzet, akkor szükséged lesz egy könyvtárra, ami olyan nyelvi primitíveket aka assembly utasításokat biztosít számodra, mint a TLS vagy egyéb nyalánkságok. Az ilyen könyvtáraknak pedig kb. semmi köze magához a nyelvhez, mivel ezt a platform biztosítja. Ha kernelre van bízva a dolog, akkor bőven elég neked egy kő egyszerű busy waiting, mivel így biztos nem gányol a kritikus részekkel. Tehát egyedül, amire neked nyelvi szinten szükséged van, hogy az egészet összehangolt, az az, ami egy nyelvet Turing-gépnek megfelelővé tesz.
66

C vagy JS éppen ugyanannyira

BlaZe · 2015. Feb. 15. (V), 00.20
C vagy JS éppen ugyanannyira alkalmas teljes memóriaképek pakolgatására: semennyire. Ezeket assembly könyvtárak hívogatásával oldjuk meg.
Inkább azt mondanám, hogy megfelelő gépi kódú utasítások végrehajtásával, és megfelelő fordítók alkalmazásával. Ezek C esetében nyelvi szinten adottak, JS esetében tudtommal nem.

A fenti példádban ált. egy sima változót közös memóriában máshol is az állítja be, aki éppen hozzáfér, de némi tervezéssel, szemaforok nélkül is simán megoldható a helyzet, mondjuk valamilyen busy waiting-gel(Pl. Peterson-algoritmus).
Pont ezért írtam, amit írtam, mert ez így önmagában nem igaz. A modern fordítókkal és modern procikon szinkronizációs utasítások nélkül az ilyen busy-waites megoldások, mint pl a Peterson-algoritmus hibásan működhetnek. Mind a fordító, mind a proci módosíthatja az utasítások végrehajtási sorrendjét (bizonyos játékszabályok betartása mellett), és teszik is. Emellett a fordító dönthet úgy, hogy egy változó legyen register allocated, így arra a változóra hiába waitelsz a másik szálon, sosem fog változni az értéke. Ha ez nem elég, a mai modern procik többségén a memória írása aszinkron módon történik, vagyis egyszercsak. Ezek mind nagyon csúnya dolgokat tudnak produkálni (természetesen többnyire élesben :)). Emiatt ha egy nyelv szeretne többszálú programozásra alkalmas lenni, akkor ezekre a problémákra választ (és eszközt) kell adjon. Ha ez nem így van, akkor csak ráépülő API, vagy implementáció, futtatókörnyezet stb tudja, de ebben az esetben a nyelv maga nem támogatja a többszálú programozást. Vagyis szinkronizációs algoritmusokat csak nyelven kívüli szinkronizációk felhasználásával tudsz megvalósítani. Ilyen pl a JS, míg pl C-ben, Javaban magad is meg tudod írni ezeket.
68

Mind a fordító, mind a proci

Chriksz · 2015. Feb. 16. (H), 14.02
Mind a fordító, mind a proci módosíthatja az utasítások végrehajtási sorrendjét (bizonyos játékszabályok betartása mellett), és teszik is.


Ha a fordító ezt nem a specifikáció szerint teszi az egyszerűen bug, az ECMAScript-ben is megtalálható ez execution contexts cím alatt.

Emellett a fordító dönthet úgy, hogy egy változó legyen register allocated


Ezt is úgy szint inkább bugnak mondanám, kb. mintha a GC eldobná az adott memóriaszegmenst, függetlenül a referenciaszámlálótól.

A kérdés itt szerintem teljesen más, az emberek keverik a szezont a fazonnal. Egy adott konkrét megvalósítás nem egyenlő a nyelvvel, ami egy absztrakt entitás.
69

Ezt is úgy szint inkább

BlaZe · 2015. Feb. 16. (H), 15.23
Ezt is úgy szint inkább bugnak mondanám, kb. mintha a GC eldobná az adott memóriaszegmenst, függetlenül a referenciaszámlálótól.
Ezt konkrétan csinálják a fordítók. Hisz nem látnak rá referenciát. Majd próbálkozik egy másik szál kiolvasni, de addigra az első szál már regiszterben tekeri az értékét. Az eredmény egy végtelen ciklus (is lehet).

A kérdés itt szerintem teljesen más, az emberek keverik a szezont a fazonnal. Egy adott konkrét megvalósítás nem egyenlő a nyelvvel, ami egy absztrakt entitás.
Pont ezért kell a specifikációnak rendelkeznie erről, és nem az implementációnak. Ahogy te is mondod az első mondatodban. Feltéve, hogy a nyelv maga támogatni akarja a többszálúságot (ahogy itt most erről szó volt). Vannak ilyen nyelvek, amik ezeket definiálják a specijükben, pont ezért. Az implementációk pedig azt követik.
70

Ezt konkrétan csinálják a

Chriksz · 2015. Feb. 17. (K), 00.37
Ezt konkrétan csinálják a fordítók. Hisz nem látnak rá referenciát.

Igazából ilyennel még nem találkoztam. Pontosan Te milyen nyelven, esetben futottál bele ilyen problémába?

A kérdés itt szerintem teljesen más


Ez erősen eltájolt volt tőlem, elnézést. :-)

Mint már fentebb is írtam, nem célom bebizonyítani, hogy JS-ben már pedig megéri többszálú programokat írni, csak annyi, hogy alkalmas rá, bizonyos szinten. Tehát én nem tudom értelmezni azt, hogy a nyelv egyszálú, főleg úgy, hogy én nem látok erre vonatkozóan explicit kijelentést a tervezőktől.
71

Igazából ilyennel még nem

BlaZe · 2015. Feb. 17. (K), 02.35
Igazából ilyennel még nem találkoztam. Pontosan Te milyen nyelven, esetben futottál bele ilyen problémába?
Javaban és c-ben. Szerencsére nem élesben, csak tesztekkel idéztem elő. C esetében mivel a fordítás nem futásidőben zajlik, a fordítónak semmi infója nincs, hogy egy változóra mikor, milyen referencia lesz, ezért optimalizálhat ilyet. Pl gcc -O3-mal láttam a következőket: ping-pongoztam 2 szállal, amikor egyik látta, hogy a másik növelte a counterét, ő is növelte a sajátját, és viszont, majd egy meghatározott értéknél leálltak. Mivel az optimalizáció miatt a countereket regiszterben tekerték a szálak, ebből végtelen ciklus lett.

Javaban kicsit trükkösebb a helyzet, ott pl ha egy T1 szál növel egy countert egy ciklusban, egy T2 szál pedig busy waitel amíg a counter el nem ér egy meghatározott értéket, akkor szintén végtelen ciklus lehet az eredmény. Itt mivel a JIT-nek van context infója, fontos hogy kicsit várni kell (pl sleep(1)), hogy a compiler azt lássa, hogy a ciklus egy hotspot és az adott counterre senki más nem tart referenciát a T1-en kívül. Ekkor be fogja optimalizálni ő is a c-hez hasonlóan, és T2 végtelen ciklusba kerül.

A fenti problémára mindkét nyelvben megoldás, ha pl a változókat volatile-ként definiáljuk, vagy atomi műveleteket használunk. A volatile kicsit mást jelent a 2 nyelvben, de ebből a szempontból azonos a működésük.

Ezek az esetek elég laborszagúak, a valóságban sokkal trükkösebben ütheti fel a fejét az ilyenfajta bug.
39

Bár közben már válaszoltak,

Hidvégi Gábor · 2015. Jan. 16. (P), 14.23
Bár közben már válaszoltak, én ezt találtam, ami megerősíti a többieket.
36

A node-ben is limitálva van,

BlaZe · 2015. Jan. 16. (P), 14.08
A node-ben is limitálva van, annyi lesz, amennyit az adott processzor ki tud szolgálni. Ha ez nem elég, akkor használhatsz thread kezelést ott is, ami átkerülhet a másik processzorra, de akkor pontosan ugyanott vagy, ahol a part szakad.
Azért a context switch költségét, a szálak altatását, keltetését stb ne hagyd figyelmen kívül. A (futó) szálak közötti adatcsere és a szálak ütemezése nem összemérhető erőforrásigényű dolgok. A memória overhead szintén egy fontos aspektus. Nem ismerem a node.js történetét, de azt se hiszem, hogy ez az architektúrális döntés (event-loop használata szálak helyett) a véletlen, vagy külső függőség műve. Egy ideje komoly igény van a nagymennyiségű kapcsolatot/requestet kezelni képes rendszerek iránt. A process és thread alapú rendszerek nem erre vannak kitalálva.
44

Nem ismerem a node.js

Hidvégi Gábor · 2015. Jan. 16. (P), 15.15
Nem ismerem a node.js történetét, de azt se hiszem, hogy ez az architektúrális döntés (event-loop használata szálak helyett) a véletlen, vagy külső függőség műve.
Pedig ez olyan hipszteres:
Dahl was inspired to create Node.js after seeing a file upload progress bar on Flickr. The browser did not know how much of the file had been uploaded and had to query the Web server. Dahl desired an easier way.
Ezek után, szerinted?
15

Az a gond, hogy a module-nál

inf3rno · 2015. Jan. 16. (P), 02.27
Az a gond, hogy a module-nál a két végletet veszed alapul. Persze abba könnyű belekötni...

Egy module-ba olyan közepes egység kell, hogy belemenjen szerintem, tehát mondjuk max 1000 sor. Terszmészetesen használhatsz más rendszert is, pl coffee, typescript, bla-bla, ami js-t generál, úgy talán nem kell ezzel törődni, nem tudom azok hogy vannak belőve, de simán lehet írni build-et, ami megoldja a csomagolást. A module kb ugyanaz, mint a package/namespace máshol.
47

Egy module-ba olyan közepes

webproghu · 2015. Jan. 17. (Szo), 11.25
Egy module-ba olyan közepes egység kell, hogy belemenjen szerintem, tehát mondjuk max 1000 sor.


A címben nem véletlenül tüntettem fel a tiszta kódot. Aki találkozott már ezzel a fogalommal, olvasott a témában könyveket (van konkrétan egy Tiszta kód nevezetű) az tudja, hogy egy 1000 soros fájl nem igazán sorolható ebbe a kategóriába.
48

Az egy dolog, hogy a könyv

Hidvégi Gábor · 2015. Jan. 17. (Szo), 11.50
Az egy dolog, hogy a könyv mit ír, meg egy másik, hogy te hogyan szereted látni a kódot. Ha jól vannak elnevezve a függvényeid/metódusaid, miért ne lehetne az egész egy fájlban?
49

Az addig oké, amíg egy ember

webproghu · 2015. Jan. 17. (Szo), 14.37
Az addig oké, amíg egy ember dolgozik egy projekten.
De ha egy fejlesztőcsapat, vagy teszem azt te átveszed az én projektemet, akkor szerinted mekkora lesz annak a költsége, amíg te átlátod/megérted az általam írt 3-5-10 ezer soros kódot egy fájlban?
A könyvben nem véletlenül írják azt amit, a szakmában sok év alatt kialakultak bizonyos konvenciók, amelyek azt hivatottak elősegíteni, hogy szép/tiszta/átlátható kódbázis készüljön.

De csak, hogy példával támasszam alá:
tavaly egy funkcionalitását tekintve viszonylag egyszerű ügyviteli rendszeren kellett lecserélnünk a felületet, ami pont így volt felépítve, fájlokba belezsúfolva 1-2-3-10 ezer sornyi kód. Fél évbe telt... egyszerűen a fejlesztők idejének nagy része azzal ment el, hogy keresgessék összevissza a több ezer soros fájlokban, hogy a korábbi fejlesztő mégis hova rakott egy adott függvényt, és az milyen más függvényekkel áll még kapcsolatban. Ezért nem lehet az egész egy fájlban. Kivétel persze, ha az ember magának programozgat egyedül, hobbiból. De egy cégnél nem mindegy, hogy egy régebbi projekt továbbfejlesztésekor 2 fejlesztő hat hónapnyi munkabérét áldozza a dologra, vagy 1 fejlesztő 2 hónapnyi munkabérét. (6 millió forint, vagy 1 millió forint)
50

Elfogadom, hogy van egy

pythonozok · 2015. Jan. 17. (Szo), 15.45
Elfogadom, hogy van egy limit, aminél nagyobb forrás fájlokat nem érdemes készíteni, de... érteni nem értem.
Az az idő rég elmúlt, amikor vi-t használtak a nagy projekteken dolgozó fejlesztők (remélem).
Ha meg egy normális IDE-t használ az ember, akkor gyakorlatilag édesmindegy, hogy egy fájl vagy sok apró.
Rosszul látom?
(eredetileg nagyjából ugyanazt akartam válaszolni Gábornak, amit te is írtál, szinte szó szerint. De eszembe jutott, hogy mi mindent tudnak az olyanok is mint, az eclipse vagy a frissen előszedett pycharm és máris nem látom ennyire egyértelműnek ezt a korlátozást)
51

Egy normális IDE használata

webproghu · 2015. Jan. 17. (Szo), 16.01
Egy normális IDE használata manapság már mindenhol alap, azt azért remélem te is belátod, hogy nem a változó megkeresése, és a forrásfájlokban való navigáció a nehéz ebben, hanem az, hogy megértsd mit is akart itt a korábbi fejlesztő. Vagy, hogy ha belenyúlsz egy függvénybe, akkor az hogyan érinti a másik 5 ezer soros fájl közepén lévő másik függvényt, aminek a kimenetét szintén használja egy 10 ezer soros fájl alján lévő harmadik függvény, és így tovább. SOLID irányelvek, tiszta kód, tervezési minták, ezek mind nem véletlenül alakultak ki, mind arra irányulnak, hogy elkerülhetőek legyenek az ilyen helyzetek.
54

Na épp erre mondom, hogy

pythonozok · 2015. Jan. 17. (Szo), 17.00
Na épp erre mondom, hogy ebben rengeteget tud segíteni egy megfelelő IDE, ha értesz hozzá.
Ott már nem vagy rákényszerítve igazán, hogy forráskódban turkálj, ott már osztályokban, metódusokban, függvényekben stb. tudsz navigálni, keresgélni.
Az IDE analizálja, felbontja, könnyen értelmezhetővé teszi akár a több tízezer soros kódot is.
Azért nézd meg, hogy a Clean Code mikor íródott eredetileg! És nézd meg, hogy mennyit fejlődtek ezek az eszközök!
55

IDE ide vagy oda ( :) ), de a

webproghu · 2015. Jan. 17. (Szo), 20.09
IDE ide vagy oda ( :) ), de a fejlesztőnek kell megértenie a kódot amit korábban más írt. Teljesen igazad van abban, hogy egy IDE ebben sokat segít, de aki felteszi a kérdést, hogy miért nem jó, ha több ezer sort egy fájlba írsz, az valószínűleg nem fog könnyen értelmezhető, szépen felépített kódot írni. :)
56

Szerintem - ha egy kellőképp

pythonozok · 2015. Jan. 17. (Szo), 20.33
Szerintem - ha egy kellőképp fejlett IDE-t használsz - nézd meg kicsit alaposabban, mikre képes! A normálisabbja simán kiemel bármit, amit közelebbről meg akarsz nézni, akár még a kapcsolatait is megmutatja projekten belül stb.
A munkának ez a része már elég jól automatizált ahhoz, hogy ha nem akarsz később emacs/vi/ed segítségével turkálni a forrásban, akkor ne legyen feltétlen szükséged a kisméretű forrás fájlokra.
60

Ha elolvasod még egyszer a

inf3rno · 2015. Jan. 18. (V), 02.16
Ha elolvasod még egyszer a könyvet, akkor láthatod, hogy olyat is írt a szerző, hogy osztály-, metódus- és változónevekkel írjuk le, hogy mit csinál a kód. Így nincs szükség arra, hogy alacsonyabb szintű osztályok kódját böngésszük ahhoz, hogy megértsük mi történik. Ír azt hiszem olyat is, hogyha több osztály van egy fájlban, akkor a magas szintű osztályoknak kell legfelül lenniük, és lefelé haladunk az egyre alacsonyabb szintű osztályok felé. Már csak nagy vonalakban emlékszem a könyvre, de nem rémlik, hogy szigorúan megtiltaná, hogy több osztály legyen egy fájlban.

Azért írtam a modulokat max 1000 sornak, mert azokban még össze lehet szedni 1-2 magas szintű osztályba a felületet, amin keresztül a többi modul eléri az adott funkciót, így nem áll fenn az a veszély, hogy a végeredmény átláthatatlan lesz. Elég elolvasni az első osztályt, hogy lásd, hogy mit csinál a kód, aztán ha az is érdekel, hogy hogyan csinálja, akkor tovább scrollozhatsz.

Na mindegy, nekem ez a véleményem, de egyelőre még én is küzdök a js-el, tiszta kód terén. Majd ha van kiforrott megoldásom a témára, akkor visszajelzek.
62

Na mindegy, nekem ez a

webproghu · 2015. Jan. 18. (V), 23.25
Na mindegy, nekem ez a véleményem, de egyelőre még én is küzdök a js-el, tiszta kód terén. Majd ha van kiforrott megoldásom a témára, akkor visszajelzek.


Azt megköszönöm előre is. Lehet tudni egyébként hol jársz a küzdelemben? Ha úgy akad szívesen konzultálnék az ügyben, vannak nekem is ötleteim, de nem tudom még jó irányba haladok-e.
63

Hát én most jelenleg itt

inf3rno · 2015. Jan. 19. (H), 08.12
Hát én most jelenleg itt tartok: https://github.com/inf3rno/dflo2/issues/5, az implementálást már egy hete el akartam kezdeni, de egészségügyi okokból ez sajna elmaradt. Talán holnap már lesz időm rá, majd kiderül.
52

Én sem értem

Hidvégi Gábor · 2015. Jan. 17. (Szo), 16.17
A szerkesztőd – betűmérettől függően – megjelenít a képernyődön 50-100 sort. Nem tökéletesen mindegy, hogy ez az ötven sor egy ötszáz vagy egy ötvenezer soros fájl közepén van?

Ha ismered a belépési pontot (ahol a feldolgozás indul), nem mindegy, hogy egy fájlon belül ugrálsz a függvények között, vagy pedig százban?

Most nem vitatkozni szeretnék veled, csak megérteni.

Az én szerkesztőmben lehet olyat csinálni, hogy egy fájl ablakát kétfelé szedni, így ugyanannak a kódnak két részletét láthatom egymás alatt.
61

Az egész inkább arról szól,

inf3rno · 2015. Jan. 18. (V), 02.19
Az egész inkább arról szól, hogy az egy fájl : egy osztály rendszerben a fájl elején fel van sorolva az összes függőség, míg az egy fájl : több osztály rendszerben nem látod a függőségeket.
57

illetve itt feltennem azt a

city99 · 2015. Jan. 17. (Szo), 21.44
illetve itt feltennem azt a kerdest is mitol jobb 100db 10 soros fajlba turkalgatni mint 1 db 1000 sorosba? Nekem spec elduran az agyam amikor kb egy 3 soros spagetti koddal eloallithato kimenetet a tisztakod elmelet alapjan sikeresen 8 fajba talalok meg szetdobalva. Igy hatvanyozva szepen a rendszer nem 50 fajlbol all hanem 2820-ba amibe aztan lehet ide oda ugralgatni, ugyan ugy ahogy az emlitett tobb ezersoros fajlban, csak igy nem a slider lesz kicsi hanema tabok szama rengeteg :D
58

Rosszul tervezett kódnál

bamegakapa · 2015. Jan. 17. (Szo), 22.13
Rosszul tervezett kódnál mindegy hogy mennyi fájlban van szétdobálva.
53

A címben nem véletlenül

MadBence · 2015. Jan. 17. (Szo), 16.45
A címben nem véletlenül tüntettem fel a tiszta kódot. Aki találkozott már ezzel a fogalommal, olvasott a témában könyveket (van konkrétan egy Tiszta kód nevezetű) az tudja, hogy egy 1000 soros fájl nem igazán sorolható ebbe a kategóriába.

Mekkora lehet egy modul? Van értelme egyáltalán azon vitatkozni, hogy hány soros egy modul? Amúgy ajánlom a héten beküldött blogmarkomat, ami a kifejezetten extrém eseteket boncolgatja (modul méret szempontjából).
59

Attól függ, hogy hogyan

inf3rno · 2015. Jan. 18. (V), 02.06
Attól függ, hogy hogyan alakítod ki az egységeket. Ha a modulodban a legelső osztály a legmagasabb absztraktciós szintű, és azon keresztül éri el a többi modul az adott funkciót, akkor szerintem átlátható a végeredmény. Sajnos kevesen tudnak szép oo js kódot írni, nekem az a tapasztalatom.
4

Ki tudnád fejteni, hogy ha

Hidvégi Gábor · 2015. Jan. 9. (P), 14.52
Ki tudnád fejteni, hogy ha van egy modulod (függvénygyűjteményed, ami egy bizonyos adattípuson végez műveleteket), akkor azt miért bontanád több fájlra?
5

- a modulom tartalmaz több

spapp · 2015. Jan. 9. (P), 15.00
- a modulom tartalmaz több osztályt
- vagy csak utálom, ha egy fájl 12526 sorból áll
- stb...

Pl. ha mondjuk egy smtp modult akarok csinálni, akkor nem lenne szerencsés mindent egy fájlba írni.
6

Ok

Hidvégi Gábor · 2015. Jan. 9. (P), 15.03
Értem, köszönöm. Azt hittem, hogy egy modul = egy osztály.
16

Imho az aszinkron része a

inf3rno · 2015. Jan. 16. (P), 02.30
Imho az aszinkron része a dolognak, ami miatt külön erőfeszítés lazán csatolt, objektum orientált, jól átlátható kódot készíteni. Én most tákolok össze egy keretrendszert, ami próbálja megoldani ezt a problémát, és az eredmény nem egy procedurális hulladék, mint pl async-nél, hanem objektum orientált. Nehézségek vannak, de úgy néz ki megoldható, és a hónap végéig elkészül belőle egy alfa verzió.