Adattípusok

Már megbeszéltük korábban, hogy egy program elkészítéséhez meg kell határoznunk a bemenő adatokat és az azokon elvégzendő műveleteket annak érdekében hogy a megfelelő kimenetet kapjuk.
A bemenő adatok meghatározása egy igen fontos dolog. Egy adatot a programozás során változóként, illetve konstansként tudjuk kezelni. A változó egy oylan hivatkozás, amin keresztül elérhető és megváltoztatható az adat amit reprezentál. A konstans ezzel szemben egy fix értéket ábrázol, annak értéke nem módosítható.
Egy adatnak két jellemzője van. Az adatot reprezentáló változó vagy konstans neve és típusa.
A változó neve egy általunk szabadon választott - az adott programozási nyelv szabályainak megfelelő - karaktersorozat.
Pl.

• a háromszög oldalainak jelölésére célszerű a matematikában megszokott a, b, c változóneveket használni. 
• ha valakinek a keresztnevét szeretnénk tárolni a programban, akkor jó választás lehet a knev változónévnek.
• valamilyen indexelési műveletnél én az i és j változóneveket használom
• koordináták jelölésére természetesen az x és y nevek egyértelműek.
• irányítószám tárolása lehet az irsz változóban
• egy érték maximumát jelölheti az YMAX konstans.

Mint látható ezek célszerű, rövid a tartalmukat valamilyen logika szerint jelző nevek. A gyakorlatok során kialakul egy konvenció ami alapján elnevezzük majd a változóinkat. Használjunk rövi egyszerű, de mégis beszédes változóneveket!

A másik lényeges tulajdonsága a változóknak a nevük mellett azok típusa. A típus azért fontos mert meghatározza hogy az adott változót hogyan kell értelmezni, mik a határai, mekkora adat fér bele, azokkal milyen műveleteket lehet végezni. Pl két szöveget nagyon nehéz összeszorozni, de egy betűt egy számmal összeadni sem nagyon lehet (bár C-ben éppenséggel lehetséges :) )

Az egyszerű adattípusok azok amiket az adott nyelv eleve implementál. 

Pascal esetében a leggyakrabban használt típusok /az összes típus a nyelv referencialeírásában/:

Egészek:

• Byte: 0..255 közti egész
• Integer: -32768 .. 32767 közti egész
• Word: 0 .. 65535 közti egész
• Longint: -2147483648 .. 2147483647
• Longword: 0 .. 4294967295

Logikai típus:

• Boolean: értéke true vagy false lehet, ami  logikai igaz és hamis értékeket jelöl.

Valós típusok:

• Real: 1.5E-45 .. 3.4E38 közti valós szám
• Double: 5.0E-324 .. 1.7E308 közti valós szám
• Extended: 1.9E-4932 .. 1.1E4932 közti valós szám

Karakteres típusok:

• Char: egyetlen karakter.
• String: karakterfüzér, aminek maximális hossza 255 lehet. 

   

Kollár Zoli "hogyan kezdődött..." sztorija (I. rész)

Sziasztok!

Megosztom én is veletek a "hogyan kezdődött..." történetemet:

'83 végén, '84 elején kezdődött a számítógép iránti érdeklődésem. Ugyanis híradástechnikai szakközépiskolába jártam, és sok osztálytársammal ellentétben engem érdekelt is a szakma. Ezért a zsebpénzemet nem bulizásra költöttem, hanem alkatrészekre, újságokra. És ekkor jelent meg a '84-es Rádiótechnika évkövny, amiben elég jó leírás volt a 8085-ös mikroprocesszorról. Napokon-éjszakákon át ezerszer is elolvastam a cikket, próbáltam megérteni, hogy hogyan működik a processzor. Pár nap múlva azt vettem észre, hogy ez tök egyszerűnek tűnik. Értelmes, logikus utasítások tömkelege, amiket megfelelően sorba lehet rendezni.

'84-ben harmadikos voltam, amikor kapott az iskola egy HT1080Z számítógépet. Szó szerint az iskola kapta, mert diákok nem nagyon nyúlhattak hozzá, csak a tanárok. Ez a gép történetesen a szakmai gyakorlatot tanító tanárom asztalára került. Távolról, sóvárogva néztem a gépet...

Kaptam egy Basic könyvet kölcsön az egyik iskolatársamtól (nem a mi osztályunkba járt). Azt is hamar átolvastam és az is tök egyszerűnek tünt. Aztán egyszer megkérdeztem a tanárunktól, hogy oda ülhetek-e elé? És megengedte, a szünetekben. Mondanom se kell, hogy ezután az összes szünetet ott töltöttem a gép előtt. Első programom ha jól emlékszem egy torpedójáték volt. Aztán a Basic nem nagyon érdekelt, és közben kiderítettem, hogy a gép Z80-as processzora majdnem teljesen kompatibilis az általam már "ismert" 8085-el. Otthon papíron kezdtem el írogatni assembly-ben az egyszerűbbnél egyszerűbb programokat, a suliban már csak a lefordított kódot kellett gyorsan bepötyögni, és örülni, ha működött elsőre. Olyasmiket írtam, hogy az egész képernyőt kitölti egy karakterrel, aztán egymás után növeli őket és megdöbbentő volt számomra a Basic és a "gépi kód" közti különbség. Soha többé nem akartam Basic-et :)

