ugrás a tartalomhoz

Vitaindító: vissza az alapokhoz!

saxus · 2011. Már. 24. (Cs), 23.58
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.
 
1

Érvek a másik oldalról

vbence · 2011. Már. 25. (P), 00.52
Első munkáim között futottam bele, hogy hasonló (szótártábláknál nem sokkal bonyolultabb) egyedekhez kellett admin felületet írni. Az első elkésztése után a következőt nem volt kedvem újra nulláról megírni, szóval jött a copy-paste. Ez működdött is az adott projekten belül, de a következő munkánál megint sok hasolnó feladat merült fel. Innentől egyértelmű volt, hogy a PHPben is az üdvözítő út az OOP, amihez már megvannak a járt utak, a fejlesztési minták.

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 :)
2

Válaszok az érvekre

saxus · 2011. Már. 25. (P), 03.29
Félreértesz: én egyáltalán nem az OOP és a tervezési minták ellen vagyok, (és aki ismer, az mondhatná: sőt!) Csupán a dependency injection kapcsán kezdem azt érezni, hogy kissé átesünk a ló túloldalára néha. (Hasonló "kedvencem" még az MVVM, XAML, ActiveRecord és társai)

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.


vs.

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".


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.

Ezeket a dolgokat nem is biztonságos minden alkalommal újraírni vagy összeollózni


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.

Vagyis bármennyire is csábító hogy munkát spóroljunk meg egy kevésbé integrált megoldással
,

É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.)

és ki tudja, heteken belül kiderülhet, hogy nem is veréb, hanem Godzilla :)


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.
43

Erre szoktam azt mondani

Ifju · 2011. Már. 28. (H), 12.03
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)

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.

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.

Erre biztos a PHP-nak kellene megoldást nyújtania?
3

architekturális felhőkarcoló :)

_subi_ · 2011. Már. 25. (P), 09.58
Az "architekturális felhőkarcoló" nagyon jó, mondhatni 10 pontos megfogalmazás. Az OOP, MVC, és egy lightweight keretrendszer még az a rész, ami előre visz. De amikor valaki kártyavárat épít az objektumokból, aminek a stabilitása, és módosíthatósága is pont olyan, az már határozottan hátráltat.

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. :)
4

http://www.gartner.com/techno

Tyrael · 2011. Már. 25. (P), 12.03
http://www.gartner.com/technology/research/methodologies/hype-cycle.jsp
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
The problem is that we developers have become a market, and like all markets, people are trying to sell us stuff. These people do not have our customers in mind -- for them we are the customer. Instead they have us in mind.


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
5

+1 for Tyrael Mindemellett a

gphilip · 2011. Már. 25. (P), 14.40
+1 for Tyrael

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.
6

innentol kezdve a kodminoseg

Tyrael · 2011. Már. 25. (P), 15.05
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.


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:
It has nothing to do with code. It has to do with finding and meeting customer needs at scale. In fact, the odds are 20-1 that your entire effort is worthless no matter what or how much you code, so don't write code to be maintained. Don't write code to be pretty. Write code to get it done as quickly as possible so you can move on to the real game: customers.


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
7

Off

Max Logan · 2011. Már. 25. (P), 15.25
Egyszerűen nem értem és szörnyülködöm, amikor valaki azért kér bocsánatot, hogy értelmesen, kellő hosszúságú mondatokban, akár több bekezdésben kifejtette a véleményét. Kár, hogy ez a jelenség most már egy szakmai fórumon is felüti a fejét.

Nem értem, komolyan nem értem ...
8

egyreszt egy igazan jo eloado

Tyrael · 2011. Már. 25. (P), 15.40
egyreszt egy igazan jo eloado sokkal kevesebb sorban ossze tudta volna foglalni amit en itt leirtam, masreszt manapsag mar az a hozzaallas, hogy amit nem lehet egyszeruen osszefoglalni, azt nem is erdemes tudni.


ps: '89-es a strip. :P

Tyrael
9

Rohanó világ

Max Logan · 2011. Már. 25. (P), 16.30
Gondoltam volna írni több gondolatot, de aztán mégsem.

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.
10

remelem azert erezted az

Tyrael · 2011. Már. 25. (P), 16.44
remelem azert erezted az ironiat a szavaimban, illetve a kepregenyben. :)

Tyrael
11

Természetesen

Max Logan · 2011. Már. 25. (P), 17.16
Igen, de ettől függetlenül nagy igazság van abban, amit írtam ...
12

megfontolod, hogy mi

Hidvégi Gábor · 2011. Már. 25. (P), 19.01
megfontolod, hogy mi fejlődhet a projektből a jövőben és ennek megfelelően döntesz


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.
13

