What are the Most Disliked Programming Languages?

https://stackoverflow.blog/2017/10/31/disliked-programming-languages/

tl;dr: az éppen divatos nyelveket (és technológiákat) többen szeretik + ms sucks

Hozzászólások

Erdekes, hogy a JavaScript a kozepmezonyben vegzett, holott ertelmes ember bottal se szivesen piszkalna...

"De az, hogy a Function az egy top-level objektum, az hatalmas erőt ad ennek a nyelvnek."

A "vérmes hákolások" melegágya. Szeretem, használom, de hogy "baromira szép funkcionális kódokat lehet vele írni", azt elvből tagadom.
Az egész nyelv és a használata egy bazinagy gangbang erőszak, amire pont az utolsó mondatod ad "felhatalmazást". Az hogy a temérdek fostenger tetejére egészen szép dolgot lehet alkotni, azt ne nevezzük már a nyelv erényének

// Happy debugging, suckers
#define true (rand() > 10)

Azert PHP kodot konnyebb hozza nem ertokent felfogni. Eveknek kellett eltelnie ahhoz, hogy rajojjek: hulye voltam a Javascripthez. Nem mondom, hogy kezdem megszeretni, de eljutottam benne egy magabiztossagi szintre. mas nyelvekhez kepest meglepoen keson, mert sokan irnak pocsek JS kodot, de azert, mert nem ertik.

A kozepmezonyt realisnak tartom, az en fejembenm is ott van most, de volt mar, hogy a JS-t utaltam a legjobban.

Viszont a node-ot, az NPM-et, az Angulart, a TypeScriptet, a Reactot es a Babelt tovabbra se szeretem. Amit "megszerettem" az a JS onmaga valosagaban, leginkabb modern bongeszokben.

Meg most talaltam egy jot:

<@realitygaps> english - the php of spoken languages

Oké, a Perl adja magár write-only kód elkövetéséhez, és ezt sokan ki is használják, de nem muß olyat elkövetni, és lehet azt is szépen kommentezni... ~15 évvel ezelőtti Perl kódjaimat például nem szívesen mutogatnám pozitív példa gyanánt, de amit egy FreeIPA webes felülete elé összedobtam testreszabott frontendként, az szerintem egészen olvasható lett pár évvel ezelőtt (A miért kellett ilyet kérdést megelőzendő: bizonyos csoportokba tartozó usereket a csoport kiemelt felhasználóiank kellett tudni matatni (user felvétele, letiltása, jelszóreset), de úgy, hogy a saját csoportján/csoportjain kívüli usereket nem volt szabad látni)

Most jutottam el oda, sok év programozás után, hogy jó pénzért Perl kódot kell javítanom, meg újat írnom.

Azért egy szívlapáttal megkínálnám azt, aki ezt a nyelvet és a hülyeségeit alkotta...

Legutóbb egy olyan bonyolult dologra volt szükségem, mint: enum.
Erre CPAN 16 féle custom tákolt megoldást ad... csodálatos....

Ebből a legrosszabb talán a C++ enumja.
Mert nyelvileg van enum, de igazából semmi mást nem jelent, mint egészekre aliasokat. Míg az enum valójában mást jelent.
Egy olyan típust, amely típus értékkészletének van egy neve. És az értéke nem feltétlenül egész szám.
Lehetne akár float konstans is. Vagy objektum. Vagy String-halmaz. Vagy bármi más. A lényeg, hogy véges számú, névvel ellátott elemek alkotják az értékkészletet, nem pedig aliasok egészekre.

Saját kódot, vagy mások által írt kódot? És hány év fejlesztésének/javítgatásának/toldozgatásának az eredményét? Nagyon nem mindegy... (Egy jól tervezett és következetesen végigvitt refaktoring csodákra képes egyébként, csak ugye az sok meló, és user oldalról mondjuk úgy, igencsak ritkán látszik a haszna...)

#define rendesen hasznalni

A nyelv legnagyobb hibaja a gyengen es dinamikusan tipusos volta. Ezt nem lehet "megtanulni rendesen hasznalni", hiszen ez csak annyit jelent, hogy nem tudsz a forditora/interpreterre tamaszkodni a valtozok tipusanak ellenorzesekor, azt neked, a fejlesztonek kell megtenned minden esetben _kezzel_. Biztos van hozza 15 fele framework, meg 3 fele masik nyelv ami JS-re fordul, de azert ez leginkabb taknyolas, ami a nyelv hianyossagait probalja workaroundolni.

Nem vagyok szoftverfejlesztő/programozó, én nem érzem ezt olyan nagy "hibának". Ill. a nyelvnek vannak olyan tulajdonságai, amik ellensúlyozzák ezt. Igen, a típusrendszerét nem sikerült rendesen kidolgozni, ezt azóta is "cipeli" magával. De már az elején olyan dolgok voltak benne, amiket a legelterjedtebb nyelvek, most/nemrég vettek át.

Ez különösen ennek fényében volt vicces: "Sok ember csak úgy beböffenti, hogy "szaraJS", ezeknek 99%-a nem venné a fáradtságot, hogy megtanulja rendesen használni."
De akár javíthatom így is:
"Sok ember csak úgy beböffenti, hogy "ajsakirály", ezeknek 99%-a nem venné a fáradtságot, hogy megtanulja rendesen használni mert akkor lecsúsznának az aktuális trendről."

// Happy debugging, suckers
#define true (rand() > 10)

+1

Ezt a panaszt sosem értettem.

C-ben, C++-ban is úgy írtam programot (amikor még ilyesmivel foglalkoztam), hogy rendesen meg volt az behúzás.

Pythonban gyakorlatilag semmi mást nem kell csinálni, csak ugyanúgy írja az ember a dolgokat, mint amikor normálisan programozik, csak épp nem kell kitenni kapcsos zárójeleket, és mégis működik.

Nem arról van szó, hogy a python miatt valami olyasmit kell megtanulni, amit eddig még nem kellett. Nem arról van szó, hogy a python program valami logikátlan, semmihez nem hasonló módon használja a behúzást.

Apró, de lényeges különbség, hogy egy "rendes" nyelvet összekeverik a whitespace nevű förmedvénnyel :-P Az, hogy idiótabiztosra akarják csinálni, meg hogy "mindenki egyformán szép kódot írjon" az nagyjából a balf@szok ellen véd - kivéve, ha az a balf@sz keveri a tabot a space-t, aztán valaki másnak is hozzá kell nyúlnia.
A behúzást a kód részévé tenni baromság szerintem, nem véletlen, hogy nagyjából két nyelv van, ahol ez megtörtént - Oké, a Fortran esetén meg az első hat pozíciónak van speckó jelentése (illetve a 73-80 posícióknak...), de az megint más :-P

Ez a te véleményed. A többség meg épp e miatt (is) szereti.
Egyébként meg a Python3-ban már nincs "kivéve".
https://docs.python.org/3/reference/lexical_analysis.html#indentation
"Indentation is rejected as inconsistent if a source file mixes tabs and spaces in a way that makes the meaning dependent on the worth of a tab in spaces; a TabError is raised in that case."
--
♙♘♗♖♕♔

Ez vitatott téma a Python közösségen belül is, hiszen most háromféle módon lehet ugyanazt csinálni (

%, format, f-string

). Azonban nekem mégis az

f-string

a kedvenc újításom a 3.6-os Pythonból, tömörebbé/olvashatóbbá teszi a kódot, és szerintem könnyebb egy kezdőnek is megtanulnia, mint a többit.

A space vs. tab témakör túlmutat a Pythonon, itt az ajánlás 4 space. Nekem ebből még sosem volt gondom. Ha csapatban dolgozik az ember, ez is egy ugyanolyan elem az

.editorconfig

fájlban, mint a többi és tartja magát hozzá a csoport mindegyik tagja.

Aki még tényleg tanult programozást, az akkor is tud szépen formázott kódot írni, ha nem kötelező. Anno azon ment a verseny, hogy például mennyit módosít (bájtban) a "kész" kódon az egységes formázást elvégző tool. Egy idő után egy néhány bájt/kB eredmény nem volt elég a győzelemhez...
Meg ugye ezzel a whitespace a kód szerves része dologgal annyi az "egysoros" gyors scripteknek, ami azért jól jön néhanapján.

"ez csak annyit jelent, hogy nem tudsz a forditora/interpreterre tamaszkodni a valtozok tipusanak ellenorzesekor, azt neked, a fejlesztonek kell megtenned minden esetben _kezzel_"

Egyetértek. De senki nem mondja, hogy nem használhatsz legalább compile time típusokat, ott a Typescript, ott a Flow, számomra (és az IDE-m számára) nagy segítség.

Mondjuk úgy, hogy nem arra lett kitalálva, amire most használjuk. Egyébként máig nem értem miért nem vált még a nyelv részévé a típusok, interfészek deklarálhatósága úgy, mint ahogy pl a flow-ban lehetőség van rá. Még csak nem is kéne futásidőben figyelembe vennie a böngészőnek, elég (első körben) ha a szintaxis részeként a programozó munkáját tudja segíteni általa egy IDE anélkül, hogy emiatt kelljen compile.