'84 nyarán a telefongyárban töltöttem a szokásos szakmai gyakorlatomat és ekkor kerültem közelebbi kapcsolatba a TAP-34-es számítógéppel. Soha ennyire lelkesen nem töltöttem még szakmai gyakorlatot, mint abban az egy hónapban. Az első pár nap Star-Trekezései után nekiálltam programozni. Milyen programot is írjak? Az a gép nem volt olyan egyszerű felépítésű mint a HT, ezért eleinte maradtam a Basic-nél, és írtam egy Disassembler programot. Persze mutogattam boldog-boldogtalannak, amíg egyszer csak az ottani főnök fel nem hívta Sz. Zolit. Zoli mai szemmel rendszergazda volt egy TPA1148-as "miniszámítógépen", de ami a sorsomat meghatározta az az volt, hogy a barátnője (ma a felesége és két gyermekük anyja) a Számítástechnikai Fejlesztési Főosztályon dolgozott. Zolinak baromira megtetszett a programom, elkérte és el is kezdte terjeszeni a gyárban, mert kiderült, hogy ilyen még nem is volt a géphez.

A '84-es év további része és a '85-ös év az érettségiig nagyrészt azzal telt el, hogy kifényképeztem a HT ROM tartalmát (csak hexadecimális kódok voltak), és papírra vetettem. Ez elég sok estémet és éjszakámat emésztette fel, főként, hogy csak negatívon voltak meg a képek és diavetítővel kellett kinagyítanom. Aztán elkeztem visszafejteni a kódokat. Készült belőle egy "nyers" változat és egy "javított". Pont tele lett vele egy A4-es spirálfüzet. Ennek a munkámnak a későbbiekben igen nagy hasznát vettem.

http://ht.homeserver.hu/doc/listak/htrom/htrom.html


Alig vártam, hogy leérettségizzek és mehessek dolgozni a Telefongyárba, mivel szerződésem volt velük, hogy suli után ott fogok dolgozni. Zolival tartottam a kapcsolatot, mivel 4.-ben is a telefongyárba (is) jártam szakmai gyakorlatra év közben is, meg mint kiderült, a "Klub"-nak is meghatározó tagja volt. Legfőképp itt találkoztunk, és szóba került az elhelyezkedésem. Megkérte a barátnőjét, hogy kérdezze meg, van-e lehetőségem az ő osztályukon elhelyezkedni. És volt!

Első nap "kezelésbe" vettek az új kollégáim, akik egytől-egyig egyetemet végzett mérnökök voltak, és nem értették, hogy mit keresek én ott. T. Lajos volt az, akinek a legnagyobb hangja volt köztük, és aszondta, ha akarok egy gépet magamnak, akkor rakjak össze egyet. Ő úgy gondolta, hogy kifogott rajtam - hát nagyot tévedett! Volt ott egy prototípus TAP-34 teljesen kibelezve, és én két-három nap alatt életet leheltem bele, mindenféle segítség nélkül. Azaz ez pontosan nem igaz, mert a Floppy meghajtók működésképtelenek voltak, és ehhez segítségül kellett hívnom egy "specialistát", aki fél óra alatt beállította az elektronikát. (Akkoriban még így működtek a floppyk :)

Egy-két hétig csak ismerkedtem a géppel, a ROM-jaival, a HW elemek címzésével, működésével, a fejlesztői programokat gyűjtögettem össze, ismerkedtem az assemblerrel. A telefongyár nagyon jó hely volt, minden műszaki leírás ot volt a polcon, az eredeti Intel katalógusoktól kezdve mittudom én már, hogy mikig.

Aztán kitaláltam, hogy írok egy jobb Basic Interpretert, mint amit a Telefongyár tákolt össze. Senki nem akarta elhinni nekem, hogy képes vagyok rá. És itt jön a képbe a füzetem: visszafejtés közben meg is értettem az interpreter működését, és képes voltam szétválasztani a nyelvhez és a hardverhez kötődő részeket. (Egy kis visszaemlékezés: a suliban az egyik iskolatársamnak volt otthon egy C64-es gépe, apja olyan helyen dolgozott, ahol ez volt a munkaszköze, így azzal is volt szerencsém párszor találkozni). Nekem a C64-ből nagyon megtetszett a "Full Screen Editora", így teljesen újra kellett írni a beviteli-szerkesztési részeket. Kazettás magnó helyett Floppy funkciókat kellett írni, úgyhogy a HT kódnak (nem akarok hülyeséget mondani, de ) kb. 70-80%-át használtam fel, a többi teljesen saját kód volt. A "gyári" basic a gép rom rutinjait használta fel a képernyőre íráshoz, és az a 8275-ös CRT kontroller miatt elég lassúra sikeredett. Nekem nem is tetszett, ezért azt is teljesen újra írtam és ez volt az a része a programnak, amivel a 19.-ik születésnapomon 32.000 Ft-ot kerestem! :) A lényeg az, hogy nagyjából fél év alatt sikerült egy sokkal jobb és jóval gyorsabb Basic Interpretert írnom, és ezzel kivívnom mérnök kollégáim elismerését.

Lajos lett a "menedzserem" és elkezdte fusiban árulni a programomat. Két szervízes srác talált is rá vevőt, a szolnoki vízműveket. Egy feltételük volt, jóval gyorsabbnak kellett lennie mint a régi és kompatibilisnek kellett vele lennie.

