Lottószimulátor - Futtató program

Most hogy készen van a Szelveny osztály, teszteljük azt. Ehhez kell egy úgynevezett tesztelő vagy futtató program. Nézzük meg hogy miért is van ez.

A Java tisztán objektum-orientált nyelv. Ez azt jelenti hogy minden objektum a programban. Az objektumok valamilyen osztály egy-egy példánya, mely a példányosítás során jön létre. Az egyes objektumpéldányok létrehozása kostruktorral történik. Ha nem definiálunk konstruktort akkor is létezik az osztály nevével azonos nevű metódus. Ennek fő feladata a memóriafoglalás és az objektum kezdeti állapotának beállítása. A Szelvény osztálynak két konstruktort definiáltunk. Egy paraméterezettet és egy paraméter nélkülit. A példányosítás után az objektumnak a publikus metódusain keresztül üzeneteket tudunk küldeni, illetve a publikus adattagok közvetlenül elérhetők (ezt én kerülendőnek tartom még akkor is ha triviális lenne a megoldás).

Minden osztályt külön forrásfájlban (.java kiterjesztésű fájl) kell definiálni. A forrásfájl nevének meg kell egyezni az osztály nevével. Így lett a Szelveny osztályunk a Szelveny.java fájlba definiálva.

Amikor egy osztályt a virtuális gépbe betöltünk akkor a JVM megpróbálja elindítani az osztály main() metódusát. Ha ilyet talál akkor elindul a metódus. Így indíthatók a programok.

Hozzunk létre most egy LottoTest osztályt, amibe létrehozzuk a main() metódust. Ennek is szabályai vannak, az alábbi kötött formában kell definiálni a main()-t.

1. public class LottoTest {
2.    public static void main(String[] args){
3.      //létrehozunk két szelvényt
4.      //sz1 automatikusan generált 5 számot fog tartalmazni
5.      Szelveny sz1 = new Szelveny();
6.      
7.      //sz2 a paramétrelistájában megadott öt számot tartalmazza
8.      Szelveny sz2 = new Szelveny(19,71,8,16,7);
9.  
10.    }
11. }

Ezzel létrehoztunk két objektumot, melyek tartalmaznak tippeket. Ezeket a tippeket írassuk most ki!
Rá kell jönnünk hogy a szelvény osztályban nem készítettünk metódust a kiíratásra, az adattag ami a tippeket tartalmazza az pedig private (nagyon helyesen), amihez ugyebár az objektumon kívülről nem lehet hozzáférni. Készítenünk kell hát valamilyen metódust ami kiíratja, vagy visszaadja a tippeket.
A Java-ban szokás definiálni egy toString() metódust. Ez kvázi szabvány. A metódus visszaad egy String típusú értéket mely tartalmazza azt a szöveget, amit az objektum adatairól  tartalmaz információt. Most ezt fogjuk megadni. Egyébként a számok tárolására használt TreeSet konténernek is van "gyári" toString() metódusa, amit fel is használunk.
Természetesen a Szelveny.java fájlt kell kiegészíteni a következő sorokkal:

1. public String toString(){
2.    // a TreeSet objektum toString() metódusát úgy írták meg hogy
3.    // [] jelek között, vesszővel elválasztva felsorolja
4.    // növekvő sorrendben az elemeit. Ez nekünk teljesen megfelel!
5.  
6.    return "Szelvény száma: "+szelvenyId+" Tippek: " + tippek.toString();
7. }

Ezek után már a tesztelő osztályunkban a példányosítások után használhatjuk is a szelvények toString()-jét a kiíratásra.

A kiíratáskor a kiertekel() metódust felhasználva, értékeltessük is ki a szelvényeket.

Ez lesz a tesztelő osztályunk tartalma:

1. public class LottoTest {
2.    public static void main(String[] args){
3.      //létrehozunk két szelvényt
4.      //sz1 automatikusan generált 5 számot fog tartalmazni
5.      Szelveny sz1 = new Szelveny();
6.      
7.      //sz2 a paramétrelistájában megadott öt számot tartalmazza
8.      Szelveny sz2 = new Szelveny(19,71,8,16,7);
9.  
10.      // ha nem adjuk meg cska az objektum nevét, akkor megpróbálja megfelelő típusúra konvertálni.
11.      //String típushoz a toString() metódust hívja automatikusan.
12.      System.out.println(sz1 + " Találatok száma: " + sz1.kiertekel(2,7,18,71,87));
13.      System.out.println(sz2 + " Találatok száma: " + sz1.kiertekel(2,7,18,71,87));    
14.  
15.    }
16. }

