Szívgörbe ábrázolása

Szívgörbét ábrázolunk Java programmal. A Valentin-nap inspirálta ezt a feladatot. Számos matematikai görbe ismert, amelyek szívformához (kardioid) hasonlítanak. Szükséges egy megfelelő paraméteres görbe. A függvény szív formájú ábrája/grafikonja és egyenletrendszere alapján is nagy a választék.

Ábrázoljuk ezt a paraméteres szívgörbét Java swing GUI felületen!

A szívgörbe ábrázolásához felhasználom az StdDraw osztályt, amely ennek a tankönyvnek a példatárából származik: Robert Sedgewick, Kevin Wayne: Computer Science: An Interdisciplinary Approach, 1st edition, Princeton University, Addison-Wesley Professional, 2016, ISBN 978-0134076423. Az osztály metódusaival könnyen beállítható a nézőpont, a vízszintes/függőleges skála, a rajzoláshoz használt toll mérete/színe és a grafikai primitívek közül csak a pont ábrázolása szükséges.

Négy megoldást mutatok. Mindegyik azonos szívgörbét rajzol a fenti egyenletrendszer alapján. Mindegyik metódus átveszi az N paramétert, amely az összetartozó x és y koordinátapárok számát jelenti. Az N db pont meghatározása/kiszámolása szükséges a szívgörbe ábrázolásához. A szívgörbe ábrázolása önálló ablakban – grafikus felhasználói felületen – jelenik meg. A feladat matematikai jellegéből adódik, hogy tipikus a t nevű ciklusváltozó használata. A metódusokat a vezérlés az 512 paraméterrel hívja meg.

1. megoldás

A heartCurveDraw1() metódus a kiszámolt x és y koordinátákat két párhuzamos, double típusú tömb adatszerkezetben tárolja. A két tömbbe összesen 2*N db double típusú szám kerül. Azonos index jelöli az összetartozó koordinátapárokat. Az egymást követő két ciklus közül az első előállítja az adatszerkezetet és a második megjeleníti a pontokat.

2. megoldás

A heartCurveDraw2() metódus a párhuzamos tömbök helyett adatszerkezetként egyetlen tömböt használ. A java.awt.geom csomag Point2D osztályú objektumai kerülnek a tömbbe. Mivel a Point2D absztrakt osztály, így a Double() osztálymetódusával (factory method) példányosítható úgy, hogy a szükséges koordinátapárokat megfelelően tudja tárolni. A tömbbe N db objektum kerül.

3. megoldás

A heartCurveDraw3() metódus nem használ tömb adatszerkezetet. Tehát nem emlékszik az összes pont koordinátájára. Ehelyett a ciklus röptében, egyesével létrehozza a pontobjektumokat és azonnal ki is rajzolja azokat (átmeneti az emlékezet).

4. megoldás

A heartCurveDraw4() metódus Stream API-t és lambda kifejezéseket használ. Az első N természetes számból készül egy sorozat, amihez röptében hozzákötődik a t-edik Point2D típusú objektum. Ezzel létrejön egy folyam adatszerkezet. Tehát van egy pillanat, amíg a program emlékszik az összes folyambeli pontobjektumra. Végül a folyam feldolgozása, bejárása során egyesével megszólítva a folyam objektumait, a pontok kirajzolódnak a vászonra.

A vezérlés

Az eredmény

A szívgörbe önálló – swing, grafikus felhasználói felület, GUI – ablakban így jelenik meg:

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat – a matematikai háttértől eltekintve – a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 21-24. óra: Objektumorientált programozás 2. rész, valamint a 29-36. Grafikus felhasználói felület alkalmaihoz kötődik.

A 2D szívforma egyenletrendszerét erről a weboldalról választottam: Heart Curve – from Wolfram MathWorld. Egy merész továbbfejlesztési ötlet: a haladóknak megtalálható a 3D szívforma ábrázolása is: Heart Surface – from Wolfram MathWorld.

Sándor is blogolt már a Valentin-nap témában: Rómeó és Júlia. Ebből kiderül, hogy vajon ki szereti jobban a másikat: Rómeó vagy Júlia.

Kölcsönös ajándékozás véletlenszerűen

A kölcsönös ajándékozás időről-időre több közösségben is felmerül. Munkahelyi környezetben és iskolai csoportokban is (például: Télapó, karácsony). Hagyományos megközelítésben így hangzik a szabály: „húzzunk neveket a kalapból”. Másképpen: mindenki 1 ajándékot ad, mindenki 1 ajándékot kap és a sorsolás véletlenszerűen történik.

Készítsünk Java programot, ami megoldja a kölcsönös ajándékozást véletlenszerűen!

