Én, az EP, és emulátor írási kalandjaim

Előszó: ez a cikk még régebben íródott, ezért a vége felé némi „aktualizáló” rész következik. Az eredeti  szándékom a cikk teljes újraírása volt (ami idő hiányában elmaradt), de talán nem is baj, hogy így történt; így legalább folyamatában jobban látszódnak a történések.

Még kétezer környékén történt, hogy egy szokásos „webes retro körutam” (értsd: céltalan böngészés a Neten „retro computing” témában) során belefutottam az Enterprise nevű masinába. Mivel még nem is hallottam erről a gépről (habár később eszembe jutott, hogy egy általános iskolás osztálytársamnak volt ilyenje, egyszer láttam pár pillanatra), elkezdtem utána olvasni. Azonnal lebilincselőnek tűntek elegáns hardware és software megoldásai, legalábbis legtöbb nyolc bites társához képest. Természetesen ki is akartam próbálni, aminek nálam megszokott módszere (valódi gép hiányában) az emulátor keresése volt. Rá kellett jönnöm, hogy itt akad egy kis probléma: ugyan rátaláltam az „Enter” nevű emulátorra, és talán az „EP32”-re is (nem emlékszem már), egyik se működött az általam használt operációs rendszer (Linux) alatt, Windows-om meg soha nem is volt (a wine – ami egy Windows emulátor szerű entitás – emlékeim szerint nem igazán boldogult akkoriban egyikkel sem). Pár napig bütykölgettem a forráskódjukat, de rájöttem, jobban járok (és többet is tanulok) ha én magam próbálok meg emulátort írni – magamnak. Hamar rákaptam a dologra, és megtetszett az emulátor írás, annak ellenére, hogy voltaképpen használható eredményig el sem jutottam (az Enterprise logó után mindig kifagyott). Viszont ebben saját volt minden, a (félkész) Z80 emuláció is, nulláról írva (és a Z80-at is ekkor ismertem meg közelebbről, addig csak távolról szemezgettem vele). Az egész csak Linux alatt futott, és nem is adtam ki soha (a neve amúgy Xepem lett volna, azaz „X EnterPrise EMulator”).

A fentiekből látható, hogy kicsit kilógok az EP-s közösségből, nekem ugyanis nem volt régen Enterprise-om (C64-em volt anno), mint a legtöbbünknek, akiket jelenleg érdekel a téma.

Sok minden történt ezután, rátaláltam a magyar Enterprise közösségre, a fórumra, lett igazi Enterprise-szom is (szégyenkezve bevallom, hogy egy-két gyors próbálkozáson kívül még nem igazan használtam – ezen hamarosan változtatni fogok!). Ami viszont történetünkben legfontosabb, lett ep128emu is (az is elképzelhető, hogy csak én találtam rá viszonylag későn ...), ami futott natívan Linux alatt is. Szeretném tisztázni: az ep128emu véleményem szerint a legjobb és leghasznosabb Enterprise emulátor. Az én „próbálkozásaimról” inkább élmenyszintű beszámolót szeretnék itt írni, nem állítom, hogy az én munkáim annyira komolyak és használhatóak (messze nem!), mint amilyen az ep128emu! Általános célú emulátornak mindenképpen az ep128emu-t ajánlom mindenkinek! Az „első” kiadatlan emulátoromra (Xepem) nem is volt szükség többé, hiszen színre lépett az ep128emu. Ami ráadásul működött is, ami nem kis előny :)