A common misconception is that number literals cannot be used as objects. That is because a flaw in JavaScript's parser tries to parse the dot notation on a number as a floating point literal.

There are a couple of workarounds that can be used to make number literals act as objects too.

Eddig olvastam, koszonom szepen.

Ezek nem annyira workaroundok, csak kikényszerítik, hogy a szám be legyen boxolva egy Number objectbe, aminek már van toString-je. Úgy is lehetne írni, hogy

new Number(2).toString()

vagy épp

Object(2).toString()

. Az remélem Java után nem akkora bűn, hogy a nem boxolt Numbernek nincsenek metódusai. :)

Ja, a lényeg lemaradt: ha egy referenciád van egy számra akkor viszont már természetesen úgy működik a boxolás, ahogy az egyszeri programozó elvárja:


var x = 2;
x.toString(); // '2'

"Sok ember csak úgy beböffenti, hogy "szaraJS""

"Nem vagyok szoftverfejlesztő/programozó"

Ok, teljesen meggyőztél. Szóval teljesen jó az, hogy ha várok egy taxit, helyette egy lovat kapok, ami ráadásul meleg és seggbe akar rakni. Na ilyen a dinamikus, gyenge tipusrendszer. Sosem lehetsz benne biztos, hogy mit kapsz.

----------------
Lvl86 Troll, "hobbifejlesztő" - Think Wishfully™

Azert a javascript fejlodik, es valami elkepeszto gyorsasaggal.
ES5, ES6, most pedig az ES7 (es.next). Mind-mind olyan dolgokat hoznak be,
amitol csak pislog az ember (arrow function, class getter setter, spread operator, observable, decorator).

Hirtelen mondj egy olyan programozasi nyelvet, amihez olyan utility van, hogy
netrol bongeszel egy neked tetszo library-t (npmjs.com), hasznalod,
majd tree-shakinggel csak azt
a par fuggvenyhivast tartod meg, amit tenylegesen hasznalsz?

Szerintem ,akkor nott fel igazan a nagyokhoz,
amikor az import/require dolog vegre osszeforr,
es nem kell ilyen glue kodokat irni a backend es frontend kodok koze (hogy barhol hasznalhato legyen).
Remelem, ezt egy even belul megoldjak (async require:).

Es tonnanyi debug cucc van hozza. De tenyleg.

Szerintem ez igazan elegans kod:

const {
isFetching,
lastUpdated,
items: posts
} = postsByDate[selectedUser] || {
isFetching: true,
items: []
}

Vajon mas programozasi nyelvben milyen bonyolult egy ilyet osszerakni?
ES5-ben hany sor lenne?:)

Szerintem a nyelvvel semmi baj sincs.
Az mas kerdes, hogy a vilag afele megy,
hogy minden oldalba benyomnak egy tonnanyi dolgot, es egy hiroldal 6-7MB-os lesz,
egy egyszeru login oldal meg 12MB(!)-os...
De ez nem a nyelv hibaja.

Lehet blogolnom kellene javascriptrol, de szerintem ez nem az a kozonseg.
Meghat egyszerubb csinalni, mint beszelni rola.

---
Saying a programming language is good because it works on all platforms is like saying anal sex is good because it works on all genders....

Ne érts félre, szeretem a javascriptet, de azért azt nem mondanám, hogy "Szerintem a nyelvvel semmi baj sincs.". Mert legyünk őszinték van. Főként sok legacy marhaság miatt, amit nem lehet kizárni a nyelvből, nem lehet visszafele inkompatibilis változtatást csinálni, mert eltörnek 10+ éve készült weboldalak.

Na ez nem igaz.
Megadhatod a module attribútumot a script tagnek HTML5 esetén, ekkor ES6 module-ként értelmezi az src URL alatt elérhető tartalmat.
Nyugodtan dönthettek volna úgy, hogy ES6-tal a legacy dolgok nem támogatottak.
Ettől még a régi kód, ami nem ES6 module-ban van, támogathatja a legacy API-kat, nem törik el semmi.
Csak épp jelezni kell az ES runtime-nak a megfelelő verziót, ami szerint értelmenzie kell a kódot.

"Megadhatod a module attribútumot a script tagnek HTML5 esetén, ekkor ES6 module-ként értelmezi az src URL alatt elérhető tartalmat."

Ez igaz. De
1) Ez egy workaround, nem megfelelő veziózás
2) Ennek hatására sem igazán változott szinte semmi. Nem változott dolgok működése, legalábbis nem komolyan, bekerült némi új szintaxis, nem kell use strict-et használni, és kábé ennyi.

Persze, lehetne, de nincs. És erről beszélek. Sok nyűgje van a JS-nek, ami azért létezik, mert szemben más nyelvekkel nem tudnak/akarnak drasztikus változást eszközölni a nyelven, a beépített objektumokon/metódusokon, stb. Pedig kellene.

Lásd pl: 'X'.length === 2 (képzelj az X helyére egy kaki emojit)

https://mathiasbynens.be/notes/javascript-unicode

Ezt "megoldották" új string metódusokkal, a régieket meg használt óvatosan. Csak úgy, mint a for...in loopot, vagy a var kulcsszót. Ezek ott maradnak, mert ott kell maradni, de ne használd. Nincs itt semmi verziózás.

"Melyik nyelvekre gondolsz?"

Kellene akármelyikre is gondolnom? A JS-ről beszélünk, nem más nyelvről. Vagy úgy gondolod, hogy JS háza táján nem történhet meg semmi, ha más nyelven nem volt rá precedens?

Ráadásul volt. Gee is említette a Pythont, aminek a 3-as verziója közt nagy változások voltak, én a PHP 7-es verzióját említhetném, ahol volt bőven breaking change a korábbi verzióhoz képest.

Az pedig, hogy ezek mennyire drasztikusak, egyrészt, nem mondtam, hogy annak kell lennie. Csak azt, hogy a JS felhasználási módja miatt a breaking változtatások egyáltalán nem lehetségesek úgy, ahogy most mennek a dolgok, pedig nem volna rossz, ha ki lenne gyomlálva a nyelv.

Na, azért ne essünk már annyira hanyat a JS-től.

"arrow function" - Lambda meglehetősen sok nyelvben van, ráadásul JS-nél kifejezetten kurva idegesítő, hogy ameddig nem ássa magát bele az ember a legmélyéig, sosem lehet biztos abban, hogy mi marad meg a kontextusból, ha az arrow functiont használja és ha a hagyományost. De példának okáért Lambda volt már a .NET 3-ban is, delegált meg még korábban. (De ha nagyon megerőltetem magam, "delegált" még C-ben is van.)

"class getter setter" - MUHAHAHAHA. Ez nem, hogy a C#-ban nem volt újdonság, de már szerintem az Object Pascalban sem.

