space vs tab

Fórumok

Sziasztok. Tudom, hogy ez flame veszélyes kérdéskör, de igyekszem tárgyilagos maradni :) A topic apropója amúgy az, hogy épp olvasgatom a PHP PSR-eket, és "Code MUST use 4 spaces for indenting, not tabs.". Szerencsére az interpreter nem kényszeríti ki, mint a YAML formátum esetében, de ettől függetlenül egy tab használó számára aggasztó a trend :)

Szóval, tab párti vagyok. Pontosabban smart-tab párti (remélem ez a megfelelő terminológia; arról a formázási megoldásról beszélek, ahol a tab szigorúan a kód indentálására vonatkozik, azonos indentálási szinten belül az egymás alá igazítást szóközzel végzem.)

Szokták ideologizálni miért jó a tab azzal, hogy az egy egység. De én inkább praktikus okok miatt használom, lényegében mert precízebb, és kevesebb a gond vele. Szóközökkel még IDE támogatás mellett is voltak problémáim, véletlenül két szint közé kerültem, és elcsúszott a kód, problémás volt idegen, máshogy szintezett kódot használni, stb.

Szóval a kérdésem: Ti, akik szóközt használtok: Miért teszitek? Hogy segít az általatok használt IDE/szerkesztő? Mi szól a TAB ellen?

(ez utóbbi kérdésre egyébként azt a választ szokták adni, hogy elcsúszhat a kód ott, ahol egymás alá igazítás lényeges. Na de erre lenne jó a smart tab megoldás, nem?)

Hozzászólások

Alapvetoen nem szamit, hogy tab vagy space. A fontos az, hogy mindenki ugyanazt hasznalja, kulonben olvashatatlan lesz a kod.

En alapvetoen space parti vagyok es pont azert mert tisztan tabbal nem lehet mindent igazitani es igy a tab valamilyen szinten mindig kevert lesz. Ha ehhez hozzaveszed, hogy sok okos editor automatikusan konvertal tobb egymas mellett levo space-t, akkor azonnal latod, hogy a tab "veszelyes". A space viszont mindenhol egyforma.

Nincs esetleg olyan editor, ami megnyitás után a sor eleji n darab space-t tab-ként jeleníti meg a szerkesztés idejére, majd mentéskor a tab-okat n darab space-ként írja fájlba?

Én szigorú tab párti vagyok.
A vi editorban tabstop=4, a commenten kívül csak az utasítás és paraméterek között lehet space. Így az igazítást mindig tab végzi. A sorok végén nem lehet sem tab, sem space. Ezeket a szabályokat betartva akár hiba is kiszűrhető. Pl. laza egérmozdulat következménye. :)
A 4 hosszú tab meg először a hosszú sorok miatt alakult ki.
A tab indentálás C esetén fontos, mert a pascal előélet miatt nem a blokk kezdetéhez igazodik a záró kapocs, hanem a nyitóval egy mélységben.
ASM forrásnál 13, 25 és 49 a megfelelő pozíció.
No, ennyit a magánéletről. :)

En tab parti vagyok, de kenyszerittetek a kigyo imadok. Sot a szerkesztom is 4 spacet ir egy tab lenyomasara,
holott mindenki tudja, hogy 8 lene ;-)

Amit nem lehet megirni assemblyben, azt nem lehet megirni.

Ja, de most syncronizalhatom minden gepemen a trukkos beallitasokat,
a szerint, hogy kivel dolgozok ill. milyen prog/script nyelven ;)

Es igen ha valaki fello egy random VM -et azon nem lesznek meg a beallitasaim.
'En is egy gombot utok le (tab) es kapok 4 space-t.'
Eleg viccess a amikor tab naci kigyo nyelves adhoc debug change
azert nem megy mert a tabbol tenyleg tab lett.

Amit nem lehet megirni assemblyben, azt nem lehet megirni.

> Ja, de most syncronizalhatom minden gepemen a trukkos beallitasokat,

Nem tudom milyen trukkos beallitasokrol van szo. Sublime Text szepen felismeri a helyes beallitast ha a fajl konzisztens. Ha valaki belerondit akkor persze megzavarodik.

> a szerint, hogy kivel dolgozok ill. milyen prog/script nyelven ;)

Ez a munka resze. Ha a coding standard azt mondja, hogy tab, akkor en is tabolok. Mint fentebb irtam, a legrosszabb az ha ossze-vissza van az egesz. A jelenlegi munkahelyemen en irtam a coding standard-et, es megsem ertek egyet a formazassal. Ennek egyszeruen az az oka, hogy a mar meglevo kod stilusat dokumentaltam. Ott ugy irok kodot, otthon meg a sajat stilusomban.

> Eleg viccess a amikor tab naci kigyo nyelves adhoc debug change

Hehh?

vim-ben a beallitasok lehetnek nyelv ill. filetypus fuggoek,
C -ben meg mindig ugy tabolok ahogy kell. ;)

'Hehh?'
1. VM fellovese valahol (csak reszleges control a tartalom felett)
2. vi inditasi beallitasok ill. extensionok nelkul
3. bele irni printf -et valamelyik rendszeren levo python filba
4. Anyazni indent hiba miatt
5. atirni spacre
6. Profit
:-)

Amit nem lehet megirni assemblyben, azt nem lehet megirni.

(Én csak azoknak a lassú kínhalálát szeretném megélni, akik azt hiszik, hogy a TAB egy szabadon állítható valami. Nem, annak kb 50-60 évvel ezelőtt definiálták a jelentését: ugrás a következő 8k+1 pozícióra.)

Szerk: tegyük hozzá, hogy a fenti a 'formátumozatlan üzemmód'-ra vonatkozik, amilyen pl. egy textfile.
Formátumozott üzemmódban (amilyen például egy HTML-form) a TAB a következő mezőre/zónára/definiált TAB-pozícióra ugrik.

És miért arra gondolsz, ha már előtte is volt tab? Te jöttél azzal, hogy 50-60 éve definiálták a jelentését, kérlek mutasd meg, hogy hol.

Tudom, a wikipedia nem túl hiteles információforrás, de itt:
https://en.wikipedia.org/wiki/C0_and_C1_control_codes

A tab-nál azt írja, hogy "Position to the next character tab stop." Nem azt, hogy 8n+1. karakter. Sőt, az extended control codes alatt találsz olyasmit is, amivel lehet állítani a tabstop pozícióját.

ad1

https://en.wikipedia.org/wiki/Tab_key#Tab_characters

Valóban, tévedtem, nincs beírva az ASCII standard-ba, csupán 'da facto standard'-nak nevezi a wiki is.

ad2

