ugrás a tartalomhoz

Objektumalapú PHPdaemon

Medvesajt · 2006. Ápr. 12. (Sze), 15.22
Szevasztok!
Felmerült bennem egy olyan kérdés, amelyre ezidáig még sehol nem talátam 100%-os mértékben megnyugtató választ. Remélem, hogy valaki tud választ adni.

Összeütöttem egy olyan php alkalmazást, amelynek feladata az, hogy a program berúgásakor felkapaszkodjon egy megadott portra, várja a porton érkező kliensek kéréseit, azokat dolgozza fel, teljesítse a teljesíteni valót, majd válaszoljon az eredménytől függően.
Ennek a koncepciónak kétféle változata is van: egyik az amikor egyszerre csak egy klienssel foglalkozik, másik pedig mikor egy megadott limitig a beérkező kliens kéréseket párhuzamosan szolgálja ki ( pcntl_fork() ).

Mind a szerver, mind a kliensoldali php egy ún. "keretrendszer (framework)" része, ez a keretrendszer pedig egy webalapú alkalmazás része (vagy fordítva).
Az alkalmazás moduláris felépítésű: Én szolgáltatok a működéséhez elengedhetetlenül szükséges osztályokat (ez a keretrendszer), illetve nyújtok hozzá egy alapmodult. A célom az, hogy más fejlesztők könnyedén, gyorsan tudjanak EHHEZ AZ EGY alkalmazáshoz újabb modulokat írni.

Hasonlóképpen kell elképzelni, mint mondjuk az Eclipse-t, bár magam is érzem, hogy az összehasonlítás egy kicsit durva, és fényéves különbségek jelentkeznek, még ha hasonlatról is beszélünk.

A kliens oldal utasításait a szerveroldal "fogja el", és hajtja végre. Ehhez biztosítanom kell a keretrendszerben azokat a megoldásokat, amelyekkel egy modulírónak nem kell, és nem szabad foglalkoznia, ha egy kicsit is érdekel a keretrendszer biztonsága, önálló entitása.
Ezért azt találtam ki, hogy a modulírók csak írjanak egy alaposztályt a szerveroldalra, amiben nem kell foglalkozniuk semmivel, csak az általuk megalkotott kliensoldali parancsok szerveroldalon történő konkrét végrehajtásával. Nekem mindig egy adott szabály szerint elnevezett osztályt kell beemelnem a szerveroldalra és példányosítanom, majd ennek a beérkezett paramétereket átadnom, és rábírnom a paraméterek alapján történő futásra.

Kérdésként viszont az alábbiak merültek fel:
1. Szerintetek mikor érdemes ezeket az osztályokat beemelnem és példányosítanom: mikor berúgom az egész szerveroldali alkalmazást, vagy pedig csak akkor, mikor az adott modulhoz érkezik a porton kérés?
2. Felvetődött a kérdés arra nézve, hogy mivel a háttérben állandóan futó démonról van szó, az általa beemelt és példányosított osztályokkal mi történik,vagy mi történjen mikor azok elvégezték feladatukat? Ez a kérdés az, amiért tulajdonképpen ide írtam, mivel számomra a php alapvetően egynyári virág, azaz feléled. végrehajt, meghal. Viszont a démon verzsön nem ez, ezért nem merek éles szerverkalandokba keveredni.

Tehát az első alkalommal példányosított osztály tulajdonságait töröljem, vagy inkább a teljes példányt? Szükség van-e a példány törlésére egyáltalán?
Gondolok itt egyrészt a hatékonyságra, másrészt a memóriakalandokra.

Remélem sikerült érthetően összefoglalnom a kérdéseimet, és köszönöm előre is az esetleges válaszokat!
 
1

Nem tudom

janoszen · 2006. Ápr. 12. (Sze), 15.29
Igazából a PHPt nem ilyesmire tervezték, tehát nehéz megmondani. Szerintem, nem nagyon találsz olyat, aki ilyesmit már csinált.

Ami a PHP programot illeti, tud memory leakes lenni, ami legtöbbször nem számít, hiszen úgyis csak 30 másodpercig szokott futni.

A példányosítási problémára javaslom, hogy nézd meg az autoloading részt a PHP5-ben, mert nagyon hasznos a betöltés vezérlésére.

Ha erőforrásokkal akarsz takarékoskodni, érdemes JIT (just in time) betölteni az osztályokat. Ez azonban (kis részt) a sebesség kárára fog menni. Általánosan az az eset áll fent, hogy akkor tölts be valamit, ha már kell. Különben nagyon gyorsan nagyon sok rendszerkakót fog megenni a programod.

Ha valami már nem kell, azt hiszem, elég megszűntetni a rá mutató összes hivatkozást (példányt) és a GC automatikusan törli.

Szervereket szokás pl. C-ben megírni. Nem hiába. A PHP tipikusan platformfüggetlen nyelv, de nem a legoptimálisabb egy ilyen feladatra. Lehet, hogy érdemesebb lenne megírnod C-ben egy socket figyelőt, amelyik berúgja a PHPt, ha már tényleg kell. Igy megkerülöd a memory leak esetleges problémáját.

Remélem, segítettem

J
2

Ez jó ötlet!

Medvesajt · 2006. Ápr. 12. (Sze), 16.17
Igen, magam is az __autoload-ra gondoltam, mint legoptimálisabb megoldásra számomra ismeretlen számú fájl beemelésére és osztály példányosítására.

Ellenben úgy érzem, hogy hallatlanul remek ötletet adtál! Azért akartam a szerveroldalt is php-ban megvalósítani, mert a modulfejlesztők kezeit nem akartam programnyelv ismerete szerint megkötni.
Viszont ha C-ben firkálom meg - ahogy javasoltad - az alkalmazás porton figyelő részét, akkor csupán akár a system parancssal berúghatja a php-t, átadja neki a paramétereket, és kész. Most hirtelenjében úgy tudom elképzelni, mint egy webszerver és egy CGI-s php közötti kapcsolatot. Kérdés, hogy ezzel a módszerrel hogyan tudnék átadni paramétereket, illetve hogyan kaphatnék vissza választ?
Asszem ez jó ujjgyakorlat lenne a C-ben :)

Egyébként a phpdaemon esetében gondoltam még az inetd-s megoldásra is.
3

Kész megoldások

janoszen · 2006. Ápr. 12. (Sze), 16.24
Erre vannak kész megoldások. Van asszem egy webszerver, ami semmi mást nem csinál, csak a PHPt rugdossa. De mondjuk, nálunk a Műegyetemen van egy számítógép labor 5 nevű tantárgy, amelyben van feladatként C-ben webszerver írása, ha meg tudsz szerezni egy kész kódot, már csak át kell alakítani...

Mindjárt megnézem, melyik volt az a rém egyszerű webszerver.
4

SHTTPD

janoszen · 2006. Ápr. 12. (Sze), 16.27
Talán ez az: http://shttpd.sourceforge.net/ de már nem emlékszem...
5

Paraméterek..

janoszen · 2006. Ápr. 12. (Sze), 16.45
Hát, van egy rakás módja a paraméter átadásnak. Command lineban rendes shell paraméterként adod át, ami az env-ben meg is fog jelenni. Egyébként CGIn keresztül is átadhatod... vagy beállítasz environment variable-kat... vagy ilyesmi. Környezettől függ...
6

jó választás

Medvesajt · 2006. Ápr. 12. (Sze), 17.09
Asszem jó választásnak tűnik már maga a gondolat is, hogy egy egyszerű webszerver feküdjön rá a portra. Végül is a feladat ugyanaz: fogadja a kérést, visszaadja a választ. Nekem csak a kérést kell a szerver által is értelmezhetően összeállítanom.
Így aztán akár egy apache is szóba jöhetne, bár az shttpd annyira kicsi, és ezáltal gondolom gyors is, hogy egyszerűen vétek lenne a parlagon hagyni heverni.

A paramétereket ekkor már simán átlehet adni GET vagy POST útján, és innentől megy minden, mint a karikacsapás. Így nincs a kliens oldalról a tipikus socket-es kapcsolódás (bár ha nagyon szabályos volnék, akkor így kéne csinálnom), csak egy fsockopen, kérni az ÁLTALAM megadott porton keresztül az ÁLTALAM megadott fájlt, és ezen az úton keresztül máris fűzzük a paramétereket. Ezt még ugyan nemtom hogyan kell, ilyet még nem csináltam, de remélem, hogy van rá lehetőség (ha egyszer alapvetően így működik egy böngésző-webszerver kapcsolat).