"observable" - Itt most nekem nem teljesen egyértelmű, hogy mire gondolsz. A ReactJS-es Observablera? Vagy lemaradtam valamiről és az observable design patternhez csináltak valamit JS-ben? (Egyébként van, ahol az is nyelvi elem, ld. C#-ban event, vagy hasonló még pl. a Qt-s signaling)

"Hirtelen mondj egy olyan programozasi nyelvet, [...] csak azt a par fuggvenyhivast tartod meg, amit tenylegesen hasznalsz?"

Ok, nem egészen ugyanaz, mivel más a két nyelv és a futtatás módja, de már a Turbo Pascal is csak azt rakta a be a végső binárisba, amit ténylegesen is használtál.

Szóval ezektől azért még nem vágom hanyat magam.

----------------
Lvl86 Troll, "hobbifejlesztő" - Think Wishfully™

Valamit felreertesz. En nem azt akartam, mondani, hogy a JS jobb, mint a tobbi.
Hanem azt, hogy nem rosszabb, mint barmelyik masik: fel van nove a feladathoz.

> "observable" - Itt most nekem nem teljesen egyértelmű, hogy mire gondolsz.

https://github.com/tc39/proposal-unified-class-features#decorators

---
Saying a programming language is good because it works on all platforms is like saying anal sex is good because it works on all genders....

Ja, par soros scriptelni nem rossz, de barmi ertelmes munkara szornyu.

A PHP a 7-essel legalabb elindult mar a megfelelo iranyba, mostmar csak a JS szarakodik a tipus nelkuliseggel. Nem gond, majd rajonnek a fejlesztok, hogy palira vettek oket, de addigra sajnos mar tul sok szart kell majd arrebb lapatolni.

Tudjuk, hogy te a flash-t szeretted, én meg attól futottam a világ végére (különösen az AS2-től).

Mindazonáltal megértem azokat az embereket, akik kényszerből használnak JS-t és utálják. Volt a webfejlesztésnek egy nyelvi aranykora, amikor bármiben lehetett szoftvert írni, mert HTML-t tulképp minden ki tudott köpni, nos, ennek vége.

Ha jól értelmezem a világ állását, akkor annak is vége, hogy egy webes frontend semmilyen módon ne kapcsolódjon a JS-hez (a CIB nem java-s netbankja már bétában van! Igaz hogy a legfrisebb JRE egy hónapja nem támogatja az applet technológiát, de eljött ez is a piros hó előtt). Se SL, se flash...

Van típusos JS, ilyen pl az amúgy Jocó cége által is használt TypeScript. Én mondjuk a típusokat vizuális környezetszennyezésnek tartom a kódban, amiket állandóan kerülgetni kell, de én típusmentes rendszerekben (PHP4, ES3) írtam baromi nagy dolgokat, amiket mások szerint anélkül nem is lehetett volna (dehogyisnem, többmillió soros rendszereink futottak benne stabilan).

Szóval értem én az álláspontod, csak hinni nem tudok benne. Igaz, más dolgok miatt én a komplett programozást otthagytam jóideje.

> Van típusos JS, ilyen pl az amúgy Jocó cége által is használt TypeScript.

Az nem JS, hanem TypeScript. Egyébként rengeteg nyelv van, ami JS-re fordul, pl. Scala.js, CoffeeScript, ClojureScript.

> Én mondjuk a típusokat vizuális környezetszennyezésnek tartom a kódban
> én a komplett programozást otthagytam jóideje.

Sajnos az aktív programozók között is sokan így gondolják!

> én típusmentes rendszerekben (PHP4, ES3) írtam baromi nagy dolgokat, amiket mások szerint anélkül nem is lehetett volna (dehogyisnem, többmillió soros rendszereink futottak benne stabilan).

Ezt én el is hiszem, de azt már nehezebben, hogy:
- nem kellett hozzá sokkal több unit teszt, mint a típusoshoz;
- nem lehetett volna könnyen hibára késztetni;
- nem kellett hozzá több dokumentáció;
- elég biztonságos volt.

”Make illegal states unrepresentable” - Yaron Minsky.

Érdemes ezt a mondást nagyon szem előtt tartani és ezt csak típusokkal lehet megvalósítani! A (statikus) típusosság csak szükséges, de nem elégséges feltétel!

> Van típusos JS, ilyen pl az amúgy Jocó cége által is használt TypeScript.

Az nem JS, hanem TypeScript.

Azért ezt nem mondanám. Oké, bizonyos értelmezés szerint igazad van. De: "TypeScript is a typed superset of JavaScript...", szóval nem esett messze az alma a fájától. Ha TS kódot írsz, akkor JS kódot írsz, ami ki van egészítve pár dologgal, szemben a többi általad felsorolt JS-re forduló nyelvvel, aminek saját szintaxisa van. Ugyanez igaz a Flow-ra is.

Udvariasságból mindig unitteszteltem, volt, hogy kollégát kértem meg, nézzük már meg, én vagyok-e hülye és ignoráns, de valahogy sose akart olyan hiba lenni, amire ne szándékosan futtattam a programot.

Szóval szerintem előzetes tervezésnél unit teszt nem akkora létszükséglet, de mondjuk egy kezemen meg tudom számolni, hány kollega volt rajtam kívül képes előre megtervezni a kódot, lépésről-lépésre, követelményekből.

Dokumentáció az több volt (ott volt a típus! API doksi és Closure compiler miatt) de nem kellett szemre átugrani állandóan, ill. elég volt azonos interfészt adni, nem kellett mindig mappelgetni.

Az is igaz, hogy ezek jórészt inputot nem küldő frontend v megbízható (értsd: saját másik DB-t ) forrásokat feldolgozó processor backend scriptek voltak, a felhasználói inputnál explicit típuskonverzió volt mindig előtte, hogy elkerüljük a haxxorkodást.

Némi félreértést vélek felfedezni a hozzászólásodban. A unit teszt nem csak arra van, hogy a program első verziójának helyességét ellenőrizd. Hanem amikor az ügyfél a 2., 3., ... n. változtatást kéri és ehhez a 2., 3., ... n. kollegád nyúl a kódhoz ami már egyáltalán nem is hasonlít az eredetire, akkor is meg tudj bizonyosodni arról, hogy a program helyesen fut. A gyakorlatban nagyon ritkán ismertek előre a követelmények és általában akkor sincsenek kőbe vésve.

Ezért álltam át a követelmény oldalra, ahol eléggé kőbe tudom őket vésni - a change requestek 90%-a a gyenge tervezési szakaszra vezethető vissza.

Mivel mi egy nagyon erős tervezési szakaszt hozunk létre formatív és szummativ tesztekkel, compliance vizsgálatokkal és nagyon erős ügyfél buy-in -t szerezve, hónapokig lehet programozni lényegi követelményváltoztatások nélkül úgy, hogy utána se kell hozzányulni.

Nyilván főleg azoknál a cégeknél vagyunk érdekesek, ahol ez eleve fontos, mert pl. offline, nehezen frissíthető hardvereszközöket adnak ki, vagy az elhúzódó fejlesztés más módon problémát jelent (a télapó szoftverének karácsonyra akkor is kész kell lenni, ha agilisek vagyunk)

Ezért álltam át a követelmény oldalra, ahol eléggé kőbe tudom őket vésni - a change requestek 90%-a a gyenge tervezési szakaszra vezethető vissza.

Csak a valós életben az, hogy mit akar az ügyfél / üzlet, az akár drasztikusan megváltozhat rövid idő elteltével. (Pl. kijön egy új törvény, ami miatt az eddigi terv nem jó vagy a konkurencia bemutat egy új terméket, amire vagy gyorsan reagál a cég, vagy a következő két évben kifejlesztett új terméket a kutya se fogja megvenni, és a következő két év pénzkidobás)

Pontosan ez az egyik oka az agile megközelítésnek.

Agile Manifesto, principle 2: Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage

Nem is azt mondta, hogy visszament 4 evszazadot es Waterfall mert "szarazagile", hanem azt, hogy ha egy eszkozon az egyik kovetelmeny tiltja a Facebookot az eszkozon, a masik meg Facebook logint akar implementalni, valakinek el kell mondania a "fonoknek" (inkabb megrendelonek, alarendelt viszonyban ez ritkan mukodik), hogy ezen valtoztatni kell, mielott a vilag 4000 pontjara szallitjak az eszkozt es visszahivjak.

Technikaibb pelda: specifikacioban egyik oldal feltetelezi, hogy unique key van egy oszlopparon. Par oldallal kesobb ket sor a kovetelmeny azonos ertekekkel ezen ket oszlopban. Rengeteg hiba adodik hibas inkonzisztens specifikaciokbol, az MS Word, amiben irjak az IT-hoz tokhulyek meg nem dobal piros jeleket az oldalsavba, hogy "precompiler error van".

Nem értek egyet az agile ezen elképzelésével, hogy valóban normális a gyorsan változó követelmény.

A fejlesztések valójában lassúak (egy MVP fél év nagyságrendileg), a hirtelen változásokat szerintem nem a gyorsan változó piaci környezet, hanem a piaci környezet és az arra adott válaszunk változó megértése okozza.

Még nem dolgoztam olyan projekten ahol “hirtelen” jött ki egy rendelet, pedig mindenféle politikai oldaltól függetlenül azért az utóbbi két kormány hajlamos volt néha gyorsan kitalálni dolgokat - még minden rám vonatkozó törvénynek olvastam az előkészítéses változatait, az adott iparágban mindig lehet tudni hónapokkal előre egy új törvényről.

Szerintem ha azt tapasztalod hogy változik a követelmény akkor az azt jelenti, hogy valaki a fejlesztés közben a fejére csap, “ja, bocsi, én mégse teljesen ilyen lovat akartam”, vagy azért mert a kész szoftverből látja az értelmezést, vagy azért mert bejön valami piaci infó, ami miatt végiggondolja az addig assumption alapján tervezett modult.

Na, mi ezt nyújtjuk nekik, a rettenet mély piackutatást, az assumptionök validálását a fejlesztésnél egy nagyságrenddel olcsóbban és gyorsabban. Azaz nem változik menetközben a piaci környezet megértése (hisz elég pontos képet kapunk), sem a válasz megértése (hisz a prototípusok és a tesztbe bevont végfelhasználók arra adott reakciói szintén elég pontos képet adnak).

Ha a körülményekről fejlesztőként úgy érzed, hogy gyorsan változnak, akkor ott hiba van a terméktervezési fázisban, és szükséges lenne bevonni egy terméktervezési tanácsadót (minket vagy valamelyik konkurenciánkat).

"Nem értek egyet az agile ezen elképzelésével, hogy valóban normális a gyorsan változó követelmény."
A piac pedig gyorsan változik.

"A fejlesztések valójában lassúak (egy MVP fél év nagyságrendileg),"
Fél év baromi rövid idő - attól függ persze, hogy 1 fős, 5 fős, 50 fős, vagy 500 fős csapat dolgozik egy terméken.

"Még nem dolgoztam olyan projekten ahol “hirtelen” jött ki egy rendelet"
Szerencsés vagy.

"a rettenet mély piackutatást, az assumptionök validálását a fejlesztésnél egy nagyságrenddel olcsóbban és gyorsabban. "
Ha fél év egy MVP, akkor míg folyik a piackutatás, és készen lesz a baromi precíz, de cserébe olcsó piackutatás, addig kijön egy csomó konkurens a saját MVP-jével (hiszen pont te állítod, hogy egy MVP-t letenni nem nagy dolog), és megy a kukába az egész.

“A piac pedig gyorsan változik.”

Hoznál példát? Minden relatív, persze, de amikor valami fejlesztés irányt váltott piacváltozás miatt.

A fél év egy MVP leprogramozására értettem, prototipust mi három hét alatt is tudunk szállítani. egy hét alatt megmondjuk a főbb fejlesztési irányokat és két hét múlva már a legfontosabb komponensek tervei is kész vannak, tesztelve..

Ha ennyi idő alatt kijön egy konkurens, akkor így jártál, ha nem csináljuk, akkor is kijött volna. De ismét csak érdekelne konkrét példa, amikor egy cég abba bukott bele hogy a UX kutatás (mondjuk egy hét) tervezés és tesztelés (két hét) miatt picit később jutottak az amúgy jó market matchű termékkel piacra, és megbukott.

Mert olyanról hogy rögtön lekódolt félkész ötletekkel kering mint elsőgenerációs roomba porszívó a bútorraktárban, emiatt megelőzték, olyanról már hallotttam, de ilyenről még nem.

Az meg hogy valaki nincs benne eléggé a piacában hogy tudja, milyen szabályváltozások várhatóak fél éven belül (nem csak magyar esetben, de nemzetközi esetekben is), nos, az megint olyan hogy ott más baj is van szerintem a piacismerettel, piackapcsolattal, nem csak a határidő, de itt is kiváncsi lennék példára.

"Hoznál példát? Minden relatív, persze, de amikor valami fejlesztés irányt váltott piacváltozás miatt."

Előző munkahelyemről meglehetősen sok példát tudnék mondani. Példának okáért, mikor csődbe ment az egyik vevőnk/partnerünk és a tartozás fejében lényegében átvettük a brandet meg a vevőket. Az egész folyamat IT szempontjából úgy nézett ki, hogy egyszer csak beállított főnök, hogy ez az új helyzet, tegyünk félre mindent és kezdjük el megtervezni, hogy hogyan fogunk még egy kiskert felhúzni, amihez át kellene alakítani meglévő, de baromira nem multisitera tervezett webshopunkat és kiegészítő oldalunkat meg az infrastruktúránkat. Gyakorlatilag hetek voltak rá, hogy produkáljunk valamit, ami működik. (Régi rendszerek átvételére nem volt lehetőség.)

Egyébként ez idő alatt volt olyan konkurencia, amely lecsapott 1-2 disztribúcióra, termékvonalra, mert a másik cég tudta vállalni a forgalmazását egyből, nekünk pár hét kellett, hogy előálljunk valamivel.

De ugyanígy voltak már dolgok, amik egyszer csak ki lettek húzva a tervek közül és ki lettek vezetve, mert kiderült, hogy üzletileg nem működik. Vagy épp kellett valami új dolog a semmiből, mert épp ez volt a marketing vagy a sales igénye. Mert adódott egy lehetőség és élni akartak vele.

De mondok jobbat: piackutatással hogy készülsz fel arra, hogy a veled kapcsolatban álló X cégnek Y beszállító egyszer csak megszakít mindenféle kapcsolatot, mert X cég Y konktaktja kikezdett az Y cég vezetőjének feleségével és emiatt örihari lett? :) Volt már, hogy ilyen miatt kellett az éppen elkészült kódot kukáznom.