Futtatás hatására a kimenet hasonló lesz  (valószínű más számok jelennek meg az sz1 kiírásakor)

Szelvény száma: -1 Tippek: [8, 51, 66, 71, 75] Találatok száma: 1

Szelvény száma: -1 Tippek: [7, 8, 16, 19, 71] Találatok száma: 2

Lottó szimulátor - osztályok első nekifutásra

A lottó szimulátorral kapcsolatban először gondoljuk át hogy milyen osztályok szükségesek az alkalmazáshoz.

A Java egy tisztán objektumorientált programozási nyelv és mint minden ilyen nyelvben osztályokkal és az osztályok alkotta osztályhierarchivál dolgozunk. Az osztályok a való világ egyes elemeinek, objektumainak absztrakció útján történő leképezései.
Most próbáljuk meg a feladattal kapcsolatban az első absztrakciót elvégezni. Képzeljük el hogy milyen osztályok és azok milyen kapcsolatai fogják alkotni a Lottószimulátort! Most nem törekszünk teljes részletességre, csupán nagy vonalakba gondoljunk a feladatra.

A lottófogadásokat szelvényeken tudjuk megtenni. Az összes fogadást és azok kezelését is meg kell valósítani egy közös helyen. Első menetben erre a két osztályra lesz szükségünk.

Nézzük ezeket részletesebben.

Szükség lesz (vagy nem?) egy olyan osztályra, ami a tippek tárolására alkalmas. Ezt úgy kell elképzelni mint a fogadó fejében lévő lottószámok, amiket meg szeretne tenni. Tehát semmi más nem jellemzi, csak maguk az ember elméjében létező számokat tartalmazza, amiket vagy megtesz a lottón vagy nem. Tehát ez még nem maga a fogadás ez csak egy tipp. Ahhoz hogy fogadás legyen belőle, ahhoz ki kell tölteni egy lottószelvényt. A kérdés az hogy maga a számsor, ami egyéb más jellemzővel nem rendelkezik azt szükséges-e külön osztályban megvalósítani vagy sem. Elsőnek induljunk el úgy hogy mégse csináljunk ebből külön osztályt.

Tehát a tippet már eleve egy szelvényen kezeljük, mert amíg nem teszik meg a fogadást addig tökmindegy hogy benne van-e valaki fejében öt szám vagy sem.

A lottószelvény osztálynak tárolni kell tudni az öt számot, illetve van egy 7 jegyű egyedi sorszáma amivel majd a joker játékra lehet fogadni. A sorszámot a szelvény létrehozásakor generáljuk. A lottószelvény a sorsolás után lehet nyertes szelvény akkor, ha legalább két találat van rajta. A szelvényobjektumnak a létrehozásakor vagy megadjuk az öt számot amire fogadást kötnek, vagy ha nem akkor generálunk öt számot. Ez tehát kétféle konstruktort jelent (többalakúság). Az hogy egy szelvény nyertes-e, azt egy metódussal fogjuk kiértékelni. Paraméterül adjuk át a kihúzott öt számot és eredményül adja vissza hogy hányas találat van a szelvényen.

Az implementációban az öt lottószám tárolására használjunk egy konténert. Ehhez használjuk a TreeSet tárolóosztályt, aminek az a jellemzője, hogy egy elemet csak egyszer tartalmazhat és az elemeket rendezve tárolja. Természetesen Integer elemekkel dolgozunk. A generálást a Math osztály Random() metódusával generáljuk. Ez a 0 és 1 között generál egy lebegőpontos véletlen számot. Ezt először 1 és 90 közöttivé kell alakítani, majd típuskényszerítéssel (cast) egésszé kell alakítani.

Íme a lottószelvényeket tároló osztály Java forrása:

public class Szelveny {
  private int szelvenyId = -1; //jelöljük így a szelvényt amíg nincs sorszáma
  private TreeSet tippek = new TreeSet();
  private boolean joker = false;