Mindjárt utána is nézek.

Ez nagyon jó gondolat, köszönöm az ötleteket! Megint csak megvilágosodott a számomra, hogy egyedül nagyon nehéz akár a jóhoz megközelítőt fejleszteni.
Ez gáz?
7

Specifikáció

janoszen · 2006. Ápr. 12. (Sze), 17.20
Nem gáz, sőt. Ahogy lespecifikáltad a feladatot, le a kalappal. Jó volt a kérdés, öröm volt rá válaszolni. Lásd "Hogyan kérdezzünk okosan?". :)

Nem szégyen, ha az ember nem tud valamit, hiszen látod, én sem tudtam pontosan megválaszolni a kérdésed. Ha jól tudsz kérdezni, még kihúzhatod magad a csávából.

Szóval mégegyszer: gratulálok és tényleg köszönet a színvonalas kérdésért.
8

Hát ez a nap ...

Medvesajt · 2006. Ápr. 12. (Sze), 18.36
... legjobb pillanata!!! :DD
Köszönöm az elismerő szavakat!

Viszont van bennem egy újabb kérdés, amely az objektumalapú php programok tervezése közben merül fel bennem időnként.
Álandóan az a fikcióm, hogy minden egyes objektumnak önállóan működőképesnek kell lennie, azaz a feladatát mindig el kell tudnia végeznie azoknak az adatoknak az alapján, amelyekkel az objektum rendelkezik.
Ezeket az adatokat vagy a példányosítás során kapja, vagy esetleg egy-két beállító metódus segítségével.
Én alapvetően mindent objektumnak tekintek, mindegy, hogy az osztály, metódus, egy egész alkalmazás vagy akármi más.
Ez azt jelenti, hogy egy osztálynak önállóan működnie kell, és az osztály belsejében lévő metódusoknak is, a kapcsolatot az osztálytulajdonságok útján tartják.
Általában úgy is írom az osztályaimat, hogy a példányosítás során beállítódnak az adatok, majd meghívok egyetlen egy metódust (általában Execute() a neve), ami elvégzi a munkát, és visszadja az eredményét.
Ez az Execute() amolyan controller az osztályon belül.
Mivel úgy gondolkozom, hogy egy objektum a működését csak akkor tudja ellátni maradéktalanul, mikor sérthetetlen marad, minden eljárása legalábbis protected (ha tervezem az exetndelhetőségét), de inkább private, és csak az Execute a public.
Ez helyes gondolkodás? Olvastam már egy csomót erről, és még régebben úgy döntöttem, hogy mivel annyiféle vélemény van erről, nem fojtom el a magamét, és aszerint építkezem. Ez az, amit a fentiekben leírtam.
Kérdés, hogy hülyeség? Te például hogyan szoktál gondolkodni?
9

OOP filozófia

janoszen · 2006. Ápr. 12. (Sze), 18.41
Hallod, ha Te nem tanultál még életedben OOP filozófiát, akkor reinkarnációja vagy az OOP egyik kitalálójanak. :)

Azokat a funkciókat, amelyek kifele funkcionalitást látnak el, public-ká kell tenni, az összes többi private.

Például lehetne olyan, hogy van egy fórum, amelyet ha példányosítasz, lekéri magának az adatokat és mondjuk egy createHTML utasításra megcsinálja a HTML-t. Viszont lehetne benne olyan publikus function, hogy sortBy(). De privateként pl benne lehetne mindenféle adatfeldolgozó és egyéb rutin.

Az Execute jó gondolat, webes környezetben főleg, miutána feldolgozás lineáris, viszont az outputot csináló moduloknál cseréld le pl createHTML-re, mert lehet, hogy később akarsz vele RSS-t is gyártatni és akkor bajban leszel. :)

Hja, ez ma jó nap. :) Jó kérdések...
10

Termelékeny nap :D

Medvesajt · 2006. Ápr. 12. (Sze), 19.17
Megint egy nagyon jó ötlet a createHTML(), annyira jó, hogy szégyellem, miért is nem jutott az eszembe :(
Ezzel aztán egy helyen tudom megvalósítani a többféle formátumban való helyezést, mint pl html, rss, wml, vagy ahogy Én hívom telós html (wap 2.0 :D ).

Sajna nem tanultam programozni, ami nagy hibám, de attól még próbálkozom magamtól :). Egész jól megy, ez a foglalkozásom. A baj az, hogy a php-hoz objektumalapú tudalmányokat nem nagyon vélek felfedezni. Illetve vannak, de némelyik annyira agyon van bonyolítva, hogy értelmetlen használni a tudalmányt.
Így aztán más nyelveket is nézegetek, mint pl Java, és ezek alapján próbálok haladni előre.

Az alábbiakat szeretném elérni (mikor már okosabb lettem):
1. Az összes objektum önállóan működőképes, van adatokkal bűvészkedő, adatokat megjelenítő és mindezeket végig kontrolláló eljárása mindegyiknek.
2. Egy alkalmazás alapvetően a fentiekhez hasonló minta alapján épül fel és üzemel.
3. A szoftverek szintjén is ugyanezt akarom elérni: azaz az adatokkal az adatbáziskezelő bűvészkedjen, a megjelenítéssel és azon belül a varázslásokkal a böngésző (nem flash) foglalkozzon, de mindezt a php hozza össze.
Ezt lehet mondani 3 rétegnek?
A legnagyobb baj az, hogy nincs kivel ezekről a dolgokról beszélgetni, mert körülöttem mindenki lámaszintű versenyző, kivétel egy kollégám. Sokszor tapasztaltam, hogy jobb a dolgokról jó sok véleményt hallani, jobban segít dönteni, mint a nagy semmi. És lám: ma kaptam Tőled vagy 3 nagyon jó ötletet is, amelyek egy csapásra levettek a vállamról egy csomó munkát előre :)

Olvasgatok egy csomó angol nyelvű tudalmányt, de a legtöbbje nagyon egyoldalú :( Még jó, hogy létezik a Java, az egy istentalálmány. Kár, hogy még csak lámaszinten ismerem. De hát ami késik, az nem múlik :))

tényleg, azok a php programozók, akiket ismerek, totál nem használják a php5 újdonságait, levannak ragadva a HTML 4.0-nál, semmi css, és bevannak tojva, ha egy függvényt kell összeütniük. Azt sem tudják mi az a template, és teli van szúrkálva a förtelmesebbnél is förtelmesebb módon html kóddal a php-juk. Gáz, az biztos, de vajon sokan így vannak ezzel?
11

Rétegezés

janoszen · 2006. Ápr. 12. (Sze), 19.40
Nem ismerem a projektedet, de én úgy oldanám meg, hogy:

1. réteg: webszerver. Ez szarakszik a socketekkel, stb.

2. réteg: PHP. mod_rewrite vagy hasonló technikával mindent ráirányítasz egy index.php-ra, amely egy PHP 5 OO modellt támogat

2/a réteg: PHP HTTP protocol layer: ez kezeli a legkért címeket, a kimenetet, MIME típusokat. Ergo azt, amivel modul szinten nem akarsz foglalkozni. Adott esetben beletehetsz pl. HTML kódformázót is.

2/b réteg: DAO. Adatbázis absztrakció. Ez lehet PHP OO alapú, de lehet mondjuk ODBC is. Lényeg az, hogy elé pakolsz egy absztrakciós réteget, hogy ne kelljen foglalkozni az adatbázissal, csak a lekérésekkel.

2/c réteg: background processing. PHP modulok megcsinálják a háttér adatfeldolgozást, avagy a "kulimunkát. Ilyen pl a Forum Data Object (FDO), amelyik lekéri és rendezi a fórum adatokat. Neki mennek pl. mindenféle kérések. (új fórum téma, téma mozgatás, törlés, stb.)

2/d réteg: interface processing. Egy interface absztakciós mechanizmus generál tartalmakat. (HTML, RSS, képek, stb). Pl a Forum Assembler, amelyik összerakja a FDO segítségével a fórumot.

3. réteg: interface. HTML, RSS, képek.

Igy minden az alatta levő rétegre épül és szépen megcsináltad. Sokszor könnyebb egy kicsit "csalni" azonban ez az átláthatóság és a használhatóság kárára megy.