----------------
Lvl86 Troll, "hobbifejlesztő" - Think Wishfully™

Brandátvétel:

Értem a problémát, ez azonban egy külön projekt. Szerintem a főnököket nem érdekelte volna, ha (hány ilyet láttam már...) multisite helyett egy cp -a unix parancs kiadásával készült volna a másik webshop... (nyilván azt is értem hogy ez műszakilag miért nem lett volna nyerő)

Üzletileg azért itt is van néhány dolog ami nem tiszta, közel sem biztos, hogy ez a lépés valóban megérte, lehet hogy az átvétel maga nem érte meg a ti fejlesztői órabéretekkel meg ami zajt okozott a rendszerben azóta, és hát ott felmerül hogy más ideiglenes megoldás biztos nem lett volna-e, de nyilván nem tudom, mennyire specialis a webshop.

Az, hogy üzletileg mi működik és mi nem, ezt hivatott a UX fejlesztés előtt eldönteni - maga a UX design azt jelenti, “tervezés abból a szempontból hogy a felhasználók hogy élik meg majd a leendő terméket”, ami miatt masszív módszertan van arra, ez hogy nem lesz hasraütés (fejből kell tudni az összes kutatási módszertan bias-lehetőségeit pl, nem egy sima kérdőívezés)

Nem mindenre lehet felkészülni ezt elfogadom, de azért amikben én voltam, ott egyfelől nem számított gyakorlatilag, ki a gyorsabb (hiába jöttünk ki hónapokkal a Google Maps előtt valamivel a HERE mapsnél, a gyakorlatban a Google ugyanúgy megkapta a fanfárt utána), másfelől a felvevői piac maga statikus maradt, azaz a termékigény és a használati szokások nem változtak.

"ez azonban egy külön projekt"

Egyik szemlélet szerint igen, másrészt nem, mert egy platformra akartunk rakni mindent. Akkor már tervben volt, hogy a nagyker oldalt is a kisker rendszerével oldjuk meg - ez egyébként időközben elkészült - pont azért, mert olcsóbb egy rendszert fejleszteni, mint 2-3-at. Vagy 4-5-öt és néhány kisebb oldalt, mert most már ez volt a legutolsó igény, mikor eljöttem.

Viszont te kértél olyan példát, ahol a megváltozott piaci helyzet hetek alatt felborítja a korábbi fejlesztési ütemtervet: tessék itt volt egy. Az, hogy megéri-e vagy sem, azt meg nem az UX fogja eldönteni, hanem azok, akik az üzletet vezetik.

Az a gond, hogy te most a saját helyzetedből próbálsz egy olyan általánosságot levonni, ami nem igaz mindenre. Egyébként meg saját magadnak mondasz ellen: Google Maps már jóval régebb óta létező szoftver, mint a HERE Maps.

----------------
Lvl86 Troll, "hobbifejlesztő" - Think Wishfully™

Amikor én dolgoztam ott, eleinte még Nokia Maps-nek hívták, és a rendszer amúgy öregebb volt, mint a Google Maps (azaz a mi rendszerünk 5 évvel idősebb volt).

De valóban, itt olyan feature-ökről beszélünk (Indoor Maps, 3D maps, etc), amiket a Nokia Maps webes vagy épp natív változata előbb tudott, mint a Google Maps, mégis abból lett nagyobb fanfár, hogy a Google-é tudja.

InDoor Maps-et mi 2011-ben vezettünk be (saját kicsi kezemmel terveztem), a GMaps 2012-ben, Bing Maps-en (szintén here engine) már tán 2010-ben is volt.

3D térképekkel mi 2010 decemberében már lőttünk egy karácsonyi demót (én fejlesztettem a berepülés szerkesztőt hozzá) tavasszal már WebGL-es változatunk is volt, 2011 szeptemberében az Apple-nél lett belőle botrány (vicces, de szó szerint ugyanazzal az adathalmazzal), a Google Maps évekkel később jött ki a WebGL alapú Earth-szel.

Nyilván volt sok kis apró ficsör (a sarokban megjelenő weather ikon, ami szintén az én ötletem volt, a menedzsment időjárás-jelentés szerűen akarta eredetileg), ami nem nagy szám, csak cuki add-on, de ezek is a Google-nél pörögtek nagyot akár évekkel később...

Jó, most megfogtál, bevallom őszintén, egészen eddig azt sem tudtam, hogy létezett a Nokia Mapsnak webes felülete. Pedig 2012 decembere környékétől volt egy 920-asom. Mondjuk így meg nem csodálkozom, hogy nem szólt nagyot.

----------------
Lvl86 Troll, "hobbifejlesztő" - Think Wishfully™

Jogos amit írsz, hogy van hogy felborulhat a piac is, volt ilyen az ADD-nél is (igaz, ott se volt elég erős a piaci immerzió), mégis azt gondolom, a legtöbb esetben, amikor “menetközben” van változási kérés, ez piacismereti okokra vezethető vissza.

Maga a piac (tehát a vevői szokások, igények) ugyanis jellemzően egy nagyon lassú adaptációs görbével rendelkeznek, a teljes piaci adaptáció sok éves (még az okostelefonoknak is több év volt a felfutása), azaz attól, hogy a pannon bejelenti a másodperc-alapú számlázást, bár ez egy előre piackutatással jól jelezhető igény (ahogy itt mesélték is a trükköket), azaz nem érdemes 5+ évre tervezett rendszerbe nem számolni vele, de nem kell félni tőle, hogy másnap mindenki felmondja a Westel-es szerződését, mégha a nyomás nagy is.