  public Szelveny(){
     //generálni kell 5 különböző számot 1-90 között.
     //Ha egy számot már kisorsoltunk, akkor helyette új kell
     for(int i=1;i<=5;i++){
         int j;
         do 
            j=(int)(Math.random()*89+1);             
         while(tippek.contains(j));
         tippek.add(j);
     }
  }

  public Szelveny(int n1, int n2, int n3, int n4, int n5){
     //paraméterekben megkapjuk a tippeket. 
     //Az hogy a tippek helyesek-e azzal ne foglalkozzunk. 
     //Nem tudjuk hogy mi volt a célja a szelvény kitöltőjének, 
     //had töltse ki ahogy akarja. Majd a szelvény beadásakor 
     //kell eldönteni hogy elfogadjuk-e a tippet, vagy sem.

     tippek.add(n1);
     tippek.add(n2);
     tippek.add(n3);
     tippek.add(n4);
     tippek.add(n5);

  }

  public int kiertekel(int n1, int n2, int n3, int n4, int n5){
     //le kell ellenőrizni az öt számot egyenként.
     //a -1 azt jelenti hogy érvénytelen a szelvény
     int talalat = -1; 

     // érvényes a szelvény ha 5 tippet tartalmaz
     if (tippek.size()==5) talalat++;
     if (tippek.contains(n1)) talalat++;
     if (tippek.contains(n2)) talalat++;
     if (tippek.contains(n3)) talalat++;
     if (tippek.contains(n4)) talalat++;
     if (tippek.contains(n5)) talalat++;

     return talalat;
  }
}

LOTTÓ feladat Javában

Nemrég nézegettem az emelt szintű informatika érettségi feladatokat és ott láttam egy lottózós feladatot. Erről jutott eszembe, hogy csináljak gyakorlásként egy ilyen lottózós példát.
Java-ban fogom megcsinálni, lehet hogy nem egy lépcsőben hanem szépen lépésről lépésre.
Itt fogom blogolni, hátha hasznos lesz valakinek.


Előszöris a feladatot kéne megfoglamazni első lépésben, aztán lehet hogy még pontosítjuk.

Szóval a cél egy lottó szimulátor készítése a következő funkciókkal:

• 5-ös lottó (90-5) feladatról van szó
• Lehessen megadni fogadásokat (akármennyit)
• A fogadásokról készítsen statisztikát (később pontosítjuk hogy mit statisztikázzon)
• Sorsolja ki a nyerő számokat
• Statisztikázza és listázza ki a nyertes szelvényeket.
• Lehessen a lottószelvény sorszámával joker-re is fogadni.
• Sorsolja ki a jokert

Hát egyelőre ennyi feladat lenne. Rengeteg ötlet jut hirtelen eszembe amit még meg lehetne valósítani. (pl. fordított lottó. Először sorsoljon, aztán kezdjen el generálni fogadásokat addig amíg lesz egy 5-ös szelvény, vagy 4-es stb...)

A fent felsorolt pontokból indulok ki és ahogy haladok, blogolni fogom a részfeladatokat... (remélem)

Egy kis retro érzés: Mi és a computer

A minap néztem az M3-at és éppen a számítógépről illetve annak programozásáról beszélgettek. Egy 1983-as ismeretterjesztő sorozat egyik epizódjába botlottam, a címe: Mi és a computer.
Tovább nézve az epizódot mindjárt tudtam hogy valahogy meg kell néznem minden epizódját, hiszen amiről bezséltek, amilyen gépeket és programokat használtak azok pontosan azok voltak amiket én magam is használtam akkor amikor összetalálkoztam az informatikával. A riportokban az akkori kissrácok ugyan azokról a dolgokról érzésekről bezsélnek amit én éreztem és átéltem.
Szerencsére a youtube-on elérhető a sorozat minden része.
A programozni tanulóknak is ajánlom, mert vannak benne feladványok, magyarázatok a programozással kapcsolatosan, gyakran nem is olyan egyszerűek ezek. Meg lehet próbálni megoldani ezeket a feladatokat.
Az egyik ilyen feladat pl az volt hogy egy maximum 10 soros verset elemezzünk és adjuk meg a rímképletét. Izgalmas és nem feltétlenül egyszerű feladat, Oldjuk meg! :)

Programozás oktatás (www.learneroo.com)

A napokban találtam egy weboldalt ahol különféle programozással kapcsolatos oktatóanyagok vannak. Az oldal néhány programozási nyelv mellett főként az alábbi témákat oktatja:

Programozási nyelvek közül az aktuális trendnek megfelelően a Java, JavaScript, Python és Ruby nyelveket oktatja rengeteg rövid, gyakorlati feladatok használatával.

Ami leginkább megtetszett az az, hogy a példák megoldását nem a saját fejlesztői környezetünkkel kell megoldani, hanem az oldalba beépített emulátor segítségével. Kapunk egy "teljes" fejlesztői környezetet, editorral, debugerrel együtt, és ott kell megírni a kért feladatokat, amit a mellékelt tesztadatokon le is futtat.

Nekem nagyon tetszik ez a megoldás.

Az említett programozási nyelvek alapjai mellett algoritmusokat, matematikai problémákat illetve különféle praktikus programozási fogásokat is oktató modulokat is találunk a weboldalon. Ezek alap esetben Java nyelven oldhatók meg, de lehet választani más (PHP, C++, Python stb) nyelvek közül is.

Az oldal nyelve angol. Azt gondolom hogy aki programozásra adja a fejét és komolyan is gondolja azt, annak elkerülhetetlen az angol nyelv értő olvasása. Az oldal nyelvezete egyszerű, minimális nyelvtudással könnyen érthető. Ennyire tudni kell minden programozónak angolul.

Ajánlom az oldalt a kezdőknek és haladóknak egyaránt. A kezdők megtanulhatják az alapokat és még egy picit többet is, a haladók pedig tesztelhetik, frissen tarthatják tudásukat.

Még egy megjegyzés! Az oldal üzemeltetője a kickstarter.com-on indított egy gyűjtést az oldal fejlesztésére. Bárki felajánlhat bármekkora összeget. 4000 dollárt célzott meg ami szükséges lenne az oldal fejlesztésére, jelenleg 406$ van felajánlva. Aki teheti támogassa az oldal fejlesztését.

Helló világ!

Van egy program, amit minden C nyelvet tanulni kezdő ember megír. Ez a Hello world!
A program elhíresült és alap példává vált. Szerintem ez az a  program amit a legtöbben megírnak.
Brian Kernighan és Dennis Ritchie által írt The C Programming Language című könyv a C nyelv bibliájaként ismert. Ezt maguk a nyelv kitalálói írták és a mai napig a leghíresebb C könyv, ami minden programozónak a polcán ott kell hogy legyen, már csak tiszteletből is. Ez olyan mint a gitározásban a Hey Joe Jimmy Hendrixtől. Mindenkinek, aki komolyan gondolja...  :)

Szóval nézzük a példát:

#include
void main() {
       printf("hello world\n");
}

A programot beírjuk egy hello.c fájlba, majd lefordítjuk és futtatjuk akkor a program kiírja  a képernyőre hello world üzenetet.

Tesztnek nem rossz... :)

A C nyelvről

Én a programozást BASIC nyelvvel kezdtem. Ez egy nagyon egyszerű, magas szintű programozási nyelv volt, amivel kényelmesen lehetett megfogalmazni a programokat. A következő az assembly nyelv volt, még Z80 mikroprocesszoros gépeken.
A két nyelv között a különbség abban rejlett, hogy a BASIC nagyon egyszerű és könnyen elsajátítható volt. Rendelkezésre álltak a különféle ciklusműveletek, feltételes vezérlésátadás, szubrutinok írása és hívása. Viszont a nyelv nagyon lassú volt mivel interpretált futtatást (azaz minden programsorra külön értelmezés, fordítás, futtatás) tett lehetővé. Az assembly nyelv nagyon gyors gépi kódú programokat készítését tette lehetővé, ezzel szemben a ciklusszervezést, az utasítások sorozatát mind alacsony szinten kellett megvalósítani, ami sokkal nagyobb hibázási lehetőséget teremtett.
Később a Pascal nyelven folytattam programozói tevékenységemet, amire komoly típusosság volt jellemző és erős szigorral ellenőrzött minden egyes programsoromat.
Van egy számomra misztikus nyelv, a C nyelv, ami gyors is és magas szintűnek is nevezhető, ugyanakkor nagyon "hanyag" lazaság is jellemzi a típusszigorát.. A típusossága nagyban hasonlít az assemblyhez, a mutatók használata - ami a komolyabb programozás alapja - kényelmes. Fordítója kifejlett és gyakorlatilag assembly programot állít elő (a mai fordítók persze ezt a lépést kihagyják, de kikényszeríthető ez a kimenet is). A lényeg hogy ez a fura nyelv, a maga fura gondolkodásával igazi forradalom volt a maga idejében a '70-es évek elején. Akkoriban egy operációs rendszert készítettek a segítségével, mégpedig a Unixot, ami napjainkban is hihetetlen népszerű, hatékony és biztonságos operációs rendszer. Erre azért felkapja egy programozó a fejét. Operációs rendszert írni magas szintű nyelven? Hmmm.
Ez aztán a csemege. Így találkoztam a C nyelvvel. Akkoriban én a Pascal mellett döntöttem, mint általános célú programozási nyelv mellett. A C-be csak az egyetemi tanulmányok kapcsán merültem bele.
Szóval most elkezdenék egy újabb témát itt a Programozz! blogon. Ez pedig a C nyelv használata lesz.
Nem akarom bemutatni a különféle agyafúrt C-s pointerezést, meg az előfordító adta csodás lehetőségeket (írtak C-ben PC emulátort is, aminek forráskód hossza belefért 2000 karakterbe). Egyszerűen alapszintű megoldásokat, alap programozási feladatokat szeretnék bemutatni a segítségével.
A cikkeket a C címkével jelölöm.