Már 2013-ban történt, hogy a fórumot böngészgetve rátaláltam a „web emu” témára. Itt egy felvetés böngészőben futó emulátorról szol, igaz az eredeti kérdés szerint plug-in vagy extension formájában. Az jutott eszembe, hogy utána kéne nézni a JavaScript lehetőségének, hiszen ez a technika „komolyabb” célokra való felhasználása felfutóban volt, és pont akkoriban botlottam bele az JSspeccy nevű JavaScript alapú ZX Spectrum emulátorba is. A dolog már csak azért is érdekelt, mert szerettem volna a JavaScript-et kicsit jobban megismerni mint amennyire a szokásos pár soros „weboldal dekoráló” megoldásokból az ember ismerheti. Megnéztem az JSspeccy forrását, és rá kellett, hogy jöjjek: nem feltétlen tudnék ilyet írni magamtól elsőre (azóta már menne ...). Ezért azt a megoldást választottam, hogy lepésenként megpróbáltam azt átírni azzal a céllal, hogy a végén csak a Z80 emuláció maradjon, a többi része pedig már teljesen az én munkám lesz és persze EP-t emulál Spectrum helyett. Az első valamennyire működő megoldás meglepően hamar működőképes lett, bár itt még a kurzor is zöld volt – tehát némi Nick emulációs hiányosságok –, és egyéb „apró” problémák :) Az emulátor az JSep nevet kapta (hé, végre valami, aminek a nevébe nem teszek X-et!).

Az JSep számomra tehát egy tanulási folyamat is volt. Sajnos ez meg is látszik rajta: a mai JavaScript tudásommal már inkább sírógörcsöt kapok azon, amilyen megoldásokat ott használtam. Igazából ez a fő gát is továbbfejlesztésének: egyszerűen nincs kedvem újra hozzányúlni ilyen kezdetleges kódhoz. Ezért teljes újraírásra lenne szükség (amit ugyan most már megtehetnék, csak éppen nem lenne sok értelme, lásd cikkem végefelé). Az emulátor jelenleg rengeteg dolgot nem tud, amit jó lenne, csak pár dolgot említve: nincs hang, pontatlan a Z80/Nick/VRAM összehangolás, nem lehet az emulátorral menteni, pontatlan Nick/videó emuláció (interlace, stb.), észszerűen (az új helyesírás szerint most akkor így kell írni?) az emulátor nem használható saját oldalon / megoldásba ágyazva. Viszont van legalább két dolog, amit az JSep tud, viszont az ep128emu nem: emulálja a boxsoft-féle egérillesztőt (terveim szerint egyszer majd az EnterMice-t is), illetve az Am9511 APU-t (mai szóhasználattal FPU lehetne – bár az APU emuláció sose lett komolyan tesztelve, software hiányában). Bizonyos limitációk a webes technikából fakadnak: többen kértek „beállító menüket”, illetve „floppy disk image csatolást”. Az a baj, hogy ők azt nem veszik figyelembe, miszerint ez egy webes emulátor, célja a web környezetbe való integrálás, helyi gépről nem fog tudni csatolni semmit (utólagos kiegészítés: erre ma már lenne lehetőség, ám továbbra sem kényelmes és célszerű pár szempontból), mindent weben át kell neki adni, vagy URL (ahonnan letölti) vagy URL paraméter (config beállítások stb.) formájában. Az JSep talán hasznos lehet egy-egy software gyors bemutatására, főleg olyanoknak, akik nem feltétlen szeretnének egy emulátort telepíteni saját gépükre. Akkor még elfogadható az arra beállított környezet webes link formájában. Dióhéjban: egy webes emulátor célja a webes környezetben való futás, ami nem túl meglepő :) Ez sok esetben kissé másfajta megoldásokat szül, mint amit a natív alkalmazások eseten (pl. ep128emu) megszoktunk. Például el tudok képzelni egy weboldalon nemi Enterprise software gyűjteményt, ahol egy klikkel ki is lehet próbálni az adott programot azonnal weben, mielőtt az ember letöltené, stb.

