Első lépésként lehet érdemes lenne tisztázni, valójában mi is a programozás.

A Wikipédia szócikk nem ad túl sok támpontot nekünk, mivel:

Számítógép-programozás (vagy egyszerűen programozás) egy vagy több absztrakt algoritmus megvalósítását jelenti egy bizonyos programozási nyelven. A programozásban megtaláljuk a művészet, a tudomány, a matematika és a mérnöki tudomány elemeit.

Hát köszi a semmit internet! 

Az én, egyszerű, konyhanyelven megfogalmazott változatom egyáltalán nem szofisztikált:

A programozás a számítógépnek adott utasítások sorozata.

Persze ez is kicsit amolyan "nesze semmi, fogd meg jól", de azért emberközelibbnek érzem. Ugye mindenki látott már programkódot? Forráskódot, akár hekkeres filmben, havernál, stb, pl ilyen kódrészletet:

Ez tökre jól néz ki, mert színes, tele van krikszkraksz karakterekkel, és még a kép is meg van döntve, úgyhogy nagy valószínűséggel valami totttttttttális mágia van mögötte.

Ha írtál már bármilyen programot, akkor tudod, hogy ezek szépen egymás után írt parancsok, amiket a számítógépünk értelmez, és végrehajt. 

Itt jön be egy kis csavar a képbe, mert azt már sokan hallottuk, hogy a számítógép nem tud mást, mint 1-eseket, meg 0-kat, meg rengeteg számot feldolgozni. De akkor most mi köze is van a fenti kódban látható "function"-öknek, "return"-öknek, "false"-oknak, meg egyeknek az 1-esekhez, és a 0-khoz?

Egy kis történelem

Az 1950es években a "számoló" gépek (értsd: computer) még egyáltalán nem voltak olyan általános célúak, mint manapság. Egyszerűen megfogalmazva: egy gépet eleinte egy feladatra építettek. Ha bármilyen más számítási feladatra akarták használni, mint amire tervezve lett, gyakorlatilag át kellett huzalozni az egész masinát, vagy egy újat csinálni.

Természetesen hamar rájöttek, hogy ez így nem túl hatékony. Jobb lenne, ha ezt az áthuzalozást, átkötözgetést egyszerűbben is meg lehetne valahogy oldani, hogy ne kelljen mindig mindent szétszerelni hozzá. Erre megszülettek különféle találékony ötletek.

Az alábbi képen a Szegedi Számítástechnikai Múzeum egyik orosz csodája látható: (sajnos a tábláját nem fotóztam le, így a nevét nem tudom)

A belsejébe be is lehet nézni, és ott szemünk elé tárul ez az iszonyú látvány:

Mivel ez még a mikroprocesszorok megjelenése előtt volt, szépen látszik, hogy itt bizony nem volt mese. Minden kábelekkel van megoldva, amit manapság már simán belezsúfolunk egy tűhegynyi chipbe.

Ám de itt már látszik, hogy a sok felesleges átdrótozást meg akarták könnyíteni, így a gép elejére került egy "kapcsolótábla", sok kis lyukkal, ahol ezeket az (át)kapcsolásokat, áthuzalozásokat rövid kábelekkel, "kényelmesen" meg lehetett oldani:

Lagalábbis ez sokkal kisebb munka volt, mint többezer új kapcsolást létrehozni. 

Megtörténtek hát az első lépések a számítógépek programozhatósága felé, de még mindig hátra volt egy elég fontos dolog. Iszonyatosan lassú a munka a géppel, ha egy embernek ott kell állnia, és drótozni egész nap.

Ez még mindig nem igazán hatékony.

Mi lenne ha csinálnánk sokféle általános célú kapcsolást belülre, amik bármikor újrahasználhatók, például két szám összeadása, kivonása, szorzása, stb. Ezeket a műveleteket számozzuk meg, és a megfelelő szám megadásával lehessen őket aktiválni. Mondjuk pl 1=összeadás, 2=szorzás, stbstb.

Így már az adott szám aktiválta a megfelelő, előre meghatározott kapcsolást, és nem kellett banándugókkal macerálni. És bár sokkal kényelmesebb volt az utasításokat egy bazinagy számlapon bepötyögni, vagy épp mindenféle kapcsolókkal, de erre is hamar rájöttek, hogy ez még bizony mindig nem túl emberközeli. Lehetne ezt egyszerűbben is.

Ha ezeket az számokat (utasításokat) tároljuk valamilyen memóriában, és mondjuk a gép magától képes beolvasni mindig következőt, és végrehajtani, akkor máris sokat könnyíthetünk az életünkön. Ezeket az utasításokat így elég egyetlen egyszer megírnia egy embernek, és onnantól a gép képes önállóan működni bármikor. Ha épp olyan kedvünk van, írhatunk másféle utasításokat is, és akkor a gép más funkciókat láthat el.

Ezt a sok számot eltárolhatjuk lyukkártyán, vagy mágnesszalagon, és bármikor elővehetjük. Hát nem nagyszerű?

Megszülettek hát az első programok, és mindenki boldog volt. Vagyis majdnem mindenki.

Ugyanis ezek a programok (utasítássorozatok) még mindig nem voltak mások, mint hosszú számsorozatok. Hiszen a gép semmi mást nem ért meg, mint a számokat. Minden számnak megvan a maga jelentése, hogy mit is kell csinálnia a gépnek.

Ez manapság is így van, a legfejlettebb, leggyorsabb processzorok sem képesek másra, mint egy adott számmal jelzett utasítás végrehajtására.