Pont a 19.-is születésnapomon került sor a bemutatóra Szolnokon. És mekkora mázlim volt! :) Valami nyilvántartó programjuk volt, ami adatgyűjtés vagy mittomén mi közben folyamatosan írt a képernyőre ezáltal baromira lelassítva a programjukat. És mivel én átírtam a megjelenítést, így az addigi 6 óra helyett kevesebb mint két óra alatt futott le a programjuk, hibátlanul. Kérdés se volt ezután, hogy megveszik. A szerzői jogvédőn keresztül fizettek, miután mindenki levette a sápot még nekem is maradt egy otthoni számítógépre való pénzem.

Folytatása követketik...

II. rész - CP/M

A Telefongyárnak is haladnia kellett a korral, ezért mindenkinek a TAP-34-es gépét átalakították CP/M-esre. Ez nem volt különösen nagy hardverigényű "beavatkozás", egy-két fóliát kellett átvágni a CPU panelen és a ROM-okat kicserélni statikus RAM-okra. Eleinte idegenkedtem az "új rendszertől", de ez csak addig tartott, amíg az én gépemre is sor került. Egy egészen új világ tárult elém, olyan programokkal mint a WordStar, Microsoft Assembler, DDT és sorolhatnám őket a végtelenségig. Az egyik legfontosabb program a DBase volt, ami hamarosan meghatározta a jövőmet. Én képes voltam reggel 6-tól este 6-ig nyúzni a gépet, pedig hivatalosan munkám nem volt. Magyarul két és fél évig csak tanultam a programozást és a hardverekkel ismerkedtem. Sorozatban gyártottam például az ébresztős-zenélős mikroprocesszoros órákat. Fejlesztési Főosztály révén alkatrészben nem volt hiány, nem kellett elszámolni velük. 10-15 óra készült el körülbelül, az enyém még mindig megvan, bár már nem működik, mert huszonév alatt elfelejtette az eprom a tartalmát. Bár megvan még a forráskód eljárt felette az idő. Nagyon szerettem azt az órát, úgy 15 évig ébredtem a C16-ra írt Kikstart játékból "kölcsönzött" kétszólamú zenéjére. Egyébként 8085-ös proci volt benne, mert az volt a raktárban feleslegbe... A főosztályon egyetlen egy eprom égető volt, amire napokig kellett várni, hogy használhassam. Ezt is megelégeltem és csináltam magamnak :)

Aztán jött a katonaság. Én sosem éreztem magamat harcias alkatnak meg hazafi se akartam lenni, ezért próbáltam minél könnyebbé tenni magamnak azt a másfél évet, amit elvettek az életemből. Kezdtem azzal, hogy rögtön első nap a budaörsi laktanyában összefutottam K. Attilával, aki szintén telefongyári és jó haverom is volt. A vállapján több csillag volt mint az égen :) Kiderült, hogy az egyik alezredes feleségénél dolgozik a számítógépteremben. Aztán még aznap elvittek debrecenbe egy hónapra kiképezni. Csakhogy én szemüveges vagyok és ezért "B" kategóriát kaptam. Ezzel nagyjából három hetet át is vészeltem - se lövészet, se sárban csúszkálás, se konyha -, mígnem valamelyik nagytudású őrvezetőnek eszébe nem jutott, hogy nem a szívemmel van baj :(

Ezalatt az egy hónap alatt se tétlenkedtem a programozással: a telefongyárban megismerkedtem egy furcsa viselkedésű sráccal, R. Palival. Szakmáját tekintve vegyész volt, de őt is inkább a számítógépek érdekelték és volt tehetsége hozzá. Nem nálunk dolgozott, hanem egy másik osztályon, de senki nem tudta megmondani, hogy neki igazából mi is a munkája. A lényeg az, hogy másik munkahely után kezdett nézelődni, és saját fejlesztésű CP/M-es gépet tervezett az oroszoknak. A termináljába a már említett 8275-ös CRT kontroller került, amit szerintem addigra magyarországon én ismertem a legjobban. Papíron, egy kockás füzetbe megírtam a terminál teljes programját, többször "lefuttattam" fejben. Mikor visszakerültem Budaörsre és kiengedtek pár napra, első utam Palihoz vezetett, ahol még aznap éjszaka beírtuk a programot. Kisebb javítások után kifogástalanul működött :)

Visszatérve a laktanyába a századparancsnok irodájában találtam magamat. Tényleg százados volt és pontosan olyan vörös volt a feje mint a szovjet zászló. Azt kérdezte (inkább üvöltötte), hogy miért nem jó nekem ott, miért kell nekem hátszél, miért akarok máshová menni? Fogalmam se volt róla, hogy miről beszél. Még aznap kiderült, hogy Attila - akivel első nap összefutottam - "intézkedett", és az alezredesnél találtam magam, mint "személyi programozója". Egy C128-as gépe volt neki, amin futott a CP/M, és meg volt neki minden programja, ami szükséges lehetett. Úgyhogy DBase tudásomat felfrissítve mindenféle nyilvántartó programokat írkáltam neki - amikor épp nem játszottam :) Cserébe csak hétköznap reggel 7-től délután 4-ig kellett a laktanyában lennem, úgyhogy király életem volt. Ezért említettem korábban, hogy fontos dolog volt az életemben a DBase.

