Mi a szoftver fogalma?

Néhány héttel ezelőtt a hardveres lecke kapcsán szóba került Ritával köztünk, hogy tulajdonképpen hogyan is lehetne megfogalmazni egy mondatban a szoftver fogalmát.
Én már ezen, mint szoftverfejlesztő elég sokat gondolkoztam, és arra jutottam, hogy tökéletes megközelítése nem létezik a dolognak. Mert ha vesszük a különböző fájlokat, akkor azokról egyértelműen nem lehet eldönteni, melyik számít programnak, és melyik egyszerű adatnak. (Ez már csak azért is igaz, mert ez a modern informatika egyik alap tétele)

Szóval, ahogy erről filozofálgattunk, felmerült, hogy jól illene a lecke-sorozatba egy külön a szoftverekről szóló lecke is. Így én el is vállaltam a megtisztelő szerepet, hogy megírjam ezt a leckét. Megpróbáltam minél emberibb nyelven leírni azt, amit a mai modern számítástechnikában fontosnak tartok tudni a szoftverekről.

Nos, kedves kíváncsi olvasóm, akkor, ahogy a harcias sebészek mondják: Vágjunk bele!

Programok, készítőik, és gazdáik
Először is, engedd meg, hogy bevalljam egy nagy hiányosságomat: A fenti kérdésre, azaz, hogy hogyan lehet megfogalmazni a szoftverek fogalmát egy mondatban? Én sem tudom a választ. Jó tudom, most azt gondolod, “szép kis szoftverfejlesztő lehetsz…” :-), de az az igazság, hogy eddig bármilyen megfogalmazást is kaptam rá, valahol hibázott. Hogy miért van ez így?

A válasz abban rejlik, hogy alapvetően nincs különbség adat és program között. Ez egy alap tétel, és abból adódik, hogy alapvetően szinte minden program, amit a számítógépen lehet futtatni az valamely másik programtól függ.
Nem szeretnék nagyon a mélyére menni a dolognak (ez ennek a leckének az 5.-ik verziója, és az előző négyben olyan mélyre mentem, hogy sosem bukkantam elő 🙂 ) legyen elég annyi, hogy az operációs rendszertől az összes felhasználói program függ. (Erről lesz majd szó még.)
Viszont az operációs rendszer is függ a gép architektúrájától, és a BIOS-tól. (BIOS – Basic Input/Output System bővebben: –> hardveres lecke) Ez azt jelenti, hogy alapvetően nincs olyan program, amely környezetfüggetlen lenne, így gyakorlatilag az összes program adat, amelyek csak úgy tudnak működni, ha a környezet megfelelő, és a vezérlő rendszer feldolgozza őket, mint adatokat. És azt pedig, hogy milyen adatok dolgozhatóak fel megint csak a környezet dönti el.

Tehát bár ebből a magyarázatból nehezen érthető miért, de arra lehet jutni, hogy a programok tulajdonképpen mindaddig, míg megfelelő környezetben megfelelő vezérlőrendszerekkel nem értelmezik őket, addig puszta adatok. És bár ez sem ilyen egyszerűen következik, de a puszta adatok is bizonyos környezetben bizonyos vezérlőrendszerek által értelmezve programokká változnak.

Erre legjobb példa ez a szöveg. Ha puszta adatként kaptad volna, és nem a leveleződdel, vagy a böngésződdel nyitod meg, akkor most mindenféle HTML (HTML – HyperText Markup Language az interneten használt szövegkezelési leíró nyelv) formázási kódokat látnál benne. Sőt nem megfelelő kódtábla használata esetén érthetetlen karaktereket az ékezetek helyén.

De tovább megyek, ha pusztán adatként kezelnéd minden alapvető feldolgozás nélkül, akkor csak számokat látnál, amik a karaktereket definiálják. És még mehetnék tovább egészen a bináris számokig (amelyeket tulajdonképpen nem is láthatnál, hiszen ha megjeleníted, akkor az is egyfajta értelmezés). Tehát ebből látszik, hogy a program és a puszta adat közt tulajdonképpen nem csak elmosódott a határ, hanem egész egyszerűen nincs is.