A neveket tároljuk el szövegfájlban ( nevsor10.txt). Soronként egy nevet. Ha különböznek, akkor elegendő a keresztnév. A soroknak/neveknek különbözniük kell. Ha szükséges, akkor hozzáírjuk a vezetéknevet, a vezetéknév első betűjét vagy sorszámot. Ezt a program beolvassa és megjegyzi egy szöveg típusú generikus nevsorLista nevű indexelhető adatszerkezetben. A nevek eredeti sorrendje nem befolyásolja a kiválasztást, mert a neveket a program összekeveri (helyben, véletlenszerűen, a shuffle() metódussal). Adott elemszámú lista indexelhető nullától elemszám-1-ig ( size()-1-ig).

A szövegfájl olvasása, tartalmának betöltése során – az ékezetes karakterek miatt – előfordulhatnak karakterkódolási problémák. Ekkor használható a readAllLines() függvény túlterhelt változata esetén a Charset típusú második paraméter, például így: Charset.forName("ISO-8859-2"). A fájlkezeléshez kötelezően kivételkezelés is szükséges (ezt most nem részletezem).

1. megoldás

Az ajándékot adó-kapó párosokat a listában egymás mellett lévő i-edik (bal) és i+1-edik (jobb) nevek adják. Az adó az elsőtől az utolsó előttiig, a kapó a másodiktól az utolsóig léptethető. Kimarad az a pár, amikor az utolsó ad és az első kap. A lista indexei szerint az adók esetében a nulladik elemétől az utolsó előtti eleméig és a kapók esetében a lista első elemétől az utolsó eleméig jelenti a kiválasztást. Mindez könnyen megoldható for számláló ciklussal. A kimaradó pár ajándékot adó tagja a lista size()-1-edik eleme és kapó tagja a lista nulladik eleme. Ez a ciklus után egyszerű kiírással megoldható.

2. megoldás

A program átmenetileg megváltoztatja a listát: az utolsó elem után bővül az első elemmel ( nevsorLista.add(nevsorLista.get(0))). Ennek köszönhetően az ajándékot adó-kapó párosokat a listában egymás mellett lévő lévő i-edik (bal) és i+1-edik nevek adják. Most nem lesz kimaradó pár, mert a korábbi utolsó elem most az utolsó előtti elem és az utolsó elem most az első. Másképpen: mindenki ad és mindenki kap.

A megoldás Stream API-t használ. Először előállít egy olyan IntStream típusú folyamot, amiben az ajándékot adó és kapó párosok adó (bal) tagjainak sorszámát/indexét tartalmazza. Ezután ezt végigjárva összefűzi a szövegeket ( mapToObj()) úgy, hogy a páros kapó (jobb) tagja az adó tag rákövetkezője. Végül a program kiírja a összefűzött szövegeket ( forEach()) a konzolra. Ha a neveket tartalmazó listát használnánk később még valamire (azaz kellene az eredeti összekevert állapota), akkor érdemes aktiválni a megjegyzésbe tett utolsó utasítást.

Eredmény

A program konzolos/szöveges eredménye mindkét esetben azonos. Persze a nevek sorrendje különbözhet, hiszen az összekeverés minden futtatás esetén másképpen alakul(hat), mert véletlenszerű. Például:

Érdemes tesztelni és átgondolni, hogy mi történne, ha üres a fájl, üres a generikus lista, 1 név van, 2 név van, illetve nem szabadna ilyet, de mi történne azonos nevek esetén. Vajon különbözik/különbözne a fenti két megoldás eredménye? Miért?

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 17-28. óra Objektumorientált programozás és 37-44. óra: Fájlkezelés alkalmaihoz kötődik.

Táblázatos hőtérkép készítése

Ebben a projektben táblázatos hőtérképet készítünk Java és JS nyelveken. Java programot készítünk az adatok véletlenszerű előállításához és a sablon alapján történő HTML fájl generálásához. JavaScript program fogja a grafikont megjeleníteni a weboldalon. Tervezünk, kódolunk, tesztelünk. Lássunk hozzá!

Mi az a hőtérkép?

A hőtérkép (heatmap) olyan grafikon, amely könnyen áttekinthetővé tesz nagy mennyiségű adatot úgy, hogy kategorizál/csoportosít és az előfordulások tartományai alapján különböző színeket rendel azokhoz. A szín hozzárendelése egy intervallumból történik. Például a világosabb a ritkább, a sötétedő szín az egyre gyakoribb értékeket jelenti. A tipikus hőtérkép kétdimenziós és az előforduló adatok mennyiségét, azok arányait, eloszlását, szóródását (nem szórását), gyakoriságát jeleníti meg. A hőtérkép gyors vizuális összefoglalást, áttekintést biztosít. A projekt során sorokból és oszlopokból álló táblázatos hőtérképet készítünk.