A folytatásban az első PC-m építése következik...

Programozási nyelvek, értelmezők és fordítók

Itt az idő hogy konkrétan belevágjunk a programozásba és igazi programot készítsünk, igazi exe-t amit tudunk futtatni (PC és Windows esetében).
Ahhoz hogy a megalkotott programokat a gép számára is érthető és végrehajtható formába öntsük, szükség van egy eszközre ami ezt megteszi. A valamilyen programozási nyelven megírt programunkat a gép számára érthető gépi kódra kell fordítani. Alapvetően kétféle megvalósítás létezik. Az egyik az értelmező (interpreter) a másik a fordító (compiler).
Röviden összefoglalva az interpretrek jellemzője hogy a forrásprogram utasításait akkor fordítja le amikor végre kell azt hajtani, míg a compilerek az egész forrásprogramot lefordítják gépi kódra, majd a linkelés után (ezt szintén nem szeretném most részletezni) létrejövő programfájl (exe) már közvetlenül futtatható.

Ebben a blogban a manapság leggyakrabban alkalmazott nyelveket, a C és a PASCAL nyelvet fogom példaként használni. A két nyelv között nagyon sok elvi különbség van. Szinte vallási fanatizmussal vetekszenek a különböző felfogások. "Miért jobb a C mint a Pascal?" típusú kérdések köré már filozófikus mélységű elemzések és eszmefuttatások kötődnek.
Jelenleg részünkről a különbség a jelölésmódban áll. Gyakorlatilag a C hardverközelibb, a Pascal meg szigorúan típusos és sokkal szebb, tisztább, olvashatóbb kód készíthető vele. De nem akarok belemenni most az ilyen szintű elmélkedésekbe.

Windows alatt Pascalhoz a Free Pascal környezetet ajánlom, C-hez pedig a Code::Blocks fejlesztőkörnyezetet. Ha a telepítésekkel probléma van írjatok! Mindkét fejlesztőeszköz ingyenesen és legálisan használható.

Ismerkedés a C#-al és a .NET Framework-el

Mivel ősztől az egyetemen .NET programozás kapcsán a C# nyelvet fogjuk tanulni, ezért egy picit elébe megyek a dolgoknak és elkezdek ismerkedni ezzel a nyelvvel és a platformmal.
Itt a blogban a C# és .NET cimkékkel ezeket a bejegyzéseket fogom jelölni.
Alapjaiban az egészet talán onnan érdemes megközelíteni hogy a Sun megtiltotta a Microsoftnak hogy a nagy sikereket elért JAVA-t a - JRE-t és a JDK-t - beintegrálja a Windows XP telepítőkészletbe. Ezért a Microsoft elkezdett fejleszteni egy hasonló dolgot mint a Java. Azaz egy virtuális gépet, egy programozói és egy futtató környezetet jól kidolgozott és átgondolt osztályhierarchiával. Ez lett a .NET Framework. A nagy különbség hogy ez szinte minden most futó windowson integrált része az operációs rendszernek, így mindenhol rendelkezésre áll, míg a Javát telepíteni kell (ez sem ördöngősség, de mégis foglalkozni kell vele). A másik különbség, hogy ugyan platformfüggetlennek tervezték a .NET-et de gyakorlatilag csak a Microsoft rendszereiben valósult meg (vannak kivételek MONO, vagy a DOTGNU).
Segítségével gyors és hatékony Windows programokat lehet készíteni a legmodernebb technikákkal.
A .Net-et jellemzően a C# nyelvvel lehet programozni, de a Visual Studio össze eszköze már erre is használható (Visual Basic.NET és a J#).
A C# - ez a blog alapja végülis - egy C++ szerű teljesen objektum orientált programnyelv. Nagy hasonlóságok fedezhetők fel a Java nyelvvel való összehasonlítás kapcsán.

Az adatok

Az algoritmusok utasítások sorozata, melyet az adott programozási nyelv lehetőségeit és eszközkészletét felhasználva a bemenő adatokból a kívánt kimenetet adja.
Beszéltünk már a strukturális programozás vezérlési szerkezeteiről. Ezek utasítások, azok ismételgetése stb. Az utasítások azonban adatokon dolgoznak. De mik ezek az adatok? Milyen típusai vannak? Számít-e a típus? Ezek a kérdések felmerülhetnek az adatokkal kapcsolatban.
Először próbáljunk felsorolni néhány adatot.

• a háromszög oldalának hossza
• a felhasználó neve
• a kedvenc színünk