Amit hirtelen itt 5 perc alatt fölvázoltam kb. 1-2 hónapnyi kemény munka megcsinálni, szóval ne ijedj meg. :)
12

Hát nézzük :)

Medvesajt · 2006. Ápr. 12. (Sze), 20.23
A projekt célja nem más, mint egy olyan keretrendszer összeeszkábálása, amely lehetővé teszi egyrészről azt, hogy egy böngésző segítségével biztonságosan, gyosan, egyszerűen tud menedzselni Linux alapú szerveredet, másrészt az, hogy az esetleges fejlesztők könnyen, és gyorsan tudjanak a keretrendszer által szabott határok között modulokat írni.
A modulok egy-egy feladatot valósítanak meg. Elméletileg egy feladat egy szerveroldali program menedzselését jelenti.
Én próbálok nyújtani egy alapvető modult (System), amellyel egyáltalán belehet lépni, stb.
Egy példa: Te úgy gondolod, hogy itt az ideje egy Bind9-et menedzselő modul megírásának. Könnyű dolgod van (ha jól dolgoztam :D ), rengeteg feladattal nem is kell foglalkoznod, szinte csak a logikával. Összeütöd a modult a specifikáció segít ebben. Az új modul segítségével könnyedén tudja bárki böngészőből módosítani a zónafájlokat, a BIND9 beállításait, olvashatja a logokat, stb.
Aztán fogom magam, Én is firkálok egyet, ez is tudja ugyanazt.
A harmadik ember, az igazi felhasználó pedig fogja magát, letölti és telepíti mindkettőt, aztán majd eldönti, hogy melyiket használja.

Bevallom, pofátlanság, de maga az Eclipse az, ami igen erősen motivál. Az Eclipse egy istenteremtmény, az pedig egy csoda, hogy ingyenes.
Hasonló dolgot akarok elkövetni. Szeretném lefektetni az első köveket, aztán majd biztosan lesznek olyanok, akik segítenek fejleszteni. Már ha tényleg jó és hasznos a koncepció.

Az egészbe beépítettem üzleti elveket is, hogy ilyenformán is menedzselhető legyen egy számítógép.

Tavaly már megírtam két verzsönjét ennek, mert szükségem volt rá. Van egy szerverem, amin vannak fent haverok és egy-két üzleti partner, ott hosztolják a domainjüket. Nekik írtam meg ezt, hogy zaklatásom nélkül tudják konfigolni a levelezésüket, stb, és Én is tudjam a rendszergazdai dolgokat csinálni. nem mintha parancssorból nem menne (istentalálmány a parancssor is :D ), de sokkal gyorsabb és egyszerűbb dolgom van így. Tulajdonképpen egy lámaszintű CPanel-t írtam. Ez gyönyörű szépen is müxik, de nagyon gépspecifikus, azaz az Én gépemhez van belőle statikusan (forráskódszinten).

Az ötlet onnan jött, hogy ezt akartam modernizálni, bővíteni oly módon, hogy ne legyen gépspecifikus, ne legyen disztribúció függő, és más is tudjon hozzá frikálgatni, ne nekem kelljen mindent megírni. Ezzel nyakamba vettem egy halom munkát, mert a megjelenítést is magamra vállalom, hogy a böngészőben látható oldal egysége ne törjön meg modulonként, illetve ezzel ne kelljen nagyon sokat foglalkoznia senkinek. Ezenkívül igyekszem minél több ajaxos dolgot belepakolni, hogy gyors és felhasználóbarát is legyen egyben. Ezeket a hozzá nem értők is tudják majd használni.

Így aztán egy füst alatt kell megoldanom egy AJAX-os réteget (van belőle egy halommal a "piacon"), és a keretrendszer által nyújtott megjelenítési réteget. Ezt az egészet úgy kell megoldani, hogy a fejlesztő egy mozdulattal eldönthesse, hogy egy adott nézet ajax-os vagy hagyományos működésű legyen, és az úgyis működjön különösebb beavatkozás nélkül.

Még jó, hogy az adatbáziskezelő rétegem már régóta megvan. Egyszerű, de nagyon hatékony, csak az SQL-el kell foglalkoznom. A melóhelyemen is ezt használom, még nem csalódtam benne.

Viszont van olyasmi, hogy akármilyen kimenetet xml-ben adok vissza, de kibocsátás előtt ebből alakítok át más formátummá? Ilyenkor csak az átalakítási szabályokat kell egyszer lefektetnem, és akkor már tényleg nem kell a kimenetformázással foglalkoznom minden egyes esetben. Ez mondjuk egy külső alkalmazás lenne, amely megkapja a kimenet xml-ben, és visszadja az előre megállapított formátumra való konvertálás eredményét. Egyáltalán van ilyen, vagy csak álmodozom????
13

Van.

janoszen · 2006. Ápr. 12. (Sze), 21.19
Két megoldás is van rá. Az egyik az XSLT, a másik pedig egy HTML layer, amelyet mondjuk, PHPból így hívnál meg:

$myformelement = new HTML_Form_Input($id, $label, $value);


De ehhez egy HTML absztrakciós réteget kell írnod. Mint látod, célszerű összefogni a labelt az inputtal, így nem lesz abból sem gond. Az öröklődés is nagy hasznodra lehet itt.
14

kuszaság van itten

Hodicska Gergely · 2006. Ápr. 13. (Cs), 08.38
Sziasztok!


Nem szeretnék külön-külön reagálni az itteni hozzászólásokra, de azért olvastam pár furcsaságot, amire reagálnék.

Eredeti kérdés: nem igazán értem a koncepciót. A kérdésed alapján először úgy tűnt, hogy egyfajta appservert szeretnél csinálni, ehhez a képest a menetközben kialakult "megoldás" ettől teljes mértékben eltér, ráadásul így már nem is látom, hogy milyen előnnyel bírna.

Le kéne írd, hogy pontosan miért is döntöttl volna ennél az infrastruktúránál, milyen előnyöket vársz tőle, mik indokolják, hogy szükséged van erre. Ennek fényében lehet konkrét megoldási javaslatokat tenni.

A példányosítási problémára javaslom, hogy nézd meg az autoloading részt a PHP5-ben, mert nagyon hasznos a betöltés vezérlésére.

Ez nem válasz a kérdésére. Ezzel automatikusan lazy loadingot valósít meg. (Itt jegyezném meg, hogy a JIT és a lazy loading az nagyon nem ugyanaz.)

Általánosan az az eset áll fent, hogy akkor tölts be valamit, ha már kell. Különben nagyon gyorsan nagyon sok rendszerkakót fog megenni a programod.

Azért X alapmodul lefordított forráskódja nem hiszem, hogy túl sok memóriát fog foglalni, ráadásul itt egy daemonról volt szó, aminél kis időn belűl nagy eséllyel szükség lesz minden modulra, szóval nyugodtan includolhatja őket már az elején is akár.

Igen, magam is az __autoload-ra gondoltam, mint legoptimálisabb megoldásra számomra ismeretlen számú fájl beemelésére és osztály példányosítására.

Mitől lenne ez optimálisabb? A saját magad által megírt "factory" lesz ez is, csak magától fog lefutni, de semmivel sem "kerül kevesebbe".

Én alapvetően mindent objektumnak tekintek, mindegy, hogy az osztály, metódus, egy egész alkalmazás vagy akármi más.

Ez itt elég erős fogalom zavar. Ezek nem olyan fogalmak, amiket helyettesíteni lehet egymással.

Ez azt jelenti, hogy egy osztálynak önállóan működnie kell, és az osztály belsejében lévő metódusoknak is, a kapcsolatot az osztálytulajdonságok útján tartják.
Általában úgy is írom az osztályaimat, hogy a példányosítás során beállítódnak az adatok, majd meghívok egyetlen egy metódust (általában Execute() a neve), ami elvégzi a munkát, és visszadja az eredményét.

Ezzel így jóformán csak az egységbezárást valósítod meg, ez a séma sok esetben nem fog működni, nem lehet minden osztály felülete ennyire egyszerű, ráadásul érdemes mindig olyan elnevezéseket használni, amelyek kifejezik, hogy az adott metódus mit is csinál. Nézd meg ezt.

Az Execute jó gondolat, webes környezetben főleg, miutána feldolgozás lineáris

Nem látom az összefüggést. Ráadásul mint a fentebb említett cikkban is írtam el kéne tolni az OOP programozást attól, hogy egy oldal generálást bezárjuk egy bazi nagy osztályba.