A táblázatos hőtérkép nem összekeverendő a következő két megközelítéssel:

  • Ha az adatok lokációhoz kötődnek és térképen jelennek meg, akkor azt tematikus térképnek nevezzük. Erről már blogoltam korábban, lásd: Céline Dion – Courage World Tour, amikor az énekesnő USA-beli államokban előforduló koncertjeinek számát jelenítettem meg. Ehhez hasonlók az amerikai elnökválasztás során használt tematikus térképek, amelyek a(z egyes) jelöltek szavazatainak arányát ábrázolják meg szintén államonként.
  • Ha az adatok webergonómiához, bannervaksághoz, inkább fókuszban lévő tartalmakhoz, felhasználói élmény (UX) tervezéshez kötődnek, akkor a weboldal grafikus elemeihez (azok pozíciója) alapján rendelünk hozzá színeket attól függően, hogy mennyi ideig nézi azt a felhasználó.

Mi a feladat (koncepcionálisan)?

Adott egy konditerem, amely hétköznapokon egy megadott időintervallumban használható. Ehhez kulcsot kell felvenni és leadni. Az első belépő nyitja és az utolsó távozó zárja az ajtót. A teremhasználat offline nyilvántartott, így nehézkes bármiféle kimutatás, statisztika. A „menet közbeni” jövés-menést nem tudjuk követni. Természetesen adott számos szabály (felelősség, biztonság, balesetvédelem, létszámkorlát), amit most nem részletezek.

Elhelyezünk az ajtó mellett, belülről egy belépéshez és egy távozáshoz tartozó QR kódot. Készítünk egy egyszerű mobil alkalmazást és megkérjük a konditermek használóit, hogy belépéskor és távozáskor „csekkoljanak”. Anonim gyűjtjük a belépések és távozások időpontját (valahol egy szerveren, bármilyen fájlban, adatbázisban).

A konditermek használatára vonatkozó összesített adatokat könnyen átlátható módon szeretnénk weboldalon megjeleníteni: heti bontásban, a nyitva tartás időszakát órás blokkokra bontva az igénybevételtől függően jelenjenek meg az adatok táblázatos hőtérképen.

Ez az állapot átmeneti. Segítheti a konditermekbe tervezett – egyéni használattól független – események ütemezését. Ezeket akkor lenne célszerű időzíteni, amikor nem, alig, vagy kevésbé használt, foglalt az adott konditerem. A továbbfejlesztés következő állapotában könnyen lecserélhető a QR kód RFID alapú proximity kártyára, proxy kulcstartóra: először csak a jelenlét nyilvántartásához, később akár az ajtó nyitásához is.

Mit valósítunk meg mindebből Java nyelven?

Egyetlen konditeremre fókuszálunk. A hétköznaponként nyitva tartás legyen 16 órától 21 óráig. Aki edzésre jön, véletlenszerűen 20 és 40 perc közötti időszakot tölt a konditeremben. 16 órától lehet belépni. Az utolsó belépés 20:40-kor lehet (érdemes). 21 órakor mindenki elhagyja a konditermet. Nem fordul elő, hogy valaki nem jelzi a belépését vagy a távozását. Mivel anonim a nyilvántartás, így elegendő a dátum/időhöz, időbélyeghez egyetlen állapotot tárolni: be vagy ki. Valaki belépett nyitáskor vagy valamikor utána, majd távozott 20-40 perccel később, de legfeljebb záráskor.

A szükséges adatokat véletlenszerűen állítjuk elő. Egy hétre vonatkozó adatokat generálunk. Ezek a fenti paramétereknek megfelelő, összetartozó belépéshez és távozáshoz köthető időpontok. Kiegészítve a napok ciklusban való léptetésével hétfőtől péntekig. Az adatokat feldolgozva, összegyűjtve, csoportosítva, kategorizálva olyan (kimeneti) formátumra alakítjuk, amely kompatibilis a táblázatos hőtérkép adatmodelljével (bemenetével). Mindez Java nyelven valósul meg.

Mi történik JavaScript nyelven?

A webes megjelenítéshez szükséges egy HTML fájl, amelyben beágyazva található meg egy téglalap alakú területként megjelenő táblázatos hőtérkép. Ez sokféleképpen testre szabható: adható hozzá felirat, beállítható a sorokhoz és oszlopokhoz tartozó szöveg és a táblázat celláiban megjelenő értékek, adott a lebegő, az egér kurzor helyzetétől függő – cellánként különböző – jelmagyarázat, és persze mindennek van formátuma (betűtípus, méret, szín, igazítás, kitöltés). A fix, adatoktól nem függő beállításokat tartalmazó weboldalt sablonként elkészítjük. Mindez JavaScript nyelven történik. Ezután Java program a weboldal sablonját kiegészíti (cseréli, behelyettesíti, feltölti) a szükséges adatokkal.