Meglepő fordulat azonban, hogy az JSep megoldása más esetben is hasznos lehet (főképpen hasznos lesz, de itt is egy alapos újraírás után lehetne számítani elfogadható eredményre): a különböző mobil eszközökre, okos telefonokra, és tabletekre gondolok most. Annak idején kipróbáltam szerzeményemet a saját okos telefonomon, az eredmény lehangoló volt, talán slideshow-nak lett volna csak alkalmas az eredmény. Viszont a mostani okos telefonommal és egy mostani böngészővel rajta egész meglepően jó eredményt képes produkálni! Ez egyrészt köszönhető persze a kérdéses eszközök hardware szintű fejlődésének, azonban a JavaScript teljesítménye is meredeken növekszik az elmúlt években, és szinte versenyt űznek a böngésző gyártók ebből. Lassan oda jutunk, hogy egy kissé heterogén mobil eszköz környezetben (Android? iOS? Windows Phone?) lehetőség nyílhat egy egységes megoldás használatára (főleg a jelenlegi mobil specifikus web API-k és megoldásokkal, amivel JS-ben akár az eszköz elmozdulása és ilyesmik is kezelhetőek). Hozzátenném, az JSep „kézzel” írt JavaScript kód, nem az asm.js megoldás, amihez akar C fordító is van (pl.: emscripten), mely képes C kódot az asm.js nevű JavaScript részhalmazra „fordítani”. Ezekre a megoldásokra azt mondják, hogy már csak kétszer-másfélszer lassabb adott esetben mint a natív kód (ezt igazolni nem tudom, még nem igazán próbáltam). Természetesen a webes technikáknak van még hova fejlődniük, az JSep-nek meg különösen ;)

Az JSep másik „sikere” az elrettentés volt :) Történt ugyanis, hogy rátaláltam a SymbOS nevű remek kis multi-tasking Z80-ra írt operációs rendszerre, ami azonban akkoriban még nem futott Enterprise-on. Egy őrült ötlettől vezérelve betöltöttem a CPC-s verziót egy CPC emulátorba, amit forráskód szinten átírtam: saját formátumba mentve adott pillanatban a memória tartalmat és a Z80 állapotát. Aztán kissé módosítottam a saját EP emulátoromat, hogy ezt be tudja tölteni, majd pár órát eltöltöttem vele, hogy a CPC memória/CPU állapotnak „pillanatképe” hogyan futtatható tovább egy tök másik gépen, az Enterprise-on :) A módosított JSep emiatt kis részben CPC-t is emulált az EP mellett! A tervem az lett volna, hogy apránként patch-elgetem a mentett CPC memóriatartalmat addig, amíg a CPC hack-ek nélküli emulátorban is elfut, ami után csak némi betöltő kell hozzá: tehát a SymbOS portolásáról lett volna szó memóriakép alapján az Enterprise 128-ra :) Tudom, az ötlet elég furcsa. Annyira őrült, hogy Prodatron (a SymbOS szerzője) válaszolt nekem, és kijelentette, hogy ez annyira hülyeség, hogy már jó :) Illetve „elrettenve” ettől, inkább portolta ő maga Enterprise-ra rendesen a SymbOS-t :) Az igazsághoz tartozik, hogy már régebben is volt az Enterprise-ra portolásról terv, de – amennyire én tudom – ennél több addig nem igazán történt. Tehát ha közvetlenül nem is, közvetve hasznos volt az JSep a SymbOS Enterprise-ra való megjelenése kapcsán is :) Persze lehet, hogy Prodatron ezt másképp mesélné el :) Az olvasótól pedig elnézést, de hadd örüljek néha egy kis sikernek én is, a sikerélmény mint motiváló tényező fontos kérdés abban, hogy az ember ne hagyja abba a dolgot. :)

Egy nosztalgikus napon (már 2015-ben vagyunk) eszembe jutott az első Enterprise emulátor projektem, az amit C-ben írtam, és csak Linux alatt futott (tehát a Xepem). Mivel az SDL2-vel (az SDL egy cross-platform „média réteg” ami elérhető pl. Linux, Windows, Android stb. rendszerekre is) szerettem volna (jobban) megismerkedni, elhatároztam, hogy megpróbálom a régi projektemet (már a forrása se volt meg) „utánozni” SDL2 alapokon, ezúttal nem saját, hanem a z80ex projekt Z80 emulációját felhasználva (amit már régebben is felhasználtam pár kisebb saját projektnél, pl. a CP/M emulációs réteg a UNIX környezetben, és hasonló őrültségeknél). Ezúttal a dolog jobban ment mint anno, ez talán annak is köszönhető, hogy a Z80 emuláció biztosan teljes, és jó volt :) Az új emulátor a Xep128 nevet kapta. Neve a UNIX-os eredetre vezethető vissza (GUI-s programok nevei – azaz X11 alatt futóak – régebben hagyományosan X-szel kezdődtek). Hasonlóan az JSep-hez, itt is a tanulás volt a fő szempont: SDL2 ezúttal. Őszintén, addig sem terveztem eljutni, mint az JSep-vel.