Jó, ha nagyon akarom akkor persze, minden piacismeret, de hogyan készülsz fel az ismeretlenre? Nem csak megamultik léteznek a világban, hanem kisebb cégek és szezonális dolgok is. Teszem azt, jön valami új divatmajomság, amit meg lehet lovagolni, de csak ha gyorsan reagálsz rá. Ki emlékszik pl. a Pokemon Go-ra? Vagy a Fidget spinnerre? Gyakorlatilag 2-3 hónap alatt lefutott divat volt.

Másrészt meg ha már okostelefonok, erre kiváló példa a Microsoft töketlenkedése a Windows Phoneval. Ahelyett, hogy mindig egy nagy verzióban akarták volna megváltani a világot, inkább sok, kicsi, rendszres release kellett volna és egy-egy releaseban megoldani valamit vagy megcsinálni valami hiányosságot.

Bár inkább most nem kezdek bele egy WP rantba, mert dühítő látni, hogy hogyan kúrt el az MS egy egyébként jó rendszert a tehetetlenségével és az agyfasz, idióta 3rd party mániájával.

----------------
Lvl86 Troll, "hobbifejlesztő" - Think Wishfully™

attól, hogy a pannon bejelenti a másodperc-alapú számlázást, bár ez egy előre piackutatással jól jelezhető igény (ahogy itt mesélték is a trükköket), azaz nem érdemes 5+ évre tervezett rendszerbe nem számolni vele, de nem kell félni tőle, hogy másnap mindenki felmondja a Westel-es szerződését, mégha a nyomás nagy is.

Hát, szerintem pedig ez egy kiváló példa az üzleti környezet hirtelen és váratlan változására.

Piackutatók lehet, hogy kimutatták évekkel korábban, hogy az ügyfelek szeretnének másodperc alapú számlázást, de amíg minden szolgáltató perc alapon számláz, tehát nincs ebben a tulajdonságban verseny, addig nyugi van.
A cég nem akar másodperc alapú számlázást bevezetni, mert akkor kevesebb bevétele lesz.
Természetesen nem fognak előre lefejlesztetni 100 különféle funkciót, amit egyébként nem akarnak bevezetni, amikor lehet olyan dolgokat is fejlesztetni, amik viszont azonnal mennek élesbe, amikor elkészültek.

Ez az alaphelyzet.

Ezt a helyzetet felrúgta az, hogy a másik cég, váratlanul bevezette a másodperc alapú számlázást, és elkezdte nyomni a TV-ben a hirdetéseket.
Ez lehet, hogy nem volt teljesen váratlan, de természetesen titokban készült, hiszen pont azért csinálták, hogy az előfizetők egy részét átcsábítsák magukhoz. Tehát a Westel nem tudta, hogy ez jön (biztosra), és főleg nem tudta, hogy mikor jön.
Mondom: meglepve és ugyan nem pánikolva, de erős sürgősség érzéssel hívtak minket.

Nem értek egyet az agile ezen elképzelésével, hogy valóban normális a gyorsan változó követelmény.

Nem jól nézed.

Nem arról van szó, hogy az agile kitalálta ezt, és néhányan elkezdték így csinálni a projekteket, és vajon ez jó lesz-e vagy nem.

Hanem a tradícionális megközelítés, amiben valakik megterveztek egy megoldást, ledokumentálták, aztán az egészet lefejlesztették, aztán ellenőrizték és végül (sokkal később) élesbe lehetett tenni, ez sok esetben nem működött jól. Azért nem, mert az üzleti környezet gyorsabban változott, mint amennyi idő alatt ez a folyamat lezajlott.
Mivel nem volt jó, ami volt, a népek elkezdtek más utat keresni, valamit, ami jobban alkalmazkodik a valós élet által adott kihívásokhoz.
Erre a problémára mindenféle emberek mindenféle megoldást / megközelítést kitaláltak, aztán egyszer csak egy csoport kitalálta, hogy készítsünk ebből (ezek egy részéből) egy kiáltványt, nevezzük el, mondjuk agile-nak.

A fejlesztések valójában lassúak (egy MVP fél év nagyságrendileg)

Dolgoztam olyan helyen (kiskereskedő cég, elég nagy itt, Angliában), ahol az ötlettől az élesbe állításig max. 3 hónap telt el. Sok esetben kevesebb.
Szóval mondjuk inkább úgy, hogy vannak lassú fejlesztések, és vannak gyorsak.
Szerintem nincs olyan megközelítés, ami mindenre jó. Attól függően, hogy adott cégnek, adott projektnek mi kell, úgy kell eszközt választani.

Szerintem ha azt tapasztalod hogy változik a követelmény akkor az azt jelenti, hogy valaki a fejlesztés közben a fejére csap, “ja, bocsi, én mégse teljesen ilyen lovat akartam

Egyszer régen a T-mobil számlázási rendszerén dolgozott a cégem. Egyik nap épp egy ügyféltől tartottunk haza kocsival, amikor csengett a telefon, és a T-mobilos kapcsolattartónk hívott. Azt mondta: Srácok, a pannon ma kijött a másodperc alapú számlázással (egész addig mindenki 30 vagy 60 másodperces egységekkel számolt). Valamit nagyon gyorsan lépni kell. Gondolkodjatok rajta, mit tud a rendszer, holnap pedig üljünk le és beszéljünk róla.

Szóval igen, lehet, hogy valaki fejlesztés közben a homlokára csap, csak éppen simán lehet, hogy ez nem gondatlanság, vagy bármi elkerülhető ok miatt van.

"Srácok, a pannon ma kijött a másodperc alapú számlázással"

Mondjuk erre speciel pont számítani kellett volna. Nem tudom volt-e nemzetközi előzménye, de még ha nem is volt, akkoriban baromi drága volt egy perc, és mindenki spúrkodott, hogy minél olcsóbb legyen a mobil.

Emlékszem, volt a három (1?) másodperces szabály: ha adott időn belül letetted, akkor nem számláztak. (Nem tudom igaz volt-e, de legenda volt.) Voltak ismerőseim, akik belehadarták a mondanivalót és letették. Ezért elterjedt, hogy csak akkor nyomják meg a zöld gombot, ha már a fülükön van a gép :-).

Én azt gondolom, az Agile Manifesto-t programozók irták, és az ő szempontjukból lett a helyzet kezelve, azaz:
- feltételezték, hogy piaci feedbacket csak futó kódra lehet kapni (valojában lehet prototipusra is)
- feltételezték, hogy a gyorsan változó követelmények a piac tulajdonsága (valójában az üzleti környezet többi összetevője - belső struktura, piacmegértés stb - sokkal gyorsabban változik)
- feltételezték, hogy ez megváltoztathatatlan sajátosság (az ő eszközeikkel tényleg, a mi eszközeinkkel nem)
- feltételezték, hogy a tervezés egy inherensen lassú folyamat (a régi eszközökkel tényleg, a mi eszközeinkkel nem)
- feltételezték, hogy a fejlesztés gyorsan, 2-3 hét alatt tud értéknövelt szolgáltatást teremteni (a jelenlegi ergonómiai és egyéb követelmények mellett ez ritka)

Jutottak valamilyen megoldásra, amely az ő nézőpontjukból, félre ne érts, megoldás, csak:
- nem képes ma azt a tempót tartani amit igért (te is 3 hónapot írsz élesbe állításra, nem 3 hetet)
- rendkivül drága (szorozd be a fizud munkáltatói költségét a csapatlétszámmal)
- olyan elemeket is változónak vesz amik más módszerekkel stabilizálhatóak
- amúgy hiába veszi változónak, a gyakorlatban éppúgy rosszul reagál rájuk (lassan, hekkeléssel, vagy felesleges komplexitással)

Ja, és kiesik az, hogy mennyire használható a piacnak a megoldás, amire ugye elsőnek gondolunk ha UX-ről van szó, nagyon darabosan és lassan (külön miniprojektekben) tud a használhatósági problémákra reagálni a klasszikus Agile.

Szóval nem gondolom, hogy az Agile lenne a Szent Grál, hiába hallgatom ezt évek óta.

Mi sem vagyunk a Szent Grál, mi azt gondoltuk végig, mi van a fejlesztés előtt:
- honnan tudjuk, a felhasználónak mi kell és miért az (user story)
- hogyan választjuk ki a lehetséges megvalósitások közül a legoptimálisabbat (patternek)
- hogyan kapunk a fejlesztésnél olcsóbban feedbacket a piacról
- hogyan tudunk a fejlesztésnél gyorsabban iterálni a terméken

Ez utóbbi kettővel amúgy az alkalmazkodási hajlandóság is nagyobb, ami a fejlesztések egyik nagy rákfenéje (embrace change, embrace change, de ha egy ház árát kiszámlázza a fejlesztőcég érte akkor annyira nem embrace)