Ezért kell egy oldalakra

Joó Ádám · 2011. Már. 25. (P), 21.42
Ezért kell egy oldalakra lebontott specifikációt fixálni. A módosításokat külön kifizettetni, nyilván az újratervezés költségvonzatával.
14

Megrendelo vs rendszerszemlelet

saxus · 2011. Már. 25. (P), 21.57
A válasz: dehát ezek a dolgok magától értetődőek.


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.

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.


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.
15

Legjobb megfogalmazas

saxus · 2011. Már. 25. (P), 22.11
Azt hiszem, ez eddig a legjobb megfogalmazas/osszefoglalasa annak, amit mondani akartam. Foleg az elso linked.

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.
16

Manapság sehol sem szokták

Hidvégi Gábor · 2011. Már. 25. (P), 22.19
Manapság sehol sem szokták említeni vitákban a hátrányokat (nem csak technológiaiakban), nyilvánvaló okokból. Az ókori Görögországban azokat nem is vették komolyan, és ki is zárták a vitából, akik egyoldalúan érveltek.
18

Hiba

saxus · 2011. Már. 26. (Szo), 01.55
Sajnos.
17

Egy pelda

saxus · 2011. Már. 26. (Szo), 01.43
Azt hiszem, ez a link, amit elobb lattam itt a twitteres dobozban, kulonosen jol szemlelteti a helyzetet:

http://propel.posterous.com/the-end-of-autoloading
19

gáz

pcjuzer · 2011. Már. 26. (Szo), 09.31
Nos ha ezek a szavak buzzword-ök neked,
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.
20

Szerintex Saxus erről akart

Hidvégi Gábor · 2011. Már. 26. (Szo), 09.44
Szerintex Saxus erről akart vitatkozni?
21

buzzword

pcjuzer · 2011. Már. 26. (Szo), 11.12
Nem pont erről akart, de mivel ilyen mondattal indított, nem tudtam elmenni fölötte szó nélkül.

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.
23

Jogos

saxus · 2011. Már. 26. (Szo), 13.15
Jogos, nem pontos megfogalmazas. Olyasmit akartam kifejezni, hogy - leginkabb az ujabb technologiaknal - ezek a szavak inkabb buzzwordkent jonnek elo, mintsem hasznalatuk vagy mellozesuk egy megalapozott dontes eredmenyekent.
26

Egy szakkifejezés szerinted

Joó Ádám · 2011. Már. 26. (Szo), 17.36
Egy szakkifejezés szerinted nem lehet buzzword?
22

Szerintem nem a fogalmakkal

virág · 2011. Már. 26. (Szo), 12.46
Szerintem nem a fogalmakkal van gond, hanem azokkal akik nem tudják a helyükön kezelni ezeket, épp ma olvastam a Kanban és Scrum című írást (mindenkinek ajánlom)

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.
24

wtf tdd?

inf · 2011. Már. 26. (Szo), 14.03
Nem értem mi a problémád a unit test-tel meg a tdd-vel?
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.
25

TTD != nem teszteljuk, amit csinalunk

saxus · 2011. Már. 26. (Szo), 16.34
és ilyen szemlélet nélkül kizárt, hogy teszteltem volna, mert annyira egyszerű volt.


A TTD -szvsz- nem mentesit a teszteles alol. TTD ide vagy oda, en le szoktam tesztelni kezzel, hogy az, amit leirok, jo-e.

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


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.
28

