AI Disclosure: A cikk elkészítéséhez generatív AI-eszközöket is használtam. A végső tartalomért és annak pontosságáért a szerző vállal felelősséget.
Van egy gondolat, ami egy ideje egyre többször eszembe jut az AI-os fejlesztés kapcsán. Nem az, hogy mennyire jól vagy rosszul ír kódot az AI, hanem az, hogy vajon meddig fogjuk még magát a kódot úgy kezelni, mint egy szoftverprojekt legfontosabb artefaktumát.
Ma ez teljesen természetesnek tűnik. Ha belenézek egy repositoryba, akkor ott van a source code, és alapvetően ebből áll maga a program. Mellette vannak tesztek, dokumentációk, konfigurációk, issue-k és mindenféle egyéb kiegészítő információk, de végül mégis a kód az, amit a rendszer valódi megvalósításának tekintünk.
Csakhogy ez nem valami örök érvényű törvény. Azért alakult így, mert történelmileg erre volt szükségünk.
Miért pont ilyenek a programozási nyelvek?
A mai programozási nyelvek egy olyan világ termékei, ahol az ember ült a gép előtt, és neki kellett pontosan elmondania a számítógépnek, hogy mit csináljon.
A programozás története ebből a szempontból tulajdonképpen egy hosszú absztrakciós folyamat. A gépi kódtól eljutottunk az assemblyig, onnan a magasabb szintű nyelvekig, majd olyan nyelvekig és keretrendszerekig, ahol már szinte egyáltalán nem kell foglalkoznunk azzal, hogy a processzor pontosan mit csinál.
Egy C programban már változókról és függvényekről beszélünk. Egy modern TypeScript alkalmazásban komponensekről, modulokról, interfészekről és üzleti logikáról. Rengeteg olyan részletet elrejtettünk a fejlesztő elől, amivel korábban még közvetlenül foglalkoznia kellett.
Ennek az egyik legfontosabb oka mindig az volt, hogy az embernek könnyebb legyen programot írni.
A nyelv szintaxisa, az absztrakciók, a típusok, a különböző programozási paradigmák és fejlesztői eszközök mind azt szolgálták, hogy egy ember fejben tartsa és kifejezze azt a rengeteg szabályt és összefüggést, amiből egy program áll.
Ezért érdekes, hogy mi történik akkor, amikor a programot már nem feltétlenül egy ember írja.
Mi változik, ha az AI írja a kódot?
Az AI számára ugyanis egészen más szempontok lehetnek fontosak, mint egy embernek.
Egy fejlesztő számára számít, hogy egy nyelv szintaxisa mennyire olvasható, mennyire könnyű megjegyezni, mennyire kényelmes benne dolgozni, vagy hogy egy adott absztrakció mennyire illeszkedik az emberi gondolkodáshoz.
Egy AI esetében ezek egy része egyszerűen elveszítheti a jelentőségét.
Nem feltétlenül probléma számára egy olyan szintaxis, amit egy ember nehezebben olvas. Nem feltétlenül kell ugyanúgy optimalizálni a nyelvet az emberi munkamemóriához, mint ahogy eddig tettük. Ha egy gép egy adott struktúrából nagyon megbízhatóan képes rekonstruálni a program működését, akkor akár olyan nyelvi megoldások is értelmessé válhatnak, amelyek nekünk elsőre meglehetősen furcsának tűnnének.
És itt szerintem nem is az a legérdekesebb kérdés, hogy milyen lesz majd a következő programozási nyelv.
Hanem az, hogy egyáltalán szükségünk lesz-e ugyanarra a szerepre a programozási nyelvre, mint ma.
Lehet, hogy a jövőben továbbra is lesz TypeScript, Rust vagy valamilyen ezekhez hasonló nyelv, csak egyszerűen egyre kevésbé mi fogjuk közvetlenül írni. Az AI előállítja majd, módosítja, refaktorálja, és adott esetben akár másik nyelvre is átülteti.
Ebben az esetben viszont a source code lassan köztes réteggé válik az emberi szándék és a futó program között.
De akkor mi lesz az igazi artefaktum?
Ez az a pont, ahol szerintem igazán érdekes lesz a változás.
Ma ha egy fejlesztő elhagy egy projektet, akkor az egyik legfontosabb dolog, amit maga után hagy, a kód. Abból kell megérteni, hogyan működik a rendszer. Persze jó esetben van dokumentáció, vannak tesztek, vannak ticketek és különböző tervezési anyagok, de végül a kód az, ami ténylegesen meghatározza, mit csinál a program.
Egy AI-val támogatott világban viszont elképzelhető, hogy ez a sorrend megváltozik.
Lehet, hogy sokkal fontosabb lesz maga a specifikáció, a domain modell, az üzleti szabályok, a rendszer korlátai és a tesztek összessége. Azok a dolgok, amelyekből meg lehet mondani, hogy mit kell tudnia a rendszernek, nem csak az, hogy hogyan valósítottuk meg.
A konkrét source code pedig ennek egy lehetséges megvalósítása lesz.
Ez elsőre talán nem tűnik nagy változásnak, pedig az. Ma ha egy alkalmazást Laravelben és TypeScriptben írtunk meg, akkor az alkalmazás lényegében az a Laravel- és TypeScript-kód. Ha technológiát akarunk váltani, újra kell építenünk a rendszert.
Ha viszont egyszer eljutunk oda, hogy a rendszer valódi specifikációja ennél magasabb szinten létezik, akkor elméletileg ugyanabból a specifikációból többféle implementáció is előállítható.
Nem a TypeScript alkalmazást fordítjuk át Rustra. Hanem ugyanazt a rendszert állítjuk elő Rustban.
Persze ettől még nagyon messze vagyunk. Egy valódi szoftver specifikációja közel sem olyan egyszerű, mint egy pár oldalas dokumentum. Rengeteg döntés, kivétel, üzleti szabály és implicit tudás van egy rendszerben, amit ma sokszor csak a kódból lehet visszafejteni.
Ráadásul maga a specifikáció is lehet pontatlan. Ha azt írom, hogy „a felhasználó akkor vásárolhat, ha van elegendő pénze”, abból még nem derül ki, mi történik két párhuzamos vásárlásnál, mikor foglaljuk le az összeget, mi történik sikertelen fizetésnél, vagy mi számít egyáltalán elegendő egyenlegnek.
A kód egyik nagy előnye éppen az, hogy ezeket a dolgokat végül valamilyen nagyon konkrét formában kénytelenek vagyunk megfogalmazni.
Lehet, hogy a programozási nyelv is átalakul
Éppen ezért nem gondolom, hogy a programozási nyelvek egyszer csak eltűnnek.
Sokkal valószínűbbnek tartom, hogy átalakul a szerepük.
Ahogy ma már nem gondolkodunk assemblyben, amikor egy webalkalmazás üzleti logikáját tervezzük, lehet, hogy idővel a source code is egy olyan réteggé válik, amivel közvetlenül egyre kevesebbet foglalkozunk.
Lehet egy magasabb szintű, gép számára is pontosan értelmezhető specifikáció. Abból létrejöhet valamilyen köztes reprezentáció, abból pedig az AI előállíthatja a konkrét programozási nyelvű implementációt.
És érdekes módon ez nem is lenne teljesen új gondolat. A fordítóprogramok már ma is pontosan ezt csinálják bizonyos értelemben. Mi írunk egy magasabb szintű nyelven, a fordító pedig létrehozza azt a formát, amit a gép végül végrehajt.
Az AI ebben a modellben egyszerűen egy újabb absztrakciós réteg lehet.
A különbség az, hogy eddig főleg azt próbáltuk elérni, hogy az ember könnyebben tudjon programot írni. Most először van lehetőségünk arra, hogy azt mondjuk: talán nem is nekünk kell többé közvetlenül megírnunk.
És ha ez valóban így lesz, akkor idővel nem biztos, hogy az lesz a legfontosabb kérdés, hogy milyen programozási nyelvet használunk.
Lehet, hogy sokkal fontosabb lesz az, hogy milyen pontosan tudjuk leírni a rendszert, amit szeretnénk.
Mert ha az AI bármikor elő tud állítani egy új implementációt, akkor maga az implementáció akár eldobhatóvá is válhat. A valódi érték pedig azokban a dolgokban marad, amelyekből az implementáció újra és újra előállítható.
És talán itt történik majd az igazán nagy változás.
Nem az lesz a kérdés, hogy milyen nyelven írjuk meg a programot, hanem hogy mi az, amit egyáltalán érdemes megőrizni a programból.
AI Disclosure: A cikk elkészítéséhez generatív AI-eszközöket is használtam. A végső tartalomért és annak pontosságáért a szerző vállal felelősséget.