Vitaindító: vissza az alapokhoz!
Mivel mostanság egyre többször előjönnek a DI, Singleton, Multiton, Unit Testing, TDD stb. buzzwordok és társaik kérdés, és ismerősök is egyre többször kérdezgetnek ez ügyben, gondoltam feldobok egy újabb témát vitaindító jelleggel.
Hogy miért? Nagyon jól tudjuk, hogy mik az előnyei a mindenféle „csudabuzzword” által takart megoldásoknak… Leginkább, ha az ember nagy projektet fejleszt. Nos, ezzel a problémám az, hogy a legtöbb projekt nem ilyen. Nagyon nem ilyen.
Éppen ezért nem értem, hogy mi ez az architektúrális felhőkarcoló gyártás, ami mostanság divatként terjed. DI nagyon jól megold néhány problémát. Egyetlen bajom vele, hogy ugyan betartat dolgokat, csak épp plusz kódmennyiséggel. Emiatt sokszor inkább úgy érzem a hasonló dolgokkal, hogy mert ez a divatos és szép ezért beleerőltetjük mindenhova, ahelyett, hogy egy percre megállnánk és elgondolkodnánk, hogy kell-e ez most egyáltalán nekünk.
Hogy megértsétek, mire gondolok, induljunk ki az alapoktól. Adott egy megrendelés. Feltesszük a bűvös varázskérdéseinket, hogy tulajdonképp mi a fenét is kell nekünk elkészítenünk. Egyszerűség kedvéért legyen most ez egy egyszerű weblap, néhány hírrel meg pár termékoldallal és egy kapcsolatfelvételi űrlappal. Rutinmeló, egy délután alatt össze lehet ütni. Nulláról.
Hogyan is fog ez lefutni? Beesik a kérés a webszerverre, elindul a rendszerünk, csinálunk egy sablon rendszert, egy SQL réteget, esetleg valamilyen user kezelő megoldást, amit majd birizgálni fognak a moduljaink. Majd miután lefutott a modulunk, jól megjelenítjük a tartalmakat a látogatónak. (Tfh. most megállunk a hasonló komplexitású rendszereknél.)
Erről a rendszerről mit tudunk? Van egy egyszerű keretrendszerünk és néhány egyszerű modulunk, ami feltételezi, hogy ők valahogyan tudnak birizgálni SQL réteget, sablon rendszert és egy bejelentkezett felhasználót. (Most ne menjünk el, hogy ez MVC vagy nem MVC rendszer, irreleváns).
Tapasztalataim szerint ennél jóval bonyolultabb (keret)rendszer átfogó design dokumentációja is elfér n*10 oldalon, amiben le van írva egyszerű példákkal ábrázolva, hogy azt hogyan is kell használni egy ilyen egyszerűé meg végképp elfér 5 oldalon.
Ezek után nem értem, hogy miért jó nekem az, hogy plusz kódokat írogassak ugyanazért a funkcionalitásért, hogy elérjek bizonyos alrendszereket. Ez egy weblap. Elindul, létrehozza a szükséges dolgokat, amik általában kellenek (és általában tényleg mind kell), csinál valamit a rendszer, majd befejezi a dolgát. Szerintem ilyen esetekben kár nehezíteni az életünket, hogy külön figyelgessük, hogy most ide ez meg az meg amaz kell. Része az alaprendszernek, jöjjön létre az inicializálás során és kész.
Ilyen esetre szerintem (majdnem) teljesen ugyanolyan jó, akár Singleton, akár egy homlokzat mintát akár globális változót használunk. (Bár a Singletonnal konkrétan itt annyi talán a bajom az Unit Testingen kívül, hogy felesleges a lazzy load, mert nagy valószínűséggel úgy is kelleni fog. -- megjegyzem sok ilyen kaliberű esetben ez se játszik.
Anno, mikor a mostani rendszereink végső alapját kialakítottuk (a korábbi munkák összegzése után kezdtük el fejleszteni) nálunk is szóba került a Singleton és a homlokzat. (DI akkor még nem nagyon volt benn a köztudatban, magam sem ismertem akkor konkrétan így). Végső döntés az volt, hogy marad a globális változó. Egyrészt, mert egyszerű, nem okoz szerializálási problémákat (pl. ha egy objektum adattagjaként beemeljük) másrészt azt a kb. 7-8 változót nem lehetetlen megjegyezni (mindenki tudja, hogy ezek azok, elég egyértelműek, doksiba le van írva és amúgy is, nem kezdünk el úgy egy rendszert fejleszteni, hogy picit se nézzük meg mi merre hány méter) és nem igényel plusz függvényhívást sem. Lehet mondani, hogy csúnya gonosz global, de attol még gyors, egyszerű és működik. Jól. És még csak véletlenül sem történt olyan, hogy valaki felülcsapott valamit.
Ráadásul szerintem unit testingnek sem mond ellen. Meg lehet adni teszt előtt/utáni eseményeket, ott meg meg lehet oldani, hogy hozza létre ezeket újra, vagy inicializálja újra a keretrendszert.
Természetesen nem vagyok a DI ellen. Csak nem látom indokoltnak minden esetben.
Vagy hozhatnék még egy példát: egy barátommal is épp beszélek Skypen, épp a Symfony2-s FileResource osztályról elmélkedünk. Véleményem szerint ezek az osztályok is indokolhatóak. Csak sokszor a feladat nem indokolja.
■ Hogy miért? Nagyon jól tudjuk, hogy mik az előnyei a mindenféle „csudabuzzword” által takart megoldásoknak… Leginkább, ha az ember nagy projektet fejleszt. Nos, ezzel a problémám az, hogy a legtöbb projekt nem ilyen. Nagyon nem ilyen.
Éppen ezért nem értem, hogy mi ez az architektúrális felhőkarcoló gyártás, ami mostanság divatként terjed. DI nagyon jól megold néhány problémát. Egyetlen bajom vele, hogy ugyan betartat dolgokat, csak épp plusz kódmennyiséggel. Emiatt sokszor inkább úgy érzem a hasonló dolgokkal, hogy mert ez a divatos és szép ezért beleerőltetjük mindenhova, ahelyett, hogy egy percre megállnánk és elgondolkodnánk, hogy kell-e ez most egyáltalán nekünk.
Hogy megértsétek, mire gondolok, induljunk ki az alapoktól. Adott egy megrendelés. Feltesszük a bűvös varázskérdéseinket, hogy tulajdonképp mi a fenét is kell nekünk elkészítenünk. Egyszerűség kedvéért legyen most ez egy egyszerű weblap, néhány hírrel meg pár termékoldallal és egy kapcsolatfelvételi űrlappal. Rutinmeló, egy délután alatt össze lehet ütni. Nulláról.
Hogyan is fog ez lefutni? Beesik a kérés a webszerverre, elindul a rendszerünk, csinálunk egy sablon rendszert, egy SQL réteget, esetleg valamilyen user kezelő megoldást, amit majd birizgálni fognak a moduljaink. Majd miután lefutott a modulunk, jól megjelenítjük a tartalmakat a látogatónak. (Tfh. most megállunk a hasonló komplexitású rendszereknél.)
Erről a rendszerről mit tudunk? Van egy egyszerű keretrendszerünk és néhány egyszerű modulunk, ami feltételezi, hogy ők valahogyan tudnak birizgálni SQL réteget, sablon rendszert és egy bejelentkezett felhasználót. (Most ne menjünk el, hogy ez MVC vagy nem MVC rendszer, irreleváns).
Tapasztalataim szerint ennél jóval bonyolultabb (keret)rendszer átfogó design dokumentációja is elfér n*10 oldalon, amiben le van írva egyszerű példákkal ábrázolva, hogy azt hogyan is kell használni egy ilyen egyszerűé meg végképp elfér 5 oldalon.
Ezek után nem értem, hogy miért jó nekem az, hogy plusz kódokat írogassak ugyanazért a funkcionalitásért, hogy elérjek bizonyos alrendszereket. Ez egy weblap. Elindul, létrehozza a szükséges dolgokat, amik általában kellenek (és általában tényleg mind kell), csinál valamit a rendszer, majd befejezi a dolgát. Szerintem ilyen esetekben kár nehezíteni az életünket, hogy külön figyelgessük, hogy most ide ez meg az meg amaz kell. Része az alaprendszernek, jöjjön létre az inicializálás során és kész.
Ilyen esetre szerintem (majdnem) teljesen ugyanolyan jó, akár Singleton, akár egy homlokzat mintát akár globális változót használunk. (Bár a Singletonnal konkrétan itt annyi talán a bajom az Unit Testingen kívül, hogy felesleges a lazzy load, mert nagy valószínűséggel úgy is kelleni fog. -- megjegyzem sok ilyen kaliberű esetben ez se játszik.
Anno, mikor a mostani rendszereink végső alapját kialakítottuk (a korábbi munkák összegzése után kezdtük el fejleszteni) nálunk is szóba került a Singleton és a homlokzat. (DI akkor még nem nagyon volt benn a köztudatban, magam sem ismertem akkor konkrétan így). Végső döntés az volt, hogy marad a globális változó. Egyrészt, mert egyszerű, nem okoz szerializálási problémákat (pl. ha egy objektum adattagjaként beemeljük) másrészt azt a kb. 7-8 változót nem lehetetlen megjegyezni (mindenki tudja, hogy ezek azok, elég egyértelműek, doksiba le van írva és amúgy is, nem kezdünk el úgy egy rendszert fejleszteni, hogy picit se nézzük meg mi merre hány méter) és nem igényel plusz függvényhívást sem. Lehet mondani, hogy csúnya gonosz global, de attol még gyors, egyszerű és működik. Jól. És még csak véletlenül sem történt olyan, hogy valaki felülcsapott valamit.
Ráadásul szerintem unit testingnek sem mond ellen. Meg lehet adni teszt előtt/utáni eseményeket, ott meg meg lehet oldani, hogy hozza létre ezeket újra, vagy inicializálja újra a keretrendszert.
Természetesen nem vagyok a DI ellen. Csak nem látom indokoltnak minden esetben.
Vagy hozhatnék még egy példát: egy barátommal is épp beszélek Skypen, épp a Symfony2-s FileResource osztályról elmélkedünk. Véleményem szerint ezek az osztályok is indokolhatóak. Csak sokszor a feladat nem indokolja.
Érvek a másik oldalról
Mindig lesz kód, amit megéri újrafelhasználhatóra fejleszteni és lesz amit nem. Viszont ha újrafelhasználható modulokról van szó, meg kell terveznünk egy illesztő felületet, ehhez egy általános rendszermagot, ehhez egy saját szemléletet a weboldalak működésére és kiszolgálására.
A copy-paste addig működik amíg nem merül fel például, hogy most "módosítani kellene az összeset egyszerre".
A PHP-ra még jellemző hogy egy igen ellenséges, veszélyes környezetet kapunk. Egy bizonyos munkát bele kell ölnünk amire (input tisztogatással, DB és output escape-eléssel) biztonságossá varázsoljuk a környezetet ahol a valódi feladatot megoldhatjuk. Úgy szintén szükségünk van tipikus funkciókra, amiket az API nem bocsájt rendelkezésünkre. Ezeket a dolgokat nem is biztonságos minden alkalommal újraírni vagy összeollózni, inkább maradna az ember egy bevált alapnál, ami fut több projektünk alatt és hónapok alatt köszörülgettük ki kisebb hibáit.
Vagyis bármennyire is csábító hogy munkát spóroljunk meg egy kevésbé integrált megoldással, az esetek túlnyomó többségében indokolt ágyúval lőni a verébre, mert az ágyú már készen van, és ki tudja, heteken belül kiderülhet, hogy nem is veréb, hanem Godzilla :)
Válaszok az érvekre
vs.
No, itt álljunk meg egy szóra. Először is különböztessünk meg projekten belüli és projektek közötti kód-újrafelhasználást.
Projekten belüli kód-újrafelhasználás megléte számomra evidens. Nem kérdés, hogy kell, ameddig van értelme. Nyilván be fog szólni néha a gazdasági indok is, amikor jobban megéri egy kisebb részre CTRL+C,V-t nyomni és az egészet átírni, mint egy már meglévő megoldást áttervezni. Ennek az az oka, hogy míg egy jól kidolgozott API-t használni nagyon kényelmes, addig áttervezni nagyon horror tud lenni. Magam is mostanság egyre kevesebb kifejezetten kódoló és egyre több inkább tervező munkát végzek, így bátran alá merem írni bárkinek azt a kritikát, hogy az OOP addig jó, míg csak használni kell. Főleg, hogy nem kevés olyan ember van, - aki bár teljesen korrekt, minőségi munkát készít - tervezésre nem vagy csak kevésbé alkalmas..
Egyébként meg nem csak szó szerint vett OOP-vel lehet szép és újrafelhasználható megoldást készíteni. Egy jól megtervezett API és projekt-struktúra esetén a template method pattern pl. adoptálható minden további nélkül. Ezzel meg lényegében eljutunk oda, hogy egy bizonyos szintű öröklődéshez hasonló funkcionalitást meg lehet valósítani OOP nélkül is. (Ha elvonatkoztatunk egy kicsit, akkor az egész weblap is felfogható olyan "osztályok" összességeként, ahol az egyes modulok a gyermekek, a keretrendszer egy absztrakt ős, amiből származtatunk.)
Projektek közötti kód-újrafelhasználás már egy problémásabb témakör, amire egy PHP nem is ad igazán jó megoldást a kopipaszta alkalmazása nélkül. (Bár, ha úgy nézzük, ha indítunk egy tetszőleges fw-n egy projektet, valahol az is kopipaszta technológia). Ezt a problémát még csak-csak fel lehet oldani pl. egy .NET-ben vagy egy Java-ban egyszerűen, ahol egyszerűen készíthetünk egy assemblyt vagy egy Jar fájlt, de PHP-ben külső segédeszköz nélkül nagyon halál és bármennyire hitegetjük magunkat, az OOP erre nagyon korlátozott megoldást ad.
Hasonló problémáinkat mi a Subvesion szoros integrálásával oldottuk meg. Másik része kódszervezés, pl. adott egy FooBase osztály a keretrendszerben, amiből kötelező származtatni egy Foo osztályt, amit használ mind a keret, mind a projekt. Általában üres osztály, de ha módosítani kell, ezen keresztül oldható meg. Persze, erre is van tervezési minta, nem is egy. Probléma vele, hogy több plusz munkát adna, mint ez az apró kerülőmegoldás viszont végeredményben nem kapnánk semmi plusz funkcionalitást. Másrészt néhol szemantikailag zavaró dolog kerülhet a kódba.
Nem is hiszem, hogy kellene. Egy minimal keretrendszert is (akár OOP, akár nem OOP) meg lehet tervezni újrafelhasználhatóra. Mindegy, hogy 1.000 vagy 1.000.000 soros.
Épp ez a bajom: nem látom, hogy mindig indokolt lenne. Egy napi 100 látogatóval rendelkező egyszerű oldalra, aminek a fele még akár statikus HTML is lehetne előre generálva nem látom indokoltnak feltétlen a nehéztüzérséget. Persze, jó biznisz a szerver-árusítás, de egyre inkább azt látom, hogy a pazarlás és az öncélú keretrendszer-építkezésekbe botlunk, mert érdekesebbnek tűnik, mint maga a projekt. (Bevallom, magamon is észreveszem/észrevettem utólag ezen tüneteket.)
Erre szoktam azt mondani főnöknek, hogy egy projekt folyamata:
1. Analízis => (részletes, funkcionális specifikáció)
2. Tervezés => (indokolt részletességű műszaki dokumentáció)
3. Implementálás => (Szoftver)
4. Utókövetés => (Hibamentes szoftver)
És, ameddig az egyes pont nincs meg nagyjából, nincs mire se időt, se árat mondani és még csak véletlenül se akarjon arról beszélni, hogy mégis mivel is lehet ezt a projektet megvalósítani. Vagy csak szerintem kell feladathoz az eszközt választani?
Szóval, ha utólag derül ki valamiről, hogy az egy Godzilla, akkor ott valami súlyosan el lett rontva a projektindítás környékén :)
--
Elismerem, hogy nem fogalmaztam mindent a legegyértelműbben, sajnos ennyire tellett ma.
Erre szoktam azt mondani
1. Analízis => (részletes, funkcionális specifikáció)
2. Tervezés => (indokolt részletességű műszaki dokumentáció)
3. Implementálás => (Szoftver)
4. Utókövetés => (Hibamentes szoftver)
Mennyit ismételgettem én hasonlót? :)
Nemcsak a megrenedelőnek, de junior projektmenedzsernek is, de általában már az 1. pont hibázni szokott, és hiába volt meg a többi, általában a végén valahol egészen máshol kötünk ki, mint ahova el akartunk jutni.
Erre biztos a PHP-nak kellene megoldást nyújtania?
architekturális felhőkarcoló :)
Ahogy egyik kollégám mondta korábban, PHP-ben a laposabb struktúrák tudnak jól működni. Ezzel maximálisan egyetértek.
A globális változók használatát - amit említettél - viszont ellenzem.
Egyébként ez klasszikusan olyan téma, ahol mindenki el fogja mondani a véleményét, de senki, senkit nem fog meggyőzni. :)
http://www.gartner.com/techno
minden uj technologianak/paradigmanak az elejen joval nagyobb a hire, mint amennyire hasznos, kesobb van egy nagy visszaeses, amikor sokan elfordulnak a dologtol, mert nem valtotta be a hype miatt hozza fuzott remenyeket.
ezutan aki megmarad, az a tenyleges kepessegeinek megfelelo szinten tudja hasznalni a dolgot
uzleti szempontbol nezve soha senki nem fogja megnezni a forraskod szepseget egeszen addig, amig a szoftver ~hibatlanul az elvarasoknak megfeleloen mukodik(megfeleloen biztonsagos, megfeleloen gyors, etc.).
innentol kezdve a kodminoseg csak a fejlesztesi/karbantartasi koltsegek miatt(technical depth) erdemes a tiszta, atlathato, "szep" kodra torekedni, amik viszont olyan szubjektiv szempontok, amik alapjan a vegtelensegig lehetne refaktoralni minimalis lathato eredmeny nelkul.
itt figyelembe kell venni a ROI-t (Return of investment) figyelembe venni: mi az amit nyerek az adott plusz fejlesztessel, megeri-e a befektetett munkat/idot/penzt.
a legtobb fejlesztonek egyszeruen olyan a beallitottsaga, hogy hajlamos elfelejteni, hogy a fejleszto a legtobb esetben nem festomuvesz, hanem szobafesto, nem a sajat oromunkre dolgozunk, hanem a megrendelesnek/felhasznaloi igenyek kielegitesere.
a masik jo cikk a temaban:
http://www.whattofix.com/blog/archives/2011/02/programmer-as-m.php
szoval a velemenyem az, hogy mindig az adott feladat donti el, hogy mennyire szep/karbantarthato/"enterprise grade" kodot kell irni.
vegszokent csak annyit, hogy nem elvitatni akarom a felsorolt eszkozok/patternek hasznossagat/letjogosultsagat, de mindig erdemes figyelembe venni, hogy hol tartunk eppen a hype gorben (erdemes meg megfigyelni pl. a scrum koruli esemenyeket, kulfoldon mar kezdenek elfordulni/elfordultak a scrumtol, sot az egesz agile fejlesztes letjogosultsagat megkerdojelezik egyesek ( http://programming-motherfucker.com/ ), Magyarorszagon meg most vezeti be esz nelkul mindenki).
Tyrael
+1 for Tyrael Mindemellett a
Mindemellett a fent említett módszerek "megtérülése" jellemzően nem a projekt átadásának időpontjára tehetőek. A TDD, a DI, a jó gyakorlat, encapsulation, abstraction mind-mind akkor térül meg, amikor hozzá kell nyúlni a kódhoz.
Amikor fejlesztnei kell, esetleg skálázódni, mondjuk új adatbázismotor vagy tempalte engine kell, hozzá kell dobni egy cachinget stbstb...
Nemrég utasítottam el egy szabadidős projektet, miután megláttam a kódját... Valószínűleg a fejlesztők az általad leírt "egyszerű" megoldást választtották az elején, madj szép elkezdtek ehhez a rendszerhez hozzpakolni mindenfélét és a végén egy kezelhetetlen káosz lett az egész.
Amikor módszert választasz, a jövőre kell gondolnod; megfontolod, hogy mi fejlődhet a projektből a jövőben és ennek megfelelően döntesz. És ez igenis fontos.
innentol kezdve a kodminoseg
ugyanazt irtuk szerintem mindketten.
technical debt-rol egy nagyon jo eloadas:
http://www.slideshare.net/enaramore/technical-debt-phpbenelux
kiemelnem a "prudent technical debt"-et mint fogalmat, es ezt kiegeszitenem a Programmer as Market-es blogpost-bol vett idezettel:
ha startup vagy, van egy jo otleted, csinald meg, taknyold ossze, probald ki, hogy mukodik-e es hogy tetszik-e az embereknek(tudatos dontes eredmenyekeppen, de halmozz fel technical debt-et, ha ettol tudsz gyorsabban elkeszulni).
20-bol 1 startup marad eletben, szoval nagyon alaposan meg kell fontolni, hogy mennyire erdemes kipolirozni az alkalmazast, vagy eppen mennyire sok munkat olunk a fejlesztesbe, mielott kirakjuk a felhasznalok ele, hogy eldontsek, hogy van-e ertelme egyaltalan annak amit csinalunk.
nyilvanvaloan a programozoknak az az erdeke, hogy minel szebb/karbantarthatobb/altathatobb kodot irjanak, de ez nem feltetlenul egyezik meg az uzleti erdekekkel, es szerintem sokkal elorebb lenne mindket fel, hogyha ertelmes kompromisszumokat tudnanak kotni, tehat a fejlesztok is felismerik, hogy nem azert irnak kodot, hogy state-of-the-art csodalatos kodkompoziciokat hozzanak letre, amit senki sem hasznal, mire elkeszul, valamint a menedzsmentnek is fel kell ismernie, hogy a felvett technikai tartozast valamikor torleszteni kell, kulonben maga ala temeti a csapatot(kell a folyamatos refact, vagy ne adj isten nullarol ujrairni a rendszer egyes reszeit, ha bizonyitott a prototipus, hogy mukodik, es tetszik a felhasznaloknak).
nem egyszeru megtalalni ezt a balanszt, elofordulhat, hogy alabecsulod a technikai tartozasod, es ugy jarsz mint a phpfog.
http://blog.phpfog.com/2011/03/22/how-we-got-owned-by-a-few-teenagers-and-why-it-will-never-happen-again/
ps: lehet hogy ezt a temat inkabb egy kulon cikk/blogbejegyzes formajaban kellene koruljarnom, mert hozzaszolasnak tulsagosan szoszatyar lett az utolso ket kommentem. :)
Tyrael
Off
Nem értem, komolyan nem értem ...
egyreszt egy igazan jo eloado
ps: '89-es a strip. :P
Tyrael
Rohanó világ
A lényeg: a világunk attól rohanó, hogy sokan így gondolják. Egy vezető réteg pedig ezt a tézist újra és újra megerősíti azokban akik ezt gondolják a világról. Azért teszik ezt, mert ez az érdekük, hogy jó sok pénzük legyen.
remelem azert erezted az
Tyrael
Természetesen
megfontolod, hogy mi
Még nem nagyon találkoztam olyan megrendelővel, aki két hétnél előrébb látott volna, egyszerűen ez nem jellemző, sőt. Szerintem nagyon nehéz így előre eldönteni, hogy mit érdemes használni.
Másik jellemző példa: az ügyfelektől kérjük, szedjék össze és írják le, mit szeretnének. Utána ez alapján bemutató, közös teszt, átbeszéljük a dolgokat, kiderül, hogy még pár dolgot el kell készítenünk. Megkérdezzük, hogy ezeket miért nem írták le? A válasz: dehát ezek a dolgok magától értetődőek. Persze.
Ezért kell egy oldalakra
Megrendelo vs rendszerszemlelet
Erre nalunk az a szabaly, hogy semmi sem magatol ertetodo. Mindig mindenre ra kell kerdezni, hogy de biztos valamint a megrendelo altal hasznalt osszes fogalmat, folyamatot, stb. definialni es rogziteni kell. Irasban a specifikacio elejen.
Fonokommel szerdan vitaztunk arrol, hogy miert fontos az, hogy tudjuk _pontosan_, hogy a rendszert kik fogjak hasznalni, hol, milyen korulmenyek kozott es hogyan. Ha ezt tudjuk, akkor lehet igazabol atterni arra a pontra, hogy tulajdonkeppen mi is kell. Nem is igazan ertette eddig szerintem, hogy miert van nekunk szuksegunk ezekre az informaciokra, holott reggelig lehetne sorolni, hogy mi mennyi aprosagban befolyasolhat es mit. Na meg, pont egy ilyen kerdeskor letisztazasaval sikerult egy kolleganak ma letisztazni egy komolyabb felreertest, ami csunyan felrevitt volna egy projektet.
Persze, de ezert keresett egy szakembert, hogy segitse ot a celjai elereseben. Ergo: neked kell elorebb latni 2 hetnel. Termeszetesen ehhez kellenek a hosszu evek meg a sok tapasztalat.
Legjobb megfogalmazas
Amit elfelejtettem az eredeti irasban megemliteni az az objektivitas hianya. Ha megnezzuk a temaban alapmunek szamito design patterns konyvet, ott nagyon jol le van irva, hogy egy minta:
- mire jo
- mikor hasznaljuk
- ha hasznaljuk, mik lesznek a kovetkezmenyei
- mikor ne hasznaljuk es mit tegyunk helyette
Nah, a "mi a hatranya" fejezet szokott leginkabb elmaradni egy uj technologia bemutatasakor.
Manapság sehol sem szokták
Hiba
Egy pelda
http://propel.posterous.com/the-end-of-autoloading
gáz
az gáz.
Ezek szakkifejezések, mint egy építőnek a boltív, vagy egy autószerelőnek a karburátor. Persze azt is lehet mondani, hogy az egy kis izé a motor meg a benzintank között ami összekeveri a benzint meg a levegőt.
Szerintex Saxus erről akart
buzzword
Egyébként van olyan fogalom, hogy "pattern abuse" vagy "pattern overusing" esetleg általánosabban "overengineering". Igen, ezeket nem árt elkerülni. Mindig csak annyira bonyolítsd el a programot amennyire muszáj.
Jogos
Egy szakkifejezés szerinted
Szerintem nem a fogalmakkal
http://www.adaptiveconsulting.hu/sites/default/files/KanbanEsScrum_MindkettobolALegjobbat_1.pdf
és nekem hasonló gondolatok jutottak eszembe mint neked. Ma már millió eszköz áll egy fejlesztő rendelkezésére, ezek természetes módon sok új fogalmat "szülnek", de nekünk kell döntenünk arról, hogy mit választunk. Aki egy 5 oldalból álló, 2 modulos weblapot elkezd felesleges és a fajsúlyához nem illő technikákkal készíteni az vessen magára. Finoman fogalmazva :)
A Scrum is hasonló téma, ott is józan, paraszti ésszel felfogható dolgok vannak leírva, a gyakorlatban viszont azt láttam eddig, hogy nem megfelelő emberek egy vezető pozícióban mindent képesek elrontani.
De ezt nem lehet kiküszöbölni, attól, hogy vannak rossz szakemberek és hülyék (bocsánat, de ez a legjobb szó) a világ még fejlődik.
Megfelelő módszer, megfelelő helyen. Ezt talán nehezebb eldönteni, mint elkezdeni a kódolást ész nélkül.
wtf tdd?
Nekem az a tapasztalatom, hogy sokkal jobb tesztekkel fejleszteni, mint azok nélkül. A legutóbbi (kis - kb 2000 soros) projektemnél pl egy nagyon egyszerű sql-t rontottam el (kimaradt egy feltétel a where-nél), és ilyen szemlélet nélkül kizárt, hogy teszteltem volna, mert annyira egyszerű volt. De ugyanebben a cuccban voltak olyan változók, amik sok helyen előfordultak, aztán a végén eszembe jutott, hogy kiemelem őket konstansokba, na mármost ez hajnal 4kor volt, amikor az ember már fáradt, és hibákat követ el. Nekem is sikerült, de pillanatok alatt kiderült, hogy hol hagytam ki a változó átírását, és javítottam 10 másodperc alatt. Szóval kis projekteknél is megkönnyíti szerintem az életet a tdd.
TTD != nem teszteljuk, amit csinalunk
A TTD -szvsz- nem mentesit a teszteles alol. TTD ide vagy oda, en le szoktam tesztelni kezzel, hogy az, amit leirok, jo-e.
Ez szamomra inkabb a tervezes hianyara utal. Velem is megestek mar hasonlok, szinte kivetel nelkul vagy a feladat alapos atgondolasa es tervezese vagy gepelesi hiba volt a hiba forrasa (megjegyzem, ezek is tipikusan olyan hibak voltak, amik 95%-ban elo nem jottek volna mas nyelveken, pl. C# vagy Java, mert le se fordul).
De mint mondtam, nem ezek a megoldasok hasznalataval van a bajom. Ezen megoldasok esz nelkuli hasznalataval es eroltetesevel van a bajom. Ugyanezekre tudnek mondani rengeteg peldat maga az OOP hasznalataval kapcsolatban is.
(megjegyzem, ezek is
erről szálljunk már le.. azért van az IDE, hogy használd az autocompletiont, és akkor nincs gond. Velem már évek óta nem fordult elő, hogy elgépelés okozott volna hibát.
ööö
hát mondjuk ennek
Biztos hogy TDD?
Én nem keverem :-)
Unit test jó, a tdd meg még jobb szerintem. A tesztek nélküli refaktorálás meg mazochista hajlamra utal. :-) Tervezésnél sajnos nem vagyok elég alapos, ezért menet közben szoktam refaktorálni, meg ide-oda tologatni dolgokat, ahhoz meg kellenek a tesztek. Ez persze nem követendő példa, bénán csinálom. :-)
TDD-nél akár az is lehet, hogy megtervezel egy felületet, és a belső felépítés a tesztekből adódóan alakul ki. Ha nem tudod elég kis részét tesztelni egyszerre a programnak, akkor beteszel egy új metódust vagy osztályt, ami már elég kis rész ahhoz, hogy egyszerűen tesztelni lehessen. Próbálkoztam egy cikk sorozat írásával a témában, de ahhoz még hozzá kell tanulnom, meg gyakorolnom.
Tervezes elodazasa refactoringgal
Ezzel szemely szerint az a bajom, hogy rettenetesen sok ido tud lenni neha valamit normalisan refactoralni. Ezert szeretek inkabb elore gondolkodni, tervezni. Inkabb ulok az egesz felett fel-egy orat, minthogy utolag fel napig mast se csinaljak, mint kodot lapatolgassak jobbra-balra.
Arrol nem is beszelve, hogy volt mar, hogy inkabb otthagytam a kodot kikommentezve, hogy ez meg az a nyugje, hogyha egyszer komolyabban hozza kell nyulni, akkor ne legyen remenytelen kuldetes, mintsem, hogy gatyaba razzam. Ok, tipikusan ezek azok a kodok, amikre nem buszke az ember, de raforditott ido/hasznossag aranya jobb volt. Az osztaly kulso felulete ugy is sok mindent elrejt ezekbol, igy nem okozott kesobb problemat.
Ertem en, hogy a te esetedben nagy segitseg a TTD, csak nem vagyok meggyozodve rola, hogy minden esetben kevesebb ido.
Én sem, ez is olyan, hogy ki
(Amúgy ez a konstans refaktorálás agilis dolog, ha jól tudom. Bejön egy ötlet, aztán át kell rendezni a kódot... Nálam akkor fordul elő sokszor ilyen, amikor menet közben alakul ki, hogy pontosan hogyan tudom megvalósítani az adott környezetben amit akarok.)
...
A TDD-ről hallottam már, de most is lusta vagyok utánaolvasni, hogy micsoda. Valószínűleg már olvastam róla, de ha nem maradt meg a fejemben, az valószínűleg azért volt, mert nem találtam értelmét, vagy valamilyen formán alkalmazom azt a magam módján.
A cikkről a véleményem: egyet tudok érteni vele nagyrészt, és a kezdeti hozzászólások is nagyon érdekesek. Szkeptikus hozzáállás egészséges mértékig szerintem nem hiányozhat akkor, amikor új dologgal ismerkedünk. Vannak olyan technológiai megközelítések, amiknek akkora hype-ja van, hogy már azért méla undor fog el (és talán mert amit ennyire nyomatni kell, azzal feltételezhetően valami nem egészen van rendben - példaként az agilis fejlesztést említeném) és vannak, amik relatíve hamar végezték az IT dev. szemétdombján (pl. a Singleton). Nincs megváltó technológia, sem tervezési minta. Ha választani kell egy megoldást, előzze meg mérlegelés mert az elemi kíváncsiság nem feltétlenül lehet szempont (persze, kísérletezni érdemes, de ezt ne a legdrágább projekten kezdjük el).
Szemléleti példaként hozom csak fel: van egy saját fejlesztésű, nagyon pici keretrendszerem a nagyon pici projektekre, OO, MVC, jól muzsikál, még DB absztrakció és minimális többnyelvűség-támogatás is akad benne. Amire ez a rendszer kevés, arra pedig ott a Drupal. És hogy az arany középutat is kilőjem: készülök egy komolyabb keretrendszerrel is, ami OO, Event-driven, AJAX/SJAX, MVC és egyéb lesz, alapjaiban fog idomulni az ExtJS 4-re (tehát RIA alkalmazások fejlesztésére szánom főként), az adatbázis kezelő rétege pedig a fejlesztőre fogja bízni a választást, hogy AR-es vagy nem AR-es megoldással kíván-e élni az adatbázis elérésekor. Igen sok esetben fogok már létező classlib-ek helyett saját megoldásokat alkalmazni, de pár dolog esetében lándzsát szúrtam meglévő eszközök mellé (Twig, Swift Mailer például).
Azt hiszem, minden fejlesztőnek az élete során meg kell tanulnia, hogyan kell egy feladatot végtelenül komplikáltan- és hogyan végtelenül egyszerűen megírni - akkor van mód arra, hogy az ember a kettő közt lavírozva tudjon helyes döntést hozni arról, mikor milyen eszközökhöz érdemes nyúlni, és mikor/melyikekhez nem.
A unit test-nek az a lényege,
A var_dump-nál minden alkalommal beteszed a kódodba, hogy var_dump, aztán összehasonlítód szemmel, hogy az az érték jön le amit vártál, aztán ha okés, akkor kitörlöd a dumpot, és ha megint gubanc van, akkor me megint beteszed.
Unit test-nél írsz egy összehasonlító tesztet, aztán minden alkalommal lefuttatod, amikor gányolsz a kódon, így minden részt megvizsgál, hogy nem e törte meg az új kódod, illetve minden eshetőségre felkészíted a kódodat, ami csak eszedbe jut.
Én az utólagos teszteléssel úgy vagyok, hogy semmi kedvem hozzá, aztán összecsapom, ezért írom meg inkább a teszteket előre.
Attól, hogy látszólag jól megy a kód sok esetben, még nem biztos, hogy minden eshetőségre felkészült. Lehetnek olyan ritkán futó, nem tesztelt részei, amik hemzsegnek a hibáktól. Var_dump-nál úgy néz ki ezeknek a tesztelése, hogy egyenként írod meg a tesztet minden metódusra, és egyenként dumpolod ki. Unit test-nél egyszerre megírod az összeshez a kódodat, az összehasonlítást a teszt program végzi, és csak akkor rinyál, ha hiba van. Szóval neked a teszt program írásával kell foglalkoznod, és nem váltogatni egyik ablakról a másikra, meg nézegetni, hogy azt írja e ki, amit vártál... Százszor egyszerűbb így fejleszteni és debuggolni, kódot átrendezni meg milliószor.
...
Hangsúlyozom: nem vagyok ellene, csak esetemben nincs rá szükség az munkáim elvégzéséhez. A már említett keretrendszerem viszont (a bonyolultabbik) nyílt kódú lesz, és bár nem fogok fáradni a UnitTest-tel, kellően moduláris, kellően dokumentált és kellően tesztelt lesz - azonban ha valaki idővel elkészíti hozzá a UnitTest-eléshez szükséges kódokat is és itt-ott módosításokat fog javasolni ezen apropóból a kódbázisban, egész biztosan nem fogom elhajtani a felvetéssel. Szemléletemből adódóan nagyon kicsi és nagyon jól tesztelhető osztályokat készítek többnyire, ahol csak lehet ott kerülöm a "feketemágiát" és dokumentálok (phpDoc). Ez egyébként egy 5.3-as projekt, annál lennebb már nem adom a sok hasznos újítás végett (late static binding, újabb mágikus metódusok, lambda és closure, etc.) de a natív névterek (namespace, use) használatán még gondolkodom.
Szerintem a UnitTest szükségességét a feladat, a keretrendszer (már ahol egyáltalán létezik...) és a fejlesztői szemléletmód (szokások) hármassága határozza meg. Ahol a feladat nem indokolja, a keretrendszer nem teszi lehetővé és a résztvevő fejlesztők is hatékonyabban tudnak dolgozni a "mezei" megszokott és bevált módszerekkel, ott felesleges bevezetni. Ha a feladat nem indokolja, időpocsékolás. Ha a rendszer nem támogatja, közel lehetetlen. Ha a fejlesztők kellően rutinosak és alaposak az előkészítés-tervezés-tesztelés hármasban, szükségtelen (szerintem). Ezért mondom: közösségi (sokrésztvevős) fejlesztésnél látom értelmét, egyéniben, vagy kislétszámú csapat esetén szerintem csak a plusz munkát generálja.
Ne keverjük a debugging-ot a
"aztán ha okés"
reszben ide
http://www.eschrade.com/page/concerning-newness (ne add fel az elso 2 bekezdesnel az olvasast)
Tyrael
COBRA
- futás ramdisken
- szeparált htdocs / php
- csak json
- csak postgres / szepralát session és clean csak stored proc
- generált class cache
- stb.
- demo apps: geoapp gmap layer / kolinet manager
nem tökéletes, de hát ez van
https://github.com/hornos/cobra
Szép munkának tűnik első
lesz minden, de doxygen a
Architecture astronauts
Hol az igazság? Nem tudom. Én alapvetően szeretem, ha gyors a rendszer és működik a kódkieg. Ezért én inkább kiszervezem libekbe a funkcionalitást és az összekötésnél melózom kicsit többet.
http://joelonsoftware.com/art
A vicc az, hogy az esetek többségében hiába küzdesz, nem úszod meg a munkát. Azt hiszem, ígyis-úgyis folyton refaktorálni kell, ha új igény merül fel, szóval felesleges nagyon rákészülni.
Mi is a baj a DI-vel? Láttad
Mi is a baj a TDD-vel és unit testinggel? Egy 20.000 soros webalkalmazás (csak a backend) készítése során sajnos nem volt elég idő megfelelő mennyiségű tesztet írni (kis része TDD-vel készült), de így is rengeteg szívástól mentett meg az a 4-5000 sornyi unit test. Ha nem lettek volna, a fejlesztési idő (amiben ugye benne van a "nem így akartam, inkább emígy működjön" dolog a megrendelői oldalról) jóval több lett volna.
Értem, hogy sokszor nem indokolt bizonyos technológiák használata, de idővel mindenkinek kialakul egy eszköztár, library, amit használ. És ha ezek között csak olyan kapcsolatok vannak, amelyek az alap PHP-ben is benne vannak, akkor megette a fene az egészet. Ez a PHP API hiányossága miatt van, ezért az ki így, ki úgy kompenzálja. De valahogy muszáj. Én nem szeretem többször megoldani ugyanazt a problémát.
ellenpélda
Ha nem egyedül dolgoznék a projekten, el tudom képzelni, hogy a 10x-esére nőne a hibalehetőségek száma, és valószínűleg a tényleges hibák száma is. Tudom, hogy mit tud okozni egy lelkes kolléga, aki ész nélkül átír bármit, vagy éppen nem aggódik azon, hogy egy-két metódusomat felülcsapta. :)
Lényegében ugyanezt írtam
Tervezés
Nem tudsz mindent előre
hit vagy tapasztalat?
Szerintem elsősorban mindenki a saját tapasztalatai alapján tud véleményt mondani egy-egy eszköz vagy módszer hasznosságáról. Továbbá szerintem igencsak a helyzettől, az adott projekttől függ, hogy mi a célravezető.
De ha neked nincs szükség mérlegelésre ezen a téren, akkor vagy elképesztően tapasztalt vagy (igazi mestere a szakmának), vagy puszta hit alapján nyilvánítasz (elhamarkodott) véleményt.
Ha az utóbbi eset áll fent, az nem csak 2011-ben nem kívánatos egy szakmai fórumon.
+1
Nem tudsz mindent előre
Valóban nem. A fent említet stratégiák nagy része pontsan azt a célt szolgálja, hogy felkészülhess váratlan vagy új dolgokra a projektedben és könnyedén végrehajthass változtatásokat anélkül, hogy
1. ezzel veszélyeztetnéd a már működő kódot, illetve
2. tökön kelljen szúrni magad
Ha egy kicsit is komoly a projekted, akkor igenis van indok rá, mégpedig a kódminőség és a (jövőbeli) hibák minimalizálása. Erre természetesen nem garancia az egységtesztelés, de a feltétele.
Ezt gondolom nem nekem
Mikortól komoly egy projekt?
Sohasem értettem, amikor valaki egy elméletet állít szembe a tényekkel. Én nem állítom, hogy a Unit Teszt rossz, de azt állítom, hogy nem indokolt minden esetben a használata. Az eddigi 1.5 év, amióta a saját projektemet fejlesztem , eltelt komolyabb hibák nélkül, de ezt nem ragozom, már fentebb leírtam…
Most mit szeretnél hallani, hogy igazad volt, és reggel arra keltem, hogy fehér lapot dob az oldal, és a log file kezelhetetlen méretűre hízott a végeláthatatlan hibahalmaztól? :) Vagy, hogy az oldal akkora Exception-t dobott, hogy kiestem a fotelből, és a falon még mindig ott vannak a vérnyomok, mert többször belevertem a fejem, amiért olyan hülye voltam, hogy nem használtam Unit Tesztet? :)
Van egy jó mondás az elméletre és gyakorlatra vonatkozóan: az elmélet és a gyakorlat elméletileg ugyanaz, gyakorlatilag különböző. :)
Ha lennének tesztjeid, akkor
Tesztek nélkül hogy találod meg a regressziós hibákat? Egyáltalán tudod, mik azok? Igen, lehet dolgozni unit tesztek nélkül is, csak el kellene tudni fogadni, hogy nem érdemes, mert többet buksz, mint nyersz.
Újabb feltételezések? :)
Részemről megköszönöm a kedélyes beszélgetést, de ahogy mondani szokták az állításaidat sem megerősíteni, sem megcáfolni nem tudom. :)
Részemről itt vége, zárszóként magamat idézném:
Grat, sikerült a beszélgetést
Aki nem ír egységteszteket, pedig tudja, hogy mi az és mire való, az egészen egyszerűen nagyképű. Nem írni teszteket azt feltételezi, hogy te nem követsz egy hibákat a kódodban vagy azonnal megtalálod őket. Ez nem feltétlen az adott osztályra vonatkozik amikor éppen írod, hanem a későbbi refactoring során keletkező logikai bukfencekre (persze az előbbinél maradva is nehéz bug-free kódot írni).
Steve McConnell Code Complete című alapműve szerint 1000 SLOC-ra 10-15 bug jut az ipai átlag szerint. Ez a te kódodban ezek szerint 300-450 bugot jelent. Még ha meg is találod a nagy részét deployment előtt és egy MS átlag 0.5 bug/KLOC-ra hozod a production kódot, akkor is jó eséllyel 15 bug van a kódodban.
Ez az arány azonban egységtesztelés (és sok egyéb QA munka nélkül) nem nagyon érhető el.
(Protesis: neked csak az előző hozzászólsom első fele szól, de nem akartam 2 hozzászólást írni külön-külön)
Fincsi lehet, amikor
nem csak var_dump-pal tesztelek
Ami a refaktorálást illeti, azt kis lépésekben, és relatív gyakran szeretem végezni, az eddigi tapasztalataim alapján ez működik.
Regressziós hibára semmit nem
Körültekintéssel, odafigyeléssel :)
Nem hiszem, hogy túl sokat ELMÉLETET kellene gyártani arról, hogy a GYAKORLATBAN Unit Teszt nélkül is karban tudom tartani a hozzávetőleg 30.000 soros saját kódomat.
Ha te úgy gondolod, hogy a SAJÁT kódodat sem tudod annyira átlátni, hogy Unit Teszt nélkül tudd azt fejleszteni, és karbantartani, akkor a következőket tudom elképzelni:
a, Meg sem próbáltad...
b, Nem megfelelően gondolod át a dolgokat, esetleg kapkodsz.
c, Az összes hype-olt technológiát egybegyűröd, és lesz egy szép tech-demód, aminek a szépségért a használhatóság terén komoly árat fizetsz.
d, Olyan elképesztően komplex folyamatokat kódolsz, ami már messze túllép a szokásos megoldásokon.
e, Eddig még nem volt olyan (100%-ban saját) projekted, ahol összejött volna a 30.000 sor vagy több, és most úgy próbálsz észt osztani, hogy nincs is valós tapasztalatod.
A 'e' variáció sem szégyen, nekem is sincs 100.000 soros saját projektem (ha csak a backend kódját nézzük), de ha másnak lenne, egészen biztosan nem próbálnék elméletek gyártani, hogy ez bizony nem működhet, és csak úgy lehet jó, ahogy ezt elképzelem, és ahogyan a legtöbben gondolják.
Két dolgot szeretnék megértetni veled:
1. A saját projektemet kb. 1.5 éve fejlesztem komolyabb hibák nélkül. Valóban működik.
2. Ha többen fejlesztenénk, nem tartom elképzelhetetlenek a 50-100x-os mennyiségű hibát sem. Egy nagyobb csapatban, többféle kódolási szokással bíró fejlesztőkkel, a határidők nyomáskényszere alatt, ahol mindenki csak azzal törődik, hogy az "ő része" jól működjön, egészen másképpen működnek a dolgok.
Ha gondolod nyissunk egy új témát a Unit Tesztelés fortélyairól vagy bármilyen más általad preferált technológiáról. De kérlek ne magyarázd meg nekem, hogy minden módosításnál, refaktorálásnál (mindkettőből volt egy pár) összeomlott a rendszer a regressziós hibák sokasága miatt, mert nem így történt. :)
Én tisztelem a te elméleteidet, esetleg te is tisztelhetnéd a gyakorlati tapasztalataimat.
+1, de
Igen, ez tényleg rengeteg mindent egyszerűsít a dolgokon, mert más hibáival nem kell foglalkozni. Igaz, hozzá kell tennem azt is, hogy 30kloc még nem olyan sok kód, hogy feltétlen több ember munkájából jöjjön össze.
Viszont, ha mégis többen dolgoznak valamin, akkor is jól elkülönülő részeken, így hasonló kisebb projekteknél szintén nem annyira probléma.
Tesztek nélkül hogy találod meg a regressziós hibákat?
Egyszer gondoltam, hogy írok egy cikket az általunk használt utólagos hibakezelésről, nem tudom mennyire lenne rá érdeklődés.
Persze, a kettő nem kizáró vagy feltételben áll egymással.
A hibakezelést is le lehet
És nem értem mi a gond az éles környezettel. Unit tesztet nyilván fejlesztés közben kell végezni. Élesítés előtt production környezetben (nem feltétlenül a live szerveren!) lefuttatod a teszteket és ha minden ok, akkor élesíted az új kódot. Ha ilyenkor nem megy az oldal, akkor valamit vagy nagyon elrontottál, vagy valamit nem teszteltél le.
És nem értem mi a gond az
Leginkább az, hogy tesztelni tesztel az ember munka közben. Akár unit, akár máshogy, de tesztel. Csak emellett azt látom, hogy szeretik magukat sokan abba a tévhitbe ringatni, hogy a felhasználók nem elég kreatívak. Pedig de, nagyon is azok.
Fú... ha ez ilyen egyszerű lenne. Volt már, hogy az egyébként megöröklött, unit tesztes, dev gépen, production környezet duplikációján jól működő kód egyszer csak elkezdett random hibákat dobálni az éles szerveren. Először senki nem értette, hogy miért, míg nem valaki egyszer csak rá nem jött, hogy egy index szétesett az adatbázisban. Unit teszt persze vígan jelezte, hogy minden jó, mert a kód valóban helyesen működött, csak az errorlog telt, mert néhány nem annyira egységtesztelhető dolog végén ott volt az ellenőrzés. Lehet mondani, hogy az ellen nem véd, de attól még oda jutok, ahova eddig: a kézi tesztelést nem helyettesíti az Unit testing, sem a TTD.
(Egyébként véleményem szerint egyszerűbb, gyorsabb és hatékonyabb funkcionálisan végigtesztelni - akár valamilyen automatizált módon - a lehető legtöbb teszt esetet, ha a kódban megfelelően ott vannak az ellenőrzések, mint külön egységteszteket írkálni mindenre. Bár, valamilyen szinten ezt is lehet TDD-nek nevezni.)
Csak azt teszteli, amit előre
Van olyan, hogy failure driven development: amikor találsz egy hibát, akkor írsz rá egy tesztet, hogy legalább ugyanebbe a hibába ne fuss bele többször. Tökéletes védelmet nem nyújthat, és nem is lehet célja ez az egységtesztelésnek. Ez is csak tesztelés, a tesztelés pedig eredendően úgy működik, hogy végiggondolunk forgatókönyveket, és kipróbáljuk.
Az egységtesztekben az a jó, hogy autmatizálva történnek és így könnyen ismételhetők.
Az egységtesztekben az a rossz, hogy ezt nem mondják el róla.
Nem mondom, hogy szükséges
Komolyan mondod, hogy jobb
Nem. Mert nincs ennyi globális objektumom. Van kb. 6-7 globális objektumom, aztán ennyi, nem szaporodnak. Persze, azt is át lehetne adni egy hasonló factory jellegű dolgon, csak minek? Azok fix építőkövei a rendszeremnek (ld. linux kernel is csomag vs bsd alaprendszer hozzáállás), az esetek 95%-ában teljesen jók arra, amire kitaláltam. A maradék 5% meg van annyira elvadult igény, hogy megérje vele pluszba foglalkoznom.
És, hogy ez a néhány globális objektumom miért szimpla mezei egyszerű globális változó? Mert - mint ahogy a neve is mondja - globális objektumom. Az alaprendszer része, ez van, ezt kell szeretni. (Mielőtt azzal jön valaki, hogy de majd egyszer véletlen felülcsapja, elárulnám, hogy 7 év alatt egyszer nem futottunk bele olyanba, hogy egy globális változót felülcsapjon valaki. Azzal, hogy a jól kitalált ősosztályokba önkényesen elkezdjen valaki ostobaságokat beleírni... Nah, azzal már több példa is volt.)
Teljesen jól működő megoldás és koncepció 2004 eleje óta, gyakorlatilag amióta PHP-zek.
És ha már KLOC. Legutóbbi projektem (kb. 1 évig fejlesztett ügyviteli rendszer) beemelt kódok nélkül kb. 270-280kloc kódsor. Beemelt kódokkal (ennek jó része a PHP Excel) kb. 550. Maga a keretrendszer egy elenyésző része és valahogy mégse jött olyan igény, hogy össze-vissza kelljen cserélgetni a dolgokat.
Ugyanezen a keretrendszeren most párhuzamosan két másik rendszert fejlesztünk. (Egy internetes és egy intranetes portálszerű rendszert).
ROI
Azt lehet vitatni, hogy egy-egy kisebb projektnél hasznos-e valóban, vagy minden haszna mellett többe kerül a tesztek megírása, mint amit nyerünk vele.
A tesztek megírása időbe kerül, ugyanakkor, ha nem írjuk meg a teszteket, akkor is kénytelenek vagyunk tesztelni, ami szintén idő. Az automatizált tesztek a tesztelést alaposabbá teheti, és mivel automatizált, mindig ugyanabban a minőségben történik, ellentétben a fejlesztői/felhasználói funkcionális tesztekkel.
Ilyenkor a kérdés az, hogy vajon tesztek megírásával csökken-e az egyéb tesztelés ideje legalább annyival, mint amennyi időt erre rászánunk. Ha nem, akkor egy-egy kisebb projektnél jogos lehet az a megállapítás, hogy nincs szükség unit-tesztekre. Szükség nincs, de hasznos.
Az a baj ezzel a
Of corpse...
Remélem, nem az jött le, hogy a tesztek ellen beszélek, mert jobb szeretek tesztekkel dolgozni. Csupán arra próbáltam rámutatni, hogy lehetnek olyan helyzetek, amikor az ember a rövidtávú előnyökért beáldozza a teszteket, még akkor is, amikor tudja, hogy ezzel nem úszta meg, és később pótolnia kell.
Ilyen helyzetet idézhet elő a rövidtávú vagy rövidlátó üzleti érdek.