(megjegyzem, ezek is

Crystal · 2011. Már. 26. (Szo), 18.19
(megjegyzem, ezek is tipikusan olyan hibak voltak, amik 95%-ban elo nem jottek volna mas nyelveken, pl. C# vagy Java, mert le se fordul)


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.
30

ööö

vbence · 2011. Már. 27. (V), 12.15
Szerintem nem azért van IDE. Sőt az IDE nem az eszköz része. - Ez egyszerűen a szkriptnyelvek gyengepontja (és a szkriptnyelvet használók "megérdemelt büntetése").
27

hát mondjuk ennek

Crystal · 2011. Már. 26. (Szo), 18.16
hát mondjuk ennek megítéléséhez le kéne mérni hogy egy hasonló tudású fejlesztő mennyi idő alatt fejlesztette volna le a projektet TDD nélkül. 2000 soros projektnél nekem egy kicsit túlzásnak tűnik, a funkcionális tesztelés sztem elég.
29

Biztos hogy TDD?

vbence · 2011. Már. 27. (V), 12.11
Nem keverjük a TDD-t (ahol előbb készül el a teszt aztán a kód), a unit teszteléssel (ami szimplán csak automatizált teszkód írása)?
32

Én nem keverem :-)

inf · 2011. Már. 27. (V), 14.22
É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.
33

Tervezes elodazasa refactoringgal

saxus · 2011. Már. 27. (V), 20.11
ezért menet közben szoktam refaktorálni, meg ide-oda tologatni dolgokat, ahhoz meg kellenek a tesztek


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.
35

Én sem, ez is olyan, hogy ki

inf · 2011. Már. 27. (V), 22.29
Én sem, ez is olyan, hogy ki kéne próbálni mindkét módszerrel. Azt hiszem neked van igazad azzal, hogy rendesen megtervezed az egészet, és nem csak a réteg felületére fordítasz időt.

(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.)
36

...

prom3theus · 2011. Már. 27. (V), 22.48
Szerintem az, hogy valaki nem használ TDD-t vagy UnitTest-et, nem jelenti azt, hogy nem teszteli a kódját mélyrehatóan. Főképp a UnitTest megoldásokkal vagyok úgy, hogy az esetek nagy részében (mivel csak olvastam róla, de az alkalmazásáról letettem, pontosabb a "mindenkor" szó) kiváltom var_dump (vagy debugger) és kellő odafigyelés, előre gondolkodás kombinációval.

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.
38

A unit test-nek az a lényege,

inf · 2011. Már. 27. (V), 23.25
A unit test-nek az a lényege, hogy egyszer írod meg, és utána akárhányszor használhatod, a teszt elvégzi az összehasonlítást helyetted.

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.
39

...

prom3theus · 2011. Már. 28. (H), 00.01
Vannak tipikusan var_dump()-pal jól ellenőrizhető és kevésbé jól ellenőrizhető dolgok. Az ezzel nem jól ellenőrizhetőkre debuggert használok. Ehhez hozzá tartozik, hogy amit egyszer megírok, azon csak igen ritkán változtatok, mert általában van annyira átgondolt, hogy a módosításra ne legyen szükség. Egyébként a var_dump() persze remekül kiváltható FirePHP-vel is a fejlesztés azonos szakaszában (többet, jobban, pontosabban lehet kideríteni vele, mint a var_dump()-pal). Amikor készítek vagy elkészülök egy új osztállyal, testcase-t írok rá ha szükségesnek ítélem - de vannak olyan egyszerű osztályaim is, mint a faék, ezeknél értelmét nem látom.

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.
69

Ne keverjük a debugging-ot a

gphilip · 2011. Már. 30. (Sze), 18.15
Ne keverjük a debugging-ot a regression testinggel :) előbbi aktív tevékenység, utóbbi passzív
60

"aztán ha okés"

saxus · 2011. Már. 29. (K), 23.07
Igazából normális kódban - szerintem - ott az ellenőrzés, hogy valóban jó eredmény jött-e ki és ha valami hülyeség jön ki, akkor visítunk (hibaüzenet + naplózás).
31

reszben ide

Tyrael · 2011. Már. 27. (V), 13.56
reszben ide kapcsolodik:
http://www.eschrade.com/page/concerning-newness (ne add fel az elso 2 bekezdesnel az olvasast)

Tyrael
34

COBRA

hornos · 2011. Már. 27. (V), 22.19
remélem még idén ki tudom maxolni:
- 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
37

Szép munkának tűnik első

prom3theus · 2011. Már. 27. (V), 23.02
Szép munkának tűnik első ránézésre, a phpDoc kommenteket viszont hiányolom belőle (meg általában a kommenteket). Sok sikert hozzá!
47

lesz minden, de doxygen a

hornos · 2011. Már. 28. (H), 18.43
lesz minden, de doxygen a fortran miatt
40

Architecture astronauts

janoszen · 2011. Már. 28. (H), 08.20
Az hiszem, Joel Spolskynak volt egy blogbejegyzése az "architecture astronaut"-okról. (Persze mobilon vagyok és nem tudom belinkelni.) Nagyon valós tendencia az, hogy nem szeretünk dolgozni és ezért minél absztraktabban csinálunk mindent, hogy legközelebb ne legyen ez meló. Ha ezt nem tartjuk vigyázó szemeink előtt, könnyen elszaladhat a ló, ami egyrészt komplexitás-problémákat, de pl. PHP esetén sebesség-problémákat is hozhat, hiszen code cache ide vagy oda, azt a struktúrát le kell futtatni. Az már csak egy apró bosszúság, hogy az ilyen automágikus dolgoknál sokszor nem működik a kódkiegészítés.

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.
41

http://joelonsoftware.com/art

Joó Ádám · 2011. Már. 28. (H), 10.07
http://joelonsoftware.com/articles/fog0000000018.html

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.
42

