@Viperion: A nullable adatbázis kezeléshez való, mert ott lehet null egy szám is. Nem hiszem, hogy játéknál ennek van különösebb jelentősége az meg, hogy pontosan hogy működik a háttérben nem tudom mire kell neked. Ilyen mélyen egy scripteléshez szerintem fölösleges beleásni magad, inkább az erős alapokkal legyél tisztában.

Hali mindenkinek.

Kicsit belemélyedtem a hálózatkezelésbe. Fogalmam sincs, hogy nekem melyik lenne a legideálisabb és legkönnyebb megoldás/módszer. Igazából valamilyen szinten valós idejű adatátvitelre lenne szükségem, mivel kisebb 2D-s alapú játékhoz szeretném használni majd. Ezt még nem tudom előre hogyan fog kinézni, lehet hogy több player is játszhat benne (de ebben az esetben max olyan 10), vagy pedig egy szimpla 2-4 személyes mód lesz benne (talán ez a biztosabb).

Amit tudok biztosan (elméletben):

-nem high FPS-vel kell kommunikáljanak a kliensek egymással és/vagy a szerverrel
-az adatfrissítést/átvitelt mádospercenként elég lenne 5-10x elvégezni
-az üresjáratokat (amikor éppen nincs frissítés/adatátvitel) kliens oldalról vezérelném, tehát pl. ha valaki halad X koordinátán egy bizonyos tempóval, akkor 5 FPS-nél nem akadozva mutatná azt, hanem ha a kliensnél az volt az utolsó adat pl, hogy halad X-en 3F-el azzal a meghatározott képkockákkal + még ami statikusan meg van határozva, akkor a következő frissítésig ezt látja a kliens, hogyismondjam offline vezérelné azt az objektumot a saját programjában, és igy az összes kliens ezt tenné, és 5-10x küldene és kérne le adatot.

Nem tudom ezt mások hogyan szokták megoldani, és hogy az általam felvázolt módszer marhaságnak minősül-e, vagy pedig van valami haszna egyáltalán (sávszélesség kímélés céljából és hogy többen tudjanak kommunikálni a ritkább frissítési rátának köszönhetően).

Amit nem tudok, hogy pontosan mit és hogyan használjak, egyáltalán elég-e nekem a PeerToPeer (a mindenki mindenkinek egyenrangúan küld adatot módszer) vagy jobb a SzerverKliens? Eddig ezt az 1 darab példát tudtam úgy ahogy értelmezni és elsajátítani:

Kommunikáció TCP/IP-n keresztül

A legfőbb problémám ezzel, amikor ez a rész van, hogy:

"Indítás után, ha meghívjuk az AcceptSocket függvényt, akkor ezzel a programunk futása felfüggesztésre kerül, amíg nem érkezik kapcsolatfelvétel az adott porton keresztül. Ezért célszerűbb ilyen esetben egy külön szálon futtatni a TCP port figyelését és kiszolgálást, hogy alkalmazásunkat a felhasználó ettől függetlenül is használhassa."

1. Hogyan tudom én ezt külön szálon futtatni?

2. Egyidőben nem tudnak többen csatlakozni egy porthoz ez ok. Ezt eddig úgy tudtam megoldani, hogy a kliens minden pillanatban amikor csatlakozni szeretne új csatlakozást létesít és indít a szerverrel, megkapja a szükséges adatot Byte formában (ezt utána átalakítja), majd bezárja a csatlakozást. Ez így szép és jó, csak hát barbár megoldás gondolom, hogy mindig "ki-be" járkálni egy ajtón.

3. Maga az üzenet/adat felhasználása, vagyis ez az egész hálózatosdi rendszer tényleges felhasználása az elemeknél/objektumoknál. Hogy is van ez?

Én eddig ezt tudtam megcsinálni:
Van a szerver és a kliens. Mindkét oldalon van egy darab statikus label1, semmi több. A Form bal felső sarkában vannak startban. A kliens az egyszerűség kedvéért nem küld a label állapotáról semmit, csak fogad üzenetet a szervertől. A szerveren azt csinálja a program, hogy a label1 halad X koordinátán jobbra, majd ha eléri a Form szélét, akkor visszaugrik 0-ra. A szerver is és a kliens is használ az egyszerűség kedvéért most egy-egy Timer-t, ez tickel 100-as intervallumon (A fenti probléma adott, hogy nem külön szálon fut a port figyelése, ezért legalább egy darab kliens applikációt meg kell nyissak). Ezután ha kap lekérést a klienstől elküldi neki a label1 X koordinátáját üzenetben mint Byte. A kliens ezután a fent említett barbár módon mikor megkapta az adatot, azt átalakítja majd átadja a label1-nek mint X pozíció, majd ugyanezt az értéket átadja mint label1.Text. Ez így szépen működik, de édeskevés a boldogsághoz.