Ezek az adatokat a számítógépen kezelnünk kell tudni. Ehhez az kell hogy a számítógép tárolni (ábrázolni) tudja ezeket. Az adatok egyik legfontosabb tulajdonsága a típusa. Ez határozza meg hogy az adatokkal milyen műveleteket tudunk végrehajtani, illetve adott műveletek eredménye milyen típusú adatot szolgáltat.
Az alapvető típusok:
egész számok
lebegőpontos számok
karakter
szöveg
logikai érték
A programozási nyelvekben általában ezek rendelkezésre állnak és ráadásul többféle megvalósításban. Ugyanis a típus mellett a másik fontos tulajdonsága az adatoknak az ábrázolható tartomány. Egész szám pl az 5 vagy a -531, de a 1232145 is. A különböző megvalósítások általában figyelembe veszik hogy pozitív számokat vagy előjeles számokat akarunk tárolni. A tárolás alapegysége a byte, ami 8 bitet jelent. Ezen a legnagyobb ábrázolható pozitív egész szám a 255. Ennél nagyobb számokat úgy tudunk ábrázolni ha több bájtot összefogunk. Ugyan ez érvényes a lebegőpontos számokra is, amik ráadásul speciálisan vannak tárolva (ezzel nem akarok most itt foglalkozni). Egy karaktert ASCII kódjával tárolunk, ami 0-255 közötti egész szám. Egy szöveg több karakter egymás után írása, azaz karaktersorozat. Ezt annyi bájton tároljuk ahány karakterből áll és speciálisan tárolni kell a hosszát, vagy jelölni kell a végét.

Egyelőre ennyit az egyszerű adattípusokról. Apropó! Ugyanis vannak összetett adattípusok is, de erről kicsit később beszélünk.

A vezérlési szerkezetek

Az előző cikkekben volt néhány nagyon egyszerű példa, amiknek a szerkezete valami ilyesmi volt:
START -> ADATBEKÉRÉS -> MATEMATIKAI MŰVELETEK -> ADATKIÍRÁS -> STOP

Az ilyen szerkezetet hívják szekvenciának, azaz sorozatnak. Elkezdődik valahol és egyenesen elágazás nélkül halad a cél felé. De mi van akkor ha nem ilyen egyértelmű a dolog? Mondjuk ellenőrizni kell valamit és az ellenőrzés eredményétől függően halad tovább a végrehajtás? Mondjuk ellenőrizni akarjuk a háromszög kerületszámoló programunkban, hogy a megadott oldalhosszakkal valóban lehet háromszöget rajzolni. (ezt a példát is meg fogjuk később csinálni)
A másik probléma az hogy mit csináljunk akkor ha egy adott tevékenységsorozatot többször végre kell hajtani? Például ki akarjuk íratni a számokat 1-100 között. Persze megcsinálhatjuk úgy is hogy írunk 100 db kiírató utasítást, csak egyrészt ez nem igazán programozás, másrészt ha vizsgán ilyet csinálnál akkor gondolkozás nélkül vágnának ki, pedig működik a program.....


Ezeket a fentebb vázolt dolgokat nevezik vezérlési szerkezeteknek. Ezeket tekintjük most át.
Egy programozási nyelv vezérlési szerkezetei (és adatszerkezeti) határozzák meg hogy az adott nyelvven milyen stílusú programozás valósítható meg. A legáltalánosabban használt programozási módszer a struktúrális programozás. Ennek lényege hogy szekvenciákkal (soronkénti végrehajtás), iterációkkal (ciklusok szervezése) és szelekciókkal (feltételes elágazások) minden probléma megoldható.

• Szekvencia: utasítások egymásutáni végrehajtását jelenti elágazások és ismétlések nélkül.
• Szelekció: egy logikai feltétel eredményétől függően elágazik a program végrehajtása.
• Iteráció: egy logikai kifejezés eredményétől függően ismételten végrehajtunk egy programrészt.Ezt nevezzük ciklusnak is.

Ezeket nézzük meg hamarosan részletesebben.

Írjuk le saját szavakkal a programot

Megkérdezheted hogy mire jó ez az egész, hogy ilyen baromságokkal foglalkozom és nem valamilyen programnyelven keresztül mutatom be a programozást. Nos a válasz az, hogy mellékes dolog az ha egy problémát leprogramozol (meghatározod az input és output adatokat, a rajtuk végzendő műveleteket) azt milyen eszközzel jegyzed le. Az elején ha elkezdjük egy adott jól ismert programnyelv használatát, akkor arra fogunk koncentrálni, hogy a nyelvnek mik a lehetőségei, milyen korlátai vannak, mik a szabályok amit be kell tartani, előtérbe kerül maga a fordító program is és elveszik a lényeg: a programozás, az algoritmizlás, az analizálás az optimalizálás. Pedig a lényeg éppen ez. Nem az a fontos hogy milyen eszközzel jegyezzük le a programot, hanem az hogy meg tudjuk fogalmazni magunknak, rendszerezni tudjuk és logikus érthető formában álljon rendelkezésre. A későbbiekben nem fogod természetesen lejegyezni így a programterveidet, de most az elején szükséges hogy ennek segítségével a lényegre koncentrálj.


Ha meg tudod fogalmazni egyszerű mondatokkal az elkészítendő programot, akkor a nehezén túl vagy. Ebben kell gyakorlatot szerezni, aztán a kódolás már gyerekjáték lesz.

Absztrakció - lépjünk közelebb a kódoláshoz

A programozással készen is vagyunk. Ha meg tudsz fogalmazni ilyen módon problémákat (bemenet, kimenet, adatok, műveletek) akkor már tudsz programozni. Nagyon fontos hogy leírd ezeket, mert különben azt hiszed hogy tudod és mikor vizsgán valóban adoptálni kell akkor meg lesünk ki a fejünkből és nem tudjuk miért nem megy.
Szóval még néhány példa:

Két bekért számról döntsük el hogy mennyi a különbségük. Ezt írjuk is ki.