Hogyan alakul az időintervallumok átfedése?

A konditerem használatának alakulását követjük, amihez táblázatos hőtérképet készítünk. Ehhez a nyitva tartás időintervallumát órás blokkokra bontjuk. Blokkonként összesítjük a jelenlétet, azaz megszámoljuk, hogy éppen akkor hányan veszik igénybe a konditermet, hányan vannak jelen/benn.

A konkrét paraméterektől függően az alábbi képen látható 3 eset egyike fordulhat elő. A és B jelöli az órás blokk elejét és végén, tehát ez 60 perces intervallum. Tarthat például: 16:00:00-16:59:59-ig. X és Y jelöli a jelenlét intervallumát, azaz a belépés és távozás időpontjait. Ez 20 és 40 perc között alakul. Haladjunk balról jobbra az ábrán.

Az első esetben ugyanarra az órára esik a belépés és a távozás. Ez az eset egyértelmű. A másik két esetben átfedés van több órás blokk között, mert különböző órára esik a belépés és a távozás. El kell dönteni, hogy ekkor hogyan összesítjük a jelenlétet. Válasszunk az alábbi két módszer közül:

  • Az első módszer szerint mindkét órához – ahol átfedés van – összesítjük a jelenlétet 1-1 főként, hiszen ha nem is végig, de jelen volt mindkét órás blokkban. Például: egy 16:50:00-17:20:00 jelenlétet a 16 és 17 órás blokkban is figyelembe veszünk.
  • A második módszer szerint időarányosan tesszük mindezt, azaz súlyozunk aszerint, hogy milyen hosszú jelenlét esik az egymást követő órákban. Például: egy 16:50:00-17:20:00 jelenlétet a 16 órás blokk esetében egyharmad, a 17 órás blokk esetében kétharmad a jelenlét adott órára eső aránya, súlya.

Az első módszert valósítjuk meg. Ez a döntés jelentősen befolyásolja, hogyan kell értelmezni később az elkészült táblázatos hőtérképet.

Objektumorientált tervezés

A koncepcionális terv alapján modellezünk. A szükséges adatok tárolására és alapfunkcióira fókuszálunk. Az osztály tárolja az összetartozó adatokat és megvalósít rajtuk értelmezhető műveleteket. Az időintervallum/időtartam kezelését a Duration ősosztály oldja meg. Tárolja a start és stop – naptól független időpontokat tároló – adatok és a rájuk vonatkozó FORMAT – megjelenítéshez kötődő – konstanst. Biztosítja a szükséges műveleteket: konstruktor, getterek, megvalósítja az időintervallumok átfedését az isOverlapped() függvénnyel, valamint ad szöveges reprezentációt a toString() függvénnyel. Az ősosztályból öröklődik az utódosztály. A DurationMap osztály a naptól független időpontokat kibővíti a hozzájuk tartozó day nappal, valamint képes tárolni az összesített, megszámolt jelenlétet a count változóban. Részt vesz a megszámolás folyamatában azzal, hogy lépésenként meghívható az  incrementCount() eljárása.

A java.time csomagbeli LocalTime osztály képes a dátumtól független, napon belüli időpont tárolására és biztosít néhány alapvető funkciót a kezelésükre. Az adattárolás a napon belül eltelt időn alapul és nekünk (bőven) elegendő a másodperc alapú megjelenítés. A DateTimeFormatter alkalmas ezen időpontok formátumának tárolására, például óó:pp:mm alakban.

A Duration osztályból annyi objektum készül, ahány jelenlét adódik véletlenszerűen. Akár több száz is lehet. A DurationMap  osztályból generált objektumok száma jóval kevesebb. Heti 5 napra, napi 5 órás blokkra 25 db készül belőle.

A vezérléshez kötődő osztály tervezését nem részletezem.

Íme a Java forráskód

A Java forráskód minden megtervezett funkciót megvalósít, támogatva a koncepciót. Most nem részletezem a működését.

A véletlenszerűen előállított adatok

A lista görgethető:

A weboldal sablonja

HTML és JavaScript nyelvű forráskód vegyesen. A Java program a fájl 31. sorában lévő ##HEATMAP_DATA## szöveget cseréli le a táblázatos hőtérkép megjelenítéséhez szükséges véletlenszerűen előállított adatokra.

További részletekért, beállításra vonatkozó, testre szabási lehetőségekért érdemes tanulmányozni az AnyChart dokumentáció Heat Map Chart fejezetét.

Az eredmény

Az előállított weboldalt böngészőben megjelenítve ezt kaphatjuk eredményként (vagy a véletlenszerűen generált adatoktól függően hasonlót):

A táblázatos hőtérkép hasznos eszköz. Elemezve könnyen döntéseket hozhatunk a koncepcionális tervezés során vázoltak alapján.