A kérdésem eléggé tág...ezen infók tudatában ti mit ajánlanátok a fent említett igényeknek megfelelően, és hogy lehetőleg könnyű is legyen megérteni/elsajátítani? Ez kicsit hosszúra sikeredett. Természetesen ha ez így 1x összejön, akkor XNA/MonoGame-ban szeretném alkalmazni.

pretender így már értem.
Egyébként tisztában vagyok az interface-kkel meg a többivel csak pár dolgot nem értek.
Ja igen még nem szoktam érteni a szándékosan csavaros magyarázatokat sem.

Már csak azt nem értem,hogy a nullable típus ami egy struct(értéktípus) miért lehet null.
Ha jól tudom,akkor az érték típusok nem lehetnek null-ok.

De viszont a nullable ami egy struktúra igen.
Miért?

int? i = null; Ez miért működik miért rendelhető hozzá a null ha a struct egy érték típus?

Szerintem:
Van neki egy olyan operator= metódusa ami bemenő paraméterként egy referenciát vár?Ez a megoldás?Vagy hogy van ez?

Idézet

---

Viperion :
A property-t értem már.

De ezt nem értem még mindig.
Nem lehetne még egyszerűbben?

"A T típus megszorítására szolgál."
Ennek semmi értelme.Mi az,hogy megszorítnai egy típust?

---

A típusok puhányok, addig kell szorongatni őket, amíg el nem kékülnek, vagy zöldülnek attól függően, hogy értékesek, vagy csak referálnak.
Egyébként itt érdemes szétnézni van sok okosság: C# pdf és videók

Az a lényeg, ha azt mondod ott a T-re, hogy "where T : IComparable", akkor a T típus helyére nem írhatsz be olyan típust, ami nem valósítja meg az IComparable interfészt. Ennél egyszerűbben nem lehet elmondani... Tisztában kell lenni néhány alapfogalommal, pl. mi az, hogy típus, öröklés, interface megvalósítása, stb.

A property-t értem már.

De ezt nem értem még mindig.
Nem lehetne még egyszerűbben?

"A T típus megszorítására szolgál."
Ennek semmi értelme.Mi az,hogy megszorítnai egy típust?

A where egy minimális angol tudással és hozzáértéssel pedig kitalálható... A T típus megszorítására szolgál. Annyit mond, hogy a Stack olyan típusú elemeket tárol, amik IComparable-k (pontosabban ezt az interfészt megvalósítják).

A property meg lehet getter, vagy getter és setter. Nagyjából csak annyi, mintha lenne egy függvényed, amivel le tudod kérni az értékét / tudod módosítani. Annyival több a getter-setter property, mintha public lenne a változó, hogy (mivel a függvényekhez hasonlít a viselkedése) egyéb utasításokat is végre tudsz hajtani előtte.

Keress példákat a neten, rengeteg van, abból jól meg lehet érteni ezeket.

Eltudná nekem valaki hozzáértő magyarázni azt,hogy a "where" kulcsszót mire használják c# ben?
És azt is,hogy a propetyk azok micsodák?

Ebből nem sikerült megértenem,hogy mire van a where:
Alapértelmezésben a generic server kódjában csak az Object típuson való metódusok és property-k engedélyezettek. Ha más metódusokat is szeretnénk használni, akkor a generic fejlécében jeleznünk kell, hogy a paraméter típusnak milyen osztály vagy leszármazottja, esetleg milyen interfészek felelnek meg, ezt a where kulcsszó segítségével tehetjük meg.

pl: public class Stack<T> where T : IComparable

----
Ebből pedig az nem sikerült,hogy mi az a property:
A 'Property' egy komponens névvel ellátott értéke. Például, egy gomb rendelkezhet a „text” property-vel, ami a megjelenítendő szövegre utal.


Egyszerűbben megtudnátok őket fogalmazni?

