Small site – big changes

This post is just a quickie. Caffeine’s clearing out of my system and I still have a couple of Overwatch matches to play (that’s how I roll nowadays: when i can’t drink any more coffee, I turn to adrenaline instead!). No, seriously – I just wanted share a few things which I’m planning to unfold in the upcoming days.

  1. The site will be in English from now on – this time, for good. For all those, who raised an eyebrow on this, i have one secret to tell: if you limit yourself to Hungarian sites, you’ll miss out on things. A lot of thing. Big things. Sorry folks, this is my decision and it’s permanent. Love it or hate it.
  2. The hashmark’d numbers from the post titles are gone – they felt cool, they felt geeky, now they have served their time and it’s time to wave goodbye to them.
  3. Site revamp – hell, it needs one. The style is crappy, the content is old, the archive is half-done (more on this later), the speed is awkward at best. Also, I’ve reached a point where I actually start to use this site for something normal or just dump the whole damn thing and let it rot in peace, archived to my cloud storage. 🙂
  4. 30 day blogging challenge. This is the real deal. I’ve decided that starting from 1st of April, for a single month at least, I’ll write a post about something I feel post-worthy. And I mean posts, not Tweets. (Well, WordPress will generate tweets for the posts anyway, but that’s another story.) There we go, consider this a commitment. Like the page, follow me on Twitter and make me want to do this. (Oh, what a load of commercialized crap…)
  5. GitHub – another important thing. I have some code to share, some stories to tell. In the past, I made tutorials centered around a lot of bla-bla-bla and with some snippets of code. Even though I love writing tutorials, this always kept me unhappy in a way and after some time, it made me itch. I literally felt writing articles with all that text as a burden. Now i want to share CODE with less bla-bla-bla. And for this, I’ll be using GitHub, not the crappy Downloads menu we have in here. Coming soon.

One more thing: transforming stuff takes time, so the site will be in this half-English state for a while. The old posts probably won’t be translated at all.

Bear with me. Stay with me. See you soon.

Posted in iNi Blog Tagged with: ,

#0400 – Szent küldetésen…

Huhh, majdnem két év telt el a legutóbbi bejegyzés óta. Rohan az idő. Sok minden történt azóta, de nem erőltetek magánéleti dolgokat senkire 🙂 Lényeg a lényeg, hogy még mélyebbre másztam azóta a Javas dolgokba és az OpenGL meg a hasonlók helyett mostanában elég rendesen beszippantottak olyan dolgok, mint az IoT, a NoSQL, a Big Data, a Cloud meg hasonlók. Emellett az erős új főirány mellett megmaradt pár oldalirány is – egyenlőre még köztük a 3D-vel. Más kérdés, hogy ez a post most abszolút nem az OpenGL-ről fog szólni…

Na de mi ez a szent küldetés? Nos, aki Java-zik, az egy idő után eljut oda, hogy meg kell hoznia egy fontos (khmm) döntést – Eclipse vs. IntelliJ. Nos, én az előbb mellett vagyok, mert tetszik, hogy bármit meg tudok vele csinálni gyakorlatilag, szénné bírom customizálni, hackelni. Egy bajom van vele – hogy a sötét témája ronda Windows-on. Tudom #FirstWorldProblems, meg ilyesmi, de akkor is irritál. 😛 Nos, konkrétan erre gondolok:

0400_eclipse_ugly_scrollbar
Arggh! A szemem...

Aaargghh! :O Mi az a scrollbar?? Komolyan? Nos, hogy teljes legyen az igazság, ez már egy pimpolt verzió, kapaszkodjatok meg! Mondom, mi változott, mire így néz ki a cucc:

  • Sajna az Eclipse alaból tök világos témával jön, ami bántja az ember szemét – szerencsére ezt át lehet állítani magában az Eclipse-ben a preferences alatt egy sötétebbre.
  • A következő, hogy az editornak is adjunk valami színvilágot, mert a sötét témára átállva nehézkesen olvasható a kód. Ehhez kell az Eclipse Color Theme plugin innen – a használata marha egyszerű, az editorok színvilágát mindenki lője be ízlése szerint.
  • By default ott világít fenn a menüsor, de azt ki lehet kapcsolni hála az égnek magában az Eclipse-ben elég könnyen (perspective customization). Ez opcionális, de engem zavart, hogy minden más sötét, ez meg világos.
  • Aztán ott az ablakkeret, ami csak a helyet veszi el az embertől, s tök felesleges egy dual monitoros rendszerben. Erre van egy plugin, update site itt, aminek a telepítése után az Alt-F11 fullscreenre teszi az IDE felületét. Yay!
  • Végezetül még mindig ott az az ordenáré scrollbar minden view-ban… Erre is van egy plugin, ami FlatScrollbar névre hallgat (update site itt) és a view-kban ilyenre cseréli a Windows gagyi scrollbarját:

    0400_eclipse_flat_scrollbar
    Hopp, ez jól néz ki - FlatScrollbar az Outline view-n!