Igen, beszéltünk arról, hogy van olyan kontextus (amit nevezhetünk 'formátumozott mód'-nak), amikor mezők/zónák/TAB-pozíciók között lehet navigálni. Namostan a szövegfájl az nem ilyen, hiszen ott nincs metainformáció arról, hogy hol is lennének ezek a navigációs pontok.

define tabstops=4,12,34

A tabstop - ugyan nem néztem utána pontosan - már 1906-ban biztosan volt az írógépeken.

A pc-re elsőként crossassembler segítségével átpakolt CP/M szövegszerkesztőben (WordStar) már/még :) egyszerűen lehetett ilyet makrózni. Ha jól emléxem, a tabstop pozícióját és hogy mit rakjon a szövegfájlba külön-külön!

A HT definíciója: Position to the next character tab stop.

Van olyan szövegszerkesztő, amelyik tudja amit 1906-ban egy írógép, és van olyan amelyik nem.
Természetesen egyeseket egész bonyolult szintaxisra is lehet programozni...
Kb. ezen vitatkozunk, a fejlett informatika dübörög, stb.

Azért össze lehetne vetni a Word-ot egy 1906-os írógéppel a tabstop megadásának eccerűségében. ;)

Ok. Maradjunk csak a WordStar képességeinél.
Ide beszúrom az elejére, de a végén esett le: Te valószínűleg soha nem láttad ezt a programot!
Két üzemmódban használtuk:
text-editor = szövegszerkesztő - pl. asm forráskód írására. Ekkor az első pozícióban tabot nyomva a 13. pozícióra ugrott, stb. Ez egy "külön program" volt, mert config belekerült a binárisba.
word-processor = dokumentumszerkesztő - pl. kézikönyvek írására. Ekkor a program ismerte a bekezdést, annak formázását, stb.
(Mindez mondjuk 48k (32k??) CP/M-en!)

Ebben a topicban a forráskódok formázásáról beszélgetünk. Továbbra is állítom, hogy egy csomó szövegszerkesztő számára a tabstop ismeretlen fogalom. Ettől kezdve az a kis nüánsz, hogy tabstop tartományában hány darab tab és/vagy space van elhelyezve már lényegtelen különbségnek tűnik.

Beláthatod, a text-editor (tudod: szerkesztő!) fogalma nem merülhet ki a "dumb terminal" képességeivel, mivel ott semilyen szerkesztési lehetőség nincs.

Most zavarba hoztál, fogalmam sincs, hogy mindez megerősíti vagy cáfolja-e azt, amit mondtam.

Talán leírom még egyszer, az eddigiekből okulva precízebben: ha szövegfájlokat termelünk (például forrásprogramot), akkor ne "definiáljuk át" a 0x09 kódú karaktert valami másra, mit amit eredetileg jelent ilyen kontextusban (vagyis a 8k+1 edik pozícióra ugrást).

(És még egyszer: itt nem arról van szó, hogy a TAB billentyű ne generálhasson 1-100 szóközt, hanem kifejezetten a 0x09 kódú karakterről.)

En tabot nyomok, de a szovegszerkesztom/IDE mar a megfelelo szamu szokozt rogzit a forrasban. Egyebkent meg EditorConfig es mindenki boldog.

Tab:
- Már általános iskolában megtanultuk, hogy szóközzel nem formázunk (igaz, szövegszerkesztés esetében)
- Egy tab egy karakter, sok space hány karakter? :)
- A tab olyan széles lehet, ahogy szeretnéd, vagy más szeretné

Kell több érv? :)

"- A tab olyan széles lehet, ahogy szeretnéd, vagy más szeretné"

Amennyire jó ez a funkció éppen annyira rossz is.
- Ha keveredik a tab és a space, akkor már szétesik a formázás.
- Ha egy alapbeállítású szövegszerkesztővel nézed (ahol 8 space egy tab), akkor még space nélkül is széteshet a formázás a sortördelések miatt.

"- Egy tab egy karakter, sok space hány karakter? :)"

Nálam általában kettő :)

"Ha keveredik a tab és a space, akkor már szétesik a formázás."

Miért keveredne? Megegyezés kérdése: ha tabot használunk, akkor nem keverjük space-szel. Ennyi erővel fordított esetben is gond lehet a keveredés, ha valaki nem tartja be a szabályokat.

"Ha egy alapbeállítású szövegszerkesztővel nézed (ahol 8 space egy tab), akkor még space nélkül is széteshet a formázás a sortördelések miatt."

Nem nézem random alapbeállítású szövegszerkesztővel. Másrészt pont ez a szép a tabban, hogy beállíthatom a szélességét magamnak, de ettől még másnál nem kell, hogy ugyanakkora legyen. Sőt: régen pl úgy használtam a tabokat, hogy laptopon (kis felbontás) csak 2 karakter szélesre állítottam, asztali gépen meg 4-re. Így ugyanazt a kódot laptopon kicsit helytakarékosabban tudtam nézni.

Én alapvetően tab párti vagyok, de általában space-t kell használnom.

"Miért keveredne? Megegyezés kérdése: ha tabot használunk, akkor nem keverjük space-szel. Ennyi erővel fordított esetben is gond lehet a keveredés, ha valaki nem tartja be a szabályokat."

Így van, elvileg gond lehet mindkét esetben, a gyakorlatban viszont jellemzően a TAB-os esetben szokott keveredni mégpedig azért, mert a Space-t használók beállítják a TAB-ot, hogy space-t generáljon, így akár TAB-ot nyomnak, akár Space-t, kizárólag space fog bekerülni. A fordított esetben viszont TAB nyomásra tab, Space nyomásra space fog bekerülni.

"a Space-t használók beállítják a TAB-ot, hogy space-t generáljon"

Onnan indultunk, hogy megegyezés kérdése. Akkor miért állítaná be, ha egyszer megegyeztünk (pl céges szinten), hogy tabot használunk? Most még mindig ott tartunk, hogy végülis nem a tab rosszabb, csak vannak emberek, akik nem tudnak betartani egy ilyen egyszerű szabályt.

Azt hiszem nem érted.

"a Space-t használók beállítják a TAB-ot, hogy space-t generáljon"

Ez azokra vonatkozik, akik céges szinten abban egyeztek meg, hogy space-t használnak. Ők beállítják az editorukban, hogy tabra is space-t rakjon be, ilyenkor nem kell figyelnie, hogy hol mit nyom. Ha space billentyűt nyom, akkor is space íródik be, ha tab-ot, akkor is.

TAB-os megegyezés esetén lehet gond, hogy ha a TAB-ra tab-ot rak be, Space-re space-t.

