Felhagy a Visual Basic fejlesztésével a Microsoft

Felhagy a Visual Basic fejlesztésével a Microsoft
2020-03-13T08:10:07+01:00
2020-05-08T11:29:40+02:00
2022-10-17T16:40:32+02:00
  • Egyébként engem nem zavarna, ha a MS befejezné a VB fejlesztését.
    Csináljanak helyette jobbat, vegyék ki belőle azokat a dolgokat, amik közutálatnak örvendenek.
    Valamint legyen hozzá egy konverter, ami a régi VB.netes kódokat átalakítaná az új, letisztultabb szintaxisra.
    Ráférne már egy ilyen ráncfelvarrás a nyelvre.
    Egyébként annyira nincs is benne sok változtatni való.
    Nagyjából már le is írtam az összehasonlításnál:
    - a bőbeszédű nevesített blokk-lezárások helyett sima End kulcsszavas lezárás
    - AndAlso és OrElse helyett sima And és Or kulcsszavak (rövid kiértékeléssel természetesen)
    - Dim helyett Var kulcsszó
    - vegyék ki belőle az If utáni felesleges Then kulcsszót
    - Select Case i helyett sima Select i
    - /**/ és // kommentelések
    - escape szekvenciás és escape szekvencia mentes string literálok
    - eljárások zárójel nélküli meghívása újból. pl:   MessageBox "text"
    - a Like operátor tudjon RegEx-re is vizsgálni
    - az IIf() helyett esetleg valami beszédesebb szintaxis
    - vegyék ki belőle a VB6-ból megörökölt és elavult dolgokat
    - stb. kisebb-nagyobb változtatások még

    A szemantikájával nem sok gond van, az a C#-pal egy ligában játszik.
    A világ legjobb nyelve lehetne.
    Sőt szívesen merném ajánlani pl. a Python helyett is, mint kezdő programozási nyelvet azzal a különbséggel, hogy típusos nyelv lenne, valamint a .net-es környezet egy erős piacképes tudást is biztosítana.
    Mutasd a teljes hozzászólást!
  • Engem se zavar ha valaki paradicsomos kaposztat eszik addig amig

    1. Nekem nem kell
    2. Foleg ugy nem kell, hogy elotte mar mas megette a felét
    Mutasd a teljes hozzászólást!
  • Felõlem bárki ehet paradicsomos káposztát addig, amíg nekem nem kell. Viszont ha sokfelé főznek ilyet, akkor jó eséllyel adódhat olyan helyzet, hogy eszi nem eszi alapon én is szembe kerülök vele. Viszont ha sehol sem főzik, akkor nekem sem kell tartani tőle.
    Mutasd a teljes hozzászólást!
  • A vb a szószátyár nyelvek egy példája. Nem a legocsmányabb ebben a műfajban, de épp elég undorító ahhoz, hogy a megszűnését üdvözölni lehessen.

    És ez kit érdekel?
    Sokak szerint a C-szerű szintaxis az undorító.
    Én pl. utálom a paradicsomos káposztát, de nem kürtölöm állandóan világgá, hogy szüntessék be a főzését.
    Mutasd a teljes hozzászólást!
  • Nekem legalábbis logikusabb és átláthatóbb egy state = i<10 ? "Small" : "Large";

    A ternary operátor szépen és jól mutat a tutorialokban egészen addig, amíg csak önmagában van és pl. rövid változókkal vagy literálokkal használják, mint ahogyan a példádban is.
    Az átláthatósági bajok ott kezdődnek, ha már hosszabb kifejezések vannak benne vagy elágazásokat raknak bele.
    Márpedig sok programozó nem tud ellenállni a kísértésnek és elágaztatja.
    A másik baj vele pedig az, ha elé és/vagy utána műveletek akarunk tenni.
    Akkor pedig már célszerű már az egész ternary műveletet zárójelezni és akkor már alig rövidebb, mint pl. a VB IIf().

    Másfelől:
    A ternary operátor nem azért jó, mert rövid.
    Sőt pont a rövid, brain fuck-os szintaxis a baja.
    Jól néznénk ki, ha egy if blokk pl. ilyen lenne egy programozási nyelvben:
    b ? {
        print("true");
    } : {
        print("false");
    }

    A ternary operátor alapvetően azért hasznos, mert redundancia mentes:
    state = i<10 ? "Small" : "Large";

    Ez pedig redundáns:
    if (i<10) {
        state = "Small"
    } else {
        state = "Large"
    }
    Mutasd a teljes hozzászólást!
  • A vb a szószátyár nyelvek egy példája.

    A VB-ben alapvetően csak a blokklezárások bőbeszédűek, más nem igazán és az IDE miatt nem kell többet gépelni se.
    Engem spec. nem zavar, bár általában egy sima End is elég lett volna, mint pl. a Ruby-ban.
    Amúgy pedig vannak előnyei is.
    Könnyebben mozgathatóak a beágyazott blokkok.
    Az egymásba ágyazott blokkoknak könnyebben látható a vége, ennélfogva a blokkok "tudatalatti" parse-olása is jobb (bár ez szubjektív vélemény).
    Mutasd a teljes hozzászólást!
  • A C-nek voltak ordas tervezési hibái, de a felsoroltak pont nem. És a sikerének az egyik titka pont az, hogy elég jól belőtte az egyensúly a speciális karakterek használata és túlhasználata között.

    Az én ízlésem szerint pedig a C szintaxis pont, hogy túl sok írásjelet, speciális karaktert tartalmaz.
    Akkor most kinek van igaza?
    Amúgy meg nem ez a sikerének a titka, hanem az hogy jól használható, jól portolható, gépközeli nyelv volt jó időben, jó helyen, ami nagyon elterjedt, ennélfogva ma már nehezen leváltható, akárcsak a JavaScript manapság a böngészőkben.
    A szintaxisa, ergonómiája mellékes, a C, C++, Java, C# robbanásszerű elterjedtsége miatt szokták meg ezt sokan.
    Ha annak idején a JVM-re pl. egy Pascal-szerű nyelvet ültettek volna, akkor jó eséllyel ez lenne ma a megkérdőjelezhetetlen szintaxis.
    Valószínűleg Anders Hejlsberg is ezt a szintaxis javasolta volna inkább a Delphi után a C# helyett.
    Ennyin múlott csak, hogy a C szintaxis ennyire elterjedt.
    Valószínűleg azért választották a C-szerű Java szintaxist a Sun-nál, mert az alacsony szinten fejlesztett JVM programozói C-ben voltak szocializálódva.
    Gyakorlatilag egy alacsony szintű nyelvet kisebb-nagyobb módosításokkal átalakítottak magas szintűvé.
    Véleményem szerint egy Ruby vagy egy Python szerű szintaxissal, esetleg egy alaposan átdolgozott VB-szerű szintaxissal jobban járt volna a világ.
    Mutasd a teljes hozzászólást!
  • Amugy nem azert irom igy, hogy megsporoljak par leutott billentyut, hanem nekem pont annyira adja magat "szandekilag", mint mondjuk a ternary operator. 
    Azt is vagom, hogy egyesek szerint mar a sima {} nelkuli egysoros if ag is szentsegtoresnek szamit, de hat ugye vannak, akik azon is kepesek vergodni, hogy melyik sorba is keruljenek azok a bizonyos {}-k. :D

    Pl. Javascriptben elterjedt "valami || fallback"

    Persze ilyen modon is szoktam hasznalni, csak nem akartam minden eshetoseget felsorolni. :)
    Arrol van esetleg valami infod, hogy ez miert lett elterjedtebb es helyenvalobb megoldas egyebkent, mint a &&?
    Mutasd a teljes hozzászólást!
  • A prog.hu-s konszenzust nem tudom neked megmondani, de én szvsz csak akkor engednék át code review-n ilyen kódot, ha az egész kifejezés értékét is felhasználod valamire. (Mellé lehetőleg a function-nek ne legyen mellékhatása.)

    A kódnak elsősorban a szándékot kell kifejezni. Például az, hogy "létezik és töröld_le", értelmetlen, de az, hogy "ha létezik, töröld_le", remélhetőleg minden olvasónak világos. Ha a forráskód hossza valamiért fontos (pl. JS és megy le a kliensre), arra utólagos minifikációs megoldások vannak, nem kell büntetni miatta a kód karbantartóját.

    (Kivételek ez alól az adott környezetben elterjedt idiómák. Pl. Javascriptben elterjedt "valami || fallback" alakban kifejezni azt, hogy "falsy" érték esetén inkább a megadott fallback-et szeretnéd használni. Ugyanúgy nyelvi zsonglőrködés, mint a te példád, de azzal ellentétben elterjedt, megszokott.)
    Mutasd a teljes hozzászólást!
  • Errol jut eszembe:

    En gyakran irok

    if(feltetel)function();
    helyett csak

    feltetel&&function();
    szeru  egysorosakat, akar tobb feltetellel is. 
    Viszont mar tobben panaszkodtak (ebbol mondjuk az egyikuk az emlitett ternary operatort sem ismerte, szoval az o velemenyere annyira nem adok), hogy nehezen olvashato tole a kod.

    Kivancsi lennek, hogy mi errol prog.hu-n a konszenzus, tenyleg annyira zavaro gyakorlat?
    Mutasd a teljes hozzászólást!
  • Egy kezdő nem is fog ilyent használni semmilyen nyelven se, mint ahogy generics-et se fog python-ban használni egy kezdő, de nem azért, mert nyakatekert, hanem, mert még nincs azon a szinten, hogy ilyenekkel foglalkozzon. Bizonyos szint felett meg már, ha odáig eljutott, nem a nyelv fogja akadályozni annak érthetőségét, hiszen azon "nőtt fel". 

    Ugyanakkor célszerű C alapú nyelvvel kezdeni és arra ráállni, mert jelenleg a piacvezető nyelvek zöme C alapú (Java, PHP, JS, C#, C++). Szerencsére nem a basic terjedt el és ennek talán meg is van az oka. Nekem speciel kezdetben se volt egyáltalán egyszerű mindenre külön töltelékszót használni, egyből megtetszett a C alapú nyelvek tömörsége, ahogy azzal találkoztam később. Lehet, aki regényt szeret írni és valami bölcsész vénával rendelkezik jobban kézreáll az üres szavak egymás után pakolászása egy programban, de a programozás az nem irodalom. Mi lenne, ha a matematikában is a különböző jelek helyett szavakat kéne használni? Teljes káosz lenne az egész. Lehet persze óvodában így oktatni, de a szakmában komoly célokra használni nincs értelme. Be kel látni bizonyos jelölések kellenek egyes területekre, mert így tömör és hatékony. Gyerekeknek játszani lehet másképp is, de a hozzáértők számára ez csak átláthatatlansághoz vezet.
    Mutasd a teljes hozzászólást!
  • Az eredeti basic nem is volt tele 600 féle kulcsszóval, ott elég lett volna ennyi is: p = Person
    Mutasd a teljes hozzászólást!
  • Nekem legalábbis logikusabb és átláthatóbb egy

    A kulcsszó az, hogy neked. Ha valakinek semmilyen ismerete nincs egyik nyelvről sem, akkor a C ternary operator-a teljesen értelmezhetetlen (mért pont kérdőjel? miért pont kettőspont?), míg a pythonos kifejezésben ott az "if" és "else" segíteni.
    Mutasd a teljes hozzászólást!
  • A C-nek voltak ordas tervezési hibái, de a felsoroltak pont nem. És a sikerének az egyik titka pont az, hogy elég jól belőtte az egyensúly a speciális karakterek használata és túlhasználata között.

    Az egyik véglet azok a nyelvek, ahol semmi mást nem látsz csak egy rakás speciális jelet és gyakorlatilag képtelenség elolvasni a kódot. A másik véglet a szószátyár nyelveké ahol szinte angol mondatokat írsz - amit elég könnyű olvasni kezdőként, cserébe írni már jóval kevésbé könnyű, mert nem szabvány angolt írsz csak egy nagyon-nagyon-nagyon szűk subsetjét, az viszont messze nem annyira letisztult mint a C alapú szintaxisok. Nekem legalábbis logikusabb és átláthatóbb egy

    // C# state = i<10 ? "Small" : "Large";
    mint egy

    #python state = "Small" if i<10 else "Large"
    A vb a szószátyár nyelvek egy példája. Nem a legocsmányabb ebben a műfajban, de épp elég undorító ahhoz, hogy a megszűnését üdvözölni lehessen. Különösen ha pár éven át már szopott vele az ember.
    Mutasd a teljes hozzászólást!
  • Ha annak idején Ken Thompson és Dennis Ritchie mondjuk egy Fortran-szerű szintaxis mellett döntöttek volna, akkor ma az volna a trendi és a C-szerű szintaxist utálnák sokan.
    Ennyi.
    Sőt tartok attól, hogy sokkal többen utálnák a C-szerű szintaxist, mint ma a VB szintaxist.
    Megjegyzem a C nyelv a B nyelvből származik az pedig a BCPL-ből, mely nyelv szintaxisa (BCPL) inkább hasonlított pl. a Fortran-ra, mint pl. a C-re.
    A BCPL-ben nem volt pontosvesszőzés, kapcsos zárójeles blokk-képzés, blokk-fejrész zárójelezés, stb.
    Gondolom azért találtak ki egy olyan szintaxist, mint a B, mert egy alacsony szintű nyelvet írtak és azt is szerették volna, hogy a szintaxisa alapvetően különbözzön a magas szintű nyelvek szintaxisától, mint amilyen pl. a Fortran vagy a BCPL, stb. volt annak idején.
    Bár szerény véleményem szerint a C szintaxis még rosszabb döntés volt, de a megszokás nagy úr és ma már szinte senki nem veszi észre a C-nek az alapvető szépséghibáit.
    Példának okáért itt van a pointer operátor (*), aminek a jelölése ugyanaz , mint a szorzásé.
    Vagy pl. az address operátor (&), aminek a jelölése szintén ugyanaz, mint a bitwise AND operátoré.
    Lett volna még szabad szimbólum (pl: $ vagy @ karakter, stb.), de mégis ezt a bugyuta megoldást választották. (???)
    Egy párszor megemlítettem ezt már más programozóknak is (többek közt szerintem már itt a prog.hu-n is) és a reakció kb. az volt, hogy most viccelek?
    Nem mondták ki, de szerintem valami ilyesmire gondolhattak :)
    "Hát ez hülye! A pointert muszály csilaggal jelölni!"
    :))))))
    Na kb. ez a helyzet sok programozóval, akik képtelenek és nem is akarnak másban gondolkodni, mint amit megszoktak.
    Tisztelet a kivételnek.


    C-szerű szintaxishoz hozzászokott programozók nem szeretik VB-ben, VB.net-ben pl:
    - nevesített blokklezárást:
        End If
        End Select
        End Function
        stb. Nekik ez (érthetően) szájbarágós.
    - a Dim kulcsszót, mert nem kifejező és több gépelést igényel
    - az AndAlso és OrElse kulcsszavakat (nem csodálom)
    - az If után a Then kulcsszót
    - a Select után közvetlenül a felesleges Case kulcsszót ugyanabban a sorban
    - hiányzik nekik a pontosvessző (mint dekoráció, vagy pótcselekvés, vagy ki tudja mi miatt)
    - az értékadás és az egyenlőség vizsgálat (=) ugyanazon jelölését az = és == jelölés helyett
    - kis-nagybetű érzéktelenséget
    - a single quote-os (') commentelést a /**/ és a // helyett
    - az IIf() beépített függvényt a ternary operátor helyett
    - dekalrarációnál az alaptípusok default értékét (0, "", False)
    - a vbCrLf jelölést a "\n" helyett
    - a VB6-ból megörökölt, de már elavult és csak a kompatibilitás miatt megtartott dolgokat (pl. On Error GoTo, stb.)
    - az IDE automatikus formázását (bár ez nem programozási nyelv feature, valamint beállítható is)
    - stb...



    A VB programozók pedig nem szeretik a C-szerű nyelvekben:
    - az utasítások utáni pontosvesszőzést
    - a blokkfejlécek zárójelezését: if(), switch(), for(), stb.
    - a kapcsos zárójeles blokk jelölést
    - a void függvények azaz az eljárások zárójellel történő meghívását (sajnos ezt a bűnt már a VB.net is átvette)
    - Type ID deklarációt a Dim ID As Type helyett
    - ! szimbólumot a Not kulcsszó helyett
    - a != jelölést a <> jelölés helyett
    - kis-nagybetű érzékenységet
    - a C for ciklus szintaxisát, valamint azt, hogy az nem csak egy szigorúan számláló-ciklus
    - switch-blokk break-elést, falltrough-t, esetek felsorolását külön sorokban case kulcsszóval, stb.
    - a Case műveletek hiányát pl: Case 1 To 5, Is > 10
    - nincs külön Exit For, Exit Do, stb., csak a break van, ami ugyanaz, mint switch-ben is
    - a Like operátor hiányát
    - With blokk hiányát
    - a függőlegesen terjengősebb forráskódot (pl. C#: Allman style)
    - stb...

    Na ennyit a siránkozásokról.
    Mindegyik nyelv teli van objektív és szubjektív szépséghibával.
    Messze nincs még "tökéletes" programozási nyelv.
    Mindegyiknek volna még mit fejlődnie bőven.
    Mutasd a teljes hozzászólást!
  • Nem feltétlenül neked szól, hanem mindenkinek:
    Az, hogy egy nyelv szintaxisa olvasható, vagy sem, teljesen szubjektív és hagyjuk már abba ezen a vitát. Ez olyan, mint a linuxos körökben a GNOME -vs- KDE, vagy az Android -vs- iPhone, nincs semmi értelme ezen vitatkozni.

    Mindenki megtanulhatta volna már, hogy nincs értelme szubjektív dolgokon vitázni.
    Mutasd a teljes hozzászólást!
  • Csak egy kis megjegyzés: ha sietsz és nem tabulálsz rendesen, akkor a projectvezetőd nem fog sietni miközben a fejedet mossa, szóval majd legközelebb rendesen tabulálsz. ;)
    De viccen kívül, ez a mondat olyan volt, mintha azt írnád, hogy siettél, ezért benne hagytál par szintaktikai vagy logikai hibát.
    Mutasd a teljes hozzászólást!
  • Bill Gates volt a Basic motorja. A Commodore-64 basic is az ő munkássága volt.
    Napokban jelentette be, hogy teljesen kiszáll a Microsoftból. Logikus az időzítés a Basic végének bejelentésére.
    Mutasd a teljes hozzászólást!
  • Én maradok a Horstnmann formátumnál.
    Ez a leglogikusabb.
    Semmi más pl. spórolás, rövidítés, stb. nem érdekel.
    Csak hogy tükrözze vissza a programlogikát.
    A két kapcsos zárójal közötti rész egybecsukható legyen úgy, hogy ne rondítson bele a látványba.
    (Értsd: egy szürke téglalapot tehetsz a helyére, ami feketedoboz, a struktura szempontjából érdektelen mi van benne)
    A kódblokk egyetlen utasításnak tekintendő, ezt pedig ez adja vissza a legjobban.

    Logikai alapon persze a GNU style lenne a legjobb, de az idegen a szememnek,én Horstmannt szoktam meg.


    Horstmann style[edit]

    The 1997 edition of Computing Concepts with C++ Essentials by Cay S. Horstmann adapts Allman by placing the first statement of a block on the same line as the opening brace. This style is also used in examples in Jensen and Wirth's Pascal User Manual and Report.[29]

    while (x == y) { something(); somethingelse(); //... if (x < 0) { printf("Negative"); negative(x); } else { printf("Non-negative"); nonnegative(x); } } finalthing();
    Mutasd a teljes hozzászólást!
  • Ez eléggé szubjektív, és túlzás olvashatatlannak hívni. Elég sok project köszöni, és jól elvan a K&R-rel.

    Már csak azért is, mert az, hogy hova teszed a {}-t, kb. irreleváns. Mivel nem ezektől a jelektől látod a struktúrát, hogy mi mi alatt van, hanem az indentálástól. Nézd meg, hogy melyik vesz el több információt: a {}, vagy az indentálás kiszedése. {} elhagyása nem okoz kb. semmit (lásd python), az indentálás hiánya viszont sokkal nehezebben követhetővé teszi a struktúrát.
    Mutasd a teljes hozzászólást!
  • Mert a K&R indentation stílust bedrótozták a szintaxisba. Ami kb. a legolvashatatlanabb az összes közül (IMHO a Whitesmiths messze a legjobb).
    Mutasd a teljes hozzászólást!
  • legrosszabb pedig a Go, ahol az olvashatatlan formázást beemelték a szintaxisba

    Mint pl.?
    Mutasd a teljes hozzászólást!
  • A Visual Studio automatikusan formázza a szövegedet. Ha meg ez nincs beállítva, akkor Ctrl+k Ctrl+d. Amúgy láttam én már olvashatatlanra formázott vb.net-es kódot is, de ma már ez a legkevesebb.  Ebből a szempontból a python a legjobb nyelv, ott nem sok mozgástere van az idiótán formázásnak, a legrosszabb pedig a Go, ahol az olvashatatlan formázást beemelték a szintaxisba.

    Akkor utáljam a fortrant? Tényleg nem értem.

    Addig nekem sincs bajom vele, amíg nem jön szembe egy olyan project ahol használni kell. Szerencsére ma ez egyre ritkább, de pár évet eldolgoztam vele, és ez akkor annyira nem javította a közérzetemet.
    Mutasd a teljes hozzászólást!
  • Ez nem feltétlen neked szól, csak erre a hozzászólásra kattintottam. Bocs! 


    Szerintem nem. Több egymásba ágyazott for és if else if sokkal könnyebben olvasható vb-ben mint C-ben. Olyan kód ami nem fér bele a képernyőbe csak ennyit lehet látni miután beszúrtál valamit a szerkesztés előtt:  (Főleg  ha siettél és nem tabuláltál rendesen)
                              }
                    valami kód
                    valami kód
                    valami kód
                    valami kód
                                     }
                            }
                    valami kód
                   }
                    valami kód
                    valami kód
                     }
    Ezután keresheted, hogy melyik hova tartozik. Az End if, ÉS a Next i (indexxel) szerintem sokkal olvashatóbb.

    De ez csak ízlés dolga. Azonban nem értem miért utálják ennyire ezt a nyelvet. FoxPro ok? Javascript? Melyek azok a nyelvek amik még ilyen gyűlöletet keltenek? A pájton valami rettenet ellenben lassú is. Az ok? Vagy abban nincs beginner-szó? Amikor ez a nyelv született jukkártyára kellett tolni a kódokat több helyen, illetve asm-ben tolták azon kívül is. Ahhoz képest minden kezdő volt. Nem értem miért kell ezt utálni annyira? Sznobok? Vagy illik?

    Én szeretem, VB-t de nem utálom a többi nyelvet ezért. A C és az ASM (minél kevesebb annál jobb természetesen ) ami még ok a mikrokontrollereknél, a többi teljesen felesleges. Akkor utáljam a fortrant? Tényleg nem értem.
    Mutasd a teljes hozzászólást!
  • Már írták mások, Dim p as New Person()

    Amit a jelek szerint nem igazán értettél meg. Mindkét nyelvben meg lehet adni a deklarációban a változó típusát, ez a Dim p as Person VB-ben, illetve Person p C#-ban, illetve lehet hagyni hogy a fordító találja ki, ez VB-ben a Dim p as New Person(), míg C#-ban a var person = new Person();

    De te a példátban a VB oldalon kitaláltattad a típust, C# oldalon meg deklaráltad, aztán csodálkoztál hogy ez utóbbi mennyivel körülményesebb.
    Mutasd a teljes hozzászólást!
  • Olvasni simán tudja egy kezdő is - írni viszont annál nagyobb szenvedés egy letisztult, C-jellegű szintaxishoz képest.
    Mutasd a teljes hozzászólást!
  • Szerintem ugyanannyi ismeret kell hozzá, mint a C#-hoz, mivel a háttérben minden ugyanúgy történik. Olvasást tekintve a VB kódot az is megérti, aki életében egy percet nem programozott. C#-ot csak az, aki tudja, hogy melyik írásjel-kombináció-komnbináci-kombináció mit jelent, főleg a C# 8-ban már, ahol még többet bevezettek, mert hát ugye kb. elfogytak az írásjelek.
    Egyetlen fájl 10e sor? Nos igen, ott nem a nyevvel volt gond. :) 
    Én ilyen függvény másolós fícsörrel még nem találkoztam...

    Mate12345:
    Igazából nagyon is következetes, csak meg kell egyszer érteni. Sőt intelligens is, nincs benne (alapból, mert kikapcsolható) felesleges cast-olás, mert ha szöveghez számot fűzöl, akkor van annyi "esze", hogy a végeredményben is szöveget akarsz. Rengeteg ilyen apróság van, ami kismillió időt megspórol az embernek, de ehhez bele kell merülni. Vagy a null kezelés. C#-ban az adatbázis-null is null és az is amikor nincs deklarálva az objektum, pedig két olyan dologról beszélünk, aminek külön-külön is van értelme. De mint mondtam, én nem a pro-kontra érvekbe akarok belemerülni, mert sohasem lesz vége, de azt nagyon utálom, amikor valaki úgy mond véleményt valamiről, hogy fogalma nincs róla, max párszor kipróbálta akarva-akaratlanul. 
    Mire gondolsz? Már írták mások, Dim p as New Person()
    Egyébként bizonyára hihetetlen, de ez a nyelv is változott az elmúlt x évben, tehát a berögzött sztereotípiák, amiket kifogásolnak általában a "tüntetők", már rég nem úgy működnek.
    Mutasd a teljes hozzászólást!
  • Én sokat VB-ztem, de nagyon utáltam. (FactoryTalk alatt kellett, a nyelvnek esélye sem volt, hogy szeressem...)

    Az elsődleges bajom pont az volt vele, mint AsyncWorker-nek: Kegyetlenül bőbeszédű és nem következetes (let, set, = csak hogy pár példa.)

    Szerinted hogyan kellene pl. megcsinálni azt, amit AsyncWorker írt?
    Mutasd a teljes hozzászólást!
  • Nem a nyelv "kinézete" maga az ami nekem gond.
    Sokkal inkább a pájton elődjét látom benne.

    Számos ember megtanult gyorsan kódolni benne, mélyebb rendszerismeret nélkül, mert a nyelv elsőre könnyű (vagy könnyűnek látszik)

    Aki c világ felöl jött, annak nem olyan jó ebben hibát keresni. Vagy bármit csinálni vele. Én el tudom olvasni a c# kódot, nem kell nekem szájbarágni. Hozzáteszem, hogy egy komolyabb methodchain-től már én is irtózom.

    Láttam (hozzá is kellett nyúlnom brrr) VB.Net kódot, ami egyetlen file kb 10e sor, és a verziókövetése úgy nézett ki, hogy amikor valami újat csinált, akkor lemásolta a függvényt, az eredetit kikommentezte, majd a függvény nevébe beletett egy index számot. És így tovább és így tovább.
    jajdejóvolt :)
    Mutasd a teljes hozzászólást!
  • Ezért mondtam, hogy ki mihez szokott.
    C# ban meg nem ritka 6-10 írásjel egyetlen sorban, na az az, ami nem olvasható.
    Valószínűleg azért is szűnik meg, mert a programozók egója nem viseli el a névben a Basic szót, mint itt ki is derült pár esetben, ugyanis én nem sok ész érvet hallottam eddig, ami technikailag indokolná a megszüntetését.
    Mutasd a teljes hozzászólást!
Tetszett amit olvastál? Szeretnél a jövőben is értesülni a hasonló érdekességekről?
abcd