Olvasnivaló, avagy a string miért immutable.
Nem olyan nehéz megérteni. Referencia típus, mivel osztály, de írásvédett, mert az hasznos.

Miért olyan nagy pain in the ass ez? Ha paraméterként kell átadni, és nem akarod, hogy copyzza, akkor megjelölöd referenciaként: (úgy rémlik, hogy lehet ilyet )

m4 ha úgy van ahogy írtad akkor a string nem is referencia típus.
És mégis annak nevezik.Kezdem felhúzni magamat ezen.

Pretender:
Az érték szerintieknél az hiszem mindig copy constructor vagy ahhoz hasonló van mert egy másolatot mindenképp létre kell hozni ahhoz,hogy bele lehessen rakni az valamibe.
Úgyhogy ha a stringnél és az Object típusnál másoló konstruktor van ami egy másolatot ad vissza méghozzá az értékről az nem mondható ref típusnak.

Úgy,hogy hiába a bedobozolás is mert nem tudom másképp kezelni őt mint egy érték típust.
Csak class oknál működött nekem eddig többit még nem próbáltam az Object és a Stringen kívül.

Gondolom c#ban is van valamiféle copy-constructor. Gondolom a String a kevés olyan osztályok közé tartozik, amikor ha azt mondod, hogy a = b, akkor nem csak rámutat, hanem lemásolja az eddig b-ben lévő string tartalmát. De amúgy fogalmam sincs.
Itt beszélgetnek róla.

Ezt nem értem.
Ha a stringek referencia típúsok,akkor ebben az esetben:
string s1 = "QJ", s2 = "PL";
s1 = s2; //Ha referencia típús,akkor itt s1 nek ugyanarra a memóriaterületre kellene,hogy mutasson mint az s2.De nem ez történik,akkor most miért van az,hogy a stringet referencia típúsnak nevezik?
Akkor most mi a külömbség a érték típúsok és a referencia típúsok között?

"most s1 nek arra a memóriaterületre kell,hogy mutasson amire s2 is mutat"
Nem, hanem a "ppppp" string memóriaterületére. A stringek amúgy sem változnak (az értékek), mert immutable-ek (megváltoztathatatlanok) javaban legalábbis. Szóval nem is lehetne gond ebből.
A "ppppp" azt jelenti, hogy létrejön egy string objektum ezzel az értékkel. És értékadáskor ennek a címét kapja meg az s1.

Van egy c# jegyzet azért tanulom a benne írtakat mert c++ ról át akarok szokni c# re az unity miatt.

Azt írta a jegyzet,hogy a referencia típúsok és az érték típúsok közti külömbség az,hogy ha egy érték típúshoz ha hozzárendelek egy másik érték típúst,akkor azok nem fognak egy memóriaterületre mutatni de referencia típúsok esetében igen.

Például:

Mivel ezek érték típúsok ezért nem lesz az,hogy x ugyanarra a memóriaterületre fog mutatni mint az y; Csak az értékük lesz ugyanannyi.

Példa2:

Ebben a példában azért fog 5 lenni a kimenet mert a class-ok referencia típúsokat hoznak létre ez miatt az történik,hogy p arra a memóriaterületre fog mutatni amire s.A p egy alias lesz s re.

Amit én nem értek az az,hogy a jegyzet szerint a string típús is referencia típús de mégis úgy viselkedik mint egy érték típús.

Példa:

most s1 nek arra a memóriaterületre kell,hogy mutasson amire s2 is mutat,
mert a string referencia típús.Ha most megváltoztatom s1-et,akkor s2 nek is változnia kell.

Ha a stringek referencia típúsok lennének,akkor most s2 nek egy alias-a kellene,hogy legyen s1.
De nem az mert s2 értéke nem változott s1 hatására.

Akkor most,hogy van ez?

Vagy itt van ez:


A bedobozolás arra van,hogy megengedjük egy érték típúsnak,hogy referencia típúsként viselkedjen.
Ez hülyeség!Meg a stringeknél is.Ez csak class oknál működik.

Mégsem jó úgy, ahogy akartam... Adott egy c# control, annak van egy Handle property-je.
Ezt át akarom adni a c++ kódnak, és ott HWND-t csinálni belőle. Első körben úgy ellenőrzöm, hogy lekérem a méretét (GetClientRect), és kiírom egy file-ba.