Kérjük be az első számot (SZ1)
Kérjük be a második számot (SZ2)
Vonjuk ki az elsőből a másodikat, majd vegyük annak abszolút értékét. (K=ABS(SZ1-SZ2))
Írjuk ki a különbséget (K)

Kérjük be egy személy születési évét, majd írjuk ki hogy hány éves:

Kérjük be a születési évet (SZULEV)
Vonjuk ki az aktuális évből a születési évet és tároljuk (KOR=YEAR()-SZULEV)
Írjuk ki a kiszámolt értéket (KOR)

Nem ragozom tovább.
Mint láthatod vannak általában használható egyéb műveletek is. Ilyen az ABS() és a YEAR(). Ezek olyan dolgok amit feltételezünk hogy rendelkezésre állnak. Mindig utána kell járni hoyg valóban léteznek-e. (Nekünk a Széchenyi Egyetemen egy absztrakt pszeudó nyelvet találtak ki és abban léteztek ilyen funkciók. Ezt ki is emelték és alkalmazhattuk! A dokumentációban szerepelt.)

És akkor nézzünk egy picit absztraktabb úgynevezett pszeudó nyelven megfogalmazott példát.
Először természetesen a kerületszámoló algoritmust nézzük:

Be: A
Be: B
Be: C
K<- A+B+C
Ki: K

Két szám különbsége (fenti első példa):

Be: SZ1
Be: SZ2
K<-ABS(SZ1-SZ2)
Ki: K

Életkor kiírása:

Be: SZULEV
KOR<-YEAR()-SZULEV
Ki: KOR

Hú mennyi programot írtunk hirtelen.....
Ezek nagyon egyszerű dolgok, de ne felületesen kezeld ezeket. Legalább 10 problémát keress, fogalmazd meg és írd le ilyen pszeudó kóddal.
Eleve az hogy keresel magadnak feladatot az is nagyon sokat segít, hiszen már analitikusan vizsgálod a körülötted lévő világot. Azon gondolkodsz vajon mi az amit ilyen módon algoritmizálni lehet?

Első program

Az első postban írtam hogy életem első önálló programja egy háromszög kerület számoló program volt. Hogyan is nézett ki ez a program? Íme:

Kérd be az A oldal hosszát (A)

Kérd be a B oldal hosszát (B)

Kérd be a C oldal hosszát (C)
Számold ki a kerületet (K=A+B+C)
Írd ki a háromszögkerületét (K)

Ennyi. Ez azon lépések sorozata mely a bemeneti adatokon műveletek elvégzése után a kívánt kimenetet adja.
Szerintem másra számítottál. Talán valamiféle programnyelven (Pascal, C, Basic) elkészített forrásszövegre. Nos ez az utolsó ám nagyon fontos lépés lesz!
A programozáshoz először egyfajta gondolkodásmódot kell kézség szinten elsajátítani.
Egyetemi tanulmányaim során találkoztam azzal a megdöbbentő ténnyel, hogy a mérnök informatikus szakra jelentkező hallgatóknál ez a gondolkodásmód nincs meg. A kb 60 fős induló évfolyamlétszámból a negyedik félév végére négyen maradtunk. A bukások két tárgyra vezethetők vissza. A programozásra és a matematikára. Mindkettő alapvetően fontos a programozáshoz.
A rendszerszemlélet, az algoritmizálás, az alapvető optimalizációs készség és egyáltalán az alapvető algoritmusokban való tájékozottság. Nem az algoritmus ismeretéről beszélek, hanem arról hogy tudjon róla  a programozó hogy létezik, találja meg és tudja értelmezni, alkalmazni algoritmizálni.
Ezek az alapvető dolgok amik ahhoz kellenek hogy valaki programozni tudjon. Persze ezek a készségek is "feltuningolhatók" vizsgaidőszakra és a sok gyakorlás amolyan készséggé tud átmenetileg alakulni. Ha pedig nem marad abba a gyakorlás akkor előbb-utóbb rögzül, reflex-é válik. Ezzel csak azt akarom mondani, hogy fel tudsz készülni a vizsgára! Kellő szorgalommal és rendszerességgel nem lehet probléma.

Elemezzük a háromszög kerületszámító problémát a Program számítástechnikai értelemben című cikkemben megfogalmazottak szerint!
Input adat: három input adatunk van. A háromszög A, B és C oldalának hossz.
Output adat: a háromszög kerülete, amit megjelenítünk
Művelet: egy picit több van mint elsőre gondolható. A triviális művelet a háromszög kerületének kiszámítása. Ez egy összeadás, ráadásul nem is egy, hanem kettő (két összeadás jel van) és rögtön értékül is adjuk az eredményt (egyenlőségjel). Ezek mellett tekintsük műveletnek, vagy tevékenységnek az adat bekérést (ebből három van) és az adatkiírást (ebből egy van).
Van három bemenő adatunk amit bekérünk egyesével, elvégezzük a számítási műveletet,majd megjelenítjük a kiszámolt kerületet.
Csupán annyit tettünk, hogy a teljesen természetes módon keletkező gondolatainkat megfogalmaztuk mondatokba és azt leírtuk. Azaz nem csupán végrehajtottuk a bemagolt formulát, ami így szól: "ká egyenlő á plusz bé plusz cé" hanem azt átírtuk matematikai formába K=A+B+C. Mivel szükségesek az oldalhosszak a képlethez ezért azokat meg kell tudnunk, azaz be kell kérnünk. Ezt is megtettük. Leírtuk hogy kérjük be. Hú de triviális ugye! Nem tettünk semmi csodát, csak leírtuk....
Picit gondolkozzatok el ezen, hogy mennyire gáz ez az egész és mennyire egyszerű is ez.

