A modern nyelv az AI korszakában

Modern Nyelvek

A modern nyelvek olyan nyelveket jelentenek, amelyek a korábbi nyelvekhez képest magasabb termelékenységet, stabilitást, biztonságot és karbantarthatóságot biztosítanak. Ezek a nyelvek aktívan bevezetik a legújabb technikákat és koncepciókat, hatékonyabb és biztonságosabb fejlesztési eszközöket kínálva a fejlesztőknek. Jellemző modern nyelvek közé tartozik a Java, Rust, Python, TypeScript, melyek a következő tulajdonságokkal rendelkeznek.

1. Objektumorientált Tervezés (OOP)

A modern nyelvek többsége objektumorientált koncepciókon alapul. Az objektumorientált megközelítés támogatja az olyan alapelveket, mint a beágyazás, öröklődés és polimorfizmus, amelyek a komplex rendszereket kisebb egységekre, objektumokra bontva teszik átláthatóbbá és rugalmasabbá a program szerkezetét. Ez különösen hatékony a nagyméretű szoftverfejlesztés költségeinek és erőforrásainak ellenőrzésében, 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 biztosítanak a kód olvashatóságának és a fejlesztési termelékenység növelésének érdekében. Az olyan funkciók, mint a hármas operátor, lambda kifejezések és mintafelismerés, csökkentik a boilerplate kódot, kiszámíthatóbbá teszik a kódot, és növelik a fejlesztők termelékenységét.

3. Modulrendszer

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

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 nyelvet és virtuális gépet alkalmaznak. Jellemző példák: JVM, LLVM, WASM, GraalVM.

A Fejlesztés az AI Korszakában és a Modern Nyelvek Korlátai

A modern nyelvek azon a feltételezésen jöttek létre, hogy az emberek írják a kód nagy részét. 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 közötti együttműködést. Azonban az AI korszakában ez a feltételezés egyre inkább meginog. Az AI-alapú eszközök, mint például a Copilot és a Cody, a kódírás nagy részét automatizálják, és egyetlen fejlesztő által előállítható kód mennyisége robbanásszerűen megnövekedett. Ennek következtében a modern nyelvek korábban előnyként érzékelt jellemzői fokozatosan elavult hátrányokká válnak.

Objektumorientált Tervezés

Az AI gyorsan és pontosan tudja elemezni azokat a struktúrákat, ahol minden információ egyetlen függvényen vagy modulon belül expliciten meg van adva. Ezzel szemben, ahogy a kontextus növekszik, az inferencia területe is bővül, ami csökkenti az AI termelékenységét és pontosságát. Az OOP-ben írt kód nem egy helyen kezeli a logikát, hanem több objektumra osztja el, ami végső soron több kontextust igényel az AI-tól. Tekintsü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, valójában mit is tesz a speak() metódus:

1. Milyen konkrét osztály példánya az animal?
2. Hol van definiálva az adott osztályban felülírt speak() metódus?
3. Hol található a Dog és Cat osztályok definíciója, és mi a belső működésük?
4. Fennáll-e annak a lehetősége, hogy a Dog és Cat osztályokat más osztályokban is felülírják?

Ezek az információk nincsenek egy fájlban vagy egy függvényben összeszedve, hanem az osztályfájlok közötti kapcsolatokat és az öröklődési struktúrát kell követni a megértéshez. Ráadásul az olyan futásidőben eldőlő elemek, mint a reflection vagy a dinamikus betöltés, az AI számára fekete doboznak számítanak, így elemzésük gyakorlatilag lehetetlen.

Szintaktikai Cukor és Kifejezések

Az AI a rejtett műveletek helyett a explicit műveleteket részesíti előnyben, és a komplex struktúrák használata helyett inkább az egyszerű struktúrák kombinálásával hoz létre egyetlen helyes megoldást. Ezzel szemben a szintaktikai cukor változatos kifejezéseket tesz lehetővé, miközben belső működésük gyakran azonos vagy hasonló. Az AI-nak egyesével kell megtanulnia ezen változatos kifejezések jelentését, és nehézséget okozhat számára annak eldöntése, hogy melyik szintaxist javasolja egy adott helyzetben.

Köztes Nyelv és Virtuális Gép

Az AI nagyrészt forráskódon alapulóan 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ás során, és a virtuális gépnek futásidőben újra kell értelmeznie azokat. Ez rendkívül nehéz feladat az AI számára a megértéshez vagy átalakításhoz. Például az AI számára a TypeScript Go-ra való konvertálása lehetséges, de a V8 engine bytecode-jának JVM bytecode-ra vagy gépi kódra való konvertálása gyakorlatilag lehetetlen.

A Valódi Modern Nyelv az AI Korszakában

A fentiek alapján 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? A választ azokban az elemekben találhatjuk meg, amelyeket a korábbi modern nyelvek elvetettek. Az AI korszakának modern nyelve

1. explicit szintaxissal és természetes folyamattal kell rendelkeznie.
2. el kell szakadnia a túlzott OOP struktúráktól, és lapos, egyszerű szerkezetet kell felmutatnia.
3. a felesleges szintaktikai cukor vagy implicit minták helyett korlátozott számú alapvető kulcsszóval kell megvalósítania számos funkciót.
4. nem komplex, hanem egyszerű és kiszámítható build rendszerrel kell rendelkeznie.

Ezen kritériumoknak a Golang felel meg a legjobban. A Go nyelv úgy lett megtervezve, hogy minimális alapvető kulcsszavakkal és egyszerű szintaktikai kombinációkkal is megvalósítható legyen a legtöbb gyakorlati funkció, és szigorúan kizárja a felesleges absztrakciókat és implicit műveleteket. Ez a struktúra 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 kiszámítható és lapos szerkezete, explicit folyamata és következetes szintaxisa, ellentétben az emberi fejlesztőkre tervezett hagyományos modern nyelvekkel, jobban illeszkedik az AI aktív részvételével zajló fejlesztési környezethez. A Go konzervatív tervezési filozófiája, amelyet egykor elavultnak tartottak, az AI korszakában éppen a legelőremutatóbb választássá válik.