Figyelem, innentől mély víz csak úszóknak… 🙂
Ok, de valahogy mégis meg lehet különböztetni a programokat az adatoktól, nem? – kérded. Alacsony szinten, azaz közelebb a gép értelmezési szintjéhez a válasz nem. De magasabb szinten, azaz közelebb az ember értelmezési szintjéhez, a válasz a talán. És egészen emberközelileg azt lehet mondani, hogy határozottan igen. Lehet válogatni. 🙂 Az elsővel nem foglalkoznék, egyrészt, mert már az előbb nagy vonalakban volt róla szó, hogy miért, másrészt, mert egészen az alapoktól kéne kezdenem felépítenem a magyarázatot. (Amit viszont kevesen értenének, és még kevesebben lennének rá kíváncsiak) A második válasz azért lett a talán, mert ha eltekintünk attól, hogy minden a környezettől, és a vezérlőrendszerektől függ, akkor mondhatjuk, hogy azok az adatok tekinthetőek programnak, melyek, ha rájuk kerül a vezérlés, közvetlen módon vezérlik a számítógép processzorát. (Processzorról bővebben szintén hardveres leckében olvashatsz)

Ez egy jó megközelítésnek számít, viszont van vele egy kis gond. Mégpedig, hogy már az “ősidőktől” kezdve léteznek olyan programok, amelyek közvetlen módon nem nyúlnak a processzorhoz, mégis egyértelműen programoknak kell őket tekinteni. Ezek mára jóval nagyobb számban használatosak. (Ennek okaira is ki fogok térni.) Ezek az úgynevezett interpreteres programok.

Ezen programok csak úgy képesek működni, hogy egy interpretert használnak (Interpreter – értelmező, egy olyan program, amely adott típusú kódot értelmez, és annak utasításait úgy továbbítja a processzor felé, mintha azok a saját utasításai lennének) ezek a programok közvetlenül nem tudják kezelni a processzort, mégis programoknak tekintjük őket. A harmadik válasz pedig azért igen, mert elvonatkoztatva a fizikai hardvertől tekinthető egy szoftver is feldolgozó egységnek, azaz processzornak, vagy még inkább virtuális gépnek.

És ha így tekintjük a dolgokat, akkor az összes interpreter tekinthető egyfajta virtuális gépnek, és így már mondhatjuk, hogy az olyan adatok, a programok, amelyek közvetlenül kezelik a gép processzorát. (És az mindegy, hogy a valós, vagy a virtuális gépét.) Persze ez az utolsó megközelítés sem tökéletes, mert manapság már vannak olyan vezérlő rendszerek is, amelyek a valós gépet és a virtuális gépet “összekötik” egy-egy program futtatásához.

Ma amúgy az interpreteres technológiának a két zászlóshajója a Java, és a .NET, és szerintem egyértelműen kijelenthető, hogy ezek fogják hamarosan meghatározni az informatikát, és a “hagyományos fordítóprogramos” rendszerek szép lassan eltűnnek majd. (A miértjéről még lesz szó) Most az informatikában járatosak biztosan le szeretnék törni a kezem, mert olyat mertem leírni, hogy a .NET interpreteres, holott nem is. (Na jó, az informatikában nagyon járatosak. :-)) Igen, a .NET egy furcsa állatfajta, ugyanis ez a rendszer keveri a “hagyományos” fordítóprogramos rendszert, és az interpreteres rendszert, így alkotva meg a JIT fordítós rendszert (JIT – Just In Time).

Amelynek a lényege, hogy a programok bizonyos részeit futásidőben az adott környezetnek megfelelően a processzor számára értelmezhető kóddá fordítja, és nem interpretálja, bizonyos részeit viszont a beépített interpreterrel értelmezi, annak függvényében, hogy előreláthatólag a program futása során melyik programrészlet fog többször futni, és melyik kevesebbszer. És mindezt azért teszi, mert a puszta interpreteres futtatás jóval lassabb, mint a közvetlen hardveres feldolgozás. (Már csak az utasítások konvertálása miatt is) Ebből következhet a jogos kérdésed, hogy akkor miért használnak interpreteres technikát? (Nyugi, nem remélem, hogy ilyen egyértelműen következik ez a kérdés, csak össze akartam kötni a következő résszel ezt. 🙂 )

A válasz egyik fele az, hogy a programozók dolgát könnyíti. Két okból. Az egyik, hogy így nekik ahhoz, hogy a programjuk több operációs rendszeren, többfajta számítógéptípuson is fusson, a hagyományos módszerrel minden operációs rendszerhez, és minden platformhoz (platform – számítógép típus) újra, és újra át kell írniuk szinte az egész programot az alapoktól. Ebből következően, nem csak hogy mindenen többször dolgoznak, de a programok verziói is eltérőek platformonként és operációs rendszerenként.

Arról nem is beszélve, hogy ez rengeteg tanulási folyamatot, és időt jelent. Hiszen az egyik operációs rendszeren megírt program bizonyos utasításai nem léteztek egy másik operációs rendszerben. Vagy például a normál PC-re megírt programban használt lebegőpontos számokon végrehajtott műveletek nem működnek egy jóval kisebb teljesítményű kézi számítógépen, mert mondjuk annak processzora nincs felkészítve az ilyen műveletekre. És még sorolhatnám.

A lényeg, hogy ezeket a problémákat egy csapásra oldja meg az interpreteres technika. Azaz egy forráskód -> egy fordítás -> egy program -> több platform -> több operációs rendszer. A másik ok, hogy a modern interpreteres rendszerekkel sokkal könnyebben implementálhatóak a szerver-kliens applikációk. Hiszen ugyan abban a környezetben, ugyan azon a programnyelven fejleszthető a szerveren futó program is, és a klienseken futó programok is. Arról nem is beszélve, hogy ezek a rendszerek készen biztosítanak olyan rendszereket, melyekkel jóval könnyebben oldható meg például a kommunikáció a két program között.

Visszakanyarodva a kérdéshez, a válasz másik fele, hogy a felhasználók dolgát könnyíti. Hiszen nagyon sokáig az volt az alapvető probléma, hogy a hasonló feladatú programok által készített állományok egymás számára értelmezhetetlenek voltak. Ez két eltérő platform, és operációs rendszer esetén fokozottan így volt/van. Ennek egyik megoldása, hogy platformfüggetlen, és operációs rendszer független programokat használunk, amik mindenhol ugyan azok. Ez viszont jelenleg szinte csakis kizárólag interpreteres programok esetében lehetséges. (A másik megoldása, amit szintén alkalmaznak, hogy egységesített fájltípusokat használnak, ilyen például az XML fájlstruktúra).

És természetesen a felhasználókra is igaz, hogy ha minden platform, és operációs rendszer alatt ugyan azt a szoftvert használhatják, akkor nem kell megtanulni egy feladat elvégzéséhez 5-10 szoftvert használni. Innen talán már nem olyan nehéz belátni, hogy miért gondolom, hogy ezek a rendszerek ki fogják szorítani a hagyományos rendszereket. Aztán, hogy ez jó, vagy rossz, az attól függ, hogy mennyit nyerünk a dolgon, egy biztos, némi teljesítmény csökkenést veszítünk.

Jó, most pedig lássuk a rendszert, amitől az összes többi program függ, még az interpreter is.

Operációs rendszerek:
Először is engedd meg, hogy eloszlassak egy tévhitet az operációs rendszerekkel kapcsolatban. Az operációs rendszer, nem az, ami szép ablakokat rajzol, meg hátteret, meg indítóképernyőt, sőt még csak nem is az, ami a fekete háttérre szövegeket ír induláskor. Az operációs rendszer mindezen rendszerek alatt működik, és tulajdonképpen működése közben nem kommunikál közvetlenül a felhasználóval. Az operációs rendszer feladata, hogy az operatív tárat, azaz a fizikai memória (lásd. hardver lecke) menedzselését elvégezze, a hardvereszközöket alacsony szinten kezelje, és azokhoz megfelelő interfészt biztosítson a futó programok számára, illetve, hogy a háttértárakat kezelje.

Ezen műveletekhez természetesen hardveres segítséget kap, a BIOS “személyében”. Minden más, amit az operációs rendszerhez adnak (hogy azért használni is lehessen valamire 🙂 ) csak kiegészítő programok, amelyek olyan feladatokat látnak el, melyek már nem feladatai egy operációs rendszernek, de ahhoz, hogy a mezei halandó felhasználó is tudjon vele dolgozni nélkülözhetetlenek.

Nem tudom, mennyire meglepő számodra, (remélem nem nagyon) de a nagy ablakos óriáson (Windows) kívül is léteznek operációs rendszerek. Általánosságban azt lehet mondani, hogy kétféle operációs rendszer létezik, az egyik a PC-DOS-ból, a másik pedig a UNIX-ból “fejlődött ki”. Ennek megfelelően a Windows összes verzióját DOS alapú operációs rendszernek, és nagyjából azt lehet mondani, hogy az összes többit pedig UNIX alapú rendszernek nevezzük. 🙂 Nem szeretnék sugallni semmit, de a unix alapú rendszerekből csak néhány nagyobb név: AIX, MAC OS, Solaris, Linux, Free BSD. Amelyeket mind különböző cégek, és szervezetek készítenek. (És például Linux disztribúcióból szinte megszámlálhatatlanul sok van.)

Miért van ez így, és mégis miért használják többen a Windows-t?
Először is a kérdés második feléhez hozzá kell tenni, hogy ez csak az otthoni felhasználók esetében igaz. (Szervereken nagyobb részt Linuxot vagy más unix alapú rendszert használnak.)
Nos, ez azért van így, mert egyrészt a unix felépítése lehetővé teszi, hogy hálózati feladatokra használják jóval nagyobb biztonság mellett, mint a dos alapú rendszerek esetében. A unix bizonyos értelemben erre lett kitalálva, és a fent említett rendszerek készítőinek pont erre az előnyre volt szükségük.

A dos alapú rendszerek alapvetően egy felhasználó kiszolgálására lettek kitalálva, és a Windows első megjelenésétől kezdve tulajdonképpen ennek az egy felhasználónak a munkáját kívánták megkönnyíteni. Mégpedig úgy, hogy felhasználóbaráttá alakították a rendszert. Ami azt jelenti, hogy a rendszer használatához elvileg nem szükséges komolyabb felkészültség. Ez mai szemmel annyira nem egyértelmű, de ha figyelembe vesszük, hogy egy alap unix rendszer esetében mondjuk egy szövegfájl megkeresése a tartalomban lévő szó alapján, már programozási ismereteket tételez fel, akkor nyilvánvalóvá válik, hogy a saját gépen megnyomott F3 nem ugyan az a kategória. 🙂

Tulajdonképpen ez a magyarázata, hogy az otthoni környezetekben a Windows terjedt el inkább. Manapság természetesen már a unix alapú rendszerek többsége is felhasználóbarátabb, mint régen volt. Sőt némelyikük már ebben is megelőzte a Windows-t, viszont nem kezdem el ajánlgatni mondjuk a linux-ot, mert azért még most is igaz, hogy a biztonságos megfelelő használathoz, a unix alapú rendszerek esetében meg kell tanulni az alap unix-al bánni. (Ha nem is profi szinten de nem árt, ha a fent említett keresést mondjuk be tudjuk karcolni a prompt után. 🙂 Hogy ilyen csúnyán fejezzem ki magam. :-))

Ha mégis unix alapú rendszert szeretnél használni (hiszen valamit csak csinálva lehet megtanulni), akkor azt tudom javasolni, hogy akkor kezdj hozzá, ha megérted az angol szövegeket (sajnos magyar leírásokból elég kevés van, illetve igaz itt is Murphy törvénye, hogy amire neked szükséged lesz, csak pont ahhoz nem lesz magyarul egy szó se a neten 🙂 ). És mielőtt hozzákezdenél, barátkozz a Windows-os dos ablakkal. (Nem sok minden lesz, amit a unix alapú rendszerben használni tudsz majd, de legalább kapsz egy képet a konzollal való bűvészkedés fogalmáról, ami az ilyen rendszerek egyik alapeleme.)

Kicsit elkanyarodtam a témától, pedig még egy fontos kérdésről szerettem volna beszélni, ez pedig, hogy miért is függenek az operációs rendszertől a programok? Erre a választ úgy lehet megadni, ha megértjük egy kicsit jobban a felhasználói programok felépítését, és azt, hogy hogyan is készülnek.

Felhasználói programok:
Először is melyek is ezek a programok? Az összes olyan programot, amely nem alapvető rendszerüzemeltetési feladatokat lát el felhasználói programnak nevezzük.

Hogyan is készülnek ezek a programok? Általánosan igaz, hogy a programokat valamilyen programnyelven írják a programozók. Egy programnyelv az emberi nyelvekre hasonlít, annyi eltéréssel, hogy a gépet utasítja bizonyos feladatok elvégzésére. Persze olyan magas szintű kontextust, mint az emberi nyelvek közül bármelyik is, képtelenség lenne a gép számára értelmezhetővé tenni. Tehát ezek a nyelvek jóval kevesebb nyelvi elemmel működnek. Nem lehet megmondani például a gépnek, hogy ha te az egérrel a bezárásra kattintasz, akkor zárja be az ablakot. Hiszen nem ismeri azt a szót, egér, nem tudja ki az a te, nem tudja melyik a bezárás, nem érti mi az, hogy kattintani, nem tudja mit jelent bezárni, és végkép nem tudja melyik ablakról beszélek, vagy hogy mi is az az ablak. 🙂

Viszont tudja, hogy van egy eszköz az XY portszámmal megjelölt porton, ahonnan jönnek különböző hexadecimális számok (egér), és fut egy program, amely vezérelte az egyik rendszer programot, hogy a YZ portszámmal megjelölt eszközre küldjön hexadecimális számokat (monitor) bizonyos frissítéssel. Nagyjából ebből, meg logikai műveletekből, amikkel a processzor tud dolgozni kéne építkezni. Elég egyértelmű, hogy így ez elég nagy kihívás lenne, éppen ezért az operációs rendszerek segítik a programozókat, mégpedig úgy, hogy a már egyébként is egyszerűsített portszámos interfészek és a felhasználói programok közé beékelnek olyan programokat, melyeken keresztül a felhasználói programok kicsit világosabban, és egyszerűbben tudnak kommunikálni a rendszerrel.

Így a programozónak már csak azzal kell megbirkóznia, hogy például az olyan feladatokat elmagyarázza a rendszernek (ezeken a programokon keresztül) mint, hogy hogyan is érti ő a bezárást. Így például, a megfelelő rendszerutasításon keresztül, küldhet egy hasonló bonyolultságú üzenetet a rendszernek: “ha egérkatt = igaz akkor ha egérhelye = bezárógombhelye akkor állítsdleéstöröldazablakait(programazonosítószám)”.

Persze ilyen nyelv nincs, és természetesen a nevek mögött is mást kell érteni, arról nem is beszélve, hogy a bezárógomb nem egy pont, így soha nem lenne egyenlő a kurzor pozíciójával, de a lényeg, hogy hasonló bonyolultsági szintre hozzák fel a programozási nyelvek, és a rendszer programok közösen az amúgy nagyon komplikált műveleteket.

Ebből következik, hogy egy ilyen egyszerű program is száz szálon függ a rendszeralkalmazásoktól, és azokon keresztül az operációs rendszertől. Más felépítésű operációs rendszeren ezek az utasítások teljesen értelmetlenek lennének, hiszen mondjuk a másik operációs rendszer nem kezel ablakokat és egeret, így ezeknek a neveknek ott semmi értelmük. De még ha kezelik is ezeket, akkor sem biztos, hogy a különböző rendszerprogramok ugyan ezen a néven ismerik ezeket az “eszközöket”, vagy hogy az eredményeik egyeznek a két rendszer alatt.

Ha nagyon figyelmes vagy, és még nem untál rá az egészre, akkor kiszúrhattad, hogy ezek az eltérések a beékelt rendszerprogramokból fakadnak. Tehát mondhatnád, hogy a két rendszerben ugyan azokat a beékelt rendszerprogramokat kell használni, és már meg is oldódott a probléma. Sajnos az a baj, hogy ez nem ilyen egyszerű, ugyanis ezek a programok egymástól is függenek, ráadásul elég, ha csak a másik operációs rendszer nem ugyan azt az XY számot adja például az egér portjának, és máris át kell írni ezeket a programokat is.

De hogy érthető legyen, a fő probléma nem is az egérrel szokott lenni, hanem, hogy a különböző operációs rendszerek más-más módon kezelik a memóriát, más-más módon kezelik a háttértárakat, és még kismillió más dologban is eltérnek, és ezek miatt nagyon nehéz lenne minden beékelt programot átírni.

Tudom, hogy néhol kicsit elszaladt velem a ló, és hosszú is lett ez a lecke, de remélem, azért ha mást nem is, de annyit elértem, hogy most már te sem tudod egyszerűen megfogalmazni a szoftver fogalmát. 🙂

Péter.