A program (számítástechnikai értelemben)

Próbáljuk megfogalmazni az előző általánosítás segítségével a számítástechnikai program fogalmát. Valahogy így szólhat:

A program olyan lépések sorozata, mely egy előre kigondolt, megtervezett műveletsorozat végrehajtásával a bemenő adatokból valamiféle kimenetet ad.

Nézzük csak az új fogalmakat.
Műveletsorozat. Programozásban elsősorban matematikai műveletekre kell gondolni, de ilyenek a nem szám jellegű adatokon végzett tevékenységek is. Hogy érthető legyen gondolj pl egy név megkeresésére egy adathalmazban. A keresés is egy művelet, de nem számokon alapszik. Vagy egy másik példa: a "Helló világ!" szöveg első három betűjének lekérdezése is egy művelet. A lényeg hogy valamiféle adaton értelmezett tevékenység.
A művelet mellett az adat a másik fogalom amit ismerni és tudni kell értelmezni ha programozást szeretnénk tanulni.
Az adatot fogjuk fel úgy hogy nem más mint egy információ, számítógépen ábrázolt és értelmezhető formában.
Művelet és adat egymástól elválaszthatatlan dolog a programozásban. A program adatokkal dolgozik. Adat nélkül nincs értelme a programnak. Az adatokon műveleteket hajtunk végre. Ha nincs adat akkor a műveletnek sincs sok értelme. Gondoljunk csak bele.Mit csinál az a program amiben nincs adat? Próbáljunk kitalálni egy ilyet. Nagyon nehéz.... Szinte lehetetlen...
Nincs olyan program amiben nincs adat és nincs olyan program, amiben nincsenek műveletek.
Picit összemosódott a program és a művelet fogalmak. Ez nem baj, hiszen a program nem más mint műveletek sorozata, tehát ha úgy tetszik egy összetett művelet (....ami természetesen adatokon dolgozik...)
Adós vagyok még két fogalommal a fenti meghatározásból. Bemenet és kimene.
A bemenet a mosógépes példa esetében a piszkos ruha, a kimenet pedig a tiszta ruha. Éppen ez volt a célunk. A bemenő adatokon (piszkos ruha) végrehajtottuk lépésről-lépésre a műveleteket (áztatás, mosás, centrifugálás) és megkaptuk a kimenetet/kimenő adatot (tiszta ruha).
A bemenetet az idegennyelvű szakirodalom inputnak a kimenetet outputnak nevezi.
Tartsuk ezeket a fogalmakat szem előtt mindvégig. Értsük és tudjuk hogy mit jelentenek pontosan!
Bement (Input), Kimenet (Output), Művelet, Adat, Program

A program (általánosítás)

Mit is jelent ez a szó: Program?
Próbálom általánosítva megfogalmazni: a program egy olyan tevékenységsorozat amit végrehajtva a kiinduló helyzetből egy új helyzet (amit szeretnénk elérni) áll elő.
Néhány egyszerű hétköznapi példa a programra:

• Egy politikai párt választási programja olyan intézkedéstervek halmaza amit az adott párt végre szeretne hajtani, ha kormányra kerül.
• Egy vállalat gazdasági programja olyan jól átgondolt hosszútávú terv, aminek lépésről lépésre történő végrehajtásával a vállalat eléri gazdasági célját.
• Egy mosógép programja olyan lépések sorozata, melyet ha elindítunk és végrehajtja a mosógép akkor tiszta mosott ruhát kapunk (áztatás, mosás, centrifugálás). Ha közben hiba adódik akkor a mosóprogram leáll.
• TV műsorprogram egy sorrend, amit a televíziócsatorna szépen sorban egymás után sugároz.

Kiemeltem néhány szót, ami nagyon fontos és talán alapvető hogy megértsük és mögé tudjunk gondolni.
Intézkedésterv: jól átgondolt még meg nem valósított lépések sorozata.
Végrehajtás: utasítások, műveletek elvégzése
lépésről-lépésre történő végrehajtás: egyszerre egy lépés elvégzése, annak eredményétől függően, vagy éppen attól függetlenül egy következő lépés végrehajtása esetleg ugyan azon lépés ismétlése.
lépések sorozata: (lásd előző pont)
elindítunk és végrehajtja: start - stop. Elejétől a végéig lépkedünk egyesével.
Hiba adódik, leáll: hibajelenség kapcsán leáll a végrehajtás. Tegyük hozzá hogy jó esetben. Mert sajnos a legjellemzőbb probléma hogy a program fut tovább és egyre nagyobb hibák keletkeznek, így a végeredmény sem lehet helyes.

Hogyan kerültem kapcsolatba a számítógéppel?