Alapvetoen smart-tab parti vagyok, de a legritkabb esetben kell ezzel foglalkoznom. Az editorom a legtobb esetben kitalalja, hogy az adott kodban epp mi a szokas, es ahhoz alkalmazkodik. Indentalaskor en tabot nyomok, az Emacs pedig azt ir be, amit jonak gondol.

--
|8]

+1

Foglalkozzon a IDE/editor avval, hogy az adott kódban mi a stílus. (Nálunk a tab "mérete" PHP-ban és Python-ban 4, JS-ben pedig 2.)

Az előző melóhelyemen amikor az ügyfél rendszerében kellett a telepített kódot matatni - ahol nem volt IDE, csak notepad -, áttértem a space használatára, mert a notepad ragaszkodik a 8 hosszú tabhoz, és "szétesett" a kód.

"Pontosabban smart-tab párti (remélem ez a megfelelő terminológia; arról a formázási megoldásról beszélek, ahol a tab szigorúan a kód indentálására vonatkozik, azonos indentálási szinten belül az egymás alá igazítást szóközzel végzem.)"

"(ez utóbbi kérdésre egyébként azt a választ szokták adni, hogy elcsúszhat a kód ott, ahol egymás alá igazítás lényeges. Na de erre lenne jó a smart tab megoldás, nem?)"

Azt hiszem nem igazán értem, hogy mit nevezel pontosan smart tab-nak. A kód akkor csúszhat el, ha az indentálás nem pontosan az egyikkel van mindenhol megoldva, ha keverve van, akkor csúszhat el. Amennyit értek a smart tab leírásodból, hogy nálad keverve van, ne ez az amikor nem jó!

"tab szigorúan a kód indentálására vonatkozik, azonos indentálási szinten belül az egymás alá igazítást szóközzel végzem."

Igazából azt nem értem, hogy azonos indentálási szinten belül mit is kellene igazítani! Azonos indentálási szintnél minden ugyanott kezdődik, tehát nem kell semmit sem eltolni (space-ekkel).

Szerk.: Közben rájöttem, hogy a szóközzel egymás alá igazításon a soron belüli igazítást érted, pl. a változónevek, értékek, ... egymás alá igazítását. (No ezt se látom egy hasznos dolognak)

Régebben TAB párti voltam, mostmár inkább space-t használok.
De úgy hogy a vim-ben továbbra is tab-ot nyomok, ami helyett ő beállítástól függően 2-4 space-t rak...

Az indok: a tab mindenhol máshogy néz(het) ki, míg a space egészen biztosan mindenhol ugyan úgy.

--
zrubi.hu

Regebben tab parti voltam en is, de mostanaban a tabot preferalom inkabb.

Az indok: a tabot mindenki ugy allitja be, ahogy neki tetszik, a space meg biztosan space marad mindenhol. A tab egy egyseg, es megjelenites kerdese, hogy mekkora az egyseg, a spacenak viszont darabja egy egyseg. Arrol nem is beszelve, hogy mennyire utalom visszatorolni a 4-8-12 akarhany spacet (nyilvan ha nem az egesz sort kell torolni).

Egy kerdes, ha spacezel, hogyan oldod meg, hogy tobb sort kijelolve jobbra - balra indentalod oket (aka tab - shift+tab)?

-
Big Data trendek 2016

Nalunk is mindenhol szokoz van, CodeSnifferrel ellenorizve minden commit utan. Ha mas a szabvany az adott projekthez, akkor mi is azzal dolgozunk.

Editorconfig nagyon hasznos tud lenni a szabvany definialasakor, tehat minden IDE (vagy text editor) egyszerre igazodik:
http://editorconfig.org/

Nincs annal rondabb, mint amikor tab es space keveredik. A smart tab az mas, bar egyel tobb dolog, amire figyelni kell.

Két idióta nyelv esetén lényeges, az egyik a whitespace, a másik a Python :-P

Ha már flame wart indítasz:

"arról a formázási megoldásról beszélek, ahol a tab szigorúan a kód indentálására vonatkozik, azonos indentálási szinten belül az egymás alá igazítást szóközzel végzem"

Na én meg sehogy, és mindenkit lebeszélek róla. Pláne erről a stílusról:


foo       = f1;
foobar    = f2;
foobarbaz = f3;

x = foo      (valami);
y = foobar   (valami);
z = foobarbaz(valami);

Több okom is van rá:

  • Csapnivaló editor támogatás, előbb-utóbb elkezdesz kézzel indentálni, emiatt nem használhatod az automatikus formázást, vagyis ha véletlenül nem veszel észre egy formázási hibát, az meg is marad.
  • Ha hozzáírsz vagy törölsz egy sort, borul az egész blokk formázása, tehát indentálhatod újra az egészet. Ez ronda és hosszú diffeket eredményez.
  • Bár elsőre jó ötletnek tűnik, hogy milyen jól olvasható lesz majd a vertikálisan igazított kód, valójában az egész kód jobbra csúszik, hatalmas üres helyeket hagyva a kódsorok közepén, emiatt az eredmény nehezen lesz olvasható.
  • Ha már a formázást kell segítségül hívni, hogy olvasható legyen a kód, az egy igen erős code smell. Ennél már csak a goto jellegű utasítások (return, break, continue), a commentek és külön kategóriában a TODO és FIXME commentek rosszabbak.

Egyébként én is tab párti vagyok, de egy jó editorban igazából mindegy. Egy érvem van viszont ellene: nem minden toolban lehet tab size-t állítani, és valamiért ezekben a toolokban tipikus a 8 karakteres tab, aminél tényleg jobb a 2/4 karakteres space indent.

Err pl. a Scala Style Guide ezt a formát javasolja:


someObjectWithAVeryLongName
  .someMethodWithAVeryLongName(
    firstParameterWithAVeryLongName,
    secondParameterWithAVeryLongName);

Ha csak lehetséges, érdemes a nagyon hosszú nevek helyett rövidebbeket használni.

Megjegyzés: a fenti megoldás esetén könnyen bejöhet TAB-ot használóknál a tab-space keveredés. A második paramétert az elsőhöz szeretné illeszteni és ha az nem tab pozícióra jön ki, akkor egy-pár space és borul is a tisztán tab indentálás.

> Ha csak lehetséges, érdemes a nagyon hosszú nevek helyett rövidebbeket használni.
Ezzel nem teljesen értek egyet, nekem a hosszú nevekkel nincs problémám, sőt.
Inkább legyen hosszú, mint ilyenek: https://youtu.be/BKQ0PxWhqdI?t=4m24s

> Megjegyzés: a fenti megoldás esetén könnyen bejöhet TAB-ot használóknál a tab-space keveredés. A második paramétert az elsőhöz szeretné illeszteni és ha az nem tab pozícióra jön ki, akkor egy-pár space és borul is a tisztán tab indentálás.

