A mostani visszatekintőben a programozási nyelvek történetében fogunk kicsit csapongani (egy átfogóbb összefoglaló könyvnyi terjedelmű lenne), elsősorban Enterprise-on is elérhető programozási nyelvekre koncentrálva. A kérdéses "időintervallumot" tehát a digitális számítógépek megjelenésétől a 8 bites mikroszámítógépek leáldozásáig jelöljük ki.
A történet kezdete talán 1937-re tehető, ekkor történt John Vincent Atanasoff felismerte az elektronikus számítógépek fejlődésének első fontos lépését: a számítógépeket célszerű digitális elven felépíteni az analóg elv helyett. A kérdés mai szemmel talán érthetetlen, de akkoriban ez komoly dilemma volt: az analóg számítógép akár gyorsabb is lehet, mint a digitális. A következő mérföldkő Neumann János nevéhez köthető: 1945 nyarán írt First Draft of a Report on the EDVAC című dokumentumban lefektette a modern számítógép felépítésének és működésének alapelveit, amit ma Neumann-elvek ismerünk.
Lényeg a lényeg: Az ENIAC (angolul Electronic Numerical Integrator And Computer), volt az első programozható, elektronikus, digitális számítógép. 1945-ben, a Pennsylvania Egyetemen kezd működni, de még két évig építik, fejlesztik. A mai értelemben tulajdonképpen nem is volt igazi számítógép: nem tárolt program elvén működik, "programozásához" huzalok százait kellett átdugdosni. Az adatbeadás kb. háromszáz tízállású, forgókapcsolóval történt, a számítógép ugyanis tízes számrendszerben működött. A meghibásodási hajlam csökkentésére a gépben lévő 17468 elektroncsövet a névleges fűtőteljesítményüknek csak 25 százalékával üzemeltették. Ezáltal a veszteségi hányad csupán heti két-három csőre csökkent.
1949-ben az EDVAC (Electronic Discrete Variable Automatic Computer) volt az első, belső programvezérlésű, elektronikus, digitális, univerzális számítógép. A gép Neumann János elvei alapján, az ő közreműködésével készült. Ezt a masinát vezetékek dugdosása helyett, már "kényelmesen", kétállású kapcsolók állítgatásával lehetett programozni, bitenként... A kimeneti eredmény értelmezése sem tűnik kevésbé macerásnak: lámpasorokon jelent meg.

Ez ugyan nem az EDVAC, viszont a legismertebb kép Neumannról

Az '50-es években a "felhasználói kör" szélesedni kezdett, megjelentek a valóságos matematikai problémákat megoldani szándékozó "igazi felhasználók". A hardware tehát már volt, a programozás azonban még igencsak macerás volt: az egyetlen "dolog" amit a számítógép megért, a gépi kód. Digitális számítógép estében ez kettes számrendszeren alapuló, közvetlen utasításként értelmezhető kódok sorozata. A gépi kód természetesen hadware-függő, más típusú számítógép nem tudja értelmezni. A programozás akkoriban úgy nézett ki, hogy operátorok valamilyen kontrolpanelen, kétállású kapcsolók állítgatásával beállították a végrehajtandó kódokat a kézhez kapott programlapokról. Persze túlontúl komplex programokat ne képzeljünk el, a számítógépeket még sokáig csak numerikus feladatok elvégzésére használták, nagyjából olyan feladatokra, mint egy mai programozható számológépet. (A magyar nyelvű szakirodalomban még a '70-es évek elején is keveredett a számítógép / számológép elnevezés).
Bele gondolni is szörnyű, hogy egy több ezer elektroncsövet tartalmazó méregdrága számítógép - ami peresze rendszeresen el is romlik - üzemidejének túlnyomó részében azzal telik az idő, hogy kacsolókat állítgassanak rajta. Ezen segített egy XVIII. századi találmány: a lyukkártya. Akkor ismétlődő folyamatok vezérlése használták: Léteztek többek között lyukkártya-vezérlésű zenegépek, szövőszékek, ahol a lyukkártyát falapocskák jelentették. Herman Hollerith az 1890-es amerikai népszámlálásra készített egy, a kiértékelést megkönnyítendő lyukkártyás rendszert. A lyukkártyát tehát nem az IBM találta fel, viszont 1928-ban szabadalmaztatott egy 80 oszlopos formátumot, amely széles körben elterjedt. A lyukkártyák alkalmazása a számítógépeknél is nagy segítségnek bizonyult: az operátorok immár a "felhasználók" által kártyalyukasztó gépen összeszöszmötölt programokat és beviteli adatokat tartalmazó lyukkártyákat kapták kézhez. Az operátor csak "dobálta bele" a számítógép kártyaolvasójába a kész lyukkártyákat, majd leste a - szintén lyukkártyán megjelenő - kimeneti eredményt. A Bell Systems a lukszalagra tette le a garasát, de azt az időközben megjelenő mágnesszalagok kiszorították a piacról.

IBM lyukkártya

Zozo azon kevés emberek egyike lehet, aki el tudja képzelni, milyen nehéz gépi kódban akárcsak rövidebb programokat is készíteni (az EXOS-t anno forráskód nélkül módosította). Nem lehet nagy öröm nullákat és egyeseket írogatni (lyukasztani), szükség volt tehát valami - alacsony szintű - programozási nyelvre, amelynek - az ember számára olvashatóbb - utasításai egyértelműen megfelelnek a gépi kódoknak. Ez az Assembly nyelv, melynek használatához persze szükséges a hardware pontos ismerete, ráadásul az is gépfüggő. Az első assemblerek szükségszerűen gépi kódban készültek.
Következő lépcsőfok az 1950-es évtizedben kialakult "egyszerűsített programozási rendszerek", amiknek autokód a gyűjtőneve. 1950-be Alick Glennie fejlesztette ki az elsőt, aminek Autocode volt a neve, ebből lett "gyűjtőnév". Ez még mindig gépfüggő, előrelépés viszont, hogy a programot komplexebb utasításonként kell megírni, amelyeket egyszerű gépi kód utasításokra lehet lefordítani egy fordítóprogrammal. Olyan fogalmak / utasítások jelennek itt meg, mint az számábrázolás, feltételes ugrás, számlálós ciklus, szubrutin, be- kiviteli utasítások, értékadó utasítás, háttértár használat, sőt, matematikai függvények. Ez már sokkal kényelmesebb volt - egy "átlagos" fizikus, matematikus elvégezhette számítási feladatait -, egészen addig, amíg nem vásárolt az intézet egy újabb, több elektroncsövet tartalmazó számítógépet. Megjegyzendő, hogy a szakirodalom egy része a Short Code különböző változatait (1950-től) programnyelvnek tekinti és nem autokódnak.

Az '50-es évek legnagyobb számítógép gyártója az IBM volt, így itt volt meg a "legtöbb tudás" a gépeikre írt autokódok továbbfejlesztésére. 1953-ban az IBM John W. Backus nevű munkatársa javasolta feletteseinek, hogy dolgozzanak ki egy, az assembly-nél és autokódoknál hatékonyabban használható, magasabb nyelvű kódot a cég akkori IBM 704 nagygépeinek programozására. Backus megkapta az engedélyt, és így egy mintegy tíz főből álló csapattal neki is látott a nyelv kidolgozásának. A nyelv első változata 1956-ra készült el és a FORTRAN nevet kapta. A név a FORmula TRANslator szavak rövidítése, amiből nyilvánvaló mire szánták: matematikai képletet fordító rendszer. Ettől függetlenül az első magas szintű programozási nyelvként tekintünk rá, vagyis az Assembly-vel szemben - elvontabb, könnyebben használható és platform-függetlenné vált a fordító különböző géptípusra történő elkészítése után. Ez utóbbira nem is kellett sokat várni: más nagyszámítógép gyártók, az 1961-es UNIVAC-tól kezdve, saját FORTRAN fordítóikat fejlesztettek. 1958-ban megjelent a nyelv frissített verziója, a FORTRAN II. Ugyanebben az évben készítették el a FORTRAN III-at, ami beágyazott assembly kódokat is kezelt, ezt a verziót azonban sosem adták ki. 1962-ben jött a FORTRAN IV, ami hatalmas lépés volt a kód hordozhatósága felé, mivel a gépspecifikus I/O utasításokat általánosították benne. Erre a verzióra épül a nyelv első ANSI szabvány verziója, a FORTRAN 66.
No de mit is kell tudnia egy "használható" magas szintű programozási nyelvnek? Tehetjük fel az akkor még nem nyilvánvaló kérdést. Egy tetszőleges algoritmus az alábbi elemekből építhető fel:

1. Szekvencia: Egymás után végrehajtandó tevékenységes sorozata. Jellemzően értékadás utasítás és aritmetikai kifejezések felírását lehetővé tevő operátorok.
2. Szelekció (feltételes utasítás): választás megadott tevékenységek közül.
3. Iteráció: Megadott tevékenységek ismételt végrehajtása. A ciklusmagot nullaszor, egyszer, vagy többször hajtjuk végre a ciklus feltételétől függően.
4. Feltétel nélküli ugrás: vezérlés átadása a program egy megadott pontjára.