Továbbfejlesztési lehetőségek

  • Lehetne több konditerem is. Ekkor rögtön felmerül az összehasonlítás lehetősége, egyben igénye is.
  • Lehetne hétköznaponként eltérő a konditerem nyitva tartása.
  • Az időpontok kezelési precíz. Egy másodpercen múlik, hogy nem fedik át egymást. Az időpontok megjelenítése lehetne óó:pp alapú is.
  • Az időintervallumok jelenleg állandóak, mindig 1 órásak. Könnyen megoldható lenne, hogy dinamikusak legyenek: például a népszerűbb időszakok felbonthatók lennének két 30 perces blokkra. A népszerűség értelmezhető minden nap (héten) másképp. Egyszerű képlettel: átlag felett, medián felett.
  • Általánosíthatnánk a létesítménygazdálkodáshoz kötődő erőforrást nem (feltétlenül) helyhez kötött, mozgatható, kölcsönözhető eszközökre is: hangszer, projektor, stúdió felszerelés.
  • Másképpen valósulna meg az adatgyűjtés, ha egyetlen QR kód állna rendelkezésre és back-end helyett a „mobil alkalmazás emlékezne” a belépésre és távozásra. Ez jelentheti legalább az aznapi adatokat, de tárolható historikusan is.
  • Hibát is kellene, lehetne kezelni. Például a kiléptetés lehetne automatikus a nyitva tartás végén. A jelenlét igazából igaz-hamis állapot: ha eddig hamis volt és történt valami, akkor igaz lesz és fordítva. Ha van mögötte állapotmegőrző emlékezet (mivel programozunk, így nyilvánvalóan azonnal objektumra gondolunk, vagy annak valamilyen fájlba vagy adatbázisba történő leképezésére).
  • A nyilvántartás könnyen megvalósítható személy hozzárendelésével, azaz lehetne nem anonim is a jelenlét.
  • Egymást átfedő időpontok esetén (ha nincsenek a hosszukra vonatkozó korlátozó feltételek) általánosítva 6 eset fordulhat elő. Például ha a jelenlét lehetne 60 percnél hosszabb, de 120 percnél rövidebb is, akkor nem lenne elegendő a fenti 3 esetet kezelni a jelenlét összesítése során.
  • Valósítsuk meg az időintervallumok átfedésénél bemutatott második – időarányos – módszert!
  • A napi jelenlét 20 fővel valósul meg a programban. Lehetne ez a paraméter is véletlenszerű, például 15-30 fő között, vagy esetleg népszerűbb a péntek.
  • Jelenleg a táblázatos hőtérkép statikus. Csak a (befejezett egész heti) múltbeli adatokat tudja megjeleníteni. Az aktuális, jelenlegi állapothoz szinkronizáció, ütemezés kell. Óránként (a blokkok végén automatizáltan), de akár 5 percenként is aktualizálható a hőtérkép.
  • A táblázatos hőtérkép megjelenítése önálló weboldal helyett beágyazható widget felületén is történhet.
  • Többféleképpen is készítettünk már grafikonokat, íme néhány a szakmai blogunkból: Kockadobás kliens-szerver alkalmazás, Sankey-diagram készítése, JFreeChart grafikon készítése.

A bejegyzéshez tartozó forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A projektfeladat – attól függően, milyen szinten valósítjuk meg – kapcsolódhat több tanfolyamunk tematikájához. A fenti forráskód a Java SE szoftverfejlesztő tanfolyam 17-28. óra: Objektumorientált programozás és a 37-44. óra Fájlkezelés alkalmaihoz kötődik. Ha többrétegű, elosztott alkalmazásként valósítjuk meg, akkor a Java EE szoftverfejlesztő tanfolyam a 9-16. óra: XML és JSON feldolgozás, dinamikusan generált weboldalba beépítve a 33-40. óra: Java Server Pages alkalmaihoz kapcsolódik. Ha fájlok helyett egyszerű adatbázist használnánk, akkor a Java SE szoftverfejlesztő tanfolyam 45-52. óra: Adatbázis-kezelés JDBC alapon, ha objektumrelációs leképezéssel oldanánk meg, akkor a Java EE szoftverfejlesztő tanfolyam 25-32. óra: Adatbázis-kezelés JPA alapon alkalmakhoz kötődhet.

Programozási Hét 2023 – CodeWeek.eu

Programozási hét CodeWeek.eu

Programozási hét CodeWeek.euAz Európai Programozási Hét idén 2023. október 7-22-ig kerül megrendezésre. Ez egy önkéntesek által működtetett, alulról szerveződő kezdeményezés. Az önkéntesek saját országukban a Programozási Hét nagyköveteként népszerűsítik a programozást. Ehhez nyílt és ingyenes (online és offline) eseményeket hirdetnek meg a CodeWeek.eu weboldalon.