Szerintem pont erre írta manfreed azt, hogy smart-tab párti. én tisztán space párti, szóval engem nem érint - de ilyenekre tudom elképzelni a smart-tabot...
--
blogom

"Inkább legyen hosszú, mint ilyenek"

Szerencsére nem csak ebből a kettőből lehet választani. Szerintem a lehető legrövidebb beszédes nevet kell választani, amit csak tudsz. Egy hosszú névnél sokszor egy frappáns, rövid név sokkal jobb, persze ilyet nem mindig egyszerű találni, vagy nem mindjárt elsőre. Erre egy extrém példa: nullaEsHaromszazKozottiSzam vs sebesseg.

"Szerintem pont erre írta manfreed azt, hogy smart-tab párti."

Mindegy milyen tab párti, ha pl. négyes tab-ot használ és az 5. pozícióra akarja igazítani a második paramétert, akkor biztosan lesz benne space, és más tab méret esetén nem lesz jó az igazítás.

Nyilván ha az ötös pozícióra akarok igazítani valamit, akkor azt öt szóközzel igazítom, és mindegy hány karakter a tab, a behúzás és az egymás alá igazítás is jó lesz.

Próbálom amúgy valahogy éreztetni, hogy itt nem arról van szó hogy összevissza keverem a szóközt és a tabot. Nyilván formázásra kizárólag szóközt, behúzásra pedig kizárólag tabot használnék. A behúzásnál ugyanis teljesen mindegy, hogy milyen széles a tabulálás, a formázásnál pedig nem.

Metódus deklarációnál szokás, ha a paraméter lista hosszú több sorra törni, és szokás ilyenkor a paramétereket egymás alá igazítani. Ezt így csinálnám a smart tabbal: (pont = szóköz, --> = tab


-->-->String valamiMetódus(String parameter1,
-->-->.....................String parameter2)
-->-->{
-->-->-->utasítás1();
-->-->-->if (valami) {
-->-->-->-->utasítás2);
-->-->-->}
-->-->}

Láthatod, hogy a tabulálás szigorúan a scope mélységét határozza meg, a szóközzel igazítás pedig azért felel, hogy scope-on belül az egybetartozó dolgok amiknek egymás alatt kell lenniük egymás alatt legyenek. Egyértelműen elhatárolódnak a szerepek, és mindegyik egy olyan feladat megvalósítását segíti amire a legoptimálisabb. Egy okos IDE ebben segít (az enyém teszi) legalább annyira, mint amennyire szóköz használat esetén segítene abban, hogy a szóközöket tabulálásként kezelje, és ne engedjen mondjuk belépni egy szóközökből álló tabon belülre. Azt is láthatod, hogy ha nem 3 karakterből állna egy tab, hanem nyolcból, a kód akkor is ugyanúgy nézne ki, és aminek egymás alatt kell lennie egymás alá kerül.

Ezzel is gond van, több is.

Kérdés: a második sornál, ha 6 tab-ot nyomsz, majd a többit space-szel, akkor is csak két tab-ot rak be és a többi helyre space-t?
1. Ha nem így van, akkor nagyon kell figyelni, hogy mikor nyomsz tab-ot és mikor space-t.
2. Ha így van, akkor a projekten dolgozóknál mindenkinél ilyen tudású editor kell.

3. A fenti formázásnál (amire példát adtál), ha refaktorálják a valamiMetódust, vagy a parameter1-et, akkor szétesik a formázás. (Ez space-esnél is szétesik, tehát ez a pont inkább a formázás ellen szól, ez a formázás nem igazán jó semmire)
4. Ha ilyen formázást használnak:


-->-->String valamiMetódus(
-->-->...String parameter1,
-->-->...String parameter2)
-->-->{
-->-->-->utasítás1();
-->-->-->if (valami) {
-->-->-->-->utasítás2);
-->-->-->}
-->-->}

akkor viszont, akkor lesz nem szép a formázás, ha a space-ek számától eltérő tab hosszúságot használnak. Bár ezt még meg is lehet ideologizálni, hogy így még jobb is. :)

> a második sornál, ha 6 tab-ot nyomsz

Miért nyomnék hat tabot? Nyomok egy entert az első sor végén, és odaugrik a kurzor ahol kell folytatni. Hasonlóan a refactor tool is tudja, hogy ez a coding style, és ennek megfelelően újraformázza a kódot. Legalábbis az én IDE-m ezt tudja. Ha pedig valamiért szét esne, akkor egy auto indent lines hívás megoldja billentyűlenyomásra.

> mindenkinél ilyen tudású editor kell.

Ezt adom, jogos. Azonban a space mellett érvelők mindig azzal jönnek, hogy a space problémáira az okos ide támogatás a megoldás. Akkor most mi van? Az okos IDE csak addig jó dolog, amíg a mi álláspontunkat segíti? (nem szükségszerűen rád vonatkozik ez, akinek nem inge...)

Egyébként megpróbálok space-ekkel élni egy kicsit, szerencsére magánprojektekben megtehetem. Majd mondom a tapasztalataimat

Nevek hosszára van egy egyszerű szabály: minél kisebb a scopeja, annál kevésbé kell egy névnek teljesnek lennie. Pl:


val grossPrices = netPrices.map(p => p * taxRate)

A lambda kifejezésen belül teljesen egyértelmű, hogy a p az egy nettó ár. Persze én is inkább rendes nevet adok a változóimnak, pl. a fenti esetben a price nevet választanám.

Viszont sajnos sokszor látok olyan kódot, amikor a nevek túlzottan implementációfüggőek. Pl:


val grossPriceList = netPriceList.map(p => p * taxMultiplier)

Mi van akkor, ha az árlistáim nem is listák, hanem valamilyen más collectionök? Mi van akkor, ha a taxMultipliert egy másik algoritmusban nem egy szorzás részeként használom?

A fent/lent (kinek mi) már általam linkelt előadásban esik szó erről is.

Szóköz.

A TAB létjogosultsága szövegfájlban erősen kérdőjeles. Ha újra lehetne kezdeni a számítástechnikát, felszólalnék a mellőzése érdekében. Billentyűként a billentyűzeten, vagy ASCII 9-es kódként oké, mint ahogy például a Backspace is, de szövegfájlban (a Backspace-hez hasonlóan) nincs létjogosultsága.