Beláthatjuk, hogy az iteráció nem feltétlenül szükséges elem, mert az előállítható szelekcióból és feltétel nélküli ugrásból. Böhm és Jacopini tétele szerint azonban minden algoritmus felépíthető a szekvencia, iteráció és szelekció segítségével. Igaz, ezt a FORTRAN-on dolgozó csapat nem tudhatta, az említett tétel csak 1966-ban született! Ahogy Edsger Wybe Dijkstra '70-es évek végén megjelent tanulmányát sem ismerték, amiben kidolgozta a strukturált programozás általános módszerét. Eszerint a csak szekvenciákból, szelekciókból és iterációkból építkező programot strukturált programnak nevezzük, amiben ismeretlen a feltétel nélküli ugrás fogalma. Ebből következik, hogy a program minden szekvenciájának - és így az egész programnak is - egyetlen belépési és kilépési pontja van. Az elvégzendő feladatot kisebb, egymáshoz csak meghatározott módon kapcsolódó részfeladatokra (szubrutinra / eljárásra / függvényre) kell felbontani, ezeken belül ugyanígy részfeladatok határozandók meg, amelyek teljes egészében megvalósítják az őket magába foglaló nagyobb részfeladatot, és így tovább. Ennélfogva a program lényegesen áttekinthetőbb lesz, a programozói munka pedig kényelmesebb, hiszen a már elkészített modulokat más programban is fel lehet használni.
A FORTRAN nyelven - sajnos - jobban érezhető a korábbi autkódok és egyéb "beidegződések" hatása, mintsem a még ismeretlen strukturált programozás elmélete.. Az IBM előszeretettel használt lyukkártyát adatok és programok bevitelére, ennek következtében a FORTRAN nyelvnek is sajátossága az "egy sor - egy utasítás" megfeleltetés. Egy sor 80 karakter - igazodva az IBM lyukkártyához - az egyes utasításokat mindig csak új sorban, a 7. karakterpozíciótól kezdve lehet elkezdeni. Az első öt karakterpozíció a címkéknek és a megjegyzés jelének van fenntartva. A 6. karakterpozícióban kellett jelezni a folytatósorokat (ha egy sorba nem fér bele a megkezdett utasítás). A 73-80. karakterek sem a programszövegnek vannak fenntartva: megjegyzés állhat itt és / vagy a rendszer használja. A számokat INTEGER, REAL, DOUBLE PRECISION vagy COMPLEX típusúként lehet kezelni, akár tömbben is. Szövegfüzéreket (ezt akkor még Hollerith típusnak hívták) leginkább sehogy. Pontosabban a későbbi változatokban a számok tárolására szolgáló változókban lehetett tárolni Hollerith konstansokat - üzenetek megjelenítése céljából, de műveleteket - az összefűzésen kívül - nem lehet velük végezni. A változók típusát ugyan lehet deklarálni, de nem kötelező, a FORTRAN bevezeti az automatikus típusdeklarálás lehetőségét. Sőt, nem csak a típusdeklarálás hagyható el a legtöbb esetben, de a változók kezdeti értékadása is. Ezzel a "szolgáltatással" még két évtizeddel később is találkozhatunk. Függvények és szubrutinok vannak, de a rekurzív hívás nem megengedett.
Bár támogatja a moduláris programozást, amely lehetővé teszi a programok szubrutinokra vagy függvényekre tagolását, a címkék és GOTO használata elkerülhetetlen volt, olyannyira, hogy még a ciklusok végét is címkékkel kell kijelölni és a ciklusszervező utasításokban a címkére kell hivatkozni. Itt (a ciklus utolsó utasításaként) "persze" nem állhat akármilyen utasítás, ezért be kellet vezetni egy amúgy semmilyen műveletet nem végző utasítást is (CONTINUE). Amúgy is kusza programjainkat kiterjesztett hatáskörű ciklusokkal borzolhatjuk tovább. A kimeneti-, beviteli utasítások illetve azok formázása is nehézkesnek tűnik, hiszen azokat nagy mennyiségű numerikus adatok feldolgozására szánták. Az ilyenfajta formai követelmények speciális programozói előnyökkel és hátrányokkal jártak.

Ha nincs kéznél terminál és szövegszerkesztő...
Az O betű van áthúzva, nem a nulla.

A "konkurencia" sem váratott sokáig magára, hisz egy általánosan használható programozási nyelvre való igényt nem csak az IBM ismerte fel: 1955-ben kezdett kidolgozni egy európai és amerikai, számítástechnikával foglalkozó tudósokból álló bizottság egy programozási nyelvet. Az ALGOL - a betűszó, az ALGOrithmic Language (algoritmikus nyelv) elnevezés rövidítése - a FORTRAN után elterjedt második magas szintű programozási nyelv. A nyelv első, nemzetközileg még el nem fogadott változatát 1958-ban (ALGOL 58, de hívták IAL-nak is), végleges definícióját 1960-ban tették közzé (ALGOL 60). 1963-ban publikálták a nyelvnek egy módosított definícióját, amely az időközben kiderült kisebb hiányosságokat és szövegezésbeli pontatlanságok kiküszöbölte ki. A 60-as szám az elnevezésben az elfogadás évére utal; annak ellenére, hogy az 1963-ban elfogadott módosított verziót nevezzük ALGOL 60-nak.
Míg a FORTRAN-t eredetileg az IBM számítógépek programozási nyelvének szánták, az ALGOL tarthat igény az első többplatformos számítógépes nyelv titulusra. Az ALGOL 60 egész, valós és logikai típust ismer. Egy sorba több utasítást is lehet írni, pontosvesszővel elválasztva. Megjelent a BEGIN és END által határolt összetett utasítás, részben ezért lehetővé válik a strukturált programozás. Az eljárások egymásba ágyazhatóak, a rekurzív hívás megengedett. Sajnos azonban az ALGOL 60 hivatkozási nyelvből hiányoznak a be- és kiviteli utasítások. Természetesen a gépi reprezentációkban ezekre szükség van, így a különböző fordítók egymással hasonlóságot sem mutató eljárásokat tartalmaztak erre a célra, ami csakhamar nyelvi kavalkádba torkollott, lehetetlenné téve az egységesítést.

A programozási nyelvek harmadik "dobogósa" az első objektumorientált programozási nyelv, a COBOL 60. 1959-ben deklarálták. Bár általános célú nyelv, elsősorban az üzleti, pénzügyi élet rendszereiben való használatra szánták. Ez pl. abban nyilvánul meg, hogy rendelkezik olyan beépített funkciókkal, amelyek lehetővé teszik a nagy adatmennyiségek és tömeges tranzakciók hatékony kezelését, támogatja a hierarchikus adatstruktúrákat.
Grace Murray Hopper ötlete volt, hogy a programnyelv közelebb álljon az angol nyelvhez, mint a hagyományos számítógépes "nyelvhez", ezért lett a COBOL "olvasmányosabb" társainál. Egy COBOL program 4 jól elkülöníthető részre, COBOL szóhasználattal Division-re, (Főrészre) oszlik. A program kötött szintaxissal rendelkező, úgynevezett COBOL mondatok (Sentences) sorozatából áll, amelyek különböző igékből (ADD, SUBTRACT, PERFORM, READ stb.) és változónevekből épülnek fel. Minden mondatot pont zár le. A mondatok összetartozó csoportjai paragrafusokba (Paragraph) gyűjthetők, amelyek egyben vezérlési szerkezetként is kezelhetők. Egyes COBOL megvalósítások annyira meghatározták a forrásprogram írásának szabályait, hogy a nyelvet használó cégek előnyomtatott lapok alkalmazásával segítették a programozókat a formai követelmények betartásában.

Grace Hopper az UNIVAC kezelőpanelje előtt

Grace Murray Hopper nevéhez - aki "mellesleg" haditengerészeti tiszt volt (ellentengernagyként vonult nyugdíjba), rakéták röppályáit számolta ki, lőtáblázatokat készített - más jelentős informatikai "fejlesztés" is köthető egy anekdota szerint: 1945 egyik estéjén, miközben kollégáival a Mark II-n dolgoztak, a gép meghibásodott. Ez akkoriban egyáltalában nem volt meglepő, a végkifejlet azonban igen: Szétszedték a gépet és egy nagy lepkét találtak benne, ami feltehetőleg zárlatot okozott. Ettől kezdve a számítógépes hibákra a "bug" (amit egyébként a XIX. század óta használták, mint mérnökzsargon, a mechanikai meghibásodás leírására), a hibakeresésre pedig a "debugging" kifejezést használta.