Az összes objektum önállóan működőképes, van adatokkal bűvészkedő, adatokat megjelenítő és mindezeket végig kontrolláló eljárása mindegyiknek.

Ez így nekem túl speciális szerkezetnek tűnik. Nem jó tervezés, ha egy osztály túl nagy felelőséggel rendelkezik. Ez így nehezen módosítható, rugalmatlan kódot fog eredményezni.

Adatbázis absztrakció. Ez lehet PHP OO alapú, de lehet mondjuk ODBC is.

Szezont a fazonnal? Miért ne lehetne az ODBC PHP OO alapú?


Felhő
15

Van oka a kuszaságnak

Medvesajt · 2006. Ápr. 13. (Cs), 11.40
Elsősorban magam védelem érdekében szeretnék rámutatni, hogy korábban már említést tettem szakmai elméleti képzetlenségemről. Ebből már látható,hogy miért nem akarok és nem tudok kalandokba keveredni nálam képzettebb szakemberekkel, de ettől függetlenül sajnos nemtom megerőszakolni a gondolkozásomat, így bár igazat kell adjak abban, hogy az objektum, mint fogalom nem összeegyeztethető azzal a képpel, ami bennem alakult ki róla, megmaradok ennél a képnél, mert ez már kialakult és erősen megkötött bennem.
Furcsa, de sokkal egyszerűbb így terveznem, mikor mindent objektumként kezelek. Gondolok itt egy osztályra, egy metódusra, egy tulajdonságra, egy adatbáziskezelőre, egy pc-re, vagy egy wc-re :D Totál mindegy a számomra, mert ezekkel az objektumokkal kell foglalkoznom, mikor programozom, vagy kimegyek wc-re.
Megintcsak leszögezem, hogy tisztában vagyok gondolkodásom megkérdőjelezhetőségével, de nemtok mit csinálni.

Az __autoload-ot még soha életemben nem használtam, de kézenfekvő ötletnek tűnik, ha egyszer így is, úgy is kell egy hasonló eljárás. Ez legalább egy sor megtakarítást jelent (a hasonló képességű, de saját készítésű eljárás meghívását jelentő sor). Szeretek takarékoskodni :D

Igazat kell adjak abban is, hogy a névelnevezési koncepció még nem túlságosan kiforrott bennem. Ez csak a saját projektemre igaz, mert a munkáimban olyan neveket adok néha, hogy a hajam égnek áll, annyira beszédesek.

És ami a legfontosabb: arra jöttem rá a legkésőbb (sajnos), hogy a szabályok nem fontosak. A szabályokat mi magunk is létrehozhatjuk. Ezek megalkotásában segíthetnek bizonyos szempontok ismerete és ezek alapos megfontolása. Ilyenekről írtál Te a hivatkozott cikkben, és sok ezren írnak hasonlóképpen.
De fenntartom ama véleményemet (amit még nem is mondtam el), hogy verébre ne lőjjünk ágyúval. Szeretem azt a megoldást, mikor egységbe zárom az objektumomat, és ALAPVETŐEN nem adok lehetőséget az egység megbontására. Egyébként ha jól emlékszem, valahol olvastam, hogy egy osztáyl ismérvei az egységbe zárás, az örökölhetőség, és még ki tudja mi.Asszem ezeket megvalósítottam azzal, hogy biztosítok egy felületet, illetve protected lesznek azok az eljárások és tulajdonságok, amelyekre úgy gondolom, hogy azok lehetnek.

Szegény kis projektemnek nem célja az, hogy az esetleges modulírók felhőtlen szabadságot élvezve úgy írjanak, ahogy az nekik jól esik. Bizonyos keretek közé akarom és KELL szorítani őket, hogy megmaradjon az egység és az a biztonság, amelyet a keretrendszernek kell nyújtania. Ezért aztán szinte az összes objektumot csak annak kijelölt felületén keresztül teszem elérhetővé. Azt, amelyik átformálás tárgyát képezheti, annak is nyújtok egy kommunikációs felületet (a választás szabadsága miatt), de nem védek le benne semmit. Viszont, mint említettem, a keretrendszer célja azt követeli, hogy mindezeket nyolcszor is megfontoljam, mielőtt egyszer ilyenre gondolok.
(amikor biztonságot említek, akkor tulajdonképpen az adott számítógép biztonságáról van szó, hiszen a keretrendszer gyakorlatilag olyan feladatokat fog ellátni, amelyekhez root jogosultság szükséges, de ezt oly módon, hogy bárki megtehesse ezt, akinek van hozzá joga. Pl.: Te, mint egyszerű felhasználó hozhass létre új aldomain-t, annak ellenére, hogy az egyszerre név és webszerver hozzáférést jelent).
Így látható, hogy a keretrendszer egyrészt kezében tartja a böngészőn keresztül bejelentkezett felhasználó ellenőrzését, állandó autentikálását, illetve állandóan összeállítja az egységes kinézetű kimenetet a böngészőbe.

Asszem a kis magán projektem mindenképpen segíteni fog abban, hogy tökéletesebb szintre emeljem az objektum-orientált programozási ismereteimet, de ez nem fog menni egyik pillanatról a másikra. Lenin aszondja: tanulni, tanulni, tanulni. Én aszondom: tanulni,tapasztalni,használni.
Bár lehet, hogy velem van a gond ...

Egyébiránt a projektem célja (a fent említetteket ismételve) egy keretrendszer megalkotása és állandó fejlesztése. Ez a keretrendszer lehetőséget kell adjon azoknak a fejlesztőknek, akiknek van némi képük egy Linuxos alkalmazás működéséről, illetve a php programozásáról, arra hogy gyorsan és egyszerűen, előre megvalósított komponensek segítségével hozzanak létre böngészőalapú alkalmazásokat egy-egy Linuxos program kezelésére.
Első körben mindezt php-ban, aztán ahogy jönnek az újabb körök, merülnek fel újabb igények, problémák, stb, fejlődik a koncepció, az alkalmazás megvalósitása, stb. Nyilvánvaló, hogy második körben az előre megvalósított komponenseket php extension-ként kell megvalósítani, ezért is fontos az általad említett névelnevezési koncepció, hogy minden irányba kompatibilis legyen a már elsajátított specifikáció.

Az is nyilvánvaló, hogy a gyorsabb és a még biztonságosabb működés érdekében a szerveroldalon is kell majd alakítani, ami azt eredményezi, hogy hosszabb távon sajnos saját alkalmazás írásában kell gondolkodni.Jelenleg Proc ötlete alapján (Köszi Proc!!) egy aranyos kis webszerver látja el eme feladatok egy nagyon kis részét (ezért is merülhet feledésbe eredeti kérdésem, mivel nem azt a megoldást erőltetem tovább).
16

re: kuszaság

Hodicska Gergely · 2006. Ápr. 13. (Cs), 12.00
Furcsa, de sokkal egyszerűbb így terveznem, mikor mindent objektumként kezelek.

Ez nem furcsa, hisz erről lenne szó.

mindent objektumként kezelek. Gondolok itt egy osztályra, egy metódusra, egy tulajdonságra, egy adatbáziskezelőre

De mit jelent az, hogy úgy tekintesz egy tulajdonságra, metódusra, mint egy objektumra?

Megintcsak leszögezem, hogy tisztában vagyok gondolkodásom megkérdőjelezhetőségével, de nemtok mit csinálni.

Dehogynem, te megad írtad a végén: Lenin... . Gondold át amit írnak Neked, de legtöbbet abból lehet tanulni, ha megnézel más forráskódokat. Érdemes esetleg tervezési mintákról is olvasni, sok tanulságos dolgot ki lehet belőle szűrni.

__autoload

Nem az autoload ellen írtam, hanem egy ott elhangzott érvre reagáltam.

Szegény kis projektemnek nem célja az, hogy az esetleges modulírók felhőtlen szabadságot élvezve úgy írjanak, ahogy az nekik jól esik.

Ez oké, de nem igazán értem, hogy a kiválasztott architektúrát ez a cél milyen szempontok alapján indokolja.

Nyilvánvaló, hogy második körben az előre megvalósított komponenseket php extension-ként kell megvalósítani, ezért is fontos az általad említett névelnevezési koncepció, hogy minden irányba kompatibilis legyen a már elsajátított specifikáció.