A Programozási Hét célja

  • a programozással való alkotás megünneplése,
  • az emberek felvértezése képességekkel,
  • az emberek összekapcsolása,
  • még több ember érdeklődésének felkeltése a tudomány, a technológia, a mérnöki ismeretek és a matematika iránt.

Miért jó ez az érdeklődőknek/résztvevőknek?

  • A programozás szórakoztató!
  • Programozni kreatív tevékenység! Az emberiség a kezdetektől fogva alkot: agyagból, kőből, téglából, papírból vagy fából. Manapság programozással is alkotunk.
  • A programozás felvértez! Sokkal többre is képesek vagyunk annál, hogy csak fogyasszuk a digitális tartalmat; programozással sokféle dolgot alkothatunk, és azokat milliók számára elérhetővé tehetjük. Létrehozhatunk weboldalakat, játékokat, irányíthatunk egy számítógépet vagy egy robotot.
  • Értsük meg a világot! Manapság egyre több minden össze van kapcsolva. Ha némi rálátásunk van arra, hogy mi történik a színfalak mögött, akkor a világot is jobban megérthetjük.
  • A programozás megtanítja nekünk a számítógépes gondolkodást, fejleszti a problémamegoldást, kreativitást, kritikus érvelést, analitikus gondolkodást, valamint csapatmunkára késztet.
  • Manapság a munkahelyek 90%-a digitális készségeket, köztük programozási ismereteket követel a munkavállalóktól.

2015-től veszünk részt az esemény szervezésében, programozást népszerűsítő előadások, laborgyakorlatok meghirdetésével és megtartásával. 2022-ben világszerte 80+ országban 4+ millió érdeklődő résztvevő csatlakozott. Ajánljuk korábbi beszámolóinkat is szakmai blogunkból, lásd: CodeWeek.eu címke.

Meghirdetett eseményeink

2023-ban hat it-tanfolyam.hu-s eseményt hirdettünk meg a Programozási Hét 2023 rendezvényen.
Helyszín: 1056 Budapest, Váci utca 47., 3. emelet, megközelítés
Dátum és időpont: 2023. október 21. 9:00-12:00-ig
Az események ingyenesek voltak, de a részvétel előzetes regisztrációhoz kötött.

Rendezvényünk plakátja

A rendezvény jó hangulatban telt, 40+ érdeklődőt vonzott. Többen rendszeresen visszatérő vendégek voltak, például a tavaszi Digitális Témahét, vagy a szeptember végi Kutatók éjszakája rendezvényeinkről. Eltérő belső motivációval érkeztek, ezek kulcsszavakban: kíváncsiság, pályaorientáció, karrierváltás, programozási trükkök. Igazán tartalmasan telt el idén is ez a rendezvényre szánt három óra. Köszönöm oktató kollégáimnak és 2 korábbi hallgatónknak, hogy előadóként részt vettek a Programozási hét 2023 – CodeWeek.eu rendezvényünkön. Prezentációinkat tanfolyamaink hallgatói számára – a témához kapcsolódó témakörökhöz, ILIAS-ra feltöltve – tesszük elérhetővé.

9:00-9:25 – Szegedi Kristóf: Játékprogramok heurisztikáinak elemzése
A tudásalapú rendszerek elméleti alapjaihoz tartoznak a mesterséges intelligencia különböző megoldáskereső módszerei, az állapottér-reprezentáció és a klasszikus keresési stratégiák, heurisztikák. Egy játék állapotait nyilvántartjuk egy adatszerkezetben. Lehet, hogy néhány lépést előre kalkulálunk (kiterjesztünk) és ezek elágazásaiból fát (fa adatszerkezet) tudunk építeni. Ezeket hatékonyan karban kell tartani konstrukciós és szelekciós műveletekkel. Heurisztika alapján döntéseket kell hozni. Vajon melyik állapot a jobb, vagy kevésbé rossz, legalább olyan jó mint ahol járunk? Ki kell értékelni és abba az irányba érdemes haladni, amelyben végül a döntések sokasága igazolja és egyben adja a nyerő stratégiát. Ha ez nem megy, akkor még mindig játszhatunk nem vesztő stratégiával, azaz lehet cél a hosszabb játékmenet, vagy akár a döntetlen állapot is. Az előadás ismertet néhány tipikus problémaszituációt, játékteret leképező reprezentációs gráfbeli navigációt és összehasonlít néhány fabejáró/gráfbejáró stratégiát. A program mindhárom Java tanfolyamunk orientáló moduljához kötődik. Előismeretként feltételezünk némi jártasságot a programozási alapismeretek, programozási tételek, ciklusok, metódusok, tömbök témakörökből.