A Xep128 szintén csak Linux alatt futott, ám bennem volt a kisördög, hogy ha már SDL (ami cross-platform) mennyire lenne bonyolult Windows-os programot is gyártani belőle (persze ez most egyszerűsítés, az SDL2 mellett volt benne közvetlen Linux specifikus dolog is, amit előbb orvosolnom kellett). Ismételném: sose volt Windows-om, Windows alá meg pláne nem programoztam még semmit! A megoldás tehát az lett, hogy kipróbáltam a Mingw nevű cross-compilert, ami Linux alatt futva képes C kódból Windows-os exe-t gyártani. El lehet képzelni meglepetésemet, amikor fel óra melóval előállt egy exe, ami a wine alatt legalábbis elfutott. Ha már idáig eljutottam (ami az elején szintén csak kíváncsiság volt részemről: menne-e Windows alá is) elhatároztam, hogy a „duál platform” jelleget megtartom (azóta ez már nem csak „duál”), a Xep128-nak mennie kell Linux (vagy más hasonló UNIX) és Windows operációs rendszerek alatt egyaránt.

A fejlesztési szokásaimon (hobbi szinten is, mert munkában amúgy is így volt mindig is) szintén próbáltam csiszolni: ezúttal már verziókövető rendszerbe tettem a dolgokat (git), és a Github-bal így egyben elérhetővé és tettem mások számára. Illetve, célul tűztem ki, hogy a Xep128 se „általános” emulátor legyen, hanem valamire szakosodjon: ahogy az JSep a web-re, úgy a Xep128 az „extrémebb” hardware elemek emulálására. Hogy miért? Mivel a Xep128 is legalább annyi (sőt több!) hiányossággal rendelkezik (frissítés: rendelkezett ...) mint az JSep, ezért csak ki kellett találnom valamit, hogy akkor miben jó legalább :) Igen, a Xep128 több tekintetben annyit sem tud (tudott) mint az JSep, csak VINT/1Hz interrupt van (volt) jelenleg például. Viszont a boxsoft féle egér szintén megy (azóta EnterMice dolgok is). Ahogy ezt is, sok dolgot egyszerű volt megcsinálni, mert az JSep-be írt JavaScript kódomat kellett „átfogalmazni” csupán C-be. Viszont új például az SD kártya cartridge támogatás, ami sem JSep-ben, sem pedig ep128emu-ban nincs (azóta ep128emu-ban is van). Jelenleg csak olvasni lehet vele (azóta már írni is), de ez már mutatja, hogy az JSep-hez képest megvan a natív implementáció előnye, ezt weben megoldani főleg egy nagy méretű disk image eseten elég nehézkes. A SymbOS Xep128-al működik, egérrel, SD kártyáról is (JSep-vel is működik, persze ott nem SD-ről).

Hogy mi még „extrém hardware”, arra jó példa a Z180 emuláció a Xep128-ban :) Nem sok embernek van Z180-al szerelt Enterprise-sza, tudtommal egyetlen egynek :) Mégis, érdekes problémának tűnt ennek megoldása (még nincs kész, de arra már jó, hogy Z180 által nem ismert Z80 opcode-okat kiszúrja például). A ZX Spectrum hardware emulátor kártya emulálása :) szintén elég őrült ötletnek tűnt, bár lehet, ez nem túl eredeti ötlet (ep128emu-ban is van, tudtommal). Azonban kétségkívül a legértékesebb az lenne, ha a félbehagyott munkát az EPNET emulációját folytatnám. Ha valaki még nem hallott volna róla, az EPNET Bruce Tanner barátunk (aki az eredeti IS-BASIC-et, és az EXOS egy részét is írta például) projektje, dióhéjban: „kössük az Enterprise-t az Ethernet LAN-unkra és az Internetre”. Ezt emulálni egy webes emulátor nem is tudná, hiszen nem képes http-n és hasonlókon kívül más, natív protokollal használni a hálózatot, jellege miatt. A Xep128 mivel natív alkalmazás, képes lehet erre. Szerény véleményem az, hogy az EPNET mindenképpen ütős kis hardware lesz majd, hiszen „Enterprise a neten” az valami új. Ennek emulálása szerintem ezért eléggé fontos feladat lehet. A SymbOS új verziójában már van hálózat támogatás (igaz még nem az EP-s verzióban), és Prodatron valószínűleg örömmel tenne EPNET támogatást is az Enterprise verzióba majd. A Xep128 EPNET emulációjával meg mindez valódi hardware nélkül is kipróbálható lenne (lenne, ha haladnék vele).