Nem látom, hogy ez miért lenne nyilvánvaló. Illetve ezt az elnevezési dolog sem tiszta.


Felhő
17

Talán annyira már nem kusza

Medvesajt · 2006. Ápr. 13. (Cs), 13.28
Gondold át amit írnak Neked, de legtöbbet abból lehet tanulni, ha megnézel más forráskódokat.

Ezt teszem nap, mint nap. Megfontolom azt is, amit Te írsz. Ma is elolvastam a cikkedet, egyből okosabb is lettem, és rendszeresen tekintek meg különféle megoldásokat. Vannak, amiket jó ötletnek tartok, ezeket beépítem a magam kis elképzeléseibe, miután kipróbáltam. De végül is csak a magam szabályainak akarok megfelelni: elsősorban egyszerű, aztán gyors legyen.
Cikked kapcsán felmerült bennem a kérdés, hogy vajon egy űrlap összeállítása során a különböző form elemek osztályként való megvalósítása vajon mekkora erőforrást foglalna le, mennyi időt venne el? Van erre nézvést tapasztalatod?
Azért kérdezem, mert ez a megoldás már felmerült bennem ötletként egyszer, mikor az volt a célom, hogy kimenet adjak vissza wml-ben vagy xhtml-ben.

De mit jelent az, hogy úgy tekintesz egy tulajdonságra, metódusra, mint egy objektumra?

Most már a fene se tudja. Az osztály, mint objektum önálló. Az osztály egy metódusa is objektum (nevezzük eljárásobjektumnak), önálló, a kijelölt feladat elvégzésére képes, ebben nem függ semmitől. A tulajdonság egy adatobjektum. Jó hülyén neveztem el őket, az biztos, de hát mint mondtam, fogalmam sincs annak elméletéről, mit hogyan nevezzek. Viszont szívesen vennék némi magyarázatot :D
Érzem, hogy ez még nagyon kiforratlan bennem, és nagyon sántít az egész. Ez gáz :(

ez az elnevezési dolog sem tiszta.

Itt konkrétan arra gondoltam, hogy mivel a második körben megvalósított extension is ugyanazt a feladatot látná el, mint most a framework egyes elemei (csak itt nem kellene osztályokat példányosítani, hanem a megfelelő függvényt meghívni), a függvények megközelítőleg, vagy totálisan ugyanazon a néven futnának mint addig. Így kevesebb munkával lehet egy-egy modult átalakítani az újabb verzsönhöz.
Ha tehát a Form->Input() ad egy input mezőt, akkor az extensionben így kellene használni: extensionprefix_input().Vagy form_input().
Mi a véleményed erről?
A szükségét azért érzem, mert így egyrészt egy réteggel lejjebb kerülök, gyorsabb lesz az alkalmazás, másrészt megvédem a keretrendszert az esetleges erőszakos átalakítástól is. Harmadrészt pedig nem akarom azt, hogy ha valami nem sikerül elsőre egy-egy fejlesztőnek, akkor azon nyomban szétkavirnyolhasson mindent. Mint mondtam: olyan keretrendszert akarok létrehozni, amibe nem tudnak belekontárkodni, akkor sem, ha nagyon akarnak. Erre viszont csak egy extension ad megoldást. Ráadásul gyorsabb is lesz :)

nem igazán értem, hogy a kiválasztott architektúrát ez a cél milyen szempontok alapján indokolja.

Ezt elsőre nem értettem meg, visszafelé kellett olvasnom :)
A válasz: elsődleges szempont a biztonság. Nem is lehet másról szó, hiszen egy számítógép sérthetetlensége a cél. A böngészőn keresztüli kapcsolat nem tezsi lehetővé automatikusan a root-os környezetet. ha igen, akkor irtózatos bug van a rendszerben. Ezért gondoltam a szerver-kliens architektúrára, mert így nem sérül a biztonság, a webszerver futhat a saját neve alatt, mert nem Ő látja el a root-os feladatokat, hanem a szerveroldal, amely futhat rootként, authentikáció szükséges használatához.
Gondolj abba bele, hogy letöltik sokan ezt az alkalmazást, ami szépen működik. Aztán letöltenek hozzá egy-két olyan modult, amelyek egyike mondjuk segít beállítani a vírusszűröt. De ha a modulíró tojt a biztonságra, és volt is lehetősége erre, akkor biztos lesz valaki, aki ezt kihasználja, és csinál valami nagyon nem szépet. Egy kis hiba a programban és máris kihasználják. Nos, Én ezt is megakarom akadályozni.
A felhasználó nem azt látja, hogy a modul bugos, hanem az alapalkalmazás a rossz, és sajnos igaza is van. ki kell zárni a lehetőségét is annak, hogy felboríthassák akár akaratlanul, akár akarva a keretrendszer biztonságát.
Ez az elsődleges és legfontosabb szempont.
18

re: kuszaság

Hodicska Gergely · 2006. Ápr. 13. (Cs), 15.35
vajon egy űrlap összeállítása során a különböző form elemek osztályként való megvalósítása vajon mekkora erőforrást foglalna le, mennyi időt venne el?

Az, hogy ugyanazt OOP elven valósítod meg, nem nagyon lesz különbség, de erről sok helyen lehet olvasni (pl. itt is). Ráadásul amiről itt beszélünk az tipikusan egy admin alkalmazás lesz, aminek még csak nem is kell nagy terhelést elviselnie, szóval pláne abszolút fölöslegesnek érzem az ettől való aggodalmad. De magad is kipróbálhatod a PEAR QuickForm nevű csomagját.

fogalmam sincs annak elméletéről, mit hogyan nevezzek

Ez némileg ellent mond a rengeteg dolgot elolvastam már ebben a témában mondásodhoz. ;) Amúgyis emlegetted a Javát, mint ami érdekel, nézd meg esetleg az Angszter Erzsébet féle két kötetes Java könyvet, melynek az első részének jó része az OOP-ről szól.

Itt konkrétan arra gondoltam, hogy mivel a második körben megvalósított extension .....Mi a véleményed erről?

Itt szintén zavarban vagyok, mert nem igazán látom értelmét, hogy miért szeretnél PHP extension irányba elmenni. A 3 érved közül kettővel nem értek egyet: "gyorsabb lesz az alkalamzás" (hova kéne ennek gyorsabbnak lenni, se sok adat, se nagy terhelés), "biztonság" (nem értem, hogy extensionként mitől lesz biztonságosabb), a "nehezebben módosítható" meg számomra nem tűnik egy jó célnak, inkább az ellenkezőjére kéne törekedni, hogy minél rugalmasabb legyen a kialakítás. Aki meg bele akar kontárkodni, az az extensionös verzióba is bele fog tudni.

A böngészőn keresztüli kapcsolat nem tezsi lehetővé automatikusan a root-os környezetet. ....... Én ezt is megakarom akadályozni.

Az rendben, hogy törekszel a biztonságra, de azt nem alapvetően ez az infrastruktúra fogja megadni, hanem az a tény, hogy nem a webszerver ér el root jogosultásgú dolgokat, hanem ezt egy külön procesz végzi. De ez lehetne akár egy cron job is. A deamon előnye persze az, hogy "egyből" reagál a kérésre. De önmagában nem garantál neked biztonságot.


Felhő
19

rere: kuszaság

Medvesajt · 2006. Ápr. 15. (Szo), 04.21
Elgondolkodtam azon, amit mondtál. Sőt, beszereztem Angster Erzsébet három könyvét, köztük az általad említett Java sorozatot. Ennek ellenére:

hova kéne ennek gyorsabbnak lenni, se sok adat, se nagy terhelés), "biztonság" (nem értem, hogy extensionként mitől lesz biztonságosabb), a "nehezebben módosítható" meg számomra nem tűnik egy jó célnak, inkább az ellenkezőjére kéne törekedni, hogy minél rugalmasabb legyen a kialakítás. Aki meg bele akar kontárkodni, az az extensionös verzióba is bele fog tudni.


Gyorsaság: véleményem szerint egy alkalmazás mindig legyen a legygorsabb. Ha tudjuk fokozni, akkor fokozni. Az eszköz nyilván lényeges: aki nem tud extension-t írni, az csak a php szintjén próbál gyorsítani.