9:30-9:55 – Kaczur Sándor: Írjunk hatékony adatbázis-lekérdezéseket!
Az Oracle HR sémában, először tipikus, hétköznapi szavakkal megfogalmazunk néhány lekérdezést, majd SQL nyelven megvalósítjuk és elemezzük, hogy helyesek-e, hatékonyak-e, mit adnak vissza. Szükség esetén optimalizáljuk, testre szabjuk ezeket. Kategóriák: egyszerű, összetett, aggregáló, soktáblás, hierarchikus/rekurzív lekérdezések. Ha lehet, grafikusan is megjelenítjük a lekérdezések eredményeit Java swing felületen, beépített JTable és JTree komponensekkel, illetve JFreeChart grafikonnal is. A Java adatbázis-kezelő tanfolyamunk tematikájához kötődik a program. Előismeretként feltételezünk némi jártasságot adatbázis-kezelés, SQL, Java swing felhasználói felület témakörökből.

10:00-12:20 – Hollós Gábor: Érvényes lottószelvényt kaptunk?
Garantáltan helyes lottószelvény helyett előállítunk valamit, amiről feltételezhetjük, hogy lehet lottószelvény. Egymásra épülő unit teszteket készítünk, hogy valóban lehet-e. Például: kapott a teszt metódus egyáltalán valamit paraméterként? Tömböt kapott paraméterként? Hány elemű tömböt? Mekkora a tömbben lévő legkisebb és legnagyobb elem? Különböző a tömbben minden elem? (Ha nagyon szigorúak vagyunk: növekvő sorrendben vannak a tömbben az elemek?) Ha minden kritérium teljesül, akkor érvényes lottószelvényünk van. Kiegészíthetjük időméréssel is. Megtudjuk, hogyan kapjuk meg azt, hogy az esetek 89%-a helyes ötöslottó szelvény lesz. A program a Java SE szoftverfejlesztő tanfolyamunk tematikájához kapcsolódik. Előismeretként feltételezünk némi jártasságot programozási alapismeretek, programozási tételek, ciklusok, metódusok, tömbök, listák, halmazok, lambda kifejezések témakörökből.

10:25-10:55 – Kaczur Sándor: Java kollekciók hatékonysága
Adott egy ismert algoritmus egy ismert problémára. A gyakorlati bemutató példákat mutat arra, hogy az ismert Java kollekció keretrendszer különböző adatszerkezeteinek funkcionalitását/szolgáltatásait felhasználva mennyire eltérő megoldásokat tudunk készíteni. Mindegyik megoldás ugyanazt az eredményt adja, de alapjaiban más gondolatmenettel születtek. Vajon melyik tekinthető hatékonyabbnak? Mennyi tárhelyet igényelnek? Mennyi idő alatt hajtódnak végre? Mennyire bonyolultak, azaz mennyire könnyű/nehéz megérteni/dokumentálni/elmagyarázni? Előkerülnek különböző Set, Queue, List, Map implementációk, programozási tételek. Amit csak lehet, mérünk, összehasonlítunk, elemzünk. Végül az eredmények alapján javaslatokat adunk: mikor, miért, mit (mit ne), hogyan (hogyan ne) használjunk. A program a Java SE szoftverfejlesztő tanfolyamunk tematikájához kötődik. Előismeretként feltételezünk némi jártasságot a programozási alapismeretek, programozási tételek, ciklusok, metódusok, tömbök, listák, halmazok, lambda kifejezések témakörökből.

11:00-11:25 – Kiss Balázs: Gondolkodjunk logikusan!
Az előadás során áttekintjük az intelligencia, a kreatív problémamegoldó és logikus gondolkodás összefüggéseit és izgalmas feladatokból válogatva közösen megoldunk néhány fejtörő feladatot. Néhány példa: Hány éves a kapitány?CHOO + CHOO = TRAIN, Logikus gondolkodás teszt. Minden feladathoz adunk rávezető példákat – ha esetleg egyik-másik nem menne, akkor ebből megtudod, miket érdemes gyakorolni, hogy menjen. A program mindhárom Java tanfolyamunk orientáló moduljához kötődik. Előismeretként feltételezünk némi jártasságot az algoritmusok, programozási alapismeretek, programozási tételek témakörökből.

11:30-12:00 – Falus Anita, Horváth Zoltán Miklós: Friss munkaerőpiaci tapasztalataink szoftverfejlesztőként
Mennyire könnyű ma szoftverfejlesztőként elhelyezkedni szakirányú felsőfokú végzettség nélkül? Milyen kihívásokkal találkozhatunk a felvételi folyamat során? Milyen elvárásokat támasztanak a munkaadók egy junior szakemberrel szemben? Hogyan telnek a beilleszkedés után a hétköznapok junior fejlesztőként kis létszámmal működő informatikai profilú kisvállalkozásnál? A tanfolyamainkon 2021-ben és 2022-ben végzett előadók karrierváltó junior szakemberként személyes tapasztalataikról számolnak be és válaszolnak a kérdésekre. A program a Java tanfolyamaink orientáló moduljához kötődik.