Megoldunk ezzel néhány problémát, nem az összeset, de közelebb kerülünk egy valamelyes jobb megoldáshoz, mert azt gondolom, az Agile csomó dolgot nem oldott meg, főleg azokat nem, amik egy digitális termék fejlesztésénél a kódoláson kívül esnek...

- nem képes ma azt a tempót tartani amit igért (te is 3 hónapot írsz élesbe állításra, nem 3 hetet)

Valamit félreértesz.

Az Agile nem ígért semmit. Sehol nincs olyan az agile manifesztóban, hogy bármilyen feladatot megoldunk 3 hét alatt. Vicces is lenne úgy vállalni be határidőt, hogy a scope akármi lehet.

A valóság az, hogy projekttől, feladattól és környezettől is függ, hogy mennyi idő alatt készól el, vagy mennyi idő alatt mehet élesbe valami.

A konkrét példában, amit írtam, a 3 hónap a marketing ötletétől az élesbe állásig tartott. Ennek a folyamatnak a marketing, product development és a fejlesztés része volt csak agile, a release processz minimum 1 hónapig tartott.

Vannak cégek, ahol Scrum-ot használnak, és egy nap hosszú a sprint. Én ilyen helyen nem dolgoztam még, nem tudom, hogy tudják ezt tartani, de sok helyen láttam 1 hetes vagy 2 hetes sprintet.
De ez sem előírás, simán lehet 4 hetes sprinttel dolgozni.

Ha egy SAFe projektet nézel, egy tipikus program increment kb. 3 hónap. Persze, ki lehet korábban is tolni funkciókat élesbe, de lesznek olyan darabok, amik nem készülnek el a PI vége előtt.

Ennél hosszabb ciklushoz nem volt még szerencsém, de semmi akadálya nincs annak, hogy valahol valaki hosszabbat használjon.

Szóval nem gondolom, hogy az Agile lenne a Szent Grál, hiába hallgatom ezt évek óta.

Aki ezt mondja, az hmm... elvakult.

Az agile egy eszköz. Feladathoz kell eszközt választani. Vannak feladatok, amihez jó (jobb, mint a tradícionális megközelítés). Vannak feladatok, amikhez meg nem jobb.
Aki úgy gondolja, hogy ez a szent grál, valószínű olyan környezetben dolgozott sokat, ami az első kategória.

rendkivül drága (szorozd be a fizud munkáltatói költségét a csapatlétszámmal)

Nem értem, mire gondolsz itt. Egy tíz fős csapat egy év alatt ugyanannyiba kerül a cégnek akkor is, ha agile és akkor is, ha waterfall projekten dolgoznak.

Mi sem vagyunk a Szent Grál, mi azt gondoltuk végig, mi van a fejlesztés előtt:
- honnan tudjuk, a felhasználónak mi kell és miért az (user story)
- hogyan választjuk ki a lehetséges megvalósitások közül a legoptimálisabbat (patternek)
- hogyan kapunk a fejlesztésnél olcsóbban feedbacket a piacról
- hogyan tudunk a fejlesztésnél gyorsabban iterálni a terméken

Ez tetszik, amit írsz. Csak azt nem értem, miért állítod ezt be úgy, mintha ez nem agile lenne ;-)

Az agile egy megközelítés, és ez, amit írsz, pontosan beleilleszkedik.
Pontosan ez történik egy agile cégnél mielőtt a fejlesztők megkapnák a feladatot (kivéve a megvalósítások közül választást, az sokszor a fejlesztőkre van bízva)

Az Agile nem ígért semmit. Sehol nincs olyan az agile manifesztóban, hogy bármilyen feladatot megoldunk 3 hét alatt. Vicces is lenne úgy vállalni be határidőt, hogy a scope akármi lehet.

Deliver working software frequently, from a
couple of weeks to a couple of months, with a
preference to the shorter timescale.

(Forrás: Principles of Agile, agilemanifesto.org )

De abban igazad van, hogy hajlamos vagyok az Agile-t és a Scrum-ot összemosni (tudom melyik mi, de ez a gyakorlatban együtt jár)

Aki ezt mondja, az hmm... elvakult.

Az agile egy eszköz. Feladathoz kell eszközt választani. Vannak feladatok, amihez jó (jobb, mint a tradícionális megközelítés). Vannak feladatok, amikhez meg nem jobb.

Tudod, az van, hogy akár a ThoughtWorks, akár a Futurice, akár a SprintConsulting jött tanácsadni, valahogy, hogy a régi szovjet viccet idézzem, mindig tank lett belőle.

Még mindig mindenkinek az lett a javaslata, hogy vezessük be a scrum-ot (vagy a scrumban-t), és legyen agilis a fejlesztés. Soha senki nem mondta azt, hogy ide az ideális a V-model lenne, a RUP egyenesen szitokszónak számított (szerintem a ThoughtWorks konzulensek amúgy keverik a waterfallal), ICONIX-ról és Crystalról pedig néha az az érzésem, az Európai Unió teljes területén én hallottam egyedül (nyilván nem, de az érzés ez).

Szóval függetlenül attól, hogy ez banki rendszer volt, sportszervezés, GIS, vagy hardver, még mindig minden folyamattanácsadó agilis scrum-ot/scrumbant javasolt 2-3 hetes ciklusidőkkel, pedig dolgoztam már outsourcingban és termékcégeknél, kicsinél és nagynál, piacvezetőnél és runner upnál is.

Nem értem, mire gondolsz itt. Egy tíz fős csapat egy év alatt ugyanannyiba kerül a cégnek akkor is, ha agile és akkor is, ha waterfall projekten dolgoznak.

Igen, ez a fejlesztés egyik rákfenéje, erre szoktam mondani, ha bugos a szoftver, dobd ki a teamet, mert ígyis-úgyis kifizettetik veled, dev time-ot veszel mindig, nem sprintet, a bugfixekkel együtt kell nézni az árat.

De itt a lényeg az volt hogy a business increment ára mennyi, azaz mennyi megtudni hogy valami piacilag működőképes-e prototipizálással és mennyi fejlesztéssel.

Pontosan ez történik egy agile cégnél mielőtt a fejlesztők megkapnák a feladatot

Ami köztem és egy PM/PO közt alapvető különbség, hogy a digitális szoftvertervezésnek is van egy lexikális és gyakorlati tudáshalmaza, meg ismert folyamatai, amik a fejlesztésre is jellemzőek. Folyamatban pl. Design Thinking, mi amúgy Goal-Directed Designt tolunk főleg, de nyilván ilyen piciben (és azért nagyon játékváltozatban, korai fázisú startupokra optimalizálva) a Google Ventures Design Sprint is. Lexikális tudásban pedig ilyen a kognitív pszichológia, a HCI kísérleti eredmények, vagy épp a mintakönyvtárak.