Így próbálom az egészet:


szerk.:
Hmm, mégis csak működik.

Idézet

---

versio :
Pretender: kiprobalhatjuk ki a bena, irjal c++-ban egy olyan programot ami 10 millio floating szamot sorbarendez, en c#-vel leverlek 10-szeresen abban biztos vagyok

---

Programozási időben igen, viszont a programod futási ideje és általa lefoglalt memória méretét tekintve szerintem nem a ráfordított kódolási idő a lényeg! Persze megvannak mindkettőnek az előnyei és hátrányai is.

ha public a valtozo pl :

public alma = 10;

akkor unityban az inspector ablakban is megjelenik a script reszlegben, es jatek kozben is allitgathatod

A c++11 ben lehet.

mintha c++ban is lehetne

de c#-nel ilyen felesleges baromsagokra nincs szukseg, mert a valtozok deklaralasakor mar erteket lehet neki adni

class gyumulcs
{
int alma = 10;

public gyumulcs()
{
}
}

Ja akk sorry én nem C++ -zok.

Itt azt mondják, hogy nem lehet.

Idézet

---

The first one is not legal in C#

---

Nem ez érdekelt.
Elmagyarázom.
A c++ ban ahogy c# ben is a típusoknak van konstruktoruk.
C++ ban a konstruktornak nincs visszatérési értéke csak neve és bemenő paraméterei,inicializáló listája és törzse.

Itt egy példa:
class myType {
public:
myType(int, bool);
private:
int itsX;
bool itsV;
};

/*Figyeld meg,kettőspontot tettem a bemenő paraméterei után.A kettőspont azt jelzi,hogy amit utána írok azt a konstruktor inicializáló listájába fogom írni.Oda csak értékadó műveletek mehetnek egyéb kifejezések nem.Legalább is c++ ban*/
myType::myType(int x, bool v):
this->itsX(x),
this->itsV(v)
{
//Ez pedig a konstruktor törzse ide jöhetnek mondjuk a számítások
}

int main() {
myType type(4444, true);
return 0;
}

Értitek már ugyanezt akarom c# ben.
Nem a konstruktor törzsében akarok a tagváltozóknak értéket adni hanem a konstruktor inicializáló listájában.

Pretender nem láttam a te hozzászólásodat csak miután ki írtam az enyémet bocsi de azért jöhetne részletesebb magyarázat erre.

Ez azt jelenti,hogy c# ben ez nem lehetséges?

Ha jól tudom c#ban nincs initlist. Legalábbis nem valid.

@Pixi: nem listáról volt szó, hanem inicializáló listáról, ami c++ban egyszerűen használható:

Ezt nézted már?

msdn.microsoft.com/en-us/library/vstudio/bb397680(v=vs.100).aspx

// The default constructor has no parameters. - ebből azt veszem ki, hogy az alapnak nincs meghatározott paramétere, azt a példa legalul szintén úgy hozza létre egy Lista segítségével:



Azért remélem ír valami hozzáértőbb személy is, mostmár én is kiváncsi lettem mit szeretnél pontosan.

Én csak azt akarom megtudni,hogy egy c# osztály konstruktorának az inicializáló listájában(Nem a törzsében),hogyan inicializálunk változókat. Erre választ nem találok sehol .

Lehet, hogy nem teljesen értem amit akarsz. Szóval te példányostani szeretnéd magát az osztályt, méghozzá úgy, hogy egy listában is számon tartod az elemeket? Én most XNA-s projektból másolok egy egyszerű példát, ugye ez is C#:



ui: ja most látom nem a listába helyezés volt a kérdés Én publikáláskor a zárójelben is ugyanazt a nevet használom, mint az adattagoknál, de ettől még ugyanúgy működik ez ne zavarjon össze.

C# nek,hogyan kell használni a konstruktor inicializáló listáját?
C++ így jó volna de itt c# ben nem akar működni.Meg oldható ez valahogy az inicializáló listában ha igen,hogyan?
public EszrevetelClass(Transform _otherTrans, Transform _originalTrans, float _speed = 4.0f):
this.other ( _otherTrans),
this.original ( _originalTrans),
this.speed = (_speed)
{}

Idézet

---