Mi is a baj a DI-vel? Láttad

Protezis · 2011. Már. 28. (H), 10.22
Mi is a baj a DI-vel? Láttad mondjuk a Symfony DI containerét? Itt egy példa, amit én követtem el. Komolyan mondod, hogy jobb megoldás az, ha mindezeket az objektumokat globális változókban tárolom?

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.
44

ellenpélda

_subi_ · 2011. Már. 28. (H), 13.13
Van egy projektben, ahol kb. 30.000 sor a backend, és tökéletesen meg voltam / vagyok Unit Test nélkül. Eddig még nem jött elő komolyabb hiba, de kisebb hibából sem volt olyan, amit a Unit Test megfogott volna. Inkább olyan kisebb problémák voltak, amiket kézi teszteléssel lehetett kiszűrni.

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. :)
46

Lényegében ugyanezt írtam

prom3theus · 2011. Már. 28. (H), 17.03
Lényegében ugyanezt írtam fentebb. Annyit fűznék hozzá még: nem a sorok száma, hanem a szervezettsége (karbantarthatóság, komplikáltság foka) és a dokumentáltsága dominál egy rendszernek. Általában. Egy kritikus tömeg (sorok, osztályok száma) elérése után pedig már mindenhogy átláthatatlan lesz egy rendszer ha azon csak egy ember dolgozik - ennek az elérését kell igyekezni elkerülni.
45

Tervezés

_subi_ · 2011. Már. 28. (H), 13.16
Szerintem megéri némi plusz időt a tervezésre fordítani. Ebben jobban bízom, mint egy "minden hibát megfogó tesztben". Szerintem jobb, ha nincs is hiba.
48

Nem tudsz mindent előre

Protezis · 2011. Már. 28. (H), 19.22
Nem tudsz mindent előre megtervezni. Nem olyanok a megrendelők, hogy ezt meg lehessen tenni. Hibázni pedig mindenki hibázik. Azt is tudjuk, hogy nincs minden hibát megfogó teszt. Tervezni és tesztelni egyaránt kell. És szerintem elég gáz, hogy az automatikus tesztelés létjogosultságát egy ilyen szakmainak mondott fórumon 2011-ben egyesek megkérdőjelezik.
49

hit vagy tapasztalat?

_subi_ · 2011. Már. 28. (H), 20.36
Mivel a saját projektemen dolgozom, szinte mindent meg tudok tervezni előre. Nyilván nem mindent, de ahol változtatni kell, ott is van lehetőségem az általam legjobbnak tartott úton végrehajtani azt. Eddig még nem volt komoly probléma, ha lett volna egészen biztosan keresnék olyan eszközöket, amik segítenek minimalizálni a hibalehetőségeket. Butaság lenne nem így tenni. El tudom képzelni, hogy a jövőben Unit Tesztet használjak, de most nem indokolja semmi.

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.
50

+1

inf · 2011. Már. 28. (H), 20.38
+1
51

Nem tudsz mindent előre

gphilip · 2011. Már. 29. (K), 07.25
Nem tudsz mindent előre megtervezni.

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

El tudom képzelni, hogy a jövőben Unit Tesztet használjak, de most nem indokolja semmi.

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.
52

Ezt gondolom nem nekem

Protezis · 2011. Már. 29. (K), 08.59
Ezt gondolom nem nekem szántad :)
53

Mikortól komoly egy projekt?

_subi_ · 2011. Már. 29. (K), 09.46
Mikortól komoly egy projekt? 30.000 sor backend ezek szerint még nem az…

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ő. :)
54

Ha lennének tesztjeid, akkor

Protezis · 2011. Már. 29. (K), 09.55
Ha lennének tesztjeid, akkor gyorsabban megtalálnád a hibákat (olyanokat is, amelyekről még nem is tudsz, de hidd el, vannak), valamint ha refaktorálni kell, akkor tesztek nélkül megőszülsz. Márpedig refaktorálni sokszor kell és te is élsz vele, még ha nem is tudod, hogy így hívják.

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.
55

Újabb feltételezések? :)

_subi_ · 2011. Már. 29. (K), 10.24
Nem tudom miért feltételezed, hogy nem refaktorálok, vagy nem tudom mi az... Azt viszont látom, hogy a feltételezés az a pálya, ahol igazán elemedben érzed magad, ezen a területen tudsz igazán villogni.

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:
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. :)
56

Grat, sikerült a beszélgetést

gphilip · 2011. Már. 29. (K), 12.00
Grat, sikerült a beszélgetést magas színvonalra emelned :)

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)
58