Én PM-et még korrektül usability tesztelni (ami messze túlmutat a “tetszik, ugye?” rendszerén nem láttam, rendesen interjúzni se tudnak általában (“kitaláltam ezt a f@sza dolgot, szerinted is cool, ugye?” -ez nem userinterjú, ez zsarolás), a UI megvalósitásaik rendszerint patchwork lopások a Héten Divatos Szoftverekből, és hát a konzisztenciával is sok szinten akadnak gondok.. de nyilván vannak kivételek...

(kivéve a megvalósítások közül választást, az sokszor a fejlesztőkre van bízva)

Mi az ilyen subtle dolgokat, mint pl. törlési logika, nem szeretünk a fejlesztőre bizni (az valahogy mindig egy “are you sure?” confirm ablakban végződik, hiába van Biblia-vastagságú szakirodalom róla, hogy miért a lehető legrosszabb ötlet).

Hasonló a mindenféle szelekciós megoldások (dropdown, radio, autocomplete, filterable list) közti kis apró különbségek, amik egy fejlesztőnek nagyjából random (egy olyan dobókocka, ami a dropdownos oldalán cinkelt, szintén rossz ötlet sokszor), mi pedig ismerjük azokat a kis apró különbségeket, amikor adott helyzetben egyik javasolt a másikhoz képest.

Szóval nyilván ez egy szakma, én azt gondolom, egy másik ember kell ahhoz, hogy beconfigolja a dropdown-t rendesen, meg aki kitalálja, hogy oda pont dropdown kell (maximum 8 elemű egyopciós listákban ahol kijelölhető egy > 50%-os eséllyel várhatóan jó default érték, szakavatott felhasználóknál vagy nemnyúlkapiszkás funkcióknál)

Deliver working software frequently, from a
couple of weeks to a couple of months

Csak hogy tiszta legyen: deliver working software frequently az nem azt jelenti, hogy az ötlettől az élesbe kerülésig számolt idő az ennyi lesz.
Az a workstream, amit említettem, ahol ötlettől élesítésig max. 3 hónap telt el, két hetes sprintekkel dolgozott, és minden két hétben szállítottak működő szoftvert.
Amikor a PO éppen prototípusokat készíttetett meg az éles weboldalon random kiválasztott valódi felhasználók viselkedését monitorozták a multi variable tesztek során, eközben a három hónap már ketyegett, de a fejlesztők a korábban elkészített user story-kat implementálták éppen.
Amikor pedig a release team átvette, becsomagolta, kézzel letesztelte funkcionálisan, teljesítménytesztelte, kipróbálták milyen az éles másolatára telepíteni a csomagot, milyen aztán rollback-elni, és közben ültek átlagosan másfél hónapon át a cuccon, és a három hónap még mindig ketyegett, a fejlesztők közben már a következő user story-kon dolgoztak.

Tudod, az van, hogy akár a ThoughtWorks, akár a Futurice, akár a SprintConsulting jött tanácsadni, valahogy, hogy a régi szovjet viccet idézzem, mindig tank lett belőle.

Egyfelől: ne is mondd, sok hasonlót láttam már.
Másfelől: ahogy leírod, hogy miket csináltok, szerintem ti már most is agile megközelítéssel dolgoztok. Lehet, hogy nem valamelyik divatos frameworkot használjátok, hanem esetleg magatoknak kidolgoztatok valamit, ami működik.

Szóval azt mondani, hogy legyetek agile, az szerintem nyitott ajtók döngetése nálatok.
Azt mondani, hogy használjatok Scrum-ot... fene tudja. Lehet, hogy tényleg jobb lenne, de egyáltalán nem biztos (nincs elég információm, hogy véleményt alkossak erről). Viszont ahogy mondod, sok tanácsadónak van egy kalapácsa, aztán mindent szegnek lát.

(kivéve a megvalósítások közül választást, az sokszor a fejlesztőkre van bízva)

Mi az ilyen subtle dolgokat, mint pl. törlési logika, nem szeretünk a fejlesztőre bizni (az valahogy mindig egy “are you sure?” confirm ablakban végződik, hiába van Biblia-vastagságú szakirodalom róla, hogy miért a lehető legrosszabb ötlet).

Aha, szerintem elbeszéltünk egymás mellett. Amikor megvalósítások közül választásra gondoltam, egyáltalán nem ilyesmi járt az eszemben, mint amit te írtál.

Az én példáimban ezt vagy egy UX szakember, vagy valami üzleti hátterű termék menedzser vagy hasonló ember döntené el (esetleg többen együtt).
Ez már, hogy confirm ablak legyen vagy X logika, ez mint a user story része kerül a fejlesztők elé. Ilyesmit nem ők találnak ki.

Azt viszont ők találják ki (sokszor egy architect segítségével vagy egy architect board által a megoldási ötletet először jóváhagyatva), hogy az adott funkciót milyen technikai megoldással (pl. ahogy a másik fórum posztban a millió felhasználós chat esetén OS threadek framework threadek, vagy file descriptorok, szinkron vagy aszinkron, stb). legyen elkészítve.

ICONIX, Crystal, XYZ Consulting cégek mind ugyanazt a snake oilt akarják eladni, nem nézik ők a vevők érdekeit, csak a saját érdekeiket. Azt állítják, hogy ők aztán tudják a tutit, minden szoftverprojektmenedzsment problémára tudják az igazat és egyetlen helyeset, csak vegye meg tőlük valaki a consulting szolgáltatást.
Csak az a nagy helyzet, hogy there is no silver bullett, egyszerűen nincs ilyen.

Az összes agilis fejlesztés egy dologban fogható össze jól: mivel előre tervezni rosszul tudunk, rövid ciklusú fejlesztéseket kell használnunk, amit előre látunk most.
Nem szabad hosszú távra lekötni sem a tervezési, sem a fejlesztési erőforrásokat előre, mert gyorsabban változik a környezet, mint ahogyan azt le tudnánk reagálni, ha lekötjük magunkat.

Ezt a gondolatot adják el neked összecsomagolva, menedzsentmentbullshittel szépen leírva.
Attól még egyiknem sem kell hinni, és a legrosszabb, amit tehet az ember: betű szerint követni bármelyiket is. A mögöttük lévő filozófiát (már amennyiben van) kell megérteni.
Aztán akkor consulting se nagyon kell.

A PM-nek meg egyáltalán nem dolga az,a mit leírtál. Usability testing? Interjúzás? UI megvalósítás? Egyik sem dolga. Neki az a dolga, hogy minden flottul menjen, minden feladatra a megfelelő szakemberek legyenek ott, és meglegyen minden eszközük arra, hogy dolgozni tudjanak. Megfelelő hardver, megfelelő pénz, megfelelő környezet. A PM az a blocker dolgok elhárítója. Ha kommunikációs gond van, megbeszélést szervez. Ha szar valakinek a széke, rendel újat. Ha nincs fókusza a bandának, akkor célokat tűz ki. Stb.
A usability testinget, a UI design-t, a business analysist meg megcsinálják, akiknek ez a dolga. De ezek közül egyiknek sem dolga az, hogy az irodára ki legyen fizetve a számla, legyen mindenkinek top hardvere, legyenek megfelelő mennyiségben meeting roomok, mindenkinek rendben legyen az útiköltség-térítése stb. Mert ez egy PM valódi feladata. A projekt menedzselése, és nem a terméké.
Egy banki alkalmazás fejlesztését mint projektet pont ugyanúgy kell menedzselni, mint egy webshop fejlesztését is.

A PM-nek meg egyáltalán nem dolga az,a mit leírtál. Usability testing? Interjúzás? UI megvalósítás? Egyik sem dolga. Neki az a dolga, hogy minden flottul menjen, minden feladatra a megfelelő szakemberek legyenek ott, és meglegyen minden eszközük arra, hogy dolgozni tudjanak.

Arra tippelek, hogy a PM itt nem Projekt Manager, hanem Product Manager lehet. Ebben az esetben van értelme, hogy ezekkel a feladatokkal foglalkozik.

Nem értek egyet az agile ezen elképzelésével, hogy valóban normális a gyorsan változó követelmény.

Pedig rengeteg minden változhat gyorsan. A piaci viszonyoktól kezdve, az anyagi lehetőségeken át, az ismereteken, tudásbázison át rengeteg minden.
A legtöbb ügyfél maga sem tudja pontosan, hogy mit szeretne. Ha őszintén belegondolsz, akkor biztosan sok olyan dolog volt, amiről azt gondoltad, hogy nagyon fontos, megvetted és egy pár napos "játszadozás" után szinte soha nem is használtad. Ugyanígy vannak az ügyfelek is, nem tudják pontosan, hogy mit, hogyan szeretnének.
Ha kezdetben azt gondolta, hogy A, B, C, D, E funkciókat szeretné mindenképp és ilyen fontossági sorrendben, majd megkapja az A funkciót és elkezdi használni, akkor rájön, hogy most már inkább a C', F, G, H funkciókat szeretné, sőt az A-n is szeretne egy kicsit változtatni, és így tovább.

Szóval az, hogy előre tudja, előre el is tudja mondani, vagy jól ki lehet belőle szedni, az szerintem csak nagyon kevés esetben igaz. Ha igaz is, akkor se biztos, hogy ugyanolyan jót kap a végén, mintha folyamatában változtathatná, pontosíthatná az igényeit.

Ide kapcsolódik ez a poén.

“A legtöbb ügyfél maga sem tudja pontosan, hogy mit szeretne”

Persze, ezért vagyunk mi.

Ez nem arról szól hogy egy 100 wattos égőt az arcába tolok az ügyfélnek, hogy MONDD KI MIT AKARSZ ...

Kell neked egy új logisztikai rendszer... oké. Kimegyünk a logisztikai központodba, ott töltünk két napot az overálos emberek közt, mondjuk, hogy ezt meg ezt lehetne javitani. Közlöd, hogy neked az kéne, hogy 10%-kal kevesebb embert tudj alkalmazni mert baromi nehéz a HR recruitment mostanában.

Oké, megnézzük mik a kulcsfolyamatok amik emberszám alapúak, ezek szoftveres támogatását átszervezzük, építünk rá egy protót, egyik nap munka után eljátsszuk a munkatársak egy részével. Kiderül hogy valamire nem gondoltunk, átvariáljuk, másnapra van egy szoftver amire a köv műszak azt mondja, tök triviális és működik.

Bevisszük a jogászodhoz, elmondja, hogy van egy törvény ami miatt ezt így nem, és hogy amúgy minisztériumi pletyka hogy januártól így lesz, meg van egy olyan felsővezetői mozgolódás hogy amügy legyen.

Mindegyik esetre készítünk altrernatíváiat, kivisszük tesztelni, akár 2-3 forgatókönyvet is. A végére minden ismert esetre fel vagyunk készülve, a mérések azt mutatják, hogy felgyorsul annyira a használat hogy nem kell annyi ember hozzá.

Leírjuk azokat a részeket amik az eredeti célszámok teljesítéséhez feltétlenül kellenek, a protót szétszedjük komponensekre, react/atomic design / amit a céged használ épp elemekre, pszeudokóddal, cross-referenciázva a követelményekre. Ellenőrízzük, hogy a változó életciklusok stimmelnek-e, minden adat konzisztens, minden adat beszerezhető, részben a fejlesztőkkel együtt. Rábólintatunk az összes kisfőnökkel, nagyfőnökkel, overálosokkal és jogászokkal.

Akkor se lennél kész sokkal előbb ha mi ezt a kört nem futjuk le, de akkor mindenki ideges lenne. Így mind a menedzsment, mind az overalosok tudják, mire számíthatnak, a pm-ek tudnak priorizálni, a tesztelők előre meg tudják írni a tesztforgatókönyvet, a programozók pedig tudnak miből dolgozni.

Ezt az egész A,B,C... funkciós A’-s stb köröket, ezeket mi futjuk le a prototípusokkal, a fejlesztő már csak azt kapja meg hogy ilyet szeretnénk, kerek legyen és babakék, négy kerékkel és neonvilágítással.

Tudom hogy scifinek tűnik de tényleg hatalmas csend van utána a menedzsment részéről, kéthetente ledemózol (azt mi visszük tesztelni), oszt kész, nincs cserélgetés, kitalálás.

Amit írsz az nagyban agile, kivéve a fejlesztés részét.

Első lépésben minden le van zsírozva és megvan minden funkció, mit hogyan kell, rengeteg terv és prototípus iterálásával. Ez eddig gyönyörű agile.
Azután x ideig csend van és a fejlesztők szépen dolgoznak, majd a végén átadásra kerül a minden szempontból tökéletes program.
Ez van másként agile esetén, ott meghatározzák az eddig felmerült funkcióknak azt a legfontosabb és lehető legkevesebb részét, amit termékként szállítani tudnak, majd ezt lefejlesztik és átadják, amit az ügyfél azonnal el is tud kezdeni használni. Az első rész fejlesztése közben és után folyamatos az egyeztetés az ügyféllel, hogy van-e valami változás, amire a fejlesztés során reagálni kell. Ezután jöhet a következő lépcső fejlesztése.

"dehogyisnem, többmillió soros rendszereink futottak benne stabilan"

Ja, nekem is futott egy sokszázezer soros PHP-ben írt rendszerem, alapvetően stabilan, csak szopás volt fejleszteni és nagyobb refactoringokat eszközölni rajta, mert mindent kézzel kellett megcsinálni.

Nem azzal a kóddal van gond, amit egyszer össze kell fosni, és nem kell hozzányúlni, hanem azzal, ami aktívan fejlődik, változik az igényeknek megfelelően.

"Én mondjuk a típusokat vizuális környezetszennyezésnek tartom a kódban, amiket állandóan kerülgetni kell"

Ja, ez a tipikus Rambo kóder hozzáállás, én tudom mit írtam bele, más meg le van szarva. Volt szerencsém egy C-n meg Lispen nevelkedett jóember Java-ban írt kódjához, aki még ráadásul meg volt verve egy kis NIH szindrómával is, mikor írta. Saját adattárolás valami kész adatbázishelyett, stb. Eredmény? Egy trigger rendszernél az egyes trigger típusok object[]-ekben voltak, 0. indexen stringben, hogy micsoda, többi indexen meg random elszórva az egyes triggerek property-jei, mert ezt így még a saját kis DB rendszere is megette, "nem kellett külön serializációt írni hozzá". (Mintha nem lett volna bőven jó egy XML vagy Json serializáció aztán az egészet letúrni SQLiteba)

Kibaszott nagy élmény volt hozzányúlni ahhoz a kódhoz.

----------------
Lvl86 Troll, "hobbifejlesztő" - Think Wishfully™

Bocsánat, félreérthető voltam.

Nyilván nem rambo üzemmódban programoztam (a 3 millió soros here mapsból max 20-25000 az enyém), a peer review-t pl nagyon fontos dolognak tartom, ha több programozó egymástól függetlenül tudja értelmezni a kódot (kevés a wtf/min), és az együtt kitalált várható változási kérésekre a tervezett módon reagálnak, akkor rendben vagyunk, illetve nyilván voltak betartandó style guide-ok és ha ezek része volt a unitteszt akkor mindig szépen megírtam, csak a saját munkámhoz nem láttam értelmét.

Szóval itt projetkenként több tucat, esetleg több száz programozóról van szó, a closure compiler miatt api docs jelleggel megadott típusdefiníciókkal.

A változó igényekről pedig fentebb írtam.

Ennél még a szocializmus politikai gazdaságtana is hatékonyabb volt. ;)
Melyik számodra ismeretlen lány a legszebb?
avagy
A legjobb barátaid közül melyiket gyűlölöd a legjobban? (Tfh nem nő vagy! ;))