Tojásrántotta algoritmusa

Az alapvető gondolkodásmód elsajátításához egy hétköznapi példa következik!
Mint korábban már többször írtam, jót tesz a megfelelő gondolkodásmód kialakításához az, ha hétköznapi tevékenységeket is "algoritmizálunk". Ennek érdekében, most tojásrántottát fogunk készíteni!

Tojásrántotta készítése

Kérdezzük meg hány tojásból készítsük a rántottát! Nézzük meg van-e annyi tojásunk, ha van akkor készítsük el, ha nincs akkor pedig jelezzük hogy nincs ennyi tojásunk.

Be: Hány tojásból készüljön?

HA van elegendő tojás AKKOR
   Törjük fel a tojásokat és tegyük tálba
   Verjük fel a tojásokat

   CSINÁLD
        Melegítsünk olajat
   AMÍG olaj eléggé forró

   Öntsd a tojást a forró olajba
   
   CSINÁLD
       Lassan kevergesd a tűzön
   AMÍG megfelelően megsül

   Tedd tányérba
   KI: A rántotta kész! Jó étvágyat

KÜLÖNBEN
   KI: Nincs ennyi tojás így sajnos nem tudom elkészíteni!

Csodálatos algoritmus! Egy nagy szelekció fogja keretbe az algoritmust (van-e elegendő tojás?) Majd a szekvenciák sorozata következik, közben két iterációval, ráadásul hátultesztelőkkel (olajmelegítés, sütés)

Erről jut eszembe egy vicc!
A programozót elküldi a barátnője boltba a következő utasítással:
- "Drágám! Menj el a boltba! Hozzál halat, ha van tojás akkor tízet!"
A programozó elmegy a boltba, majd miután bevásárolt hazajön és odaadja kedvesének a táskát, benne a bevásárolt dolgokkal. A barátnője megnézi, majd megkérdezi:
- "Miért hoztál tíz halat? És hol a tojás? Vagy az nem volt?"
- "De volt!" - mondja a programozó!

:)

Szóval a programozó mindig úgy végzi el a feladatot, ahogy az meg van fogalmazva. Abból baj nem lehet..... Legfeljebb át kell fogalmazni a feladatot, ha nem a megfelelő eredmény születik!
Gondolkozz el ezen! Hogyan kellett volna mondani a barátnőnek, hogy megértse szerencsétlen programozó, hogy mit is akar tőle a kedvese?

Legnagyobb szám kiválasztása

A következő bejegyzésben egy egyszerű algoritmust készítek el. A cél, hogy megmutassak egyfajta gondolkodásmenetet.
Elvárt ismeretek: adatbekérés, kiírás, összehasonlítás, elágazás, iteráció

Feladat: A bekért pozitív számok közül írassuk ki a legnagyobbat!

Az adatbekérést nem ellenőrizzük, feltételezzük hogy egész számokat kapunk. Feltételezzük hogy nem kell megjegyezni az összes bekért adatot.