A TAB nem nyomtatható karakter, hanem vezérlő utasítás, a Backspace-hez, Newline-hoz és különféle escape szekvenciákhoz hasonlóan. Termimálba kiírva például nem törli ki (nem írja felül szóközökkel) az átugort betűket, hanem azokat békén hagyva egyszerűen előre ugrik valamennyit a kurzor. A Newline sajnos megkerülhetetlen szövegfájlokban, mivel 2 dimenziós betűtömböt kell 1 dimenzióssá leképezni, így szükség van elválasztó karakterre. A TAB-ra ez nem teljesül, anélkül boldogan lehet élni, és aki megszabadul tőle, az a legegyszerűbb huszárvásággal szabadult meg egy tök fölösleges és ilyesmi vitákra okot adó dologtól.

Egy szövegfájl, sőt, egy forráskód – ezt az egyet leszámítva – a kinézetet specifikálja. Betűk, újsor, melyeknek mind pontos kinézetük van. A jelentést később az IDE és a fordítóprogram adja hozzá. A szövegfájl szintjén nem jön be a szemantika. Nincs olyan karakter, hogy „metódus vége” vagy „osztály vége”, melyet bekonfigurálhatnék az IDE-ben, hogy hány sor kihagyásra szeretnék. (Régesrégen páran a form feed-et használták erre, azóta remélem ez a szokás már rég kihalt.) Nincs olyan karakter, hogy „kódblokk nyit”, amely az IDE preferenciái szerint tenné a nyitó kapcsos zárójelet a sor végére, vagy a következő sorba. És így tovább. A szövegfájl tartalma pusztán kinézet, semmi több.

Kivéve persze a TAB-ot, mert ez az egyetlen karakter szemantikát akar hordozni már a fájl szintjén is. Miért? Nem látok semmi okot, ami létjogosultságot adna neki. Ha nem létezne, senkinek nem jutna eszébe kitalálni.

Ahogy a kapcsos zárójel helyzetével, az operátorok körüli szóközökkel, és kismillió hasonló dologgal kapcsolatban a használt kódolási stílus adja meg a kinézetet, melyet a szövegfájlban meg kell valósítani, nem látom, hogy az indentálás miért érdemelné meg, hogy egyetlen kivételként „meta” szintre emeljük és úgy kódoljunk, hogy a forrásfájl egyszerre többféleképp is kinézhessen szépen olvashatóan.

Aki valaha kilépett már az IDE világából, és cat-olt kódot terminálra, futtatott diff-et, inline-olt e-mailbe, copy-paste-elt stb., tuti sokat szívott a TAB-bal, míg a szóközzel aligha.

> ahol a tab szigorúan a kód indentálására vonatkozik, azonos indentálási szinten belül az egymás alá igazítást szóközzel végzem

Régen én is így csináltam. Megbukik, ha tartanod kell magad valami jobb margóhoz (például 80 oszlopot követel a projekt kódolási stílusa). Megbukik, ha szeretnél jobb oldalt egy szépen kinéző, több (eltérően indentált) soron keresztül átívelő kommentet. De leginkább gyakorlatilag észszerűtlen a karbantartása, leellenőrizhetetlen hogy jól csináltad-e, avagy rakat időt elcseszel a leellenőrzésére, illetve az ezzel kapcsolatos reflexszé váló szokás rabolja hosszú távon az idődet a tényleges kódolástól.

> véletlenül két szint közé kerültem, és elcsúszott a kód [...] elcsúszhat a kód ott, ahol egymás alá igazítás lényeges

Itt kell az IDE-nek segítenie. Ha szóközökkel elcsúszhat, akkor TAB-bal is – mikor szúrod ki, ha a TAB után ott van még egy szókoz?

> problémás volt idegen, máshogy szintezett kódot használni

Fogadjunk, hogy nem jobban, mint másmilyen kapcsoszárójelezésű, operátorok körüli szóközözésű, vagy bármi egyéb szempontból másmilyen stílusú kódot használni.

Nem értem, miért kéne „meta” szinten, vagyis többféle beállítással jól kinéző módon kódolni, ahelyett hogy egyféleképpen írnám meg. Fölösleges pazarlása a szoftverfejlesztői erőforrásoknak.

Ha már érdekel annyira a téma, hogy megkérdezted a HUP-on, határozottan a TAB-ok teljes elhagyását javaslom: Szerintem ez az egyetlen út, amellyel megnyugtatóan lehet egyszer s mindenkorra a legtisztább és leghatékonyabb módon lerendezni ezt a dilemmát.

> észszerűtlen a karbantartása, leellenőrizhetetlen hogy jól csináltad-e, avagy rakat időt elcseszel a leellenőrzésére

vs

>> véletlenül két szint közé kerültem [...]
> Itt kell az IDE-nek segítenie.

Egyébként én pont hogy a jobb margó kötelező betartását tartom hülyeségnek. Értelemszerűen nem írok indokolatlan hosszú kódot, de nagyon áttekinthetetlen tud lenni amikor egy komplexebb kifejezés több sorra van bontva. Itt is tudna segíteni az IDE amúgy is.

>> problémás volt idegen, máshogy szintezett kódot használni
> Fogadjunk, hogy nem jobban, mint másmilyen kapcsoszárójelezésű, operátorok körüli szóközözésű, vagy bármi egyéb szempontból másmilyen stílusú kódot használni.

Python kód összeollózva több különféle forrásból, van ami 4, van ami 3, van ami két szóközzel volt indentálva. Káosz.

> de nagyon áttekinthetetlen tud lenni amikor egy komplexebb kifejezés több sorra van bontva

Itt nincs határozott álláspontom, de meg tudom érteni a margó pártján állókat is. Sokaknak bizonyára jelentős könnyítés, ha előre belövik a szövegszerkesztőt adott szélességre, és tudják biztosra, hogy vízszintes görgetés nélkül ki fog férni minden. Sokat javít a kód átláthatóságán, ha csak egy dimenzió mentén kell görgetni, nem kettő mentén. Évekig kódoltam 80-as margóval (és mellesleg két szóközös indentálással), sima ügy volt (kivétel csak speciális esetekben volt megengedett, például kommentben ennél hosszabb URL).

> Python kód összeollózva több különféle forrásból, van ami 4, van ami 3, van ami két szóközzel volt indentálva. Káosz.

Erre praktikus az IDE támogatás ami villámgyorsan berakja/kiveszi a szóközöket.

múltkor pythonoztam egy keveset, s a falnak mentem a PEP8 79 karakteres margójától... (pedig alapvetően szeretem a pythont...)

ráadásul olyan szinten erőszakos volt a PyCharm, hogy a

....def test_should_do_something_when_an_one_condition_and_an_other_rare_condition_is_met(self):

függvénynevekben kitörte a

self

paramétert új sorba. Jajj.
Vagy ha volt egy kicsit hosszabb sztring a kódban, ugyanez...

