Az AI korszakának modern nyelve

Modern nyelvek

A modern nyelv olyan nyelvet jelent, amely a korábbi nyelvekhez képest magasabb termelékenységet, stabilitást, biztonságot és karbantarthatóságot biztosít. Ezek a nyelvek aktívan alkalmazzák a legújabb technikákat és koncepciókat, és hatékonyabb, biztonságosabb fejlesztői eszközöket kínálnak a fejlesztők számára. Tipikus modern nyelvek közé tartozik a Java, a Rust, a Python, a TypeScript stb., amelyek a következő jellemzőkkel rendelkeznek.

1. Objektumorientált tervezés ( OOP )

A modern nyelvek többsége az objektumorientált koncepciókon alapul. Az objektumorientáltság olyan elveket támogat, mint a encapsulation, inheritance, polymorphism, és a komplex rendszerek kisebb egységekre, objektumokra bontásával áttekinthetővé és rugalmassá teszi a program szerkezetét. Ez különösen hatékony a nagyméretű szoftverek fejlesztésekor a fejlesztési költségek és erőfeszítések szabályozásában, valamint a karbantartás során felmerülő problémák csökkentésében.

2. Szintaktikai cukor és kifejezések

A modern nyelvek különféle szintaktikai cukrokat és kifejezésalapú szintaxist kínálnak a kód olvashatóságának és a fejlesztési termelékenység növelése érdekében. Az olyan funkciók, mint a ternary operator, a lambda expression, a pattern matching, csökkentik a boilerplate kódot, kiszámíthatóvá teszik a kódot, és javítják a fejlesztő termelékenységét.

3. Modulrendszer

A modern nyelvek lehetővé teszik a programok több egységre bontását és kezelését a modulrendszeren keresztül. Ez megkönnyíti a kód újrahasználatát és a függőségek kezelését, valamint egyszerűbbé teszi a karbantartást még a projekt méretének növekedése esetén is. Tipikus példák erre a Java Maven/Gradle, a Rust Cargo, a TypeScript npm/yarn rendszere.

4. Köztes nyelv és virtuális gép

A modern nyelvek a platformfüggetlenség, a teljesítményoptimalizálás és a biztonság érdekében köztes nyelveket és virtuális gépeket alkalmaznak. Tipikus példák erre a JVM, LLVM, WASM, GraalVM stb.

Fejlesztés az AI korszakában és a modern nyelvek korlátai

A modern nyelvek azon a feltételezésen alapultak, hogy a kódot nagyrészt emberek írják. Természetesen a modern nyelvek célja az ismétlődő feladatok csökkentése, a termelékenység növelése, valamint a nagyméretű szoftverek hatékony megvalósítása olyan struktúrákon keresztül, amelyek lehetővé teszik a fejlesztők együttműködését. Az AI korszakában azonban ez a feltételezés egyre inkább megdől. Az AI-alapú eszközök, mint a Copilot, Cody, automatizálják a kódírás jelentős részét, és drámaian megnövelik a kód mennyiségét, amelyet egyetlen fejlesztő képes előállítani. Ennek következtében a modern nyelvek olyan jellemzői, amelyeket korábban előnyként éreztek, fokozatosan elavult hátrányokká válnak.

Objektumorientált tervezés

Az AI gyorsan és pontosan képes elemezni olyan struktúrákat, ahol minden információ egyetlen függvényben vagy modulban van expliciten megadva. Ezzel szemben, minél több a context, annál több részletet kell következtetnie, ezért az AI termelékenysége és pontossága csökken. Az OOP-ben írt kód a logikát nem egyetlen helyen kezeli, hanem több objektum között osztja szét, ami végeredményben több contextet igényel az AI-tól. Nézzük az alábbi kódot.

 1public class AnimalHandler {
 2    public void handle(Animal animal) {
 3        animal.speak();
 4    }
 5}
 6
 7public class Main {
 8    public static void main(String[] args) {
 9        AnimalHandler handler = new AnimalHandler();
10
11        Animal a1 = new Dog();
12        Animal a2 = new Cat();
13        Animal a3 = new Horse();
14
15        handler.handle(a1);
16        handler.handle(a2);
17        handler.handle(a3);
18    }
19}