Na, ez már tök jó, így jutottam oda, ahol az első kép van – és itt a történet vége, ha szépen, szabályosan akarunk játszani. Ugyanis az editorokra nem működik a FlatScrollbar. Daaaamn… Hát akkor – ha már az Eclipse opensource – jöjjön egy kis hackelés! A cél az, hogy vagy lecseréjük, vagy legrosszabb esetben eltűntessük a Windows világító scrollbarjait.

Nem mászok bele nagyon az Eclipse-be, a hozzá tartozó GUI alapját adó SWT-be, meg hasonlókba – aki akar, olvasson utána! Egyszerűen csak leírom, hogy mit hackeltem meg, lehetőleg úgy, hogy egy junior is utánam tudja csinálni. Nos, az SWT gyakorlatilag egy jar file az Eclipse plugins alkönyvtárában, és valami org.eclipse.swt.win32.win32.x86_64..jar néven fut. Gyakorlatilag ebben kell lecserelnünk egyetlen classt, abba is csak két sort kell beszúrni. Tehát, kell egy új java project, oda bevágni ezt a jart librarynak, majd annak az egy classnak (név szerint StyledText) a forráskódját kell begyűjteni a netről – innen! Hogy Neked, kedves olvasó, konkrétan melyik verzióra lesz szükséged, az rohadtul nem egzakt sajna – függ attól, hogy milyen Eclipse verziód van, mikor olvasod ezt a postot, etc. Nekem konkrétan ez a verzió kellett Eclipse Mars.2-höz (4.5.2). Pár próbálkozásba bele fog telni, míg megtalálod a megfelelő verziót – gyakorlatilag a legújabbtól elindulsz visszafele addig, amíg nem találsz egy olyat, ami fordul abban a java projectben, amihez hozzáadtad az SWT-s jart libraryként. Ha ez megvan, jön maga a hack – kód sor kód kell a setScrollBars(boolean vertical) függvénybe:

0400_eclipse_scrollbar_hack
Tudom, ronda és brutális, de teszi a dolgát...

A kód a könnyebb copy-paste kedvéért:

if (verticalBar != null) verticalBar.setVisible(false);
if (horizontalBar != null) horizontalBar.setVisible(false);

Save és ha így is lefordult és megvan a class file, onnantól egyszerű a dolog – Eclipseből kilépni, belemásolni a class file-t az eredeti jarba az Eclipse/plugins alatt, újraindítani az Eclipse-et és jó lesz. Végeredményben valami ilyet kell látnunk:

0400_eclipse_hidden_scrollbar
Scrollbarok elrejtve ;)

Egy dologra még mindig nem válaszoltam – tehát milyen szent küldetésről van itt szó? Hát arról, hogy habár ezzel a hack-kel el lehet lenni ideig-óráig (pontosabban a következő Eclipse update-ig, amikor is újra meg kell hackelni az új SWT jart!), én szeretném, ha FlatScrollbar lenne az editorokban is. Fogalmam sincs, hogy ennek hogy fogok nekiállni (illetve azt még sejtem 🙂 ), meg hogy lesz-e ebből valami, de a motiváció adott, hiszen senki sem szeret egy ronda IDE-vel dolgozni! 🙂

Posted in iNi Blog Tagged with: , , ,

Buildelés (sic!) Java-ban…

Egy jó rövid bevezető…

Igen, igen, megint egy olyan téma, amely első körben úgy tűnik, távolabb áll az OpenGL-től… Pontosabban nem is annyira, hiszen Javaban is lehet OpenGL-t programozni! A cikk lényege igazából, hogy megosszak némi tapasztalatot, illetve feljegyezzem őket magamnak is, későbbre. Ki tudja, lehet, hogy egyszer csak nekiállok pont Javaban alkotni valamit…. 😉 Tehát a blog alaptémájához képest semi-offtopic téma következik, kéretik szódával fogyasztani. 🙂

Az előszó részeként még megemlíteném, hogy átlag java coderrel ellentétben előszeretettel használom a 3rdparty jarokra a “lib” kifejezést, ami betudható a régi C/C++os múltamnak. Halkan megjegyzem egyébként, hogy valahol jogos az elnevezés szerintem, hiszen végeredményben class librarykról beszélünk… 😉

Read more ›

Posted in Java mélyvíz Tagged with: , , ,

#0399 – 2400

Pontosan ennyi munkanapot töltöttem el a Siemens-világban, március utolsó péntekével bezárólag. Vicces belegondolni is, hogy ez a teljes életemnek is egy elég szép nagy szelete… Olyan dolgokat láttam, olyan helyekre jutottam el, ahová másképp valszeg nem mentem volna (gondolok itt első körben Afrikára, Indiára, stb). Szóval azt mindenképpen elmondhatom, hogy sokat köszönhetek a nagy, zöldbetűs cégnek 🙂