Biztonság: az extension felmerülésének elsődleges oka. Nem vagyok annak a híve, hogy olyan elemeket, amelyeket NEM AKAROK nyilvánossá tenni, szabad prédája lehessen bárkinek. Ezeket nem akarom elérhetővé tenni semmilyen formában, még dokumentáció szintjén sem. Az extension egyrészt védelmet nyújt, hogy ne piszkálódhasson bele akárki. Valljuk be, ez nagyobb védelmet nyújt, mint egy private jelző. Tehát nem törekszem arra, sőt, elakarom kerülni még a lehetőségét is annak, hogy egyes framework elemeket módosíthasson bárki. Ezzel függővé teszem a framework működését, mivel azt csak az extension-nel működöképes, mind a szerver, mind a kliensoldalon.
A gyorsaság másodlagos dolog ebben az esetben, hiszen nem ezért merült fel bennem ennek a gondolata, de hasznos.

se sok adat, se nagy terhelés

Lesz sok adat, és lesz nagy terhelés az adatbáziskezelőn, mivel igyekszem minden lehetséges adatot adatbázisban tárolni, és az azokkal kapcsolatos műveleteket ott elvégezni. Ezek esetneként nagy mértéket ölthetnek, főleg, ha belegondolok, hogy a rendszert úgy tervezem, hogy akár több száz domain-t is lehessen vele hosztolni. Végül is ez szerver kérdése, melyik mennyit bír. Nem dölhetek hátra nyugodtan azzal a gondolattal, hogy "ááá, úgy sincs sok adat, nincs nagy terhelés", amikor nemtom előre hogy mennyi adat lesz a rendszerben, és azt sem, hogy milyen intenzitással fogják használni a rendszert. Nem tudhatom, hogy ki milyen modult fog írni, és az milyen mrétkben terhelei a rendszert, alapjában véve semmit sem tudok. De azt sejtem, hogy ha lassú lesz a rendszer, akkor csakis azt fogják okolni, és nem a valódi vétkest. Ezért, és már csak a tökéletességre való törekvés jegyében is, minden század másodpercet megkell ragadnom, akár esik, akár fúj.
Szerintem ez minden fejlesztő alap feladata.

Ez némileg ellent mond a rengeteg dolgot elolvastam már ebben a témában mondásodhoz. ;)

Na,ez jó sav volt, most megfogtál :)) De hozzá kell tennem, hogy Angster Erzsébet könyvéből ismertem meg az objektum specifikációját, és látom azt is, hogy egy objektum alapvetően egységbezárt, azzal csak a kijelölt felületén keresztül lehet érintkezni. Persze ezt felülbírálja az adott feladat, de ez is olyan, mint a sebességnövelés: amíg lehet, addig nincs felülírási jog. Tehát ha csak nagyon muszáj.

Amiről itt beszélünk az tipikusan egy admin alkalmazás lesz

Azt kell mondjam, hogy nem. Most nem akarok írni arról a rengeteg ötletemről és tervemről, ami itt zsong a fejemben, vagy már le is van speckózva. Természetesen az volt az alap koncepció, és talán az is marad az alapja, de szeretném ezenkívül rengeteg másra is használni. Ha már egyszer olyan sok munka van benne.

... nem alapvetően ez az infrastruktúra fogja megadni, hanem az a tény, hogy nem a webszerver ér el root jogosultásgú dolgokat

Nem, ezt nem így képzelem. Bár igazad van, a processz jogosultsága fogja megmondani, hogy mit lehet és mit nem. De addig eljutni se lesz egyszerű, és ez az, amit Én biztonságnak nevezek. Így is óriási bug, hogy egy webszerver root-os feladatokat láthat el, mégha nem is publikus portra kapcsolódik. Ennek ellenére, azt az utat, amíg eljut a végrehajthatóságig, komoly kontrollal egészítettem ki, és ezt tovább akarom mélyíteni, hogy ebbe a jól kitalált kontrollba soha, senki ne tiporhasson bele, akár csak egyetlen betűt is. Ebben az esetben a framework, mint objektum :) sérthetetlensége sérül, márpedig ez a legfontosabb: a framework szent és sérthetetlen.
Csak ez az egy szabály fogja tudni többé-kevésbé garantálni a teljes működőképességet földön, vízen levegőben és a sínek között :D

Mondjuk ezek már szigorúan speciális "előírások", amelyek kigondolását megelőzte némi tervezés is. Vannak igen szakképzett ismerőseim (remélem nevezhetem őket barátaimnak), akik olyan szinten művelik a szerverkezelést, amelyről soha életemben álmodni se merhetek. Egy-két ötlet tőlük ered. Csak annyi: első a biztonság. A második is, és a harmadik is. És így tovább.
Ha nincs rés? Majd csinálnak. Ezért aztán nemcsak a réseket kell betömnöm az alkalmazásban, hanem még a lehetőségét is elvenni, hogy rést csinálhassanak.
Mivel ezt processz szinten nemtom megoldani, megoldom feljebb. Bár igen szép lenne: kernelbe épített saját szerver :DDD
20

rerere :)

Hodicska Gergely · 2006. Ápr. 15. (Szo), 09.48
Gyorsaság: véleményem szerint egy alkalmazás mindig legyen a leggyorsabb. Ha tudjuk fokozni, akkor fokozni.

Szerintem ez manapság nem a legjobb hozzáállás. A korai/felesleges optimalizálás elég veszélyes fegyver. Sokkal fontosabb, hogy egy rugalmas, könnyen karbantartható kódot alakíts ki.

Az extension egyrészt védelmet nyújt, hogy ne piszkálódhasson bele akárki. Valljuk be, ez nagyobb védelmet nyújt, mint egy private jelző.

Itt megint azt látom, hogy egy adott cél érdekében nem jó eszközt próbálsz használni. Vannak encoderek is a PHP-hoz, erre a célra teljesen jó lenne. Persze nem akarlak lebeszélni extension írásáról, csak érzésem szerint magadat fogod szivatni vele.

Lesz sok adat, és lesz nagy terhelés az adatbáziskezelőn, mivel igyekszem minden lehetséges adatot adatbázisban tárolni, és az azokkal kapcsolatos műveleteket ott elvégezni.

Ez mitől lesz sok adat? Legyen a szerveren pár 10 darab funkció (web, ftp stb.), mindegyikhez tartozzon nagyon sok felhasználó, ez még mindig nagyon kevés adat egy adatbázis szempontjából, ráadásul ezek tipikusan olyan dolgoka, amit nem fognak folyamatosan használni, néha beállítasz valamit, aztán csókolom.

Ezért, és már csak a tökéletességre való törekvés jegyében is, minden század másodpercet megkell ragadnom, akár esik, akár fúj.
Szerintem ez minden fejlesztő alap feladata.

Szerintem meg a valós igények felmérése a feladat. Plusz lásd amiket a fentebbi két részben írtam. Nem érdemes ilyen fogalmakkal dobálózni általánosságban, manapság sok egyéb szempont (ROI) sokkal fonotosabb.

egy objektum alapvetően egységbezárt, azzal csak a kijelölt felületén keresztül lehet érintkezni. Persze ezt felülbírálja az adott feladat, de ez is olyan, mint a sebességnövelés: amíg lehet, addig nincs felülírási jog.

Itt megint nem szerencsések a fogalmak. Nem felülbírálja az adott feladat, hanem meghatározza, hogy hogyan tervezed meg az osztályod. Plusz szintén nem szerencsés, hogyha az osztály hierarchia kialakítása során már teljesítmény szempontokat veszel figyelembe. PHP esetében az absztrakciós szint növelése persze több kód parse-olásával jár együtt, de ezen valamilyen opcode cache használatával lehet segíteni, szóval ez sem egy valós érv.

Azt kell mondjam, hogy nem.

Publikus weboldalt fog kiszolgálni ez a cucc? ;)

Nem, ezt nem így képzelem. .... kernelbe épített saját szerver :DDD

Ezzel itt most semmi újat nem írtál le. Ráadásul messze nem érzem biztonságosabbnak, hogyha egy webszerver fut rootként, mintha van egy speciális szerver procesz, ami kifejezetten csak azt tudja, amit leprogramoztál benne. Mondjuk konkrétumok nélkül persze ez az állítás nem sokat ér.


Felhő
21

rererere :D

Medvesajt · 2006. Ápr. 15. (Szo), 15.24
A korai/felesleges optimalizálás elég veszélyes fegyver.