versio :
meg jo hogy nem kell destructor, kit erdekel mikor torlodik a memoriabol az legyen a rendszer dolga, pont ezert jo a c# , nem tudsz torolni valamit ami meg kellhet, vagy nem hagysz benne valamit ami mar nem kell, c++-ban az idod felet ezeknek a faszsagoknak a debuggolasaval toltod , a produktivitas meg zero

---

Ez hülyeség. Megísz magadnak egy memória management-et és az központilag megoldja a memória kezelést, figyelmeztet, ha nem volt törlés stb. Többszörösen öröklést meg nem muszáj használni csak azért mert a nyelvben ott van és feltétlenül el kell gáncsolnia magát a fejlesztőnek, tervezni kell úgy, hogy ne legyen rá szükség.

Pretender: kiprobalhatjuk ki a bena, irjal c++-ban egy olyan programot ami 10 millio floating szamot sorbarendez, en c#-vel leverlek 10-szeresen abban biztos vagyok

Idézet

---

versio :
c++-ban az idod felet ezeknek a faszsagoknak a debuggolasaval toltod , a produktivitas meg zero

---

Hát, ha valaki béna...

@Viperion:
Csak egy konkrét implementációt tartalmazó osztályból tudsz öröklődni, a többi legfeljebb interface lehet. Hogy miért? Mert hülyék, és azt mondták, hogy nincs rá szükség. Túl sokszor valóban nincs, de néha nem ártana, ha lenne...

Amit versio linkelt, az meg nem igazi öröklődés, hanem generices trükközgetés. De hát ilyen egy hatékony nyelv...

versio én nem értem,hogy hogyan gondolja a megvalósítást azon a linken. De amúgy kösz.

Viperion, ha csak ez hianyzik a boldogsagodhoz

http://putabout.wordpress.com/2008/04/06/tobbszoros-oroklodes-c-ban/

Miért nincs a c# ben többszörös öröklődés?

meg jo hogy nem kell destructor, kit erdekel mikor torlodik a memoriabol az legyen a rendszer dolga, pont ezert jo a c# , nem tudsz torolni valamit ami meg kellhet, vagy nem hagysz benne valamit ami mar nem kell, c++-ban az idod felet ezeknek a faszsagoknak a debuggolasaval toltod , a produktivitas meg zero

Tévedés, hogy ne lenne destruktor, szintaxisa:



Az egyetlen gond vele, hogy nem igazán jó semmire, nem determinisztikus, hogy mikor hívódik meg a függvény, mivel a GC (GarbageCollection) saját maga kezeli a memóriát, nem igazán érdemes beleszólni, hogy kit mikor dobjon ki, annyit kell tudni erről, hogy különböző generációkba osztja az egyes objektumokat, és ennek megfelelő sorrendben szabadul meg tőlük, amikor helyre van szükség, pontosan ezért nem lehet megmondani mikor fut le a destruktor, így nem igazán szokás használni, egyszerűen felesleges.

Már nem lényeges a kérdés megoldottam a problémát ha akarjátok törölhetitek.
Amúgy köszi mindent.

Egyébként az volt a baj,hogy amelyik osztály örökli a MonoBehaviourt abban nem használható a konstruktor.

Itt miért kapom ezt a hibakódot: CS1729





Tudom mit jelent ez a hibaüzi de nem értem miért kapom hisz át adok neki én egy transform objektet és mégis.

.NET-ben nincs destruktor, illetve managed objektomoknál nincs is értelme, mert a GC felszabadítja, ha nem hivatkozik rá senki. 1-1 managed objektumra, ha nem hivatkozik semmi, akkor halottnak nyílvánítja a rendszer és onnan vagy feltámad, vagy a GC kinyírja egyszer, ha úgy tartja kedve.

Nem managed objektumoknál van értelme a "destruktornak", itt az ún dispose pattern-t lehet használni. Ennek lényege, ha a coder elfelejti meghívni a Dispose-t, akkor kinyírás előtt a rendszer megteszi.

A fentieknek semmi köze a C++ féle destruktor fogalmához, teljesen más a kettő memória kezelési mechanizmusa.

Semmi köze nincs ahhoz, hogy inline, vagy sem.