Olvassuk el és értelmezzük a feladatot.

Mit csinálunk? Bekérünk számokat.

Mi lesz ezekkel a számokkal? Kiíratjuk a legnagyobbat.

Ez eddig elég egyszerűnek hangzik, de gondoljunk bele egy picit mélyebben. 

Hogyan határozzuk meg a legnagyobbat? Nyilván összehasonlítással.

Sorra kell vennünk az adatokat és a nagyobbat megjegyezve ismételni az összehasonlítást addig, míg az összes adatot égig nem vettük. 

Éppen ezt a tevékenységet kellene programozni!

1. az aktuális legnagyobb számnak jegyezzük meg a 0 értéket. Ennél csak nagyobbakkal kell foglalkozni.
2. Kérjük be a soron következő számot.
3. hasonlítsuk össze az aktuális legnagyobb számmal
4. ha nagyobb mint az aktuális legnagyobb, akkor felejtsük el az eddigi legnagyobbat és helyette jegyezzük meg az éppen soron lévőt legnagyobbként.
5. ha van még további bekért szám akkor vegyük a következőt és folytassuk a 2. pontnál
6. írassuk ki a megjegyzett legnagyobb számot.

Hát ennyi a teendő. Kész a program, jöhet a kódolás.
Először célszerű valamilyen szabványos általános jelölésrendszert alkalmazva a programot leírni. Később már erre nem lesz szükség egyszerűbb feladatnál, de most tegyük meg.
Picit pontosítani kell a feladatot. Honnan tudjuk, hogy van-e még további kiértékelendő szám? A feladat kiírásában az szerepel, hogy pozitív számokkal kell dolgozni. Ezért most hozunk egy olyan döntést, hogy ha 0-át kapunk kiértékelésre, az azt jelenti hogy nincs több kiértékelendő adat.
(Itt jegyzem meg, hogy az ilyen döntéseket mindig egyeztetni kell a megrendelővel és azt el kell fogadtatni vele, hiszen ő tudja hogy pontosan mit is szeretne megvalósítani!)
Ezzel a döntéssel már elkészíthető az alkalmazás.

Az adatmodell és a pszeudó nyelvű megoldás:

A REPEAT...UNTIL iteráció úgynevezett hátul tesztelő ciklus. Ez azt jelenti, hogy a ciklusmag lefutása után értékelődik ki a ciklus feltétele. Tehát a ciklusmag legalább egyszer lefut. Az UNTIL után megadott feltétel a kilépés feltétele.

Írjuk meg Pascalban ezt a feladatot:

Ennyi volt a legnagyobb számot kiírató programocska.
A feladat elején megfogalmazott ismeretek birtokában elkészíthetők az alábbi módosított feladatok is! A feladatok egyre összetettebbek, de mind megoldható szelekcióval és iterációval.
Próbálj ezek közül minél többet elkészíteni pszeudó nyelven és az éppen tanult programnyelven is (C/Pascal)
Ha elküldöd emailen a megoldást, szívesen véleményezem!

Írd át a programot, hogy kiírja a legnagyobb és a legkisebb számot is!
Írd át a programot, hogy kiírja azt is hogy hány szám lett összesen megadva!
Írd át úgy a programot, hogy pozitív számok mellett a 0 is szerepelhessen input adatként!
Írd át úgy a programot, hogy összesen 10 adatot kell bekérni és azok közül kiválasztani a legnagyobbat stb...
Írd át úgy a programot, hogy először megkérdezi, hogy hány adatot szeretnék megadni és fogadjon el negatív számokat is.

  

Programnyelvek, programozás őstörténete

Minap egy antikváriumba, megláttam egy FORTRAN programozással kapcsolatos könyvet, mely kiadásának dátuma 1970 volt. Eltöprengtem azon, hogy a könyv egy évvel idősebb nálam. Azt tudom, hogy a számítógép programozás nem éppen újkeletű dolog, de azt hogy magyar nyelvű szakirodalom már ilyen korán megjelent, nem gondoltam. (messze a PC-s korszak még, szűk réteg aki számítógéphez fér)
A könyv akkor 12 Ft volt most 275 Ft-ot kért érte az antikvárium. Gyorsan körülnéztem még és végül megvásároltam néhány régi, programozási nyelvekről szóló szakkönyvet.