Nem értem, hogy miért. Akármelyik ügyféllel is beszélgetek, mindegyiknek ez az igénye, de még nekem is, ha valamilyen programot használok: legyen a lehető leggyorsabb. Ezt mondjuk nem forráskód szinten értem, sok minden befolyásolhatja a sebességet. De miért veszélyes?
Olyan egyszerű dolgok vannak, amelyek ugyan sokaknak nem jelent semmit, nem is tudják, de elméletileg gyorsítanak a futáson. Vegyünk pár példát.Bár nem okoskodni akarok, félre ne érts!!
A leglámaszintűbb példa: nem teszek for ciklus fejébe tömbelem számláló függvényt. Ezt Én inkább egyszer megteszem a cikluson kívül, és aztán ennek eredményét használom.
Vagy soha nem használom például a mysql_num_rows()-t, mysql_fetch_array()-t.Ez utóbbira nincs is szükségem általában, mivel a lekérdezéseimben alias-olom a mezőket. Ezzel is megspórolok valamennyit.Ezenkívül, mint mondottam volt, ami az adatokkal kapcsolatos, azt az adatbáziskezelőre bízom, ezért aztán tőle kérdezem le, hogy hány sort is kaptam vissza lekérdezésem eredményeképpen.

Ellemben azt is el kell ismernem, hogy vannak alkalmazásrészletek, amelyek a fenti képet felborítják, ugyanis nem szükségesek, de mindenképpen hasznosak abban a szellemben, ahogy Te mondod:

rugalmas, könnyen karbantartható kódot alakíts ki.

Ilyen például egy sql-t összeállító metódus, amely egy kapott tömbdimenziós tömb alapján összeállítja az adott sql-t, mondjuk egy keresésnél, vagy olyan helyen, ahol túl sok időt venne igénybe az előzetes leprogramozása a sok lehetőségnek. Ezzel a megoldással tulajdonképpen megspóroltam egy csomó fejlesztési időt, tökéletesen átlátható, viszont pluszként belekerült a kódba, amely nem kötelezőa futáshoz, de felettébb hasznos és kívánatos. Viszont ezt is úgy, hogy a lehető leggyorsabb legyen. Nem tudoksokat a kódoptimalizásálásról, hiszen ehhez nagyon kéne ismernem a php működését, de amit tudok, azt nem utólag javítom ki, hanem már eleve abban a szellemben végzem a munkámat. Nem hiszem, hogy ez vezsélyes fegyver lenne. Viszont kíváncsian várom, hogy szerinted miért az?

egy adott cél érdekében nem jó eszközt próbálsz használni.

Maximálisan igazad van abban, hogy egy encoder használata is elegendő volna. Viszont egy extension írása mindig is vonzott. Mondjuk úgy, hogy számomra az lehetne a hab a tortán, ha megtudnék vele birkózni. Nem hiszem, hogy annyira rossz eszköz lenne, ha egyszer ugyanazt a célt szolgálja, csak más szinten. A tudás nem fog rosszul jönni, az egyszer biztos :))

Legyen a szerveren pár 10 darab funkció (web, ftp stb.),

Hát ha csak pár tíz darab funckció lenne, akkor nem is adnám ki a modulírási lehetőséget a kezemből. De hát mindegyik funkciót többféleképpen lehet megvalósítani, gondolok itt arra, hogy webszerverként nem egyedül az Apache van a világon. Egy funkciót nem egyetlen program lát el, ezt a felhasználó választja ki. Ha nme választhatja ki, akkor oda függetlenség. Márpedig ez is nagyon fontos szempont: a felhasználó döntsön, ne mi kényszerítsük bizonyos útra. De még ez se elég, hiszen egy funkciót többféleképpen lehet lekezelni, csak gondolj a hagyományos vagy virtuális levelezésre. Szóval sok kis apró részlet van, arról nem is szólva, hogy taníthatónak kell lennie a rendszernek. De ez még mindig nem lassít a futáson, hiszen ez is csak adminfelület. De mint mondtam, vannak olyan terveim (üzleti vonatkozásúak), amelyek erős forgalmat is generálhatnak a keretrendszerben: egyrészt az erős adatbázishasználat, másrészt a sok látogató, akik már nem adminfelületen tevénykedkednének, illetve nem adminfeladatokat látnának el. Erről nem szeretnék bővebben írni, mivel nem teljesen kiforrott, nem is speckóztam le, ráadásul azt sem akarom, hogy valaki ezt elolvassa, aztán a homlokára csapva maga is nekiálljon hasonló dolognak - ergo nem akarom, hogy megelőzzenek.

Szerintem meg a valós igények felmérése a feladat.

Az első igény, ami felmerült bennem, az a lámaszintű, biztonságos program, melynek segítségével a haverjaim és Én böngészőn keresztül tudjuk menedzselni a hosztjainkat illetve a szerver legfontosabb funkcióit. Erre nem akartam áldozni havi 20ezret (CPanel), ezért egy rendszergazda barátommal összeültünk, és összeütöttük az első verzsönt. Nekik amúgy egy nagyon komoly szerverhoszting cégük van a BIX-ben. Aztán még merültek fel igények, és tovább fejlesztettük. Meglett a kettes verzsön.
Azóta is ez fut, de mindig gyűltek az igények, a problémák, az ötletek, csak éppen idő nem volt rá. Nekem is voltak ötleteim a jövőre nézve, és úgy döntöttem, hogy egy olyan alkalmazást próbálok megfirkálni, amely nemzetközileg is megállja a helyét. Egyrészt referencia miatt, másrészt mert szükség van rá, sokrétű, és rugalmasan, könnyen bővíthető bárki által. Ezt az ötletet elég jól kidolgoztam, de valljuk be, hogy nem tartottam közvéleménykutatást. Viszont van nagyon sok ismerősöm ebben a szerveres világban, akik pont ilyenekkel foglalkoznak, és azért velük mindig konzultálok keresve újabb ötleteket.
Összegezve: amit elképzeltem, az ugyan kis szegmens fog át, ellenben megvan az esélyem, hogy hiányzó űrt tölt majd be. Arról nem is szólva, hogy ROI számítás szerint a SAJÁT MUNKÁM mindenképpen megfog térülni 100%-osan. Lehet, hogy nem azonnal, és nem azonnal anyagilag, sőt, lehet, hogy soha nem lesz anyagi vonzata, de erkölcsi haszonra mindenképpen számítok. Ha nem túl nagyképűség ilyenre vágyni.

Ezzel itt most semmi újat nem írtál le.

Ez való igaz, de csak poénnak szántam. Annyira messze vagyok attól, hogy egyáltalán csak belekontárkodjak a kernelszintbe, hogy nem is gondolhatok ilyesmire mondjuk 2 éven belül. Viszont tudom, hogy mi lehetne a legjobb megoldás :))
Egyébként már működik a kettes számú webszerver is, rendesen pöcörög, egy csomó munkától kiméltem meg magam és feltételesen leendő modulírókat is.
Nem rootként fut, isten mentsen, de eltud látni root-os feladatokat, és ez a lényeg. Egyébként itt jött elő egy újabb ötlet: mennyire lehet idomítani a szerveroldalt, azaz ki döntse el, hogy a szerveroldal milyen jogokkal fut, mit tehet és mit nem? Ugye az alapkoncepció az volt, hogy root-ként, de hát ez gáz. És ne is Én döntsem el. Ezért aztán ezt rábízom arra, aki majd egyszer ezt ismeretlenü letölti és elkezdi a rendszer konfigurálását. ez legyen az Ő felelősége. Punktum :DD
22

program szervezés

Hodicska Gergely · 2006. Ápr. 15. (Szo), 16.56
...legyen a lehető leggyorsabb...De miért veszélyes?

Én nem arról beszéltem, hogy ne igyekezz optimálishoz közeli kódot írni. Ez teljesen jó dolog. Én arról besszéltem, hogy amikor kialakítasz/tervezel egy programot nagy vonalakban, akkor nem érdemes már az elején elveszni apró, teljesítményt érintő kérdésekben. Odafigyelhetsz ezer apróságra, de ezt az egészet hanyatvágja egy rossz query, egy hiányzó index stb..