Az Xep128 egyik nagy hátránya jelenleg, hogy köszönőviszonyban sincs a felhasználóbarátság (legalábbis, ha a felhasználó nem command line fetisiszta, mint én) fogalmával :) Az JSep esetén ez még elfogadható annak jellege miatt („web”), hogy nem lehet szabadon configolni, helyi file-okat betölteni ROM-kent, disk image-ként stb. Azonban a Xep128 egyik lényeges jellemvonása pont az, hogy natív applikáció. A problémát azonban nehezíti, hogy lényegében az SDL csak egy (SDL2 - vagy több) „ablakot” ad, amibe szabadon lehet „rajzolni”. Ha az ember beállító paneleket, stb. akar, azt neki kell megrajzolnia kvázi képpontonként (még egy szöveg kiírása is így megy). A másik lehetőség, hogy az SDL mellett az emulátort futtató operációs rendszer saját GUI elemeit kell felhasználni. Ez azonban azért problémás, mert így akkor megszűnne azonnal a csaknem teljesen közös Linux/Windows kódbázis (ami javarészt csak az SDL-en át „érintkezik” az OS-sel, így nem lát különbséget, azt meg az SDL elintézi), és külön Linux és Windows specifikus implementációk szükségesek ennek kialakításához (azóta pl. a FILE: implementáció használ file kiválasztó ablakot Windows és Linux viszonylatában is). Más függőséget nem igazan szeretnék bevezetni, bár léteznek SDL-re épülő platform független GUI megvalósítások, ezek kinézete sem túl esztétikus, meg hát méretük sem kifejezetten apró …

Amit én érdekesnek találok, az a „nagy egyesítési elmélet”: valami „app store” szerű cucc Enterprise-ra, neten át, ahogy kell. Valódi hardware-en ott az EPNET ehhez, működik. JSep eseten HTTP/AJAX neten át szintén. Végül pedig Xep128 esetén az EPNET emulációval kb. az első esetnél vagyunk.

Nagyon érdekes amúgy látni az emulátorok közötti forráskód szintű kapcsolatot. Az JSep Z80 emulációja még mindig az JSspeccy féle, ami azonban a FUSE-ból származik (a FUSE egy eredetileg UNIX-ra írt ZX Spectrum emulátor – Free Unix Spectrum Emulator). A Xep128 Z80 emulációja a z80ex nevű Z80 emulátor projektből jön (habár erősen módosítgatva lett általam), ami meglepő módon szintén a FUSE-ból nőtte ki magát. Erre amúgy csak később jöttem rá, mindenesetre érdekes. Az összes említett projekt software licence (GNU/GPL) amúgy ezeket a forráskód átvételeket lehetővé is teszi (betartva néhány szabályt, például, hogy biztosítani kell az ember saját munkájának a forrását is aztán, amiben felhasználja). A Xep128 kapcsán elégedett vagyok a z80ex-szel, viszont az JSep oldalán az újraírást tervezem, hogy az eredeti FUSE kódbázisból kiindulva hozok létre Z80 emulációt, ahogy az JSspeccy is tette.