nem tartom a kötelező-margót ördögtől valónak, de a függőleges monitoromon is kifér 100-120 karakter. Ráadásul engem kevésbé zavar, ha egy sor hosszú - ha van egymás alatt öt, 78 karakter hosszú sor, az jobban zavar, mint ha egy sor lenne 115 karakter. azt az egy sort még fejben tudom tartani :)
--
blogom

> Erre praktikus az IDE támogatás ami villámgyorsan berakja/kiveszi a szóközöket.

Őszintén megmondom nem tudom, hogy az IDE-m milyen támogatást ad erre. Tud kód újraformázást beillesztésnél, de python kódnál egyszerűen elrontja, mert ha pl öt szóközzel van indentálva a kód, amit beillesztek, de én négyet használok, akkor ő négyre számít, és aszerint formázza újra a kódot. (Legalábbis így rémlik, rég volt, hogy próbálkoztam ilyesmivel)

"Sokat javít a kód átláthatóságán, ha csak egy dimenzió mentén kell görgetni"

Ezt adom, de erre való a jó IDE-kben a soft wrap, ami okosan töri a sort (megfelelő behúzással folytatja a következő sorban, nem a sor elején). A fullhd monitorok korában, de akár még az 1366-os laptopok korában is, elfér azért egy képernyőn több mint 80 karakter.

A 80-at céges style guide határozta meg, nem én találtam ki és nem is értek egyet vele. Manapság amit kódolok ott nincs szigorú limit, érzésre próbálunk olyan 100-120 körülit tartani. Ha muszáj lenne fix határt szabni, akkor is valszeg ilyesmi 100-120 körüli értékre szavaznék. Úgy is, hogy gagyi 1366-os laptopot használok.

"A fullhd monitorok korában, de akár még az 1366-os laptopok korában is, elfér azért egy képernyőn több mint 80 karakter."

Azért van számos előnye is a szűk margóknak.
Amíg írja valaki a kódot, addig valóban érthetetlen, hogy miért is kell szűk margók közé kényszeríteni magunkat.
- Ha viszont egy távoli gépen kell megnézni egy egyszerű nézegetővel, akkor fájdalmasan érinthet minket a zanzásított kód.
- Ha debuggolni szeretnénk és a kód mellett az outputot, a beállított töréspontokat, változók értékeit (...) is akarjuk egyszerre látni, akkor megint csak előny a szűkebb margó.
- Ha egymás mellett szeretnénk több kódot is nézni, akkor is előny.
- A szűkebb margó kicsit kényszerít is, hogy jobban átgondold, hogy mi is kerüljön egy-egy függvénybe, milyen mélységű elágazások legyenek, milyen hosszú azonosítókat használj, ...

Igazad van és éppen ezért nincs igazad.
"A TAB létjogosultsága szövegfájlban erősen kérdőjeles."
"...ASCII 9-es kódként oké..."
Ezek a jó meglátások, de nem teljesen ismerted fel az okát.
Miert jött létre ez a topic? Bizony az új fejlesztéseknek köszönhetően! Gondolj bele, az itt fórumozók jó része írógépről legfeljebb töriórán hallott, sornyomtatót a múzeumba látott, terminált esetleg "használt", azaz betűket írt-olvasott rajta, de valójában lila gőze sincs a képességeiről.
Az új fejlesztés lényege, hogy valami korszakalkotót, világmegváltót és minden eddiginél jobbat készítünk. Miközben azt sem ismerjük, aminél jobbat csinálunk! Hosszú tapasztalatom szerint ilyenkor lép fel a funkcióvesztés.
A válasz nagyon egyszerű. A TAB (alias tabulátor) az egy írógép alapfunkció. Lehet fix értéke, de a táblázatok kitöltésének megkönnyítése végett programozható!. Teccik érteni, soft tab az írógépen! Ilyen hagyományos funkciók a margó, az automatikus (és állítható nagyságú, vagy kihagyható) soremelés és még sokan mások... ("+1 a margóra" :( )
Sornyomtató és terminál esetén pl. a "form" kitöltését lehet TAB segítségével vezérelni. Ezek már akkor működtek, amikor még DOS sem létezett!
Nincs egy darab class sem, hanem ahogy korábban írtam "ASM forrásnál 13, 25 és 49 a megfelelő pozíció". Ez egy írógépnél 3 mozdulattal beállítható! Nem hülyék találták ki. Viszont a fejlett IDE, nem enged beépíteni más szövegszerkesztőt, miközben a CR/LF egyes variációjít mocskosul összekeveri. De nem kell aggódni, van egy checkbox a konfigurácíóba, amely hatására ezeket a hibákat kijavítja. Jó ideig törtem a fejemet, hogy mennyi esze lehetett annak, aki ekkora szart hozott össze. Így ebben az esetben marad a tabstop=4 és a 13. pozícióhoz hármat nyomok. Másik forradalmian új szövegszerkesztőnél meg másképp.

Amíg ilyenek léteznek, addig van létjogosultsága a tabnak.
Egyébkén meg miért ne adnám meg a formázást? Hiszen html-ben is megadom. ;)

> Ezek a jó meglátások, de nem teljesen ismerted fel az okát. Miert jött létre ez a topic? Bizony az új fejlesztéseknek köszönhetően! [...] Az új fejlesztés lényege, hogy valami korszakalkotót, világmegváltót és minden eddiginél jobbat készítünk. Miközben azt sem ismerjük, aminél jobbat csinálunk! Hosszú tapasztalatom szerint ilyenkor lép fel a funkcióvesztés.

Biztos bennem van a hiba, ne haragudj, de ebből én egy kukkot sem értek.

> A válasz nagyon egyszerű. A TAB (alias tabulátor) az egy írógép alapfunkció.

A tabulálás, vagyis a gyorsan-kényelmesen adott helyre ugrás egy írógép alapfunkció. Hasonlóan, szövegszerkesztőkben is fontosnak tartom, hogy ez megmaradjon a számtalan egyéb kényelmi funkció mellett. Ugyanakkor a papíron nem marad nyoma annak, hogy te hol használtad ez a kényelmi funkciót a szóköz megfelelő számúszor leütése helyett, és ugyanígy szövegfájlban sem lenne szabad hogy nyoma maradjon.

> Egyébkén meg miért ne adnám meg a formázást?

Látod, pontosan ezt mondom én is. A szóközökkel megadod, a szövegfájlban eltárolt tabbal nem (mivel azt mindenki másképp fogja megjeleníteni).