A fenti kódban az AI-nak a következő következtetéseket kell ismételnie ahhoz, hogy megtudja, a speak() metódus valójában mit csinál:

1. Az animal milyen konkrét osztály példánya?
2. Hol van definiálva a speak() metódus, amelyet az adott osztály felülír?
3. Hol vannak a Dog és Cat osztályok definíciói, és mi a belső működésük?
4. Van-e lehetőség arra, hogy a Dog és Cat osztályokat más osztályok felülírják?

Ezek az információk nincsenek egyetlen fájlban vagy függvényben összegyűjtve, csak az osztályfájlok közötti kapcsolatok és az öröklődési struktúra követésével érthetők meg. Ráadásul az olyan futásidőben eldőlő tényezők, mint a reflection vagy a dynamic loading, az AI szempontjából fekete doboznak számítanak, így gyakorlatilag lehetetlen az elemzésük.

Szintaktikai cukor és kifejezések

Az AI az explicit műveleteket preferálja az implicit műveletekkel szemben, és inkább egyszerű struktúrákat kombinál egyetlen helyes válasz létrehozásához, mintsem komplex struktúrákat használna. Ezzel szemben a szintaktikai cukor különféle kifejezéseket tesz lehetővé, miközben a belső működésük gyakran azonos vagy hasonló. Az AI-nak egyenként meg kell tanulnia e különböző kifejezések jelentését, és nehézségekbe ütközhet annak eldöntése, hogy egy adott helyzetben melyik szintaxist ajánlja előnyben.

Köztes nyelv és virtuális gép

Az AI nagyrészt a forráskód alapján tanul. Ezzel szemben a köztes nyelvből (bytecode) a változónevek és egyéb jelentések eltávolításra kerülnek a fordítási folyamat során, és a virtuális gépnek kell újraértelmeznie azokat a futás pillanatában. Ez egy nagyon nehéz feladat az AI számára a megértéshez vagy átalakításhoz. Például az AI képes átalakítani TypeScript kódot Go kóddá, de a V8 engine bytecode-jának JVM bytecode-dá vagy gépi kóddá alakítása gyakorlatilag lehetetlen.

Az AI korszak igazi modern nyelve

A fenti tartalmon keresztül láthatjuk, hogy a modern nyelvek jellemzői valójában elavult elemek, amelyek nem alkalmasak az AI korszakára. Akkor melyik nyelv lehet a legmegfelelőbb modern nyelv az AI korszakában? Erre a korábbi modern nyelvek által elutasított elemekből kaphatunk tippet. Az AI korszak modern nyelve:

1. Explicit szintaxissal és természetes folyamattal kell rendelkeznie.
2. Túl sok OOP struktúrától mentes, lapos és egyszerű struktúrával kell rendelkeznie.
3. A szükségtelen szintaktikai cukor vagy implicit minták helyett korlátozott alapvető kulcsszavakkal hoz létre különféle funkciókat.
4. Komplex build rendszer helyett egyszerű és kiszámítható build rendszerrel kell rendelkeznie.

Az ilyen kritériumoknak leginkább megfelelő nyelv a Golang. A Go nyelvet úgy tervezték, hogy minimális alapvető kulcsszavakkal és egyszerű szintaktikai kombinációkkal is képes legyen megvalósítani a legtöbb gyakorlati funkciót, és szigorúan kizárja a szükségtelen absztrakciót és az implicit műveleteket. Ez egy olyan struktúra, amely nemcsak a fejlesztők, hanem az AI számára is előnyös a kód értelmezésében és generálásában.

A Go olyan jellemzői, mint a kiszámítható és lapos struktúra, az explicit folyamat és a következetes szintaxis, ellentétben a humán fejlesztőkre szabott hagyományos modern nyelvekkel, jobban illeszkednek egy olyan fejlesztési környezethez, ahol az AI aktívan részt vesz. A Go konzervatív tervezési filozófiája, amelyet egykor elavultnak tartottak, paradox módon az AI korszakában válik a legelőremutatóbb választássá.