Én pl. nem sajnálok egy plusz változót bevezetni, csak azért hogy akárcsak egy kis, lokáis környezetben olvashatóbb legyen a program. Vagy pl. van egy bonyolultabb feltételem, akkor kiemelem egy beszédes nevű függvénybe, és ezáltal nem csak olvashatóbbá válik a kód, de sokszor tapasztalom, hogy ezáltal hibatűrőbb (én is jobban átlátom), és a későbbiek során sokkal könyebben módosítható lesz. Optimalizálhatsz ilyen szinten ezer apróságot, de mindez eltörpül pár igaznán fontos architektúrális döntés mellett.

Ráadásul van még egy olyan szempont is, hogy sok esetben megéri egy mondjuk több memóriát evő megoldás választása, ha azt jóval hamarabb lehet megvalósítani, ugyanis olcsóbb venni még egy kis mermóriát a gépbe, mint kifizetni a fejlesztő x napi munkáját.

Vagy soha nem használom például a mysql_num_rows()-t, mysql_fetch_array()-t.Ez utóbbira nincs is szükségem általában, mivel a lekérdezéseimben alias-olom a mezőket.

Nem értem, hogy ezekkel a fügvényekkel mi bajod lehet.

Nem hiszem, hogy ez vezsélyes fegyver lenne. Viszont kíváncsian várom, hogy szerinted miért az?

Lásd amit legelső részben írtam.

számomra az lehetne a hab a tortán, ha megtudnék vele birkózni. Nem hiszem, hogy annyira rossz eszköz lenne

Na eljuttotunk az igazi okig. ;) Nem mondtam, hogy rossz eszköz lenne, csak az indokaid alapján nem éreztem a szükségességét.

Hát ha csak pár tíz darab funckció lenne, akkor nem is adnám ki a modulírási lehetőséget a kezemből. De hát mindegyik funkciót többféleképpen lehet megvalósítani, gondolok itt arra, hogy webszerverként nem egyedül az Apache van a világon. Egy funkciót nem egyetlen program lát el, ezt a felhasználó választja ki. Ha nme választhatja ki, akkor oda függetlenség.

Az egy dolog, hogy a programod meg a moduljai képesek lehetnek a világ összes szerver funkcióját kezelni, de ettől még egy adott szerveren igen csak véges számú funkció fog ténylegesen futni, és ezeket nem fogják túl gyakran abajgatni, szóval ez a része a programnak kb. nulla terhelés.

A többire most nem reagálnék, mert egyre terjengősebb ez a száll, plusz folyamatosan behozol valami új dologot, változnak az érveid. Sok sikert az alkalmazáshoz!


Felhő
23

Köszönöm a segítséget!

Medvesajt · 2006. Ápr. 15. (Szo), 17.20
Nem értem, hogy ezekkel a fügvényekkel mi bajod lehet.

Minek indexlejen a fetch_array, mikor nincs is rá szükségem?
Minek számoljak a num_rows()-szal, mikor eleve visszajön az eredmény?
Illetve mindek számoljak, mikor eleve számoltatható az eredmény még az adatbáziskezelő oldalán? Amúgy semmi bajom sincs velük, de mikor még kezdtem az egész php programozást lámaszinten, írtam egy wapos csetet (amely most is üzemel), és felmerültek bizonyos erőforrás problémák, mikor már több százan voltak fent. Ekkor újra kellett dolgoznom, és csak a num_rows() kivétele, és amúgy minden egyebek az adatbáziskezelőre bízva meghozta a gyümölcsöt. Ezért aztán - mivel nem akarok kétszer dolgozni - inkább fejlesztés közben csinálom ezeket a dolgokat. Amúgy egy-egy lekérdezést, vagy inkább úgy mondom, hogy lekérdezési környezetet (ez egy új fogalom :)) ) szoktam tesztelni parancssorban és egyéb módon (mysql_query_browser),hogy lássam mennyi ideig tart.

Egyébként tényleg érdekes, hogy hová jutott ez a szál :DD

Én pl. nem sajnálok egy plusz változót bevezetni, ... Vagy pl. van egy bonyolultabb feltételem, akkor kiemelem egy beszédes nevű függvénybe,

Felhő, mi tökéletesen egyformán dolgozunk. Ugyanezt a módszert követem Én is, hiszen így a logikus.

plusz folyamatosan behozol valami új dologot, változnak az érveid.

Igen, mert csak egy kis részletét emeltem ki a szál elején a dolgonak, és ahogy bonyolódik a szál, úgy kerülnek felszínre az eddig láthatatlan okok. Az érveim nem változnak, ugyanazok, csak lehet, hogy hülyén próbálom elmagyarázni őket. Vagy más.

Sok sikert az alkalmazáshoz!

Köszönöm szépen, és ha lesznek még kérdéseim, biztos, hogy ide fogok fordulni!
24

re: opt

Hodicska Gergely · 2006. Ápr. 15. (Szo), 20.27
Minek indexlejen a fetch_array, mikor nincs is rá szükségem?

Pontosan nem tudom, hogy itt mire gondolsz, de ha arra, amit sejtek, akkor a függvény második paraméterével ez orvosolható.

Minek számoljak a num_rows()-szal, mikor eleve visszajön az eredmény?

Speciel ezt nem sokat használtam, de nehezen tudom elhinni, hogy egy amúgy memóriában lévő adatstruktúrán annyira "drága" legyen végigszaladni. Akár persze elő is fordulhat, de akkor sem hiszem, hogy egy alkalmazás összteljesítményét ez döntően befolyásolni képes.


Felhő
25

Drágaság

Medvesajt · 2006. Ápr. 16. (V), 14.00
... nehezen tudom elhinni, hogy egy amúgy memóriában lévő adatstruktúrán annyira "drága" legyen végigszaladni.

Az a baj, hogy nemtom, hogyan lehetne ezt tesztelni, azaz azt, hogy adott terhelés mellett mik azok a feladatok, amelyek túlságosan drágák. Talán az APD, bár még nem használtam, vagy az Apache ab programja, amit szintén nem használtam. Leteszteltem saját módszerrel, és önmagában nem drága az, ha a num_rows()-szal számolgatunk. De mi van akkor, mikor többszázan tipornak az alkalmazáson? Ilyen tapasztalataim nem voltak soha, de egyértelmű volt, hogy ha egyetlen ilyen program egy egész szerver teljesítményét visszafogja (legalábbis webszerveri teljesítményét), akkor ott valami gáz van. Egy tanultabb barátom hívta fel a figyelmemet arra, hogy az adatok feldolgozása lehet a ludas, illetve szó szerint megnevezte a num_rows()-t, mint egyik lehetséges okozót. Magamtól soha nem gondoltam volna rá. És tényleg javult a terhelhetőség, ugyanolyan látogatási szám mellett kevésbé érzi meg a webszerver, mint annak előtte. Azóta alakult ki az a koncepcióm, hogy amit lehet, azt végezze el az adatbáziskezelő, az úgyis gyorsabb, a többit pedig a php.

akkor sem hiszem, hogy egy alkalmazás összteljesítményét ez döntően befolyásolni képes

Pedig hidd el, előfordulnak ilyen esetek. Mikor már ezek a kis optimalizálási trükkök sem segítenek, akkor egy szinttel lejjebb kell lépni: jobb gép, más beállítások, esetleg egy önálló gép csak arra a feladatra. Vagy a fürtözés, amiről szót sem tudok szólni, de mint megoldás, az is szóbajöhet.
26

profiling

Hodicska Gergely · 2006. Ápr. 16. (V), 14.11
Az a baj, hogy nemtom, hogyan lehetne ezt tesztelni, azaz azt, hogy adott terhelés mellett mik azok a feladatok, amelyek túlságosan drágák.

Vannak különböző profiling eszközök, amikkel meg tudod találni a gyenge pontokat.

azt végezze el az adatbáziskezelő, az úgyis gyorsabb, a többit pedig a php.

Kíváncsi vagyok jelen esetben (num_rows) ezt hogy váltod ki DB oldalon?

És tényleg javult a terhelhetőség, ugyanolyan látogatási szám mellett kevésbé érzi meg a webszerver, mint annak előtte.

Ha nem volt semmilyen eszközöd ennek a megállapításra, akkor ezt honnan tudod?

Pedig hidd el, előfordulnak ilyen esetek.

Előfordulhatnak persze ilyen esetek, csak nem ezen a szinten. Ilyesminek nagyon nagy forgalmú oldalak esetén lehet jelentősége, de itt ahogy kivettem nem ilyesmiről volt szó, ezért is fogadtam kétkedve ezt a num_rows cserétől hirtelen megjavult esetet.


Felhő