Ezeknek a számoknak a sorozata a gépi kód, az egyetlen dolog mind a mai napig, amit egy mikroprocesszor megért. Nevezik még bináris kódnak, bináris futtathatónak, ami a  "binary executable". Gyakorlatilag ugye az EXE, amire a windowsban rákattintunk, és a program elindul.

Mivel az emberi agy nehezen dolgozik számokkal, ám de sokkal könnyebben szavakkal, így magától adódott, hogy életük megkönnyítése érdekében az akkori mérnökök kitaláljanak maguknak egy emberbarátibb jelrendszert. Minden ilyen számkód (utasítás), kapott hát egy pár betűből álló "nevet", úgynevezett mnemonicot, amit sokkal könnyebben megjegyeztek.

Tegyük fel, hogy be akarunk olvasni egy számot a 123-as memóriacímről, és hozzáadni 10-et. Jelenlegi egyszerű, fiktív példánkban a következő számsorozat egy program, amiben

• a memóriából beolvasás utasítás a 163-as kód
• ezt koveti a memóriacím ahonnan adatot akarunk kiolvasni, ez a 123
• az összeadás utasítása mondjuk a 42
• a hozzáadandó szám pedig a 10

(Ez a kis program természetesen még nem írja ki sehová a végeredményt, csak egy rettenetesen leegyszerűsített példa)
Tehát a számok sorozata, amit a processzorunk látni fog:

Ugye már jojózik tőle az agyad? Na de ha az utasításokhoz ilyen mnemonicokat rendelünk, és megegyezünk, hogy a LOAD az 163-as számot jelent, az ADD pedig 42-t, akkor máris az emberi szemnek kellemesebb módon tudjuk leírni ugyanazt:

Ezt már azért egy angolul minimálisan értő ember is el tudja olvasni, és első ránézésre fel tudja fogni, hogy mit is csinál ez a kis programrészlet. Az átalakítása a számítógép számára is értelmezhető kódra pedig nagyon egyszerű, csak visszacseréljük a LOAD-ot a 163-ra, az ADD-ot 42-re és kész a futtatható program.

És itt megszületett az assembly nyelv.

Az assemblyt alacsony szintű (low level) programozási nyelvnek hívjuk, mert gyakorlatilag a processzor közvetlen vezérlése, nagyon alapszintű utasításokkal. Nyelvnek hívjuk, hiszen ez már közelebb áll az emberi nyelvhez, mint a számok sorozata. Értelemszerűen itt már szükségünk van egy fordítóprogramra, ami ezeket a mágikus szavakat kicseréli a nekik megfelelő számkódjukra. Ez az assembler. Az assembler programok eleinte csak az egyszerű mnemonic->számkód fordítást végezték, manapság már ezek is jóval fejlettebbek, rengeteg beépített kényelmi funkcióval. 

De hogy jön ide a JAVA és a többiek?

A fejlődés következő lépése az volt, mikor kitalálták, hogy bizony vannak vissza-visszatérő feladatok, amiket felesleges többször megírni gépi kódban/assemblyben, pl egy szám kiírása a képernyőre, nyomtatóra, vagy egy adat beolvasása szalagról, vagy bekérése a felhasználótól, stb.

Ezek jópár, akár 50-80 vagy 200 utasításból álló sorozatok is lehettek, kellett valami még emberközelibb. Megszülettek hát a magasszintű programozási nyelvek, ahol ha a programozó leírta, hogy PRINT, akkor végrehajtódott a megfelelő, előre megírt utasítássorozat, és a gép kinyomtatta a megadott szöveget.

Természetesen ehhez kellett egy program, ami értelmezte a PRINT parancsot, és lefordította a megfelelő számok sorozatára. Ez volt kezdetben az interpreter, később a compiler, de ebbe már nem megyek bele mélységeiben.

A magasszintű programnyelvek fejlődésével egyre kényelmesebben programozhatóak lettek a gépek, viszont nagy hátrány, hogy a könnyű programozhatósággal együtt nőtt ezen rendszerek fordítóinak bonyolultsága is. Így a végső, lefordított bináris kód mindig hosszabb, és lassabb volt, mint amikor egy ember leült, és megírta azt az adott feladatra optimalizáltan.

A legtöbb manapság használt informatikai rendszerünkön már persze totál értelmetlen, és elképzelhetetlenül hosszú idő lenne csak assemblyben fejleszteni bármit is. Nagyon nem lenne hatékony, és igen nagy rutinnal rendelkező programozókat igényelne. Általában speciális helyzetekben azért használják még, ahol pl elvárt a lehető legnagyobb sebességű futás, vagy esetleg nagyon kicsi a rendelkezésre álló memória. Pl specializált hardverek, robotika, stb.

Röviden össszefoglalva, a ma használt magasszintű programnyelveken leírt, ember számára is értelmezhető szövegből (a forráskódból) egy fordítóprogram előállítja a végleges bináris számsorozatot, amit majd a processzor végre tud hajtani. Innen ered a "forrás"kód elnevezés egyik része, a "kód" pedig a fent említett, hosszú számok bepötyögésének idejéből ránkragadt szó. Csakúgy mint a "kóder", és a "kódolás" kifejezés is.

Fun fact: Képzeld el, amikor a fenti képen lévő orosz szupermasina belsejébe bemászik egy bogár (bug), és véletlenül rövidzárat okoz valahol a kábelek között. Innentől indulhat a bogártalanítás hosszú, és kellemetlen folyamata, amit ma "debugging"-nek nevezünk :) 

Az első ismert dokumentált bug 1947 szeptember 9-én, a Harvard Egyetem MARK II számítógépében:

Ui.: Ha a fenti hablaty nem érdekel, vagy esetleg nem volt egyértelmű, cseppet se aggódj, olvasd el a következő részt. Ja, és ne pánikolj, meg don't foss 😉