So long and thanks for all the fish! :)
So long and thanks for all the fish! :)

Más kérdés, hogy így utólag visszanézve, azért árat is fizettem ezért, nem is keveset. Kezdjük azzal, hogy egy akkora cégcsoport, mint a Siemens, egy saját kis világot épít ki magának, amely, minél több időt töltesz ott, annál jobban beszippant. Ebben a világban mások a szabályok, mások a szabványok, az eszközök. Dolgozhatsz pl. éveken át java fejlesztőként úgy, hogy a standard Java SE API-n kívül bármi, amit látsz, a cég saját, zártforrású terméke, SDK-ja, API-ja, amiről a “kerítés túloldalán” még csak nem is hallottak. És így tovább… Nos, ez az az ár, amit megfizettem. Most itt állok egy másik cégnél 32 évesen és őrült módjára próbálok rengeteg lemaradást behozni. Nem arról van szó, hogy úgy érzem, nem tudok programozni vagy valami, de ha olyan szavakat hallok, hogy Hadoop vagy Node.js, akkor jelentem, ezekkel eddig max a JavaWorld-ön találkoztam valami hírben. Itt pedig ezekre projectek épülnek vagy fognak épülni hamarosan! Szóval ez úgy elég izgalmasan hangzik, meg kell hagyni! Itt vagyok kicsivel több, mint egy hete és már most úgy érzem, hogy rengeteget tanultam, pedig csak a felszínt kapargatom… Kicsit újra elkapott az az érzés, mikor anno a szakdogámat írtam és kb. bármihez nyúltam, újdonság volt… Igen, ez a “gyerek az édességboltban” érzés! 🙂 Azt hiszem, hobbyprojectekre egy darabig kevesebb időm lesz, viszont már most van pár téma, amikről szeretnék cikket írni, meg amit szeretnék kipróbálni… (Hello, WebGL!) Egy biztos: most már egy darabig tuti maradok az erő Javas / JavaScriptes oldalán! 😉

Posted in iNi Blog Tagged with:

#0398 – Hello, GitHub!

Egy ideje törtem már a fejem, hogy kellene pár újdonságot tanulni, nézegettem, hogy mik az aktuális buzzword-ök a java és az OpenSource világában… Alakult is pár dolog, nekifeküdtem ilyen-olyan dolgoknak (Maven, Tycho, Spring Framework, Java 7 finomságok, stb), illetve nagyon elgondolkodtatott a Git, mint verziókezelő rendszer. Nincs kifejezettebb bajom a Subversion-el, főleg, hogy kapásból az iNi-t hostoló DotRoll is támogatja a Subversion repo-k létrezhozását, de egy kolléga elég ódát zengett nekem a Git-ről, hogy érdekelni kezdjen a dolog… 🙂 Húztam, halasztottam, mindig ott volt, hogy “Na majd kipróbálom!”, aztán mindig elmaradt. Ma reggel aztán jött az utolsó lökés – olvastam egy cikket a JavaWorld-ön, egészen pontosan azt, amelyiknek a címe “Hiring managers advise job seekers to contribute to open-source projects“. Ez a cikk arról szól, hogy az az új trend, ha ITs állások kerülnek szóba, hogy a CV mellett a cégek interjúknál egyre nagyobb figyelmet tanúsítanak annak, hogy aktív-e a leendő kolléga valamilyen OpenSource projectben vagy sem. Hogy ez miért jó? Többek között azért, mert látják, hogy

  • Tud az emberünk csapatban dolgozni
  • Milyen minőségű kódot ad ki a kezeiből, mennyire alapos
  • Milyen témák érdeklik, mibe fektetett energiát
  • Milyen a nyelvtudása (angol kódkommentek, ugyabár!)
  • stb.

Elkezdtem még kicsit olvasgatni a témában, s valóban, ez a dolog durván trendi lett! Volt karriertanácsadással foglalkozó oldal, ahol egyenest azt mondták, hogy “GitHub is the new LinkedIn”! (A GitHub – aki nem tudná! – egy, a SourceForge-hoz hasonló, OpenSource projecteknek ingyenes tárhelyet és version controlt biztosító oldal, amely amellett, hogy ingyenes, kisebb összegekért egy csillió kényelmi szolgáltatást is kinál!) No, mondom akkor itt az ideje megnézni, mit is tud ez a csodacucc, úgyhogy elkezdtem szépen meló után olvasgatni a Git-ről, a GitHub-ról, meg arról, hogy ezeket hogy tudom használatba venni. Első kellemes meglepetésem természetesen maga a Git volt, technikailag. Valahol félúton áll az általam imádott IBM Clearcase és a jobb híján használt SVN között, ami a működést illeti – legalábbis annak alapján, amit eddig láttam belőle. A következő az volt, hogy kiderült, hogy marha jó a Git-hez készült Eclipse-integráció: gyakorlatilag egy csimpánz is képes seperc alatt használatba venni a Git-et az EGit nevű plugin segítségével, ráadásul jó kis tutorialok is akadnak a neten, mint pl. ez itt.