Kívánságodra a hosszú lét lerövidítem.
Addig, amíg minden szövegszerkesztő nem tudja azt a minimumot, amit még egy írógép is tud, kényszerből hordozni kell a formázási információt. Az a funkcióvesztés, amikor egy írógépnén sokkal többet tudó szövegszerkesztő kevesebbet tud, mivel még az írógép alapfunkcióit is kifelejtették az alkotók. És a példaként említett IDE ragaszkodik a saját ostoba szövegszerkesztőjéhez. (Ez is csak egy példa, de történetesen ezzel dolgozok.)

"mivel mindenki másképp fogja értelmezni"
Nem.
IDE - Tab size: 4, Keep tabs
fordító - list n=0, b=4 (nem kérek FF-et és tab size=4)
külső editor - tabstop=4
nézegetés -> pdf
Ez csak egy bizonyos eset, de odafigyeléssel az összes formátum egyformának látszik.

Megadnám én szóközökkel a formázást, de sokkal több billenytűt kell néha lenyomni. Pedig még írógépen is volt olyan, ahol a "BACKTAB" működött!

Esküszöm, továbbra sem értek egy kukkot sem hogy miről hadoválsz.

> Addig, amíg minden szövegszerkesztő nem tudja azt a minimumot, amit még egy írógép is tud

Csomó mindent tud az írógép, amit szövegszerkesztő szerintem egy sem. Betűk felülírása, a billentyűleütés ereje szerinti vastagság-színteltség, stb. Nem értem, mi a rákot akarsz kihozni az írógépes analógiából.

> kényszerből hordozni kell a formázási információt

Dafuq, de most tényleg?

> Az a funkcióvesztés, amikor egy írógépnén sokkal többet tudó szövegszerkesztő kevesebbet tud, mivel még az írógép alapfunkcióit is kifelejtették az alkotók.

Hát komolyan, mi nem egy nyelvet beszélünk.

> IDE - Tab size: 4, Keep tabs [...]

Tehát nem azért 4 szóköz, mert a fájlban ez benne van, hanem mert néhány szoftvert magadnak így konfiguráltál be. De a szomszéd srác gépén már nem 4, hanem akármennyi; ha terminálba cat-olod, akkor nálad is 8, ha "diff -u"-t futtatsz, akkor a sor elején 7 (utána már 8), stb. Na ez az a problémakör, ami szóközök használata esetén nem létezik. Egyszerűen egy fölösleges szopófaktort kiiktatsz.

> Megadnám én szóközökkel a formázást, de sokkal több billenytűt kell néha lenyomni.

Ismétlem, bár azt hiszem elég egyértelműen leírtam már: Nem azzal van bajom, hogy létezik egy gyors kombó, sőt akár egy külön dedikált billentyű a billentyűzeten, amelyik 4-8-akárhány oszloppal arrébbviszi a kurzort. Igenis legyen! Az nem tetszik nekem, hogy a végén a fájlba TAB karakterek kerülnek szóközök helyett.

Két eset van:

Az egyikben a nyelvben számít, hogy tab vagy szóköz van bizonyos helyeken (pl. Python) --> itt egyértelmű, hogy mit és hogy kell használni, hiszen az eredmény eltér attól függően, hogy tab vagy szóköz.

A másikban a nyelvben nem számít, hogy tab vagy szóköz vagy mindkettő van, a kód olvashatósága miatt használjuk bármelyiket is --> itt sosem értettem, hogy miért kell hülye szövegfájl-formázásokkal játszani (akár tab-szóköz, akár sorhossz, akár hasonlók kapcsán), helyette ezt javaslom:

- a fájlban írjuk le, hogy "if(a>1){print(b);};"
- az egyik fejlesztőnek jelenítsük meg így:

if ( a > 1 ) {
print(b);
};

- a másik fejlesztőnek meg így:

if (a>1)
{
print(b);
}
;

Vagy ahogy akarják. Mindaddig, amíg ezek eltérő eredményre nem vezetnek, csak akarat kérdése, hogy hol így, hol úgy jelenjen meg a kód. Persze vannak idegesítő mellékhatások, pl. az, hogy a "hányadik sorban van a print(b)" kérdésre nincs egyértelmű válasz, dehát valamit valamiért :-)

A miért ne használj leírásban:

"Thus, hard tabs may break source code readability and editability if there is more than a single person editing the file. "

Én ezt igazán nem értem. Nem pont az okozna problémát, ha beleszerkesztek a négy szóközre beállított szövegszerkesztőmmel egy három szóközzel indentált fájlba?
Miért okozna problémát az, ha egy tabot másképp jelenít meg a szerkesztő. Tény, hogy nem teljesen ugyanazt látod. Kinyúlik, vagy zsugorodik a kód szélességre. Naés? Pont ez a jó benne, mindenki kedvére állíthatja be anélkül hogy befolyásolná hogy más mit lát.

Egyébként a miért használj tab-ot cikket erősen javasolnám minden space hívőnek, sokkal jobban elmagyarázza azt, amit nekem nem sikerült jól átadnom az érveléseim során. (szóköz igazításra miért oké, szóköz indentálásra miért problémás, stb)

"Én ezt igazán nem értem."

Szerintem azért nem érted, mert azt gondolod, hogy mindenki ugyanolyan jól kezeli a TAB és Space billentyűket indentálásra (csak TAB) és igazításra (csak Space), mint Te és sehol sem fog soha keveredni. Nekem az a tapasztalatom, hogy ez nem így van. Legtöbben nem igazán foglalkoznak vele, hogy éppen indent vagy igazítás van, ha sok helyet kell kitölteni (pl. 10), akkor nyomnak pár tab-ot (pl. 2-őt 4-es tab beállításnál) és pár space-t (pl. 2-őt). Ha ott éppen sor eleje volt és csak egy indentálási szint, vagy sor közben csak igazítás miatt kellett, akkor máris elromlik a megjelenés más tab méret esetén.
Míg soft tab-os (csak space kerül be tab lenyomásakor is) esetben, a fentihez hasonló, nem törődöm embereknél (én is ilyen vagyok, nem igazán akarok azzal foglalkozni, hogy az üres rész melyik része indent, melyik igazítás) nem lesz ilyen gond, ha szemre jó lesz nálam, akkor mindenkinél jó lesz.

Értem mire gondolsz. Az igazság az, hogy én csak azt nem akartam feltételezni, hogy azért lehet rossz a tool mert rosszul is lehet használni.

Az én igényességem a kódomra kimerül abban, hogy alkalmanként (commit előtt pl) megnyomom az automatikus auto indent funkciót az IDE-ben, ami a beállított coding style alapján helyrerakja a dolgokat, még ha el is rontanám, és túltabolok.

"Egyébként a miért használj tab-ot cikket erősen javasolnám minden space hívőnek,"