szerk.:
Na jó, kicsit konstruktívabb is legyek... c++ban az az alapvető szabály, hogy a header nem tartalmaz implementációt, egyfajta interfaceként szolgál csak. Egyéb nyelvekben (pl. c# és java) ez nem így működik, ott egyetlen fájl tartalmazza a deklarálást és a definiálást (tudjuk a különbséget!)

Attól, hogy a deklarálás és a definiálás egyetlen helyen van, még nem lesz inline, szimplán más elvet követ a két nyelv. És nagyon fontos, hogy ne akarjuk az egyiket úgy használni, mint a másikat.

C#-ban pedig nincs destruktor, csak valami dicső függvény (finalize talán? vagy az java?)

A c# nek van szemétgyűjtője,akkor én mire használjam benne a destruktort?
És miért kell az osztályon belül létrehozni a metódusok törzsét.Nekem c++ után ez úgy tűnik,hogy c# ben csak is inline módon létezhetnek az osztályokban a metódusok.
Példa:
public class Xy
{
private Xy(); //Így nem jó
public float getXyValue(); /*Nem jó nem lehet később megírni benne a metódus megvalósítását mint a c++ ban. Ugy akarnám mint a c++ ban:
visszatérési_értéke osztálynév::metódusa() {törzs} Így nem inline c++ ban.
}

Csak így jó, de ez C++ ban inline, C# ben is?Mert ha ige akkor nagy kóddal rendelkező metódus esetén ez fos módszer az tuti.
public class Xy
{
private Xy() {}
public float getXyValue() { /*Ngayon sok kód*/ }
}

Megoldodott, a projekt fájlban a IncludeAssemblyInVSIXContainer-t át kellett állíteni true-ra.

Valaki írt már visual studiohoz plugint? (konkréten MEF komponenst).
Az a bajom, hogy k*rvára nem töltödik be, a log viszont azt mondja, hogy igen...debugolni sem tudom mert "no symbols loaded".

Amugy csak azért kéne hogy az UML editorban úgy tudjam kiexportálni a xaros képet hogy átlátszó legyen a háttér...

A Skynet jo példa, de most már nem mondok semmit. Majd megcsinálom és akkor rájöttök (meg én is) mi motoszkál bennem. (lehet hogy csak valami betegség, de legalább megpróbálom)

Idézet

---

(A jelszós példányosítás meg egy nagyon programozó szinten lévő biztonsági mech szerintem így első ránézésre. Jelszóval védjük fájljainkat, adatainkat a neten, mért ne lehetne egy objektumot is védeni. Lehet, hogy nagyságrenddel biztonságosabb programokat lehetne csinálni...)

---

Ez fájt, de nagyon. Ezek szerint azért van az a sok sechole egyes programokban, mert valami galád eljárásban galád módon példányosítanak egy osztályt? Ki, vagy mi ellen védenénk jelszóval az objektumokat? A Skynet ellen?

Bukta:
Azért negatív mindenki, mert olyan felütéssel kezdted, hogy minden nyelv szar, mert vannak benne korlátok. Erre nehéz sok jót mondani.
Amúgy meg ha már olyan régóta használják olyan sokan, és még jön is ki belőle új változat, akkor nem lehet, hogy amire tényleg szükség van az belekerült? Pl magadnak definiálható hozzáférés módosító nem kell, de lambda kifejezés meg igen.

Persze ha valami világrengetőt kitalálsz, az oké, ha hiányolod. De néhány nagyon gyenge hasraütésszerű példával bizonyítani, hogy szar minden.
"Azért szart a gazdaság, mert nincs ingyen sör meg ingyen internet"

Idézet

---

Honnét tudod minek mi értelme van?

---

Mondjuk onnan h 8 eve aktivan programozok?
A legjobb pelda a C++0x bol kivett conceptek. Baromi jo otlet, baromi hasznos lett volna, de a kutya nem hasznalta/nem ertette.

Bukta: Te szerintem kevered az adatbázis kezelést a programozással, vagy csak nagyon unatkozol. Egyébként vicces lenne jelszóval levédeni osztályokat, biztosan örülnének neki az adott libet használók.

Hasra ütés helyett szerintem többet ér ha nekiállsz kódolni, megpróbálod megvalósítani amiket szerinted nem lehet. És ha tényleg nem lehet, akkor posztolod a problémát, esetleg a kódot ami már majdnem tudja amit kellene, de mégse.
Szerintem sokkal értelmesebb és szakmaibb viták lennének belőle, minthogy leállsz szidni egy olyan nyelvet amit milliók használnak és még mindig nem váltotta fel más az adott területen és amit nem csak úgy hasra ütés szerűen építettek fel.