Mindig is érdekeltek a különféle programozási nyelvek. Nem maga a hatékonyság, vagy a használhatóság az ami felkeltette az érdeklődésemet, hanem magának a nyelvnek a logikája, működése, szintaktikája. A régi nyelvek meg azért érdekesek, mert látni lehet a fejlődést, ahogy egyik a másikból építkezve egy újat - talán jobbat - hoz létre. Nem ismerem a régi nyelveket. BASIC majd PASCAL voltak a tanulónyelveim. Mellette kis gépikód és Assembly is adódott. Utána megismerkedtem a dBase/Clipper nyelvekkel, amik az adatbáziskezelési feladatokhoz voltak nagyszerű eszközök, majd jött a C és végül az obejktumorientált progrmaozás a JAVA, a C++ és a C# nyelveken keresztül.
Most elhatároztam hogy meg fogok ismerkedni néhány régi programozási nyelvvel. Nem feltétlenül azért, hogy használjam, hanem hogy megismerjem a programozás történelmét.

Szeretem a régi szakkönyvek előszavait, bevezető fejezeteit olvasni, mert sok érdekesség van benne. A FORTRAN könyvben is találtam egy érdekes gondolatot a programozással kapcsolatban:

"...nem a programozási nyelv oktatásáról van szó, hanem a programozási nyelvnek mint eszköznek a felhasználásával a megfelelő szaktudomány oktatásáról."

Itt arra utal a szerző, hogy egy programozási nyelv oktatása, megismerése nem azonos a programozás szaktudományának oktatásával, megismerésével.
Később ezt írja:

"A lényeges különbség a hagyományos oktatási módszerrel szemben itt az, hogy az egyes eljárásokat nem csak formulák hanem egyúttal programok formájában is megfogalmazzák. Ehhez természetesen elkerülhetetlen valamelyik konkrét algoritmikus nyelv ismerete, azonban a hangsúly nem ezen van. Ennek az  oktatási módszernek előnye, hogy a numerikus ismereteken túlmenően kifejleszti a hallgatóban az "algoritmus teremtés" készségét, amelyre egy holt képletnek élő programmá való "átvarázsolásához" van szükség. Tulajdonképpen ez az amit programozásnak nevezünk." (Lőcs-Vigassy FORTRAN programozási nyelv 6. oldal)

A gondolat nagyon sokatmondó! A Programozz! blog bevezetőjében említettem hogy ki kell alakulnia az algoritmikus gondolkodásnak ahhoz, hogy valaki tudjon programozni. Írtam ugyan itt, hogy sokan azt mondják: "Pascalban ezt simán megírom, de C-ben nem megy!"
Nos aki ezt mondja azzal az a helyzet, hogy sajnos nem tud programozni. Tud "pascalul", de nem tud programozni. Ismeri a nyelvet és az használja is, de nem tud algoritmust alkotni. Ez nagy baj! Egy programozónak a nyelv "csak" egy eszköz. A holt képletek élő programmá történő átvarázsolásához ennél több kell és ezt hívják programozásnak.

Még egy érdekes dolog, amit a könyv elszavát olvasgatva érzek. A programozás mérnöki feladat, a kódolás szakmunka. Például annak idején a programozói tevékenység nem terminál előtt zajlott, hanem programkártyákon kézzel, ceruzával írta meg a programozó a programot, majd ezt átadták a kódolónak, aki a megfelelő módon bevitte a gépbe és elkészítette a lyukkártyát, amin a betölthető programok voltak.

A példa nem teljesen "ül", hiszen itt gyakorlatilag a kódoló gépi kódra fordította (compiler) át a FORTRAN programot. Manapság a kódoláson azt értjük, hogy adott programnyelven leírunk egy algoritmust.
Ha belegondolunk mégiscsak helyes a hasonlat. Aki kódol, az egy működő modellt valósít meg. Aki programozik az magát a modellt készíti el. A kettő a programozás mai értelmében összeolvad és egyben jelenti az algoritmizálási képesség és egy programnyelv ismeretét, de a kettőt külön kell tudni választani ahhoz, hogy programozni tudjunk! Először algoritmust tervezünk, majd lekódoljuk valamely programnyelven.

Ez az átvarázsolás lesz az,  amit a programozónak tudnia kell, különben csak egy ócska bűvésztrükk betanulására és többé kevésbé sikeres bemutatására lesz képes...