Én meg a miért ne használj leírásában a 4. pontot (Style guides) javasolnám megtekintésre, talán ez a legerősebb indok mind felett, azaz a legtöbb nyelvnél az ajánlott a soft tab megoldás (space).

> Nem pont az okozna problémát, ha beleszerkesztek a négy szóközre beállított szövegszerkesztőmmel egy három szóközzel indentált fájlba?

Ez problema, de ha a fajl olvashato volt nalad akkor olvashato marad masnal is. A kevert tab-space sokkal rosszabb dolgokat szokott okozni.

Ez teljesen igaz. Odafigyelést igényel ha az ember tabot használ, és szóközzel igazít. Küldtél nekem privátban egy példakódot, gyötrelem, és értem amit mutatni akarsz. Viszont én saját tapasztalatból azt tudom mondani, hogy legalább annyi odafigyelést igényel az, ha csak szóközökkel igazít az ember. (vagy ez, vagy én vagyok béna :))

Amikor szóközzel igazítottam hajlamos voltam elrontani azt az esetet, amikor egy többszintű if-ből tértem vissza pythonban. Három szint, az 12 szóköz visszatörlése. Olyan könnyű eggyel több, vagy kevesebb backspace-t nyomni, és ugye pythonnál nagyon nem mindegy. De jártam már úgy, hogy csak utólag vettem észre egy kódomban, hogy egy blokkot csupán három szóközzel húztam be, nem néggyel. Persze egy okos IDE segít ebben. De egy okos IDE abban is segít, hogy a tabokat és a szóközöket jól használd, tehát igazából ez nem érv egyik irányba sem.

Amit még írtál, hogy a gyakorlatban nem sokat számít az, hogy állatható legyen a tab mértéke. Ezzel igazából nagyrészt egyetértek. Azért nagyrészt, mert azért van egy eset, amikor hasznos tud lenni, de még valójában sose kellett élnem vele.

Tegyük fel egy szűk ablakban dolgozol egy java kódon. Két indentálási szint mire eljutsz a metódus írásáig, tegyük fel van még egy try-catch blokkod, azon belül egy switch. A tényleges utasítások így már az ötödik szintnél kezdődnek, 4 szóközzel számolva az 20 karakter.

Ha szóközzel van formázva a fájl, akkor azzal nincs mit tenni, így néz ki. Ha viszont tabbal, akkor átlőheted a tab méretét 2, vagy akár 1 karakterre is. A kód nyomottabb lesz, de kisebb helyen elfér, mondjuk egy szűk terminálban. Vicces egyébként, hogy fentebb valaki pont a terminállal példázódott, miszerint ott nyolc karakter a tab, de valójában ez is állítható.

Nekem csak a tab indentalasra.
Azt is elmondom, hogy miert: az valtozik, hogy hogyan esik jol olvasni a kodot, van, hogy a negy space kellemes a szememnek, van, hogy a ketto, van, hogy a nyolc. Ha tabbal indentalok, akkor ezt barmikor meg tudom valtoztatni menetkozben.
Semmi ertelme nincs annak, hogy space-szel indentaljunk.

A világ legértelmetlenebb témája. Döntse el adott cég/projekt, aztán mindenki kövesse azt.

Nálunk pl. ez meg van mondva, oszt' kész:
https://google.github.io/styleguide/cppguide.html#Spaces_vs._Tabs
https://google.github.io/styleguide/javaguide.html#s4.2-block-indentati…

Személy szerint régen Visual Studióval nyomtuk a cégnél, ami default space-es beállítással települ. Én írtam egy style guide-ot, meg volt mondva, illetve group policy is volt rá, hogy ezt tabra cseréljük. Aztán olyan sűrűn találkoztunk nem tabos kóddal, meg folyton jött ki új Visual Studio, meg mittudomén (kb. 3 éve volt, jellemző, hogy annyira lényegtelen téma, hogy már nem is emlékszek rá), feladtam a küzdelmet, töröltem a group policyt, és inkább az lett a mondás, hogy egy az egyben default formázást használunk, és kész. Ahogy a világon senki más, én se tudtam egyértelműen eldönteni, melyik a jobb, de a space volt egyszerűbb és elterjedtebb, ennyi.

Most is inkább space felé hajlok, de az IDE-re bízom az automatikus indentálást (asszem tab billentyűt nyomok túlnyomó többségben, az meg csinál vele, amit akar). Ha valaki elémrak egy máshogy konfigurált IDE-t, ami automatikusan jól tabozik, és nekem nem kell vele foglalkozni, eszembe se jutna küzdeni vele. Lényeg, hogy részemről minimális erőfeszítés legyen a stílust követni. Ennek a vitának se látom értelmét, de azért csak hozzászóltam :).

--

"A világ legértelmetlenebb témája. Döntse el adott cég/projekt, aztán mindenki kövesse azt."

Azért nem az, mert a cég/projekt döntésénél is fontos, hogy melyik miért jobb/rosszabb, mint a másik.

Illetve a fentieknek Te magad mondasz ellent:
"Én írtam egy style guide-ot, meg volt mondva, illetve group policy is volt rá, hogy ezt tabra cseréljük. Aztán olyan sűrűn találkoztunk nem tabos kóddal"

Tehát nem csak annyi, hogy egy cég/projekt eldönti és mindenkinek kiadják, hogy kövesse azt, hogy ha azt nem lehet/tudják/akarják követni.

"Lényeg, hogy részemről minimális erőfeszítés legyen a stílust követni."

Pont ez a hátránya a TAB-osnak, mert ott kell egy kis erőfeszítés, amit egy projektnél biztosan lesz egy pár ember, aki nem fog megtenni.

Arra gondoltam, hogy egy cég/projekt esetén egyszer persze le kell futni ezt a kört, de az újra meg újra feltűnő flamewarok már nem túl produktívak. Annak meg végképp semmi értelme, ha eltérő helyeken dolgozó emberek próbálják egymást meggyőzni, és ilyen szándékom nem is volt.

Egy jó IDE esetén a legtöbb indentálásnak automatikusnak kellene lennie. Tehát amikor a sor végén { van, és nyomsz entert, magától beljebb ugrik, stb. Illetve ha egy blokkot beljebb/kijjebb akarok tolni valami refaktor miatt, és esetleg nem történt meg magától, akkor kijelölök több sort, tab/shift tab, és megy a helyére, őrültség lenne soronként space-eket/tabokat rakosgatni. Ha megszokja az ember a tab gombot, akkor már tök mindegy, hogy az IDE milyen karaktert tesz oda. De biztos van olyan is, akinek jól esik a sok space nyomogatás :).

--