Érdekes tény, hogy az „igazan gyors” JavaScript – úgy tűnik – az asm.js és hasonló technikák irányába fog elmenni, ami nem kedvez a „kézzel írt” JavaScript kódnak, mint amilyen jelenleg az JSep is. A már említett emscripten (C-ből asm.js) fordító ráadásul pont SDL API-t „emulál”. Így elvileg a Xep128 kisebb-nagyobb módosításokkal alkalmas lehetne a Windows és Linux natív működés mellett emscripten-t használva webes emulátor „generálására” is (azóta alkalmas is). Az is igaz, hogy SDL viszont van Androidra is, tehát elvileg az is lehetséges, hogy a Xep128-at Android natív appnak fordítsa le valaki, némi munka árán. Ki tudja, lehet, hosszú távon jobban megéri majd egyetlen emulátort fejleszteni, és nem web / natív bontásban kettőt? Ehhez azonban az én tudásomnak is gyarapodnia kell még. Pont ez az egyik tanulsága is cikkemnek (legalábbis szerintem): ha az ember már úgy is meg akar tanulni valamit, miért ne tegye ezt egy olyan projekten át, ami egyben a hobbijával is kapcsolatos, de ami tudást aztán máshol is fel tud majd használni? A másik érdekes következtetés: most is, de főleg régebben sokan kérdezték miért nem használok Windows-t, mint bárki más, az emulátorral se lett volna gondom. Az lehet (és nyilván az ember személyes OS választása nem csak ezen múlik), viszont akkor nem is akartam volna írni egyet, ezáltal meg sem ismertem volna a gépet annyira, a Z80 gépi kódot, stb. Lehet, csak egy gyors kaland lett volna „na, erre a gépre is ránéztem” alapon (amire nyilván elég sok példát említhetnék, ahogy bárki más is - gondolom) az EP. Így viszont menet közben szerettem meg, mondhatni. Más hasonló témában is jártam már így amúgy, és nem csak a „régi számítógépek” kapcsán, érdemes néha nagyobb dolgokba is belevágni.

Végezetül, szeretnék köszönetet mondani mindenkinek a fórumon, két személyt külön kiemelve: Zozo, aki sok tanáccsal és információval látott el az EP kapcsán (illetve néha igényekkel is az emulátor kapcsán), és István (az ep128emu szerzője) aki több esetben is irányt mutatott az emulátor írás rejtelmeinek útvesztőjében. Meg persze mindenkinek, aki kipróbálta, véleményezte munkámat (itt megemlítve Gflorez fórum társunkat, aki lelkesen kipróbált mindent, „egerészésben” adott tanácsokat, sőt ikont is szerkesztett aztán az emulátorhoz). Külön köszönet az olvasónak, aki kisregényemet – itt és most – képes volt végigolvasni :)

Ám ezzel nincs vége …

Eredeti cikknek szánt betűhalmazom (mely fentebb ért volna véget) bizony nem épp tegnapi, azóta sok víz folyt le a vén Dunán. Legérdekesebb hír azóta talán az, hogy István újra foglalkozik aktívan az ep128emu emulátorral, ami örvendetes hír minden EP-snek, és iránta érdeklődőnek! Hiszen, én, mint az Xep128 szerzője is be kell, hogy ismerjem: azért az ep128emu-t a Xep128 messze nem képes pótolni. Azóta az ep128emu-ba is bekerült egy-két „hiányzó” dolog (a Xep128-hoz képest), például az egér, és az SD kártya emuláció. Ez utóbbi esetben megint azt látom, hogy bár a Xep128 közvetlenül nem feltétlen hasznos túl sok ember számára, ismét nem volt értelem nélküli a dolog, hiszen az ep128emu jelenleg a Xep128-tól „örökölte” az SD emulációs képességeit. Ilyesféleképpen talán hasznosabb is a munkám, mintha csak a talán kevesek által ismert vagy használt Xep128-ban lenne benne ez a – szerintem hasznos – képesség.