A felmérés módszertana a probléma: "But this dataset is a rare way to find out what technologies people tend to dislike, when given the opportunity to say so on their CV."

Na most egy CV nem feltétlenül az őszinteségről szól, hanem arról, hogy el kell adnunk magunkat a HR-eseknek, hogy aztán végre a főfejlesztőnél is interjúzhassunk.

Márpedig a JS szinte mindenütt a követelmények között van. Pláne azok körében, akik CV-t írnak.

Érdekes, hogy az ABAP nincs benne a listába, pedig Én azzal kelek, azzal fekszek

Azért be kell látni, hogy az alsó harmadban olyan nyelvek vannak, amelyeket vagy nagyon elhivatottak használnak vagy még annyira újak, hogy nem volt idő szopni velük.

Hol marad az Erlang?
--
Ami elől menekülsz, az után szaladsz.

The use of COBOL cripples the mind; its teaching should, therefore, be regarded as a criminal offense.

Edsger W. Dijkstra

R - mint a legjobban kedvelt nyelv...khmmm...hu de sok a data analyst aki programzonak kepzeli magat (akkora fos az R, hogy ahhoz kepest a himalaja csak egy bolhafa@sznyi dudor :D)

Amugy nem az van, hogy mindig az a legutalatosabb nyelv, amivel epp sz*pik az ember? :)

En ezt OS-bol ismerem.

Mivel gep elott toltott idom 99%-a iOS vagy MacOS, igy annak ismerem leginkabb a hibait. Sokszor el is konyvelem, hogy "ez nagyon szar". Aztan elemkerul egy Windows vagy egy Android vagy egy systemd virussal fertozott Linux es visszavonok minden szarozast, amit ennek a kettonek szantam.

Ami a programnyelveket illeti, egyedul a C++ nem okozott nekem csalodast. Kiveve azt a par hulyet, aki lehetoseget lat a tobbszoros oroklesben, es nem jo, ha utanuk kell dolgozni. De C++-ban aranylag keveset dolgoztam, az teny.

Azt megértem, hogy az emberek nem akarnak assemblyben programozni. Azt viszont nehezen tudom felfogni,
hogy mi a fenének más programnyelv, amikor ott a C.

> Sol omnibus lucet.

ott a C

ott a C++

Igy mar egyetertek.

De a legtobb programozonak nagyon faj a segge, ha nem kaphat reference countingot, meg minel kevesebb circular reference-ben kell gondolkodnia. :( Sot, mar az is baj, ha az a csunya nyelv tud reference counting nelkul mukodni, netan pointereket tud definialni, mert az akadalyozza a csapatmunkat. Ha csak egyvalaki anelkul gondolkodott, a tobbiek mar nem ertik. Igy sajnos a piacnak adaptalodnia kellett, es letrejott tobbezer olyan nyelv, ahol csak reference counting van GC-vel. Ezekben a nyelvekben a kepzetlenebbek/tehetsegtelenebbek is tudnak programozni es meg igy is munkaerohiany van.

Nem a seggem fáj, hanem gyorsabban lehet dolgozni egy GC-s nyelvben, és áttekinthetőbb a kód, és a performnancia még ezekkel is bőven elegendő. A legtöbb programozót pont ezért fizetik, nem pedig valami mesterségesen kitalált szépségérzet/büszkeség miatt, amit egy hardcore-abb programnyelv egyeseknek okoz. Hidd el, nem olyan szar az a GC, és ritkán van olyan problémánk, ami esetén mikrooptimalizálni kellene, pedig nálunk aztán van skálázódás. Ezt hívják fejlődésnek, és ezért nem lyukkártyázunk már, pedig az milyen hardcore volt, ugye?

Már kiskoromban is nagy C=64 rajongó voltam, a játékok nem nagyon érdekeltek. A többi gyerek játszani használta, én már akkor is BASIC programokat írtam rajta, egy fekete-fehér TV-n :D Akkor még nem igazán értettem, mi az a gépi kódú programozás, meg számrendszerek. Nemrég előszedtem, aztán elkezdtem kutatni, hogy épült fel a gép, hogyan működik. Láttam vannak rajtam kívül sokan, akik 6502-es CPU-val mindenféle SBC-t építettek. Most ez lett a hobby.

Egyszer C64-en ASM-ban lekódoltam egy tetris-t, teljesen működött, forgattad az elemeket, random jöttek, helyükre kerültek, teljes sornál levette a sort, és nem tudtam kimenteni magnóra :)

Első egyenes húzó rutinon olyan "gyors" volt, hogy öröm volt nézni ahogy csak úgy szórja ki azt a pár pixelt másodpercenként..

Gyere legközelebb árok party-ra Ajkára.