Lényeg a lényeg, hogy olyan szinten vagyok lenyűgözve, hogy eldöntöttem, minden további forráskódomat, amit feltöltök a netre, azt szépen berendezem a GitHub-ra, és teszem ezt lehetőleg majd olyan minőségben, hogy a jövőben, ha esetleg egyszer úgy alakul, ne féljek akár a CV-mben is feltűntetni! 🙂

Végezetül valami, for the LOL jelleggel…. Official GitHub-song (wtf?! 😀 ).

Posted in iNi Blog Tagged with: , , , ,

#0397 – That discovery!

Ezúton is köszönném Sárga Tapsifüles néven kommentelő olvasómnak, hogy fáradt vagyok, alig élek és aludtam három órát talán… akarom mondani, köszönöm neki az inspirációt (lásd a #0396-os bejegyzés kommentjeit!) ahhoz, hogy kiküszöböljem az utolsó dolgot, amit a Javaban szívásnak tartottam… Szóval most már hivatalosan is a Java-t tartom a tökéletes programnyelvnek! 😀 No, de mi is történt múlt éjjel?

Ahogy korábban már említettem is, az utolsó dolog, amit a Java-ban utáltam, az a JNI volt, polgári nevén Java Native Interface, ami arra szolgál, hogy natív libeket (gy.k. DLL-eket vagy SO-kat) tudjunk felhívni Java kódból. Csak épp az volt a gond vele, hogy effektíve nem segít, ha egy 3rdparty libed van, amihez nincs by default JNI wrapper, ugyanis akkor neked kell azzal szórakoznod, hogy wrapper classokat meg interface-eket írogatsz (meg részben generálgatsz, de ez más kérdés), kapásból a java és a C oldalon is! Mindeközben C#-ban egy DLL-ből egy függvényt p/Invoke-al beimportálni annyi, hogy:

1
2
[DllImport("mydll.dll"]
public static extern void DoSomething();

Szóval ez kissé piszkálta a csőrömet és emiatt évek óta kerültem a natív interopot a Java-ban, mint a tüzet… Aztán jött a tegnap éjszaka, amikor oda jutottam, hogy kéne egy wrapper a BASS libraryhoz. A neten létezik egy NativeBASS nevű cucc, csak épp az egy monster, mert a full funkcionalitást implementálja, meg appletre van kiélezve, stb, stb. Szóval ágyúval verébre, miközben nekem kb. 5 függvény kell… Gondoltam, ok, megnézem mi változott az elmúlt években natív interop téren… Aztán pedig…

Szóval igen, úgy néz ki, időközben ez a JNA (Java Native Access) nevű megoldás szépen beérett és most már meglepően pofás, egyszerű megoldást kinál a natív interopra. Kódban kifejezve ez így néz ki:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Platform;
 
/** Simple example of native library declaration and usage. */
public class HelloWorld {
    public interface CLibrary extends Library {
        CLibrary INSTANCE = (CLibrary) Native.loadLibrary(
                (Platform.isWindows() ? "msvcrt" : "c"), CLibrary.class);
        void printf(String format, Object... args);
    }
 
    public static void main(String[] args) {
        INSTANCE.printf("Hello, World\n");
        for (int i = 0; i < args.length; i++) {
            CLibrary.INSTANCE.printf("Argument %d: %s\n", i, args[i]);
        }
    }
}

Tehát a lényeg – egy classban megmondom, hogy melyik natív libből húzzuk be a metódusokat (8. sor), aztán már csak a metódusok felsorolása van szépen sorban (10. sor). A legnagyobb “nehézség” összepárosítani a megfelelő paramétertípusokat, de ez .NET-ben is így van, szóval… 🙂 Mindemellett a JNA tud olyat is, hogy Platform.is64bit(), ami megint csak marha hasznos, mert futásidőben tudom eldönteni, hogy akkor most a 64 bites vagy a 32 bites DLL-t töltöm be, annak függvényében, hogy milyen JRE-n fut a cucc! Jah, és természetesen ez az egész multiplatform, fut az OSX-től Androidig mindenen! YEEEHAAAW! 😀

Mondanom sem kell, hogy onnantól, hogy rátaláltam és megértettem, hogy működik, kb. 2 perc alatt berántottam a Maven-es projectembe, kb. negyed óra alatt lekódoltam vele a BASS wrappert, aztán elégedett vigyorral az arcomon mentem aludni úgy hajnali 4 körül…

Posted in iNi Blog Tagged with: , , , , ,

#0396 – Bonzai Engine

Ezt csak úgy érdekességképpen… Szóval miközben a saját kis java alapú OpenGL kódjaimat kalapálom abban a kis szabadidőmben, körülnéztem a neten, hogy mit tud most egy commercial-színvonalú, javas OpenGL engine. Ha valaki nekiáll így keresni, első körben a jMonkey Engine-be fog belefutni, ami biztos tök jó, mert nem most óta fejlesztik, de nagyon gáz a PR-ja: ezeréves screenshotok, a leggagyibb indie-kategóriát is alulról súroló játékok, meg ilyesmik a referenciák, amik valljuk be, nem túl meggyőzőek… Aztán mikor már kezdtem elszontyolodni, akkor futottam bele a Bonzai Engine-be, ami egy jóval fiatalabb cucc, de azért egész jól demonstrálja, hogy azért van kakaó a javas engine-ekben – bőven elég ahhoz, hogy elvigyenek egy multiplatform indie játékot a hátukon… Az engine egyébként nem túl meglepő módon ugyanazon az LWJGL csomagon alapul amivel én is elkezdtem mostanában szórakozni…. Íme két videó, mindkettő egy-egy, a Bonzai-al készült demóból való:

Ami a legmókásabb, hogy az engine Youtube-csatornáján ott egy videó arról is, ahogy vagányan futkorászik a dolog egy mobilon… Hmm, lehet ki kéne próbálni… for science! 🙂

Posted in iNi Blog Tagged with: , , , ,

#0395 – Tisztázzunk pár dolgot!

Szóval az előző, illetve pár korábbi, Microsoft-fikázó ™ post kapcsán úgy érzem nem árt egy kis magyarázat… Kezdjük tehát azzal, hogy mi volt a célom az egész kirándulással a .NET világába! Adott egy 30 év körüli senior fejlesztő, aki királyul elvan a munkájával, szereti, amit csinál és örül neki, hogy azzal foglalkozhat, ami a hobbija. Nos, ez lennék én. 🙂 Van azonban egy probléma: van, amikor a munka egyszerűen nem jelent szakmai kihívást, bármennyire is szeretném. Minden nagyobb project életében időről időre vannak olyan periódusok, amikor épp dögunalom van – amikor a dokumentációt kell írni, amikor tesztelik a cuccot, amikor épp nem kell új feature-t fejleszteni, vagy amikor olyan feature-t rendeltek meg, amivel hónapokig el fogtok szüttyögni, de igazából favágómunka. (Pl. teljesen hülye-biztos GUI-k összerakása, stb) Ilyenkor az ember valami olyat keres, ami kapcsolódik a programozáshoz, de napi néhány óra intenzív fejtörést biztosít. Kicsit olyan ez, mint a hardcore gamerek esetében a PvP – mindig keresik az olyan ellenfelet, akit épp csak meg bírnak verni, viszont rohadtul elunják újra és újra elkenni ugyanazoknak a nooboknak a száját 🙂 Szóval mikor valaki azt kérdezi, mit akarok én az OpenGL-lel, akkor a válaszom nem az, hogy játékot fejleszteni, meg megélni belőle, meg hasonlók (bár mondjuk 20 évesen még hittem, hogy ez lehetséges, de lássuk be, ez Magyarország és ráadásul még pesti sem vagyok…). Persze biztos jó lenne valami kis indie játékot megcsinálni, de ha egyszer nincs idő, akkor nincs. Ennek ellenére a téma bőven nyújt még lehetőségeket – effekteket, algoritmusokat leprogramozni, azokat szénné optimizálni, stb. Maga az életérzés, a kihívás tehát számomra a lényeg, s ha alkotok is valamit, akkor azt simán azért, mert meg tudom tenni, nem pedig azért, mert bármi komolyabb célom van vele.

Nos, hogy ezt letisztáztuk, jöjjön a következő dolog: miért a negyedik generációs nyelvek? Miért nem jó nekem a C++, stb? Semmi bajom a C++al, tudom, hogy mindent meg lehet benne csinálni, stb. Évekig dolgoztam vele, azt használtam a szakdolgozatomhoz is, stb. Ellenben viszont továbbra is hobbyról beszélünk és abban a kis időben, amit rá tudok fordítani, szeretnék valami látványosabb haladást elérni. Számomra az, hogy memory leak-eket meg címzési hibákat vadásszak, kontraproduktív időrablás tehát az előbbieket figyelembe véve…

Akkor miért nem használsz valami “félkész” cuccot, pl. Unity? Nos azért, mert ott már nagyon sok mindent megírtak helyettem. Az már valahol a ló túloldala, ahol már tényleg csak a contentre kell koncentrálni, stb. Tök jó persze, ha az ember játékot akar csinálni, de rohadtul nem a megfelelő eszköz, ha az érdekel, hogy hogyan tudsz egy komplett megvilágítási rendszert leprogramozni.

Ok, és akkor miért pont a Java? Mi a baj a C#-al? Félreértés ne essék, semmi bajom a C#-al! Egy marha jó nyelvnek találom és vérzik a szívem, ha pl. arra gondolok, mennyivel nehezebb javaban natív libhez wrappert írni! DE és itt a nagy DE – amíg a Javat a “community driven” kategóriába sorolom, addig a C# (és vele együtt a .NET) mögött effektíve egyetlen cég áll. Ez számomra a probléma gyökere. A .NET egy szép nagy, kövér, nyílt szabvány, amit simán implementálhat bárki, ha jól tudom, de mégsem tették meg túl sokan sajnos. Amennyire én látom, ez azért van, mert a Microsoft halál nyugodtan játszik az egész .NET világgal a saját szájíze szerint, azok pedig, akik követni akarják a folytonosan változó szabványt, arra kényszerülnek, hogy loholjanak a Microsoft után ész nélkül. A gond viszont az, hogy amíg a Microsoft eszméletlen mennyiségű pénzt tud arra fordítani, hogy valamit továbbfejlesszen, ha az érdeke úgy kívánja, addig pl. a Mono-t adományokból és támogatásokból tartják fenn. Tehát, ha mondjuk épp jön a Windows 10 ( 🙂 ) és az MS úgy dönt, hogy ehhez feje tetejére kell állítani a kurrens .NET runtime-ot, szó nélkül megteszi. Nekik könnyű dolguk van – egyetlen OS-en gyorsan átütik az implementációt és kész. A Mono fejlesztői meg csak pislognak – már az is idő, mire eljut hozzájuk ez az infó, aztán ki kell találni, hogy ezt hogy ültetik át legalább a három fő platformjukra (OSX, Linux, Windows), majd le kell implementálni és tesztelni, dokumentálni, etc. az egészet – jóval kevesebb forrásból. No, erre mondtam, hogy a szabvány követői szépen loholnak a Microsoft után… Btw ezen az oldalon egész jól lehet látni, hogy mennyivel lagol a Mono a Microsoft mögött 🙁 Számomra a .NET akkor volna tökéletes, ha maga a Microsoft támogatná legalább a három fő platformon a cuccot, csak ugye ez nem fog megtörténni, mert onnantól, hogy bármit támogatnának hivatalosan is, ami nem Windows-os, szépen elkezdenék sajátkezűleg beverni a szögeket a Windows koporsójába…

Végezetül itt egy link a trolloknak, akik még mindig a Java vs. C/C++ témán csámcsognak… Legyen annyi elég, hogy a Java köszöni és jól érzi magát a piacon, majdnem holtversenyben az ANSI C-vel! 😉

Posted in iNi Blog Tagged with: , , , , ,

#0394 – Itt a vége…

… annak, hogy tovább erőltessem a .NET-et és a C#-ot. Újra meg újra rájövök, hogy az egész nem más, mint a Microsoft lassú erőlködése, hogy leklónozzák a java-t, meg mindent, ami mögötte van. Csak éppen amíg a java mögött megszámlálhatatlan mennyiségű cég és rengeteg beleölt energia van, addig az egész .NET kb. egy bohóckodásnak tűnik, ami igazából egyetlen cég nevéhez fűződik (nem, azok a nyúlfarknyi tool-ok, amiket random pár fős cégek írnak, nem számítanak!). Szóval röviden, velősen:

De ha már itt tartunk, pár dolog, amit gyűlölök és mindig is gyűlölni fogok…

  • A Visual Studio-nak nincs igazi alternatívája – ha lenne is, valószínűeg az MS felvásárolná és megszüntetné… A java világában, hogy csak a legnagyobbakat említsem, ott a Netbeans és az Eclipse – mindkettőnek pörög a fejlesztése, mint az őrült, ugyanis a verseny motiválólag hat a fejlesztésekre.
  • A multiplatform teljes hiánya. Microsofték a mai napig meg vannak győződve róla, hogy az emberek egyedül Windows-t használnak és arra fejlesztenek. Hiába kvázi nyitott szabvány a .NET, az egész mechanizmus nem támogatja pl, hogy Mono framework-re fejlesszek Visual Studio-ból. Egyszerűen nevetséges és felfoghatatlan…
  • Android, iOS detto – röhejes, hogy olyan “nevenincs” cégek, mint a Xamarin (akik valljuk be, nem folynak épp a csapból is…) effektíve egyeduralkodók, ha a mobilos .NET-en van a sor. Óriási piaci rést hagy ki azzal a Microsoft, hogy kizárólag Windows Phone-ban gondolkodik (van egyáltalán .NET Windows Phone-ra? Gondolom van…)
  • A Visual Studio fejlesztésébe láthatólag nincs beleszólása semmilyen communitynek – ez meg is látszik rajta rendesen, hiszen maga az IDE klasszisokkal le van maradva egy Eclipse-hez vagy NetBeans-hez képest és ráadásul fizetős (az Express meg hiányos). A hiányzó funkcionalitást pedig mi mással lehetne pótolni, mint fizetős 3rdparty cuccokkal… Király, nem?

Ahogy én látom, dobniuk kellene az egész .NET-et és erősebb JVM integrációt kellene inkább produkálni a Windows-al. Appservert az IIS-be, preinstallált JVM-et az oprendszerbe (akár saját JVM-et is!), hogy az átlaguser észre se vegye, ha egy alkalmazás java alapú. A Visual Studio-ban nyugodtan koncentrálhatnának a C++ra (esetleg a webes cuccaikra) és a felhasználói élményre, illetve, ha nagyon akarják, csinálhatnának egy java IDE-t (még akkor is, ha ezzel a Dunába vinnének vizet) ahelyett, hogy WPF-et, Metrot meg minden baromságot implementálnak a VS .NET-es részéhez…

Szóval azt hiszem – legalábbis, ami a privát projectjeimet illeti – végeztem a dologgal. Elegem lett abból, hogy behóckodnom kell azzal, hogy Linuxon mono, Windows-on .NET, stb, stb. Miért? Minek? Tegnap egy új Eclipse IDE telepítését, bekonfigolását, stb. beleszámolva kb. 2 óra alatt összehoztam egy crossplatform OpenGL projectet java-ban, úgy, hogy

  • A buildet Maven manageli, nem kell egy jart sem kézzel piszkálnom
  • A render LWJGL alapú, szóval kapásból megy Linuxon, OSX-en és Windows-on módosítás és újrafordítás nélkül
  • Az asset-eket kezeli az Eclipse, sőt a jaroknak hála kapásból VFS-em is van
  • Ki sem kell mozdulnom az Eclipse-ből, helyben van hozzá shader editor, stb
  • Van integrált debugger, profiler, stb. kéznél
  • … meg ami még nem jut eszembe

És akkor még arról nem beszéltem, hogy az Eclipse-hez akkor írok plugint, amikor akarok – ellenben sok szerencsét azzal, hogy hasonlót kövessek el a Visual Studio Express-el. :p

Szóval good riddance…

Várjunk csak… és a Tao Classic???

Nos igen, a TC is megy a levesbe – ami azt illeti, sajnálom, de ez van. Elmorzsoltam egy könnycseppet, átgondoltam az egészet… A több száz letöltő közül alig kaptam valakitől is visszajelzést, segítséget meg összesen egyetlen embertől, az is minimális volt 🙁 Ez van, rétegigény, úgy látszik. Én pedig naiv voltam… Mindeközben pedig apa lettem, szóval nem fogom a megcsappant szabadidőmet arra elpazarolni, hogy a Monoval meg a Microsoft baromságaival bohóckodjak effektíve a semmiért! Innentől a kódot is vegye, vigye, aki akarja 🙂 Hát, kb. ennyi. Egy normális bejelentés lesz majd a TC dedikált oldalán, meg a SF.net-en, stb.

Szeretnék már az OpenGL-re koncentrálni inkább és ezt olyan eszközökkel tenni, amik nem akadályoznak folyamatosan…

Posted in iNi Blog Tagged with: , , , , , , , , ,

#0393 – OpenGL, totál kezdő, 2014…

Egy nagyon jó barátom ma feltette a kérdést: hogyan kellene nekiszaladni az OpenGL-nek úgy, hogy C++ban már van tapasztalata (főállásban C++ coder!), de a 3D dolgokban szinte semmi? A célja az volna, hogy minél hamarabb eljusson oda, hogy modelt tudjon betölteni és animálni, esetleg később valami egyszerűbb játékot összerakjon… Nos, igen, mondhattam volna neki, hogy “Hé, nézz fel az oldalamra, ott egy rakás cikk!” – csak éppen 2014-ben ezek az OpenGL-es cikkek elég elavultak 🙁 Szóval egyenlőre maradtunk abban, hogy átdobok neki ma este pár linket, meg adok 1-2 jó tanácsot… Aztán, mivel úgy tűnik, a post írásának pillanatában nincs a gépnél, gondoltam megörökítem ezeket a tanácsokat, hátha jók lesznek még valamire, valakinek 🙂

Jobban belegondolva ez egyfajta post mortem cikk is lehetne arról, hogy mit csinálnék másként, ha most kezdeném az OpenGL-es “karrierem” 🙂 No mindegy, csapjunk a lecsóba! Tehát…

  1. OpenGL = Multiplatform. Pont! Lehet, hogy elsőre felesleges vesződségnek tűnik, de hidd el, nem az! 2014-et írunk, a Windows messze nem olyan egyeduralkodó már, mint volt, s akkor még nem beszéltünk a mobilos OS-ekről, stb. Ha már C++ban kezdesz neki, amihez kb. egy kenyérpirítóra is írtak fordítót, akkor ne kösd magad egyetlen OS-hez sem! (Főleg ne kizárólag a Windows-hoz, mert figyelembe véve a Microsoft mostani össze-vissza kapkodását, azon sem lepődök meg, ha a Windows 9-ben nem lesz OpenGL! 😛 )

  2. Felejtsd el a régi OpenGL-t! Fogadni mernék, hogy az egyetemeken még mindig tanítják a glBegin / glEnd, stb cuccot (baráti nevén: immediate mode), pedig már akkor elavult cucc volt, mikor én voltam egyetemista! Ha olyan tutorialt látsz, amiben ilyennel szórakoznak, ott könyveld el, hogy a cikk írója el van maradva (pl. mint én a cikksorozatommal! 🙁 ) és hátrálj el onnan!

  3. Amihez csak tudsz, használj bejáratott, több éves múltra visszatekintő, ingyenes libraryket, amiket a mai napig fejlesztenek! 1-2 példa:
    • Lineáris algebra: GLM
    • OpenGL Extension-ök: GLEW
    • Ablak-kreálás: FreeGLUT

    Hiába mondja bárki, hogy ezeket vagy egy részüket te is meg tudod írni, ne ess abba a hibába, amibe én: minél többet kínlódsz a segéd-dolgokkal, annál kevesebb időd marad a tényleges 3D-re!

  4. Kezdőként ne szórakozz az OpenGL context-ekkel, ha nem muszáj! Elkedvetlenítő és zavaros tud lenni, te pedig nem fekete ablakokat és crashelő progit akarsz látni, hanem forgó-csillogó-világító dolgokat! 🙂 Szóval ahelyett, hogy megpróbálnál rájönni, hogy hogyan fogsz ablakot nyitni két-három különféle OS-en, tudd le az egészet röviden, pl. kb. ennyivel:
  5. 1
    2
    3
    4
    5
    6
    
    glutInit(&amp;argc, argv);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);	
    glutInitContextVersion (4, 4);
    glutInitContextFlags (GLUT_CORE_PROFILE | GLUT_DEBUG);
    glutInitWindowSize(screen_width, screen_height);
    glutCreateWindow("OpenGL 4.4");

    (Itt jegyzem meg halkan, hogy a Tao Classic-ban ezzel a context-kreálással szívok istentelen módon és azt mondom: korrekt, generikus, multiplatform context-kreáló kódot írni márpedig vicces dolog…)

  6. Keress egy jó tutorial-sorozatot, de ne ragadj le ott! Nézz példakódot, minél többet! Más emberek másként csinálják akár tök ugyanazt a dolgot, főleg, ha nem egzakt területről van szó, mint pl. az optimális 3D kód írása… (Pár link lesz lentebb!)

  7. Ne szórakozz az IDE-vel – nincs szükséged a Visual Studio 2020 GigaMegaEnterprise Edition 5 DVD-s változatára ahhoz, hogy elkezdd a dolgot. Tökéletesen megfelel akármilyen C++ fordító, IDE. Ami neked tetszik. Kezdőknek jó példa pl. a Code::Blocks. Ez utóbbi már csak azért is jó, mert kapásból multiplatform! 😉

  8. Ne félj toolokat használni, amikkel megkönnyíted a kísérletezésed, mint pl. a gDEBugger vagy a GLSL Hacker. Némelyik bonyolultnak tűnik, de egy idő után alap cucc lesz az eszköztáradban!

  9. Az új OpenGL-nek és a hozzá kapcsolódó szabványok gyors fejlődésének hála észre fogod venni, hogy a Neten a GLSL-ről (az OpenGL shader nyelve) szóló információtömeg egy nagy katyvasz, ezerféle forrásból milliárdnyi infó, ezerféle GLSL verzióhoz. Márpedig szükséged lesz valami szolid alapra, mert az OpenGL 3.0 után elég nehéz lesz megkerülnöd a GLSL-t! Kezdésnek, bármilyen viccesen hangzik is, a Wikipedia-t ajánlom, egészen pontosan a GLSL oldalt. Itt látszik, hogy épp melyik az aktuális GLSL verzió, illetve az oldal tartalmaz egy átfogó, de nem túl részletekbe menő bemutatást is a GLSL-ről.

Hát, ennyi lenne, ami hirtelen eszembe jutott. Ismétlem: a célom nem egy step-by-step guide megírása volt, csak pár irányvonal a kezdéshez! Remélem, valakinek segít! 😉 A kérdések és a rohadt paradicsom jöhetnek kommentben…

Végezetül, pár link, naprakész tutorialokkal, stb:

Posted in iNi Blog Tagged with: , , , , , , , , ,

What the …

A die hard coder's blog about basically anything slightly related to programming, gaming, IT, etc. Stuff I've experienced, opinions and rants, written in mostly a caffeine-happy state of mind. Oh, and some articles too...

The Archives