A Xep128 még a fenti történés előtt (és az eredeti cikk megírása után) is sokat fejlődött azért, csak nagy vonalakban: file kezelő szintű FILE: eszköz (ami azóta ep128emu-ba is megérkezett), natív Linux (GTK-3) és Windows file selector ablak (szóval némi GUI, ha több nem is), minden Dave interrupt implementált, SD kártya írás is megy már, „amatőr hang” már van, stb. Elmondhatjuk, hogy mára a Xep128 tud legalább annyit (vagy inkább többet), mint az JSep tudott, igaz ez még mindig nem egy ep128emu ettől még (messze nem).

Az JSep jelenleg „halott” projekt, olyan értelemben, hogy nem hiszem, hogy tovább fogom fejleszteni. Elvégre, egy emulátort is nehéz csiszolgatni, az ember ne akarjon két emulátort írni és folyamatosan fejleszteni, főképp, ha nem „csereszabatos” - mivel egyik C a másik meg JavaScript nyelven íródott -, illetve ha ugyanannak a gépnek az emulációjáról van szó ráadásul. Ugyanakkor, szintén új keletűbb hír, hogy a Xep128 már lefordítható HTML5/JavaScript (a „web”) „platformra” is, amiről már fentebb írtam, viszont jelenleg már működő demó verzió is van ebben a tekintetben (ami így jó is „az JSep helyett”). Ez többek között azért jó, mert így elég egyetlen emulátort fejleszteni, és az számtalan platformra elérhető, legyen szó, Linux/UNIX (Raspberry Pi is ideértve), OSX, Windows, vagy akár már a „web” is. Talán legjobban pár mobil platform hiányzik még, nekem konkrétan az Android (tableten biztos jól mutatna … habár a webes verzió is esetleg produkálhat értékelhető eredményt egy ilyen eszközön is ma már). Engedtessék meg, hogy röviden megemlítsek egy közkeletű tévedést, ha már JavaScript: semmi köze a Java-hoz! Azon kívül, hogy valószínűleg marketing okokból hasonló elnevezést adtak neki. A JavaScript – főleg manapság – a „web programozási nyelve” - és natív eleme a böngészőknek, míg a Java-hoz külön plug-in és az JRE kell, és mint programnyelv is ég és föld a kettő, már eleve.

Szintén színesíti elfoglaltságaim palettáját az Xemu projekt. Itt azt tűztem ki célul, hogy legyen egy „emulációs keretrendszer” amin belül többféle gépet is tudok emulálni, így nem kell mindenhez külön emulátor projekt, nulláról kezdve. Ennek keretein belül már elérhető a Commodore LCD (eléggé ismeretlen, forgalomba nem került gép, amihez én írtam először működő emulátort még anno, igaz az szintén JavaScript-ben volt még), Commodore 65 (igen, 65, nem 64 …) a Mega-65 (mostanában a fő „műsorszám” az Xemu projektben, de erről magában lehetne írni pár tíz oldalt -  és nem is EP vagy Z80 specifikus -, ezért most ettől eltekintek), illetve pár „ismertebb” dolog is (Primo, Commodore VIC 20, folytatása következik majd persze, mind emulált gépek számában, mind pedig feature-ök tekintetében, TVC és pl. Jupiter Ace készülőben – tehát a jövő évezredben talán, magamat ismerve). Mivel a Xep128 sok tekintetben hasonló alapokra épül, a távlati tervem az, hogy ez is az Xemu projekt keretein belül él majd tovább előbb-utóbb. Ez negatív változást az esetleges Xep128 felhasználók (ha van ilyen egyáltalán …) számára nem hoz, viszont megint csak a karbantarthatóság kérdéséről van szó. Természetesen az Xemu is tovább akarja vinni a sok platformos jelleget (a „webet” mint platformot is ideértve), ám ezúttal ehhez csatlakozik a „sok célúság” szempontja is, ahol „cél” alatt most azt értem, hogy emulálandó számítógép, mint cél. Persze, most itt nekünk ebből az egészből az EP a lényeg.

http://xep128.lgb.hu/ 
http://jsep.lgb.hu/

http://xep128.lgb.hu/web-demo/

https://github.com/lgblgblgb/xemu/wiki

http://c65.lgb.hu/web-xemu/xc65.html

– LGB