Üdvözöllek a Programozz! blogomon. Ezt az oldalt azért hoztam létre, hogy ha valaki programozási nehézségekkel küzd az segítséget kaphasson.
Egy picit untatnálak a saját szakmai történetemmel is.
Jelenleg 39 éves vagyok és 13 éves korom óta foglalkozom programozással. Talán azt is gondolhatod hogy ez nem nagy szám, hiszen manapság a srácok 13-14 évesen simán programoznak. Ám ha utánaszámolsz, kiderül hogy 26 évvel ezelőtt voltam 13 éves és 26 éve éppen (2010-26) 1984-et írtunk. Ekkor jelent meg az első IBM PC, persze nem az akkori KGST országokban, hanem az USA-ban. Itthon Magyarországon ekkor még javában dúlt a szocializmus és a hírhedt COCOM lista (csúcstechnológiai termékeket tartalmazó fekete lista) bizony tiltotta az efféle eszközök behozatalát az országba. Most már ugye érthető hogy nem volt olyan természetes 13 évesen számítógép előtt gubbasztani és bármit is csinálni vele.

Szóval nem a mai PC architektúra volt az amin akkor "számítógépezni" lehetett, hanem inkább a kisebb játékgépek. Talán mondanak ezek a nevek valamit: Commodore 64 vagy ZX Spectrum. No nem ezeken tanultam programozni, hiszen ezek a gépek is szerepeltek a korábban említett COCOM listán. Voltak jófajta szovjet és magyar gyártmányok. Egy ilyen gép volt a Hiradástechnikai Szövetkezet által gyártott HT-1080Z (a linken megnézheted milyen is volt ez a gép, hogyan néztek ki az akkori menő játékok a Galaxy Invasion és a Kígyó) Érdekes lehet hogy ezen a szocialista országban gyártott gépen a Microsoft által fejlesztett Basic interpreter futott.
Szóval ez volt az a gép és platform amit akkor a kis vidéki falucska megkapott egy nyári szünetre a mosonmagyaróvári Agrártudományi Egyetemtől. Néhányan körbeültük a matematika tanárunkkal és ő megmutatta hogy mi is ez az egész. Ezt írta ki fekete fehéren a hozzá csatlakoztatott TV-re:
READY?
Emlékszem a tanár szavaira:

"Most azt jelzi hogy kész, várja a parancsaidat! Utasíthatod arra amit ismer és azt végrehajtja. Persze te magad is tudod tanítani és akkor már több mindent tud végrehajtani. Meg kell adni a bemenő adatokat és azt hogy azokkal milyen műveleteket végezzen, majd ki kell írni az eredményt. Ezt hívják programozásnak!"

Valahonnan innen indultam el és azt hiszem ez az első amit egy programozni megtanulni szándékozónak is meg kell jegyeznie. A számítógép mindent végrehajt amire utasítod és azt pontosan úgy teszi ahogy megtanítod neki. Ha hibás a program akkor azt a hibát te követted el és nem a gép!
Szóval 1984 júniusában megírtam életem első programját, ami bekérte egy háromszög oldalainak hosszát és kiszámolta a területét és a kerületét.
Meg tudod írni ezt a programot? Neeee! Ne kérdezd meg hogy milyen nyelven! A programozás nem nyelvfüggő. A programozási nyelv az egy eszköz aminek segítségével a számítógépet megmondod hogy az általad kitalált programot hogyan hajtsa végre. Itt most arra gondolok hogy, el tudod-e mondani szavakkal, magyarul, hogy hogyan is néz ki ez az egyszerű program. Na ezt egy külön cikkben fogjuk kitárgyalni hamarosan....
Ezután elkerültem középiskolába. A továbbtanulásomat alapvetően már a számítástechnika határozta meg. Mint fentebb írtam akkoriban nem volt jellemző hogy otthon bárkinek számítógépe lehessen, de még az iskolák sem rendelkeztek számítógépekkel, nem is beszélve a számítástechnika oktatásról. Azonban volt egy lehetőség Esztergomban (180 km-re a falumtól, akkoriban ez is nagyon nagy távolság volt).

Az I. István Híradástechnikai Szakközépiskola kapcsolatban állt a Sárisápi Termelőszövetkezettel ahol a magyar tervezésű és gyártású PRIMO számítógépet készítették, így akkor 1985-ben az iskola kb 20 számítógéppel rendelkezett és éppen tervezte bevezetni a számítástechnika oktatást. Ez a helyzet szinte példátlan volt abban az időben. Más középiskolában nem volt ilyen lehetőség a számítástechnika közelébe férkőzni. Nem volt kérdés, Esztergomba vezetett az utam. A számítástechnika órák ekkor nem abból álltak hogy megismerjük az Internetet (aminek híre-hamva sem volt akkor még), vagy hogy szövegszerkesztőt vagy táblázatkezelőt használjunk. A számítástechnika oktatás ekkor magát a programozást jelentette. A PRIMO is Basic interpreterrel volt felszerelve, így Basic programozási nyelven tanultam meg a programjaimat leírni először.
A számítástechnika órákon kisebb programokat, algoritmusokat készítettünk, audio kazettára mentettük az elkészült kódot és JUNOSZTY tv volt a monitorunk.
Aztán nemsokára megismerkedtünk a Z80 Assemblerrel is. A gép közeli programozás magának a mikroprocesszornak a megismerését jelenti. Véleményem szerint ez már nem tartozik a programozás témaköréhez, inkább a számítógép architektúrák, operációs rendszerek világa.
Szóval röviden ennyit a kezdetekről, a történetről.