Java program memória használatának mérése

Három különböző megközelítésben generálunk szövegeket és töltjük bele ezeket generikus listába. Olyan környezetet építünk, amely képes tesztelni/mérni a Java program/környezet memória használatát előtte/utána. A tárigény (memória, háttértár, feldolgozandó adatok mennyisége, adatforgalom) fontos eleme a hatékonyságnak. Gyakran előfordul, hogy a tárigényt csökkenteni kell egy program tervezése, implementációja vagy továbbfejlesztése során.

Feladat

A Java program előállít 100000 db 20 hosszúságú szöveget véletlen kiválasztott angol ábécé-beli betűkből. A szövegeket generikus listába tölti be. A program méri az általa felhasznált memória méretét/nagyságát úgy, hogy a műveletek előtti és utáni eredményekből különbséget számol. Egyszerű következtetéssel, becsléssel nagy mennyiségű adatra/memóriaterületre számíthatunk, így érdemes megabájt mértékegységet használni.

Közös konstansok

  • final int MIN_LIMIT=(int)'a';
    97, a kis ‘a’ betű, a „legkisebb” generálható véletlen betű/karakter ASCII kódja
  • final int MAX_LIMIT=(int)'z';
    122, hasonlóan a felső korlát
  • final int STRING_LENGTH_LIMIT=20;
    a véletlenszerűen generálandó szövegek hossza
  • final int STRING_COUNT=1000000;
    a véletlenszerűen generálandó szövegek száma, amik generikus listába kerülnek

Három különböző módszer

  • method1():
    Az első módszer esetén String típusú szövegobjektumok keletkeznek úgy, hogy karakterenként kerülnek összefűzésre (konkatenáció) a += művelettel (operátorral). A véletlen karakterek sorszámaira int2char típuskényszerítés szükséges explicit módon (char). A vezérlés egymásba ágyazott ciklusokkal történik.
  • method2():
    A második módszer esetén StringBuilder típusú szövegobjektumok keletkeznek. Szintén karakterenként generálva. Összefűzésüket az append() metódus végzi el. A típuskényszerítés és a vezérlés megegyezik az előző módszerrel.
  • method3() :
    A harmadik módszer során a StringBuilder típusú szövegobjektumokból a Stream API beépített funkcionális műveletei állítják elő a generikus listát. A vezérlés egyetlen ciklusból áll.

Java forráskódok

Íme az első módszert megvalósító metódus. Futtatása 620 MB memóriát igényel:

Ez a második módszer metódusa, amely futása során 235 MB memóriát használ:

A harmadik módszer metódusa. 494 MB „memóriaterületbe kerül” lefuttatni:

A metódusok hívása

Eredmények

A tesztkörnyezet az alábbi eredményeket írta ki konzolosan:

Más nézőpontok

  • Az is mérhető, hogy a program futása közben hány darab objektum keletkezik, melyik mennyi ideig „él”, melyik mennyi helyet foglal. Ez részletesebb képet nyújthat, összevetve a fenti globális helyfoglalással.
  • Figyelhető, hogy az automatikus szemétgyűjtő (Garbage Collector) milyen gyakran fut. Némileg befolyásolható, paraméterezhető a tevékenysége.
  • A forráskód bonyolultsága összefüggésben van annak karbantarthatóságával. Fontos lehet, hogy milyen könnyen dokumentálható, továbbfejleszthető.
  • A memóriafogyasztás szempontjából „túloptimalizált” program verzióváltás(ok) esetén több tesztelést, módosítást igényelhet. Ha egyáltalán valaki hozzá mer nyúlni. 😉
  • A memóriahasználat mérése során figyelembe kell venni, hogy a Java programon kívül Java futtatókörnyezet (JRE) is működik az operációs rendszeren, aminek szintén van erőforrásigénye.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Bemutattunk többféle módszert, illetve teszteredményeket. Részletes magyarázatot/indoklást most nem adunk a szakmai blogban. A Java SE szoftverfejlesztő tanfolyam szakmai moduljának 17-28. óra Objektumorientált programozás alkalmain természetesen széles körű áttekintést adunk a témakörrel kapcsolatosan, valamint más módszereket is bemutatunk. A hatékonyság klasszikus dimenziói: időigény, tárigény, bonyolultság. Több esettanulmányunk is van, amely egy-egy algoritmus lépésszámát méri, memória- és/vagy sávszélesség igényt mér, illetve elvi és/vagy koncepcionális bonyolultságot próbál meghatározni. Ezek közül többször redukálunk, csökkentünk tipikusan lépésszámot, memóriaigényt.