Fincsi lehet, amikor

inf · 2011. Már. 29. (K), 14.57
Fincsi lehet, amikor egységtesztelés nélkül refaktorálsz, gondolom amikor bejön egy hiba, akkor napokig keresed var_dump-pal, hogy mi lehet a gond....
59

nem csak var_dump-pal tesztelek

_subi_ · 2011. Már. 29. (K), 15.48
Eddig még nem volt olyan hiba, ami 20 percnél többet vitt volna el. Erre írtam, hogy ahogy szükségét érzem ráállok a Unit Tesztelésre. Egyébként nyilván tesztelek, és nyilván nem csak var_dump-al, hanem van egy teszt controller-em erre a célra, és nem vagyok rest megnézni azt sem, hogy az elméletileg jól működő kód nem viselkedik-e furcsán a valós használat során. Soha nem küldök semmilyen kódot élesbe, mielőtt megvizsgálnám, hogy miként viselkedik.

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.
63

Regressziós hibára semmit nem

Protezis · 2011. Már. 30. (Sze), 01.01
Regressziós hibára semmit nem írtál. Írtál arról, hogy javítod a hibákat, de hogy hogyan találod meg őket, arról nem. Erről írnál pár gondolatot?
66

Körültekintéssel, odafigyeléssel :)

_subi_ · 2011. Már. 30. (Sze), 08.56
Körültekintéssel és odafigyeléssel kerülöm el a regressziós hibákat, elég jól átlátom, hogy mi, mire van hatással. Talán azért mert 100%-ban a saját kódom.

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.
67

+1, de

saxus · 2011. Már. 30. (Sze), 10.21
Hatalmas plusz egy, de azért tennék egy megjegyzést:

Talán azért mert 100%-ban a saját kódom.


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.
61

Tesztek nélkül hogy találod meg a regressziós hibákat?

saxus · 2011. Már. 29. (K), 23.24

public function something()
{
  // ... mindenféle kód

  // Legutóbb ezzel probléma volt, mert xyz, gondoltam berakok egy ellenőrzést, hogyha megint előjönne, akkor tudjunk róla.
  if ($result < 0 || $result > 1) 
  {
    systemlog(ERROR, __CLASS__, "A result már megint nem 0..1 között van a Foobar helyen. result=.$result);

    throw new Exception("Tralala...");
  }
  
  return $result;
}
Az a problémám az Unit testekkel, hogy sajnos nem csodafegyver. Csak azt teszteli, amit előre betanítanak neki. Na most, a probléma ott jön, hogy mi van, ha nekünk az éles rendszerben jön elő hiba... Sajnos a tapasztalat azt mutatja, hogy unit teszt ide vagy oda, inkább az utóbbiakból van a probléma. Főleg, ha nincs semmi információnk csak az "az oldal nem megy" klasszikus.

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.
64

A hibakezelést is le lehet

Protezis · 2011. Már. 30. (Sze), 01.11
A hibakezelést is le lehet tesztelni unit tesztel. Igen, valóban nem csodafegyver, nincs ingyen ebéd. Egyébként érj el 100%-os code coveraget és akkor nagy meglepetés már nem érhet.

É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.
65

És nem értem mi a gond az

saxus · 2011. Már. 30. (Sze), 02.03
És nem értem mi a gond az éles környezettel.


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.

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.


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.)
68

Csak azt teszteli, amit előre

Joó Ádám · 2011. Már. 30. (Sze), 12.45
Csak azt teszteli, amit előre betanítanak neki.


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.
57

Nem mondom, hogy szükséges

inf · 2011. Már. 29. (K), 14.55
Nem mondom, hogy szükséges nálad, én kis projekteknél inkább gyakorlásnak használom azért, hogy hozzászokjak.
62

Komolyan mondod, hogy jobb

saxus · 2011. Már. 29. (K), 23.46
Komolyan mondod, hogy jobb megoldás az, ha mindezeket az objektumokat globális változókban tárolom?


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).
70

ROI

Ifju · 2011. Már. 31. (Cs), 11.26
Remélem, senki nem vitatja, hogy a Unit-tesztelés hasznos!

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.
71

Az a baj ezzel a

inf · 2011. Már. 31. (Cs), 22.05
Az a baj ezzel a gondolkodásmóddal, hogy nem veszitek bele a teszteknél, hogy mondjuk fél év múlva ugyanahhoz a projekthez hozzányúltok, mert kell benne egy kis fejlesztést csinálni. A tesztek akkor is meglesznek, és ha valami elromlik, akkor mutatják.
72

Of corpse...

Ifju · 2011. Ápr. 4. (H), 15.12
Persze. :)

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.