Mai szemmel nézve kicsit meglepő az az évtizedes vita, melyik a "jobb", a FORTRAN, vagy az ALGOL? Mert mik is a FORTRAN előnyei? Ilyet nehéz találni. A szintaktika teljes agyrém, a programlista olvashatatlan, úgy néz ki, mint amit az autokódokból tákoltak össze. Amikor fentebb azt írtam, hogy "a kimeneti-, beviteli utasítások illetve azok formázása is nehézkesnek tűnik" nagymértékben szépítettem a tényeket, hogy ne spoilerezzek... Minden ki- és beviteli utasításhoz ugyanis KÖTELEZŐEN(!) tartozik egy címkével kijelölt(!!) FORMAT formátumleíró utasítás. A BASIC PRINT USING ehhez képest leányálom. A FORTRAN program egy hatalmas katyvasz, szemlátomást arra tervezték, hogy pár soros numerikus algoritmusokat írjanak FORTRAN-ban.
Ezzel szemben az ALGOL letisztult, logikus és áttekinthető programszerkezeteket nyújt, teljes körűen támogatta a strukturált programozási paradigmát. A változók típusa már nem "esetleges", mese nincs, definiálni kell. Ez egyébként a fordítóprogram egyszerűsödését is eredményezi. Szókészlete meglepően szűk, könnyen tanulható, mégis jobban segíti a programozó munkáját. Ez nem szubjektív vélemény: a '60-as években az ALGOL-t széles körben használták algoritmusleíró nyelvként, publikációs célra. A FORTRAN piacvezető státuszát mindezek ellenére semmi sem veszélyeztette 1979 végéig.

Az eddigi programozási nyelvek szükségszerűen csak fordítóprogram formájában létezhettek. Egyrészt a gépek teljesítménye miatt, másrészt a későbbi interpreteres nyelvek már magasabb fokú interakciót feltételez, mint a lyukkártyákkal való zsonglőrködés, várva a nyomtatón megjelenő (szám) adatokra...
Időközben azonban a ki- és bemeneti eszközök is fejlődtek: Megjelent a mágnesszalag, ebben szintén az IBM volt az úttörő: 1952-ben az IBM 726 mágnesszalagos egysége volt az első számítógéphez illesztett háttértár.
Egy, a számítógéphez kapcsolt másik eszköz, a Teletype (teleprinter) a lyukkártyához hasonlóan nem új találmány volt: 1887-től használták távírókhoz. Ez egy elektromechanikus szerkezet, amely billentyűzeten gépelt üzenetek küldésére és fogadására (papírra nyomtatva) alkalmas.
Az '50-es vége felé megjelentek az első katódsugárcsöves képernyők. Ezek először még nem is voltak monitornak nevezhetőek, méregdrága egyedi megoldások voltak, egyedi feladatokra. Volt olyan, amiben az elektronnyaláb nem soronként pásztázta a foszforréteget, hanem "összevissza" mászkált és vektorokat rajzolt ki...
A "jövő is elkezdődött" 1958-ban: a Texas Instruments elkészítette az első integrált áramkört. 1964-ben az IBM 2260 az első - természetesen csak szöveges megjelenítésre alkalmas - monitorral szerelt elektronikus terminál. Az első 4 bites mikroprocesszort pedig majd 1971-be készíti el az Intel (Intel 4004)
Még egy fontos fejlődési lépés, ami nagy hatással volt a programozási nyelvekre (is): az időosztásos rendszerek megjelenése. A megoldás elvét 1957 elején Bob Bemer az Automatic Control Magazine-ban megjelent cikkében írta le. Még ennek az évnek a végén elindult a megvalósítási projekt, amelyet John McCarthy vezetett egy módosított IBM 704 gépen, amit később egy szintén módosított IBM 7090 gépre cseréltek. A projekt eredményét 1961 novemberében mutatták be, ami a Compatible Time Sharing System vagy CTSS néven vált ismertté, és kisebb módosításokkal 1973-ig használatban is maradt.

IBM 360 számítógép (bal oldalon) munkaállomás, Teletype-pal

Nem számítógép, IBM 2260 terminál (még mikroprocesszor nélkül). A számítógép a háttérben van a mágnesszalagos egységektől jobbra

John McCarthy általános célokra használható, de kifejezetten mesterséges intelligencia-algoritmusok leírására alkalmas nyelvet szeretett volna megalkotni. A fejlesztést 1958-ban kezdte, eredményeit 1960-ban publikálta. Rámutatott, hogy pár egyszerű operátor és egy függvények ábrázolására alkalmas primitív szintaktika segítségével teljes értékű, általános programozási nyelv alkotható, amit Lisp-nek (List Processing - listafeldolgozás) nevezett el.
Bár először fordítóprogram készült hozzá, az első teljes (LISP 1.5) értelmező program 1963-ban készült el, így a Lisp lett az első interpreteres nyelv. Ezt persze akkor még csak igen kevesen tudták használni.
Egy LISP program függvénykifejezések kiértékelésének sorozata. A LISP tehát a korábbi nyelvekkel szemben a funkcionális programozás nyelve. (A funkcionális programnyelvek a programozási feladatot egy függvény kiértékelésének tekintik. A két fő eleme az érték és a függvény, nevét is függvények kitüntetett szerepének köszönheti.) Hosszú ideig az egyedüli ilyen nyelv volt. A LISP nyelvben a programok és az adatok azonos szerkezetűek, nem különülnek el egymástól. Ezáltal egy LISP program létrehozhat és végrehajthat egy másik programot, a LISP programok önmagukat is módosíthatják.
Érdekesség, hogy az interpreter-es megvalósítás a Lisp esetében egyszerűbb, mint a fordítós, ami érthető is a nyelv pár jellemzője alapján: A nyelv fő adatstruktúrája a láncolt lista. A nyelvben a programok és az adatok listák formájában tárolódnak, és a listák rekurzív feldolgozása a programozás alapvető eszköze. Hamarosan a mesterséges intelligencia kutatás előszeretettel alkalmazott nyelvévé vált, bár ez alatt nyilván nem a felhasználók szélesebb körét kell érteni. Kezdetben a LISP rendszerek viszonylag nagy tárigénye és lassúsága akadályozta a nyelv elterjedését. A '70-es évek közepétől kezdve azonban a fejlődés a számítógépek sebességének és tárkapacitásának gyors növekedését és a hardware költségeinek csökkenését hozta magával. Ez tette lehetővé a LISP nyelv széles körű elterjedését. Ekkoriban megszületett a Lisp-gép is (Lisp-Machine), azaz a célzottan Lisp programok futtatására készített számítógép, amely már a gépi utasítások szintjén is "Lispül gondolkodik".
Szabványosítás hiányában a LISP változatok nagy száma a programozó számára gazdag lehetőségeket kínál, aki azonban a nyelvvel akar megismerkedni, annak ez nehézséget is jelent.

John McCarthy

A Lisp nyelv könnyebben olvasható adaptációja a Logo parancsnyelv, amit Wally Feurzeig és Seymour Papert alkotott meg 1966-ban. Az első megvalósítás LISP nyelven készült egy PDP-1-es számítógépen. Később a nyelv a teknőcgrafikájáról vált ismertté, de ez későbbi fejlesztés.

Nem kis fába vágta az IBM a fejszéjét, amikor a FORTRAN, COBOL és ALGOL előnyös tulajdonságait akarta egy nyelvbe gyűrni. Ez amolyan "egy programozási nyelv mindenek felett" elképzelés volt, erre utal a szerénynek nem mondható névválasztás: PL/I, vagyis Programming Language number 1. Tudományos, mérnöki, üzleti és rendszerprogramozáshoz (is) szánták... A nyelv definíciója 1964 áprilisában készült el. Annak ellenére, hogy az IBM pénzt és egyéb erőforrásokat nem kímélve az akkori kor nagy tudósait bízta meg az első fordító elkészítésével, az csak 1966-ra készült el! Igazi "öszvérnyelv", bő utasításkészlete és nyelvi gazdagsága miatt nehéz fordítóprogramot készíteni hozzá.

Kenneth E. Iverson 1957-től a Harvard Egyetemen egy matematikai leírást dolgozott ki, amit matematikai állapotok leírására és a tanítás megkönnyítésére szánt. 1960-ban az IBM-ben kezdett dolgozni, ahol Adin Falkoff-fal kibővítette ezt a jelölésrendszert, majd 1962-ben megjelentette A Programming Language című könyvében. Ezt a jelölést használták is az IBM-en belül a számítógépes rendszerekkel kapcsolatos rövid kutatási jelentések elkészítéséhez. Meg is született az ötlet, hogy ez a jelölésrendszer egy komplett számítógépes rendszer leírására - programozási nyelv - megvalósítására is alkalmas. A nyelv - ami a fentebb említett könyvről kapta a nevét - elkészültét 1964-re datálják.
Az APL nyelv nem hasonlít semmilyen más programnyelvhez, inkább algebrai formulák sokaságára emlékeztet. A program minden esetben interpretált, nem fordított. Az adat függetlenül létezik a programon kívül, így a felhasználó program definiálása nélkül képes adatokat manipulálni. A nyelv központi adattípusa a többdimenziós tömb. A beépített formulákkal egyszerű kifejezésként írhatunk le bonyolultabb mátrix műveleteket, rekurzív kifejezéseket. Ennek eredménye egy nagyon tömör programkód. Az APL azonban speciális billentyűzetet vagy szerkesztő programot igényel, mivel a lexikális elemek között görög betűk és speciális karakterek is találhatóak - ez nagy mértékben megnehezíti az átjárhatóságot az egyes implementációk és platformok között.
A nyelv főbb alkalmazási területe értelemszerűen a matematikai algoritmusok és a statisztika.

Charles H. Moore amerikai csillagász Kaliforniában, az Egyesült Államok Nemzeti Rádiócsillagászati Obszervatóriumában (NRAO) egy rádióteleszkóp vezérlési és adatfeldolgozási munkáin dolgozott. Munkájához egy gyors, kompakt, rugalmas és kibővíthető programozási nyelvre lett volna szüksége. A FORTRAN, ALGOL, COBOL nem tetszett neki, nekilátott hát egy úgynevezett negyedik (fourth) generációs programozási nyelv elkészítéséhez. A cél főképp a programozó eredményességének javítása volt a gép hatékonyságának feláldozása nélkül. 1968-ban készült el egy korai változattal, munkáját az IBM 1130 (3. generációs) számítógépen végezte. Moore úgy érezte, hogy olyan nyelvet alkotott, amely a "majdani" negyedik generációs számítógépek általánosan használt programozási nyelve lehet. (Akkor már nyilvánvaló volt, hogy nagy integráltságú (VLSI, Very Large Scale Integration) áramkörökből felépülő számítógépek megjelenése a közeljövőben megtörténik - ezeket hívjuk ugyanis negyedik generációs számítógépeknek). Ezért a nyelvet FOURTH-bak ("Negyedik") szerette volna elnevezni, azonban az IBM 1130 operációs rendszere csak legfeljebb ötkarakteres file-neveket fogadott el. Így lett a FOURTH-ból FORTH, amely nem kevésbé kifejező, jelentése: "tovább, előre".
Moore eredményeinek híre szájhagyomány útján gyorsan terjedt először a rádió csillagászok körében, majd Amerika nyugati partjának tudományos köreiben. Moore és néhány kollégája megragadva a lehetőséget otthagyták régi munkájukat és 1971-ben megalakították a "Forth Inc." céget, mely a Forth implementációk kereskedelmi változatainak és software-csomagoknak az előállításával foglalkozott. Kezdetben nagy lelkesedés övezte a nyelvet, azonban ez rövid idő alatt lelohadt. Az ok abban kereshető, hogy a nyelv legfőbb előnyei, úgymint a tömörség (tehát nehezebb olvashatóság) és a nagy sebesség nem bizonyultak fontosabbnak, mint a korabeli nyelvek könnyebb elsajátíthatósága a nagyszámítógépek korában. Ezenkívül ebben az időben kevés helyen álltak még a programírók rendelkezésére olyan interaktív eszközök (képernyő, billentyűzet), amelyek a FORTH használatához elengedhetetlenül szükségesek. A korábbi programozási nyelvek fordítóival szemben a FORTH már csak monitorral felszerelt rendszerben volt használható, egy elsőség tehát a FORTH-nak is jut...
A FORTH a mikroszámítógépek megjelenésével került ismét az érdeklődés középpontjába az 1970-es évek végén. Itt már a szűkös memória, és viszonylag lassú központi egység jobb kihasználása tömör és gyors programozási nyelvet igényelt. Ezeknek a követelményeknek az addig méltatlanul mellőzött FORTH nyelv minden szempontból megfelelt. Így lett - a BASIC mellett - a FORTH a személyi számítógépek legáltalánosabban használt programozási nyelve. A mikroszámítógépek terjedésének köszönhetően felhasználói közösségek alakultak ki az USA-ban és Európában. Ezek a csoportok bővítették a nyelvet, új változatokat hoztak létre. Ezek közül kettő terjed el szélesebb körben:

• Fig-Forth: A Forth Interest Group Inc. egy nemzetközi felhasználókból álló csoport, amely abból a célból alakult, hogy kidolgozzák a saját verziójukat, amit Fig-Forth-nak neveztek el. Ez a társaság a "Forth Installation Manual" című leírást tekinti a nyelv alapjául, amely saját kiadványuk.
• FORTH-79 és FORTH-83
  A Europian Forth User's Group (EFUG) a Forth-77 nevet adta saját változatának. Ahogy a nyelv fejlődött, létrejött egy köztes Forth-78 változat. 1980 első hónapjaiban létrejött a Forth-79. Ez utóbbi változatot fogadták el "hivatalos" Forth-ként. Az újságok és a szoftveripar széles körben támogatták a Forth-79-et. A Forth-83 kiterjesztett és modernizált változata a Forth-79-nek. Ezt a változatot az American National Standards Institute (ANSI) is saját szabványaként fogadta el.

A FORTH a "legalacsonyabb szintű magasszintű programozási nyelv". Teljesen más elvek szerint működik, mint a "hagyományos" magas szintű programozási nyelvek: úgynevezett láncolt kódú interpretált nyelv. A program "Szavakból" épül fel, a szavakat tartalmazó szótár(ak) szavak mutatókkal összeláncolt sorozata. A legelemibb műveleteket elvégző szavakból egyre komplexebb műveleteket elvégző szavakat készíthetünk. A program futása közben tehát a (cím)interpreter elmegy a címekre, ahová a szó erre a célra fenntartott mezőjében talált mutatók küldik. Ott esetleg újabb mutatókat talál (a szót felépítő másik szóra), amelyeken továbbmehet. A sok küldözgetésnek egyszer vége kell, hogy szakadjon: előbb-utóbb valamelyik hívott szónak ki kell rukkolnia vele, hogy mit is kell csinálni. Ezeket a végső szavakat, amelyek tehát nem más szavakra utaló mutatókat, hanem végrehajtható gépi kódokat tartalmaznak, primitíváknak nevezzük. És mivel újabb szavakat is készíthetünk - akár primítívákat is ASSEMBLER szótár használatával -, a FORTH-ban mindent meg lehet tenni, amit gépi kódban az adott számítógépen lehet.
Persze azért a FORTH sem habostorta... Bármilyen műveletet csak az (adat)veremben elhelyezett számokkal végezhetünk. Ennek megfelelően aritmetikai műveletet csak fordított lengyel formában írhatunk fel, ami jelentősen eltér a magas szintű nyelvekben megszokottaktól: a verembe helyezett elemekkel folyamatosan "zsonglőrködni" kell, hogy azok a megfelelő sorrendben legyenek a következő művelet elvégzéséhez. Adattípusok a hagyományos értelemben nem léteznek, pusztán a felhasznált szavaktól függ, hogy a verembe helyezett 16-32 bites számsorozatokat előjeles egésznek, egésznek, vagy duplapontos egésznek tekintünk-e.
Érdekesség, hogy mindezek ellenére (vagy épp mellette...) a FORTH az első programozási nyelv, amiben nem is létezik a hagyományos értelemben vett GOTO utasítás! A vezérlési szerkezetek persze használják a BRANCH szót, de azzal a memória egy címére lehet ugorni, aminek semmi köze a GOTO-hoz. Nem is lehetne hova ugorni, hiszen se címke, se sorszám nincs a FORTH-ban.

A magyar származású Kemény János ifjú matematikust 1953-ban meghívták a Dartmouthi Főiskolára matematikaprofesszornak. Alkalmazta Thomas Eugene Kurtz professzort, akivel már korábban megismerkedett. Két év múlva Kemény a Matematikai Intézet vezetője lett. Kemény eltökélt szándéka - szinte már hitvallása - volt, hogy a számítástechnikát közelebb hozza az emberekhez (akiknek túlnyomó többsége akkor még csak TV-ben láthatott ilyen csodát), reményei szerint a jövőben egyre több feladatot oldhatnak meg széles körben számítógép segítésével az élet egyre több területén. Kurtz könnyen azonosult ezen elképzeléssel, így szorosabb kollegiális viszony alakult ki közöttük.
1959 körül vásároltak egy alig szekrény méretű "olcsóbb" (47,000 dolláros, ez ma több, mint fél millió dollár) Royal McBee LGP-30 számítógépet, amelyet néhány hallgatóval programoztak, eleinte assembly nyelven: a frissen publikált ALGOL 58 fordítón kezdetek dolgozni. (Ahogy erről már volt szó, FORTRAN fordító akkor még csak IBM gépekhez volt). Ez persze távol volt a "széles kőrtől" már csak a drága gépi idő nem túl hatékony kihasználása miatt. (Ez még az operátorok és lyukkártyákkal kora volt: a szükséges "szertartások" elvégzésével egy program lefuttatása órákig is tarthatott a program és adatok bevitelétől a kimenő eredmények kézhezvételéig).
A "szélesebb kőrhöz" két dolog hiányzott: egy hatékony időosztásos rendszer, és egy könnyen tanulható, általános célokra használható programozási nyelv. A megcélzott felhasználói kör tehát nem az informatikusok voltak, hanem nagyjából mindenki más, akinek csekély, vagy semennyi informatikai ismerete nincs.
Első lépésként Kemény 1962-ben javasolta az egyetemi számítógépközpont megépítését, amit 1966-ban adtak át. 1964-re pedig Kemény és Kurtz elkészítette az első kereskedelmileg sikeres időosztásos rendszerét, a Dartmouth Time-Sharing Systemet (DTSS), amit üzembe is helyeztek a Dartmouth College-ben. Így már semmi nem akadályozta, hogy modemhez csatlakoztatott terminálok - egyszerre akár több is - telefonvonalon keresztül kommunikálhassanak távoli számítógépekkel, programokat futtathassanak rajta. És hogy milyen programokat? Az ugyanabban az évben elkészült BASIC (Beginner's All-purpose Symbolic Instruction Code) programozási nyelvűeket! Kemény tehát nem csak a nyelvet definiálta, de ő is programozta (ahogy Charles H. Moore is tette). 1964 Május elsején, hajnalban az alábbi program fut le, két terminálon egyszerre:

10 LET X=(7+8)/3
20 PRINT X
30 END

A nyelv a FORTRAN alapján készült, sok szerkezet onnan köszön vissza, igaz letisztultabb formában. Az első változat - ami még fordítós volt - meglehetősen primitív, strukturálatlan volt. A nyelv fejlesztését 1975-ig aktívan folytatták, újabb elemekkel bővült, és elkészült a Teletype-on(!), majd később elektronikus terminálokon használható interpretált változata. Ennek hatására nemcsak a főiskolákon, de a középiskolában is elkezdtek szaporodni a teleprinterek, rövid idő alatt a BASIC lett az a programozási nyelv, amivel a legtöbb embert találkozhatott, és találkozott is.
A szabványosítás csak 1974 januárjában kezdődött meg, végleges szabványt 1977 decemberében tették közzé, ami Minimal BASIC-ként vált ismertté. Dijkstra már 1975-ben bírálta a tervezetet (ami lényegében egy struktúrálatlan nyelvet ír le), szerinte "lehetetlen megtanítani a helyes programozást azoknak, akik a BASIC-kel ismerkedtek meg első programozási nyelvként". Nyilvánosan kikelt a GOTO utasítás ellen, és külön ellenezte a BASIC oktatását az iskolákban.

Kemény János (bal oldalon áll), diákok és teleprinterek társaságában

Niklaus Emil Wirth svájci informatikus professzor rész vett az ALGOL továbbfejlesztésében. Sir Tony Hoare brit informatikussal kidolgozta az ALGOL-W nevű javaslatot, ezt azonban elutasították Adriaan van Wijngaarden összetettebb javaslata helyett, amely az ALGOL-68 lett. Wirth elhagyta a project-et, úgy döntött, az ALGOL-W-ből maga készít egy programozási nyelvet, elsősorban oktatási célokra. Hangsúlyozandó, programozás oktatására szánta a nyelvet: célja a helyes programozási gyakorlatok ösztönzése strukturált programozás és adatstrukturálás segítségével. Az ALGOL felhasználásával és továbbfejlesztésével készült nyelv leírása 1968-ban készült el és a Pascal nevet kapta Blaise Pascal a francia matematikus-filozófus tiszteletére. 1970-ben készült el az első fordítóprogram a nyelvhez, az erről szóló publikáció 1971-ben jelent meg. 1973-ban látott napvilágot a javított (Revised Report) kiadása. Ekkor definiálták a Standard Pascal nyelvet, amely a nyelv különböző implementációjának alapja lett. Több egyetemen is kifejlesztették a nyelv változatait, ereje azonban akkor mutatkozott meg igazán, amikor a megjelentek a személyi számítógépek. A PASCAL a '80-as évek első felének legnépszerűbb programozási nyelvévé vált.
Az ALGOL-hoz képest is meglepően kis méretű Pascal-fordítóprogramok írhatóak (köszönhetően a nyelv merevebb szabályainak). A nyelv szintaktikája kísértetiesen hasonlít az ALGOL-éhoz, kulcsszókészlete az elődjéhez hasonlóan meglehetősen szűk, a használható előre definiált eljárások és függvények azonban sokat bővültek. Ami továbbra is hiányzott belőle: a string-kezelés. Van már ugyan külön char (karakter) típus, de ez leginkább csak üzenetek megjelenítésére használható. Az egész és valós típus mellett megjelent a felsorolt, résztartomány, rekord és halmaz típus. Újítás a dinamikus tárkezelés lehetősége. A kissé "agyonstruktúrált" nyelv leírásába azért pár sületlenség is szorult, amit soha sehol, egyetlen fordító nem valósított meg: például az illeszkedő tömbparaméter épp a nyelv merev struktúrája okozta korlátokat lenne hivatott enyhíteni, ha egyszerűen megvalósítható lenne a fordítóprogramokban. A legtöbb fordító viszont bővítette - nem szabványos módon - a string-ekkel végzett műveleteket. Strukturált programozás ide vagy oda, vegyük jegyzőkönyve: ha egy deklarált változót elkezdünk használni kezdeti értékadás nélkül, azt a PASCAL megteszi "meghatározatlan" értékkel!
Wirth elég termékeny volt, 1975-ben készült el a Modula programozási nyelv, amely alapvetően a Pascal továbbgondolása (túlgondolása...) volt. Ez azonban nem terjedt el, és inkább kísérletinek tekinthető nyelv. Ez nem vette el a kedvét, 1977-ben kezdett dolgozni a Modula-2 nevű programnyelven. Az első megvalósított verzió futtatása egy PDP-11-es számítógépen történt 1979-ben. A Modula nyelvek fő jellemzője - erre utal a neve is - a moduláris programozás támogatása. A programok egységekre vannak osztva, amelyek különálló modulokként működnek.

A Pascal mellett a kor másik "nagyágyúja" a C nyelv, amit Dennis Ritchie fejlesztett ki Ken Thompson segítségével 1969 és 1973 között. A viszonylag alacsony szintű nyelvet rendszerprogramozásra készítették az UNIX operációs rendszerhez. A nyelv különlegessége, hogy egyesíti magában a hardware-közeli programozás és a magasszintű nyelvek előnyeit. Az 1973-ra a C nyelv (és fordítója) elég hatékonnyá vált, így a UNIX rendszermag legnagyobb részét, melyek PDP-11/20 assembly nyelven íródtak, egy merész húzással újraírták C-ben. Ezzel minőségileg új szakasz kezdődött a számítástechnikában: jól vizsgázott egy olyan magas szintű programozási nyelv, amely megfelelő kényelmet biztosít ugyan a felhasználónak, de annyira hatékony és "assemblerszerű", hogy lehetővé teszi operációs rendszer megvalósítását. Ugyanakkor elindult a karrierje egy olyan operációs rendszernek, amely nem assemblyben, hanem egy gépfüggetlennek mondható magas szintű programozási nyelven íródott.
Ettől függetlenül a C egy általános célú programozási nyelv, igaz kevésbé típusos, mint a Pascal. Maga a nyelv mindössze karakter, különböző hosszúságú egész (int, short, long), és lebegőpontos (float, double) típusokat biztosít. Rendelkezik egy sajátos adatszerkezettel is, amelyet union-nak nevezünk. Összetett adatstruktúrák létrehozásával a programozónak kell gépészkednie. Mindezek ellenére, vagy éppen ezért a nyelv hamar népszerű lett a "komolyabb" programozók körében. Dennis Ritchie az első C fordítót PDP-11-en írta meg, de gyorsan más gépekre, így az IBM System/370-re, a Honeywell 6000-re és az Interdata 8/32-re is elkészült. 1978-ban megjelent a Dennis Ritchie és Brian Kernighan nevével fémjelzett 'A C programozási nyelv' című könyv első kiadása. Ez a könyv, melyet a C programozók csak K&R néven emlegettek, sokáig szolgált a nyelv formai leírásának forrásaként. A C nyelvnek az a verziója, melyet leírt, az a "K&R C" nyelv. A K&R C a nyelv legalapvetőbb részének tekinthető, melyet egy C fordítónak mindenképpen ismernie kell. Sok éven keresztül, még az ANSI C bevezetése után is, a "legnagyobb közös osztó" volt a K&R, ha a legnagyobb mértékű (forrás szintű) kompatibilitásra volt szükség.
Mivel szabványos nyelv, így a különböző platformokon levő fordítói a szabvány miatt (a szabvány erejéig) egységesek, így lehetőség van a kód hordozhatóságára forráskód szinten. Bár maga a nyelv kicsi, függvénykönyvtáraival sok minden megoldható. Ilyen a string-ek kezelése, input/output megvalósítása vagy a számtalan matematikai könyvtár jelenléte.

Dennis Ritchie (áll) Ken Thompson és egy PDP-11 társaságában

A Prolog a Lisp-hez hasonlóan a mesterséges intelligencia kutatásában használatos programozási nyelv. Míg a Lisp elsősorban Észak-Amerikában terjed, a Prolog nyelvet a franciaországi Marseille-ben fejlesztette ki 1972-ben Alain Colmerauer és Philippe Roussel. A név a francia eredetű programmation en logique (logikai programozás) kifejezés rövidítése, utalva arra, ez tekinthető az első logikai programozási nyelvnek. 1973-ban készült el az első publikus Prolog változat, Fortran nyelven. Érdekesség, hogy Magyarország a Prolog egyik legaktívabb alkalmazójává vált: a világon másodikként, 1975-ben nálunk készült PROLOG interpreter (Szeredi Péter vezetésével), ez szolgált alapjául a későbbiekben (1980-tól) kifejlesztett MPROLOG (Moduláris PROLOG) nyelvnek, amely nemzetközi elismertséget és gazdasági sikert is hozott a Számítástechnikai Koordinációs Intézetnek.
A Prolog meglehetősen sajátos programozási nyelv: A hagyományos nyelvekben parancsokat, utasításokat írunk le, míg egy Prolog program leíró jellegű, kijelentésekből épül fel. A Prolog rendszer azt képes eldönteni, hogy előre megadott formulák halmazának egy adott formula (a célformula) logikai következménye-e vagy sem. Természetesen csak egy igen/nem válasszal nem jutnánk sokra, lehetőség van arra is, hogy a változók azon értékeit is megismerjük, melynél a célformula valóban következmény lesz. A Prolog nyelv elemi objektumai a termek. Ezek azok az objektumok, amelyekről bizonyos állításokat megfogalmazunk, és amelyekre a lekérdezésben megfogalmazott állítás vonatkozik. Termnek nevezzük tehát a konstansokat, a változókat és az összetett termeket.

Az első kereskedelmi forgalomba került 8-bites mikorpocesszort az Intel fejlesztette ki 1972-ben. 8008-as "nevű" (az Intel a Pentium-ig számmal jelölte a processzorait) processzor 3500 tranzisztort tartalmazott, 500-800 kHz órajelfrekvencián hasított. Ebből a neves alkalomból egy tehetséges, fiatal programozó, Gary Kildall felkereste Hank Smith-t, az Intel software-részlegének vezetőjét, és felajánlotta, hogy készít egy magas szintű nyelvet kimondottan az új processzorhoz. Némi rábeszélés után meg is kapta a megbízást, és barátja Kathryn Strutynski segítségével 1973-ra elkészült a PL/M első verziójával.
A nyelv IBM PL /I nyelvének szintaxisán és koncepcióján alapult, ebből már sejthető, hogy Kildall elég nagy fába merte belevágni a fejszéjét. Talán kicsit túl nagyba, hisz a 8008-as korlátai miatt a nyelv inkább csak "bemutatóra" szólt. A probléma a 8080-as processzor 1973 végi bevezetésével oldódott meg. A nyelv ezután már kellően hatékony volt, hogy Kildall belkezdjen vele egy lemezes operációs rendszer fejlesztésébe...

1974-re el is készült a CP/M (a rövidítés jelentése eredetileg Control Program/Monitor volt, ez később Control Program for Microcomputer-re változott) operációs rendszer első változata, eredetileg Intel 8080 processzorral szerelt számítógépekhez. Hamar szabvány lett a mikroszámítógép-iparban, hiszen a közös platform (Intel 8080 és Zilog Z80) nagymértékben csökkentette a programok fejlesztési idejét (nem kellett portolni a különböző géptípusokra).
Kildall és felesége, Dorothy 1974-ben céget alapított a CP/M forgalmazására. Ennek először "Intergalactic Digital Research" volt a neve, de - vélhetőleg ennek kicsit vicces és tudományos-fantasztikus jellegű hangázása miatt - csakhamar átnevezték Digital Research, Inc.- re. Kildall irányítása alatt folytatódott a CP/M fejlesztése, a 2.x verzió 1978-ban már kimondottan a mikroszámítógépekre készült. Az elkövetkező pár évben számtalan üzleti alkalmazás és programozási nyelv - jellemzően fordító formájában - készült a '80-évek közepéig virágzó operációs rendszerre. Hegyekben álltak a Pascal fordítók - az ALGOL-t szinte teljesen kiszorította. C fordítóból is van többféle, bár ez a nyelv a 16 bites gépek slágere lett inkább. Emellett akadtak kuriózumok is, mint FORTRAN, COBOL, PL/I fordítók.

Jean Ichbiah (a francia illetőségű CII Honeywell Bull munkatársa) vezette csapat az Amerikai Egyesült Államok Védelmi Minisztériumának pályázatára fejlesztette ki az Ada programozási nyelvet 1977-1983 között. A nevét Lady Ada Lovelace (1815-1852) után kapta, aki Charles Babbage (ő az első személy, aki előállt a programozható számítógép ötletével) barátja és bizalmasa volt.
A fejlesztés fő irányelve az volt, hogy az új nyelv elősegítse nagyméretű programok létrehozását, azok stabilitásának növelését. Ennek megfelelően a legbiztonságosabb, típusokon alapuló programozási nyelvként tekinthetünk rá. A biztonságon levő hangsúllyal nem meglepő, hogy az Ada egy erősen típusos nyelv: minden adatelemet előre definiálni kell egy bizonyos típusú vagy altípusúként, valamint folyamatos a típusellenőrzés a modulok között és azokon belül is. Teljes körű támogatást nyújt a szekvenciális vezérlőstruktúrákhoz, valamint a minden részletre kiterjedő hibakezeléshez.
Eredetileg úgy tervezték, hogy ez lesz az egyetlen nyelv, amit az Amerikai Egyesült Államok Védelmi Minisztériuma szoftverfejlesztésre használni fog, de ez a vezérelv sosem terjedt el. Az Ada egy szigorúan szabályozott és jól dokumentált nyelv. A fordítók szigorú alkalmassági teszteken kell, hogy átmenjenek. Nem is csoda, hogy 1995-ig egyetlen(!) dialketusa volt, az Ada 83.

1974 telén Paul Allen, egy 21 éves, nagy szakállú, hosszú hajú fickó, hetekik győzködte barátját, hogy hagyja ott az egyetemet, és alapítsanak együtt egy szoftvercéget. A két évvel fiatalabb srác azonban az utolsó pillanatban meggondolta magát, és folytatta tanulmányait a Harvardon. Az illetőt Bill Gates-nek hívták. 1975 januárjában aztán megjelent a Popular Electronics, címlapján az Altair 8800-zal. A számítógépet 439 dolláros áron kit készletként (a felhasználónak otthon kellett összeforrasztania a gépet) árulták, de kb. másfélszeres áron (621 dollár) összeszerelve is meg lehetett vásárolni. A gépben az Intel 8080-as processzora volt, alapkiépítésben 256 byte RAM-ot tartalmazott. Szoftver viszont nem volt hozzá...
Allen felismerte a gép jelentőségét, tudta, hogy erre vártak eddig - egy olcsó számítógép, szoftver nélkül. Az egész éjszakát átbeszélték. Másnap felhívták Ed Roberts-et, a MITS főnökét, és blöfföltek: "Van egy BASIC-ünk", mondták. Miután Roberts már tucatjával kapott naponta hasonló hívásokat, rutinosan szerelte le a fiúkat: "Aki először mutat egy működő BASIC-et, azé a szerződés".
A feladat tehát adott volt. Gyorsan írni kellett egy BASIC értelmezőt, mielőtt más megelőzné őket. Volt azonban egy kis probléma. A fiúk még csak fényképen láttak Altair-t, és ezidáig még az Intel 8080-t se ismerték. Allen tehát fogta az Intel 8080 dokumentációját, és gyorsan írt egy emulátort PDP-10-re. Szerencsére ez a feladat nem volt idegen számára, korábban már írt egy Intel 8008 emulációt, így volt gyakorlata ilyen téren. Eközben Gates abbahagyta tanulmányait a Harvard-on, és elkezdte tervezni a BASIC-et - fontos kritérium volt, hogy beleférjen 4kB-ba. Miközben Gates évfolyamtársai egyszerű kártyajátékokat írtak BASIC-ben, addig ő assembly-ben egy új BASIC értelmezőt fejlesztett. A matematikai lebegőpontos rutinok azonban kifogtak rajtuk, emiatt harmadik embernek felfogadták maguk mellé Monte Davidoff harvardi diákot, akinek volt már tapasztalata hasonló rutinok elkészítésében.
A program végül alig három hónap alatt elkészült. A BASIC-et Paul Allen vitte el Új-Mexikóba, a MITS-hez, egy papírszalagon. Az út közben, a repülőgépen ülve írta meg a jegyzetfüzetébe azt a pár tíz bájtos programot, amivel a lyukszalagról lehetett beolvasni az Altair-be a BASIC-et. Induláskor aggódtak, vajon működni fog-e a program - az emulátoron ugyan működött, de mi van, ha hibás az emuláció?
Szerencsére működött, az első parancs, amit kipróbáltak, a PRINT 2+2 volt.
A szerződés megköttetett. Paul Allen és Bill Gates megalapította a Micro-Soft-ot (akkoriban még így, kötőjellel írták a cég nevét), és az Altair BASIC lett az első kereskedelmi szoftver, ami mikroszámítógépre jelent meg. A programot a MITS árulta, a Micro-Soft jogdíjat kapott minden eladott példány után. A 4kB-os változat 60$-ba, a 8kB-os 75$-ba került.
Az Altair Basic az alapja a Microsoft összes későbbi BASIC verziójának, ezt továbbfejlesztve készítették el számos géptípusra a Microsoft BASIC-et, majd az MBASC-et CP/M-re, az Osborne 1 számítógép megjelenésekor. A BASIC interpreterek a Microsoft üzleti tevékenységének középpontjában maradtak az 1980-as évek elejéig, az MS-DOS megjelenéséig.

Szintén 1974-ben kezdett BASIC-et fejleszteni Gordon Edwin Eubanks, de ő egészen más okból: A kaliforniai Monterey-i Haditengerészeti Posztgraduális Iskolában tanult, a diplomamunkájához fejlesztett egy BASIC-et, tanára - Gary Kildall - ösztönzésére, - hogy, hogynem - az új CP/M operációs rendszerhez. A BASIC-E nevet kapó BASIC fordítós BASIC volt. A forrásnyelvi programot egy köztes p-kódba fordította, amelyet aztán egy különálló futásidejű interpreter hajtott végre. Ez ugyan kicsit kényelmetlenebb volt, mint az interpreteres Microsoft BASIC, de számos előnyökkel is rendelkezett, úgy mint, kevesebb RAM-igény (ez akkoriban igen súlyos szempont volt...), gyorsabb futás, fordítás közbeni hibafelismerés.
Az IMS Associates, Inc. (egy mikroszámítógépeket gyártó cég volt, legismertebb termékük az IMSAI 8080 számítógép, ami egy Altair 8800 klón) látott is fantáziát a BASIC-E-ben, de volt egy akadály. Mivel Eubanks tanulmányait a Haditengerészet finanszírozta, a diplomamunkához fejlesztett nyelv nem hozható kereskedelmi forgalomba. Seymour Rubinstein , az IMSAI marketingigazgatója felvette a kapcsolatot Eubanksszal, és szerződést ajánlott, miszerint készítsen egy eladható verziót az IMSAI 8080 számítógéphez. Eubanks elfogadta az ajánlatot és a következő évben, szabadidejében fejlesztette tovább a BASIC-et, amikor még tengerésztisztként állomásozott az USS George Washington tengeralattjárón, Vallejo-ban (Kalifornia államban). Az 1977-ben elkészült CBASIC nagyon népszerűvé vált a CP/M felhasználók körében. Legfőbb erénye - a Microsoft termékéhez viszonyított ára mellett - a bináris kódolású decimális (BCD) számábrázolás. Ezzel a módszerrel a számok konverziója és megjelenítése lényegesen egyszerűbbé, a számábrázolás pontosabbá - ugyanakkor valamivel lassabbá - válik. Ez a számábrázolás csak jó pár évvel később válik általánossá a mikrogépeken, ebben bizony az Enerprise IS-BASIC-je is úttörőnek számít!

1978-as hirdetés

1977-ben pár hónap eltéréssel megjelentek az első otthoni felhasználásra szánt (megfizethető) számítógépek: az Apple II (június), TRS-80 Model I (augusztus), és a Commodore PET (október). Az már többé nem működik, hogy otthon este papa, mama, gyerekek kapcsolók állítgatásával programoznak be egy betöltő rutint, ami betölt valamiféle nem létező programot. Szükség van tehát valami programozási nyelvre, ami:

• ROM-ban van - tehát belefér nem túl sok ROM chip-be (a költséghatékonyság is szempont) -, és így bekapcsolás után máris rendelkezésre áll.
• Elég kicsi, hogy működjön a kor 8 bites számítógépeinek mindössze 4-16 kB majd később 64 kB RAM memóriájával is.
• A nyelv általános célú, kellően interaktív, tehát interpreteres nyelv (papa, mama, gyerekek tanácstalanul néznének, ha "alapos programtervezést és kódolást" követően, a C fordító hárommenetes fordítás végén hibát jelezne...)
• Kazettás rendszerben is működik (lehet, az adott géphez nem is illeszthető drága lemezmeghajtó)
• Könnyen tanulható, kezdők is hamar elsajátíthatják használatát. (Lisp, FORTH kiesik...)
• Létező implementáció kell, mégpedig mihamarább (Logo, Prolog kiesik)!

A BASIC viszont mindenben megfelel a fenti követelményeknek! Így vált a '80-as évek 8 bites gépeinek szinte egyeduralkodó elsődleges, ROM-ban tárolt programozási nyelve a BASIC. Kezdetben annak is a már - többféle processzorra - létező Microsoft BASIC verziói, ami kellően szűk implementáció volt, hogy teljesítse a hardware lehetőségeket (ez esetben inkább limitációkat). A BASIC alá még berakunk néhány, a hardware-t működtető rutint, amit KERNEL-bek hívünk (A Commodore: KERNAL-nak) és kész az interaktív home-computer! Igaz, a Microsoft sorra készítette a BASIC újabb verzióit, de alapjaiban nem változott. Így történhetett meg, hogy 1994-ben, Magyarországon 8000 Ft-ért árult, Microsoft licenc BASIC 2.0-át futtató Commodore 64-en egy BASIC sor maximális hossza 80 karakter lehetett, egy 1928-as, lyukkártyára vonatkozó szabvány miatt... De az ON GOTO, DATA is FORTRAN örökség (többek között).
Érdekesség, hogy röviddel az említett három home computer megjelenése előtt piacra került az "első" (?) 8 bites home-computer, aminek a neve nem hagy kétséget afelől, mire szánta a kaliforniai VideoBrain Computer Company: ez volt a "VideoBrain Family Computer". A gép a Fairchild Semiconductor F8 processzora köré épült, 1 KB RAM-mal és 4 KB ROM-mal rendelkezik és volt hangkeltés, 16 színű grafika is! Billentyűzete már volt (rendes mikrokapcsolós billentyűk!) és TV-re lehetett csatlakoztatni.. Ára kezdetben 500 és 1100 dollár között mozgott a választott csomagtól függően, ez később 350-900 dollárra csökkent. A kevéske program cartridge formájában volt megvásárolható. Hogy ne csak egy billentyűzettel rendelkező konzol legyen, szükség volt valamiféle programozási nyelvre is. Valamilyen megmagyarázhatatlan okokból azonban a fejlesztők nem a BASIC mellett tették le a voksukat: az APL egy változatát az APL/S választották. Érthető, hogy a kevés memória miatt tömör programnyelvre van szükség, de ennél még a FORTH is jobb választásnak tűnik. A gép nem is aratott üzleti sikert.
A Minimal BASIC már a '80-as évek elején is kevés volt, így a számítógépgyártók rákényszerültek, hogy a hardware lehetőségeihez illeszkedő (pl. grafika, hangkeltés) implementációkat készítsenek. Ennek is köszönhető, hogy rengeteg, egymással alig kompatibilis BASIC implementáció készült.
A mikroszámítógépekkel a FORTH aranykora is beköszöntött, a már említett okok miatt. 1982-ben megjelent Jupiter Ace 8 KB-os ROM-ja nem BASIC-et tartalmazott, hanem egy meglepően jól használható FORTH változatot. (A gép nem lett üzleti siker.) A nyelv könnyű bővíthetősége miatt mindenféle gépre mindenféle bővítéssel készültek implementációk szép számmal, köztük olyan komplex fejlesztő rendszerek, mint a White Lightning a memóriában éppen nem dúskáló ZX Spectrum-ra. De C16-ra is van Game-Forth.

Azzal a software-kiadók is tisztában voltak, hogy a BASIC tökéletes a kezdőknek, de a professzionálisabb felhasználókat már nem feltétlenül elégíti ki - már csak az interreter-es nyelvek lassúsága miatt sem. De mi a gond a 8-bites gépekre készült fordítós nyelvekkel? Egy program elkészítése ezeken a nyelveken a következő munkafolyamatokra tagolódik a feladat megfogalmazása után:

1. algoritmuskészítés (tervezés)
2. a forrásprogram szerkesztése, javítása. Ehhez valami szövegszerkesztő betöltése szükséges, amit többnyire nem tartalmazott a programcsomag.
3. a forrásnyelvi program fordítása, a jellemzően parancssoros compiler-programmal. Ha a fordítás szintaktikai hiba miatt sikertelen, visszaugrunk az előző munkafolyamatra... Nagyobb mérető fordítót igénylő programozás nyelv esetében először egy közbenső kód jön létre, így ez a munkafolyamat két részre oszlik.
4. A lefordított kódból futtatható file előállítása, azaz a programkód és a programnyelv által biztosított könyvtári rutinok összefűzése. Ha a program nem létező rutint / eljárást hív, az természetesen hiba, visszaugrunk a 2. pontra.
5. Ha előáll a futtatható állomány, következik a tesztelés, ahol ellenőrizzük, hogy a program szemantikailag helyes-e. Ha nem, következik a hibakeresés. Ha szerencsénk van, és a programcsomag tartalmaz hibakeresésre / nyomkövetésre alkalmas debugger programot, amivel megtalálhatjuk a hiba okát és a 2. pontra ugorhatunk. Ha nincs ilyen eszköz, ugrás az 1. pontra...
6. A dokumentálást most nem is részletezzük...

A fejlesztői ciklus - amíg egy programból eredményt látunk - óhatatlanul meghosszabbodik. A forrásprogram hibáinak jelzése a fordítás közben azért nehézkes, mert minden hibához igen sok "következmény" hiba is csatlakozhat, ami áttekinthetetlenné teszi a hibajelzéseket. Sok fordító ezért inkább leáll az első észlelt hibánál, ezeket így egyenként lehet kiszűrni. Nagyszámítógépre ugyan már léteztek integrált fejlesztői környezetek (IDE - olyan software alkalmazás, ami mindezen felsorolt eszközöket egybe integrálva tartalmazza) de ez a mikroszámítógépek memóriájába nem fér bele(?)
Nem így gondolta Anders Hejlsberg dán software-mérnök, aki először Nascom mikroszámítógéphez készített egy Pascal-fordítót 1980-ban. A fenti munkafolyamatot ő is kényelmetlennek és lassúnak érezte, így ebből a fordítóból kerekedett ki a 8-bites számítógépek (természetesen CP/M-hez való) első integrált fejlesztői környezete, a PolyPascal. Niels Jensen, Ole Henriksen, Mogens Glad és Philippe Kahn 1983-ben megalapította a Borland-ot és rögtön "lecsapott" a programcsomagra, ugyanakkor maga Hejlsberg is elszegődött a Borland szolgálatába. 1983-ban kiadták a programcsomagot Turbo Pascal néven, a következő két kiadása (2.x, 3.x) pedig az eredeti kódbázis inkrementális továbbfejlesztését képezte.
A Turbo Pascal lényegesen kiterjesztette a szabványos Pascal lehetőséget az egymást követő verziókban: megjelent a byte és file és string típus, megvalósította a string-kezelést, számos új eljárás bővítette ki a nyelv lehetőségeit. Az overlay technika pedig igyekezett megkerülni a 64 kByte-os memóriakorlátot. A programcsomag használatát az egyszerű és intuitív menürendszer tette kényelmessé. A fordító ezek ellenére nagyon gyors volt, hiba esetén a szerkesztő-mód azonnal a hiba helyére ugrott. A szövegszerkesztőjét az akkor már de facto szabvány WordStar szerkesztőről mintázták.
A Turbo Pascal-nak nem kevés érdeme volt abban, hogy a Pascal széles körben ismertté váljon (csaknem minden más implementációt kiszorított a piacról). 8080 / Z80 és PC-s (x86) verziója is volt, így életútja messze túlmutat a 8-bites gépek "világán".

Enterprise-ra - mondhatjuk némi költői túlzással - a bőséges a választék programozási nyelvekből, nagyobbrészt persze CP/M verzióknak köszönhetően:

• Altair BASIC: PoviSoft-ot ihlette meg, hogy interneten megtalálható a BASIC disassemblált kódja és készített Enterprise-verziót.
• Hisoft-Pascal: a standard Pascal csaknem teljes implementációja. Eredetileg magnós rendszerbe készült, nincs benne file-kezelés. Ennek pótlására egyszerű alternatív megoldást tartalmaz. Sajnos dokumentáció nem volt hozzá, így rejtve maradtak képességei. Povi készített belőle némi javítgatással egy remekül használható eszközt.
• IS-Lisp: Ehhez volt - egyébként csapnivaló színvonalú - dokumentáció, mégsem használta senki... Szövegfüzérkezelő függvények nincsenek implementálva.
• Brainfuck Compiler: ez nem "korabeli" programozási nyelv, és nem is nagyon használható "valós" feladatok elvégzésére. A cél a lehető legkisebb fordítóprogram elkészítése volt.
• A Spectrum - , CPC -, ZX81 emulátorok tökéletesen alkalmasak a BASIC használatára.

CP/M-verziók:

• Algol-M: szakdolgozathoz készült, nem került kereskedelmi forgalomba. Nem is lett volna alkalmas erre: noha az ALGOL-M az ALGOL 60 mintájára készült, fejlesztésekor nem volt szándék, hogy a nyelvnek formális részhalmazává tegyék. Előre definiált függvények egyáltalán nincsenek. Kár, némi fejlesztéssel jól használható eszköz vált volna belőle. Nem futtatható állományt fordít.
• Aztec C: Az 1980-ban alapított Manx Software Systems C programozási nyelvű fordítóprogramokra szakosodott. Fő termékük az Aztec C volt, mellyel jelentős üzleti sikereket értek el, ennek legfőbb oka, hogy a Z80-as fordító támogatta lebegőpontos számábrázolást. Az Aztec korának egyik legáltalánosabban használt C fordítója volt. Bár a C alapvetően nem a 8 bites rendszerek programozási nyelve volt, ennek ellenére meglepően teljes implementáció.
• BASIC-E, C-BASIC: A BASIC-E diplomamunkához készült, így nem kerülhetett kereskedelmi forgalomba. Ennek továbbfejlesztett változata lett a C-BASIC. Érdekes, "hibrid" BASIC mindkettő: a sorszámozás nem kötelező, a struktúrált programozást azonban még nem támogatja teljes körűen. Fordítós BASIC, de sajnos nem futtatható állományt fordít, hanem egy közbenső kódot. A Microsoft BASIC mellett korának második legkedveltebb BASIC-je volt.
• BBC-BASIC: Az Acorn Computers Ltd fejlesztette ki a BBC megrendelésére 1981-ben. Tartalmaz egy beépített assemblert.
• C/80
• Cobol-80: A Microsoft implementációja. Fő riválisa a Micro Focus COBOL volt.
• Fortran-80: A Microsoft 1977 júliusától árusította a FORTRAN-80 implementációját 8 bites mikroszámítógépekre. A komplex-típus nincs benne implementálva, de ez valószínűleg nem sokaknak hiányzott.
• Hisoft-C: A C 8-bites rendszerekre készült "bemutató" változata. Hiányzik belőle a float, double típus, ez behatárolja felhasználási területeit.
• LISP/80
• Micro-Prolog: 8 bites mikroszámítógépekhez készült verzió. ZX Spectrum, Commodore 64, BBC Micro, MSX, CP/M verzió készült belőle.
• Microsoft BASIC-80: a Microsoft BASIC legkiforrottabb, legbővebb 5.x verziója. "Hagyományos" interpreter-es BASIC. Az internetes archívumokban fellelhető BASIC-programok szinte kivétel nélkül futtathatóak vele. A BASIC programok általában szöveges formában tölthetőek le, ezeket be tudja tölteni (jó lassan), a SAVE parancs már a gyorsabban használható tokenizált formában ment.
• Mix-C
• PL/I-80: A Digital Research implementációja.
• PolyPascal-80, Turbo Pascal 1, 2: történeti jelentőséggel bíró változatok.
• Turbo-Pascal 3: Turbo Pascal legkiforrottabb verziója, ami futtatható 8 bites rendszereken.
• Turbo-Modula-2: a Turbo Pascal-hoz hasonlító integrált fejlesztői környezetet biztosít.
• Z80 fig-FORTH: szabványos fig-FORTH verzió. Disassemblált - megjegyzésekkel ellátott - kód is van hozzá.

Variációk egy témára
Első példa egy egyszerű sebességteszt, ami elsősorban az aritmetikai utasítások végrehajtási idejét teszteli. A program funkciója minden esetben azonos: egy 15000-szer lefutó ciklusban A változóba a ciklusváltozó modulo 2-es (egész)osztását, B változóba egy összeadást eredményét (ciklusváltozó értéke plusz 3), C változóba a ciklusváltozó értékének kétszeresét tölti.

A végrehajtási idők, EXOS 2.4 operációs rendszerrel, 4 MHz órajelen:

C-BASIC v2.08	1006 s
IS-BASIC 2.1	508 s
IS-LISP	201 s
BBC BASIC 3.0	145 s
MBASIC 5.2	116 s
ALTAIR BASIC 4.0 (8K)	78 s
Locomotive BASIC (CPCEmu)	60 s
IS-BASIC 2.1 / ZZZIP	23 s
IS-FORTH	19 s
Hisoft-C 1.33	18 s
Z80 fig-Forth 1.1g	17 s
Fortran-80 v3.44	14 s
Aztec C 1.06d	12 s
Turbo Pascal 3	12 s
Hisoft-Pascal	8 s

Második példaként álljon itt a '21 játék' (ugyanaz, mint a gyufaszál húzó játék, csak nullától előre számolunk) öt különböző nyelvű változata. Ebben látunk példát ciklusszervezésre, feltételes szerkezetre is. Érdekesség, hogy Enterpress Pascal cikksorozat I. részében Hajnal Csaba azt írja az IS-BASIC-ről, hogy "egyáltalán nem szabványos alig-BASIC", ehhez képest mindent szabványosan csinál, a vezérlési szerkezetek pedig később a Visual BASIC-ben ugyanebben a formában köszönnek vissza...

Vissza