--- id: 2ceff210f0c200f8a3416690cac45bb5 author: Rabbit Princess title: 'Nyelvtervezési összehasonlítás LLM-alapú kódgenerálási környezetben: az absztrakció költsége és a Go explicitsége' description: Az objektumorientált polimorfizmus, a szintaktikai cukor és az összetett modulfa, amelyek megnövelik az LLM kontextusának következtetési költségét, elemzése, valamint annak vizsgálata, hogy az explicit vezérlési folyamattal és egyszerű szintaxissal rendelkező Go miért előnyös az AI-alapú kódgenerálás szempontjából. language: hu date: 2025-05-18T04:44:19.742674221Z path: /blog/posts/modern-language-of-the-ai-era-z2d7204f1 category: ai lang_canonical: ko: https://blog.naver.com/sjc02183/223844938175 --- ## Modern nyelvek A modern nyelvek olyan nyelveket jelentenek, amelyek a korábbi nyelvekhez képest nagyobb termelékenységet, stabilitást, biztonságot és karbantarthatóságot biztosítanak. Ezek a nyelvek aktívan alkalmazzák a legújabb technikákat és koncepciókat, és hatékonyabb, biztonságosabb fejlesztőeszközöket nyújtanak a fejlesztők számára. Jellemző modern nyelvek közé tartozik a Java, a Rust, a Python és a TypeScript, amelyek a következő jellemzőkkel rendelkeznek. ### 1. Objektumorientált tervezés ( OOP ) A modern nyelvek többsége objektumorientált koncepciókra épül. Az objektumorientáltság támogatja az olyan elveket, mint az egységbe zárás (encapsulation), az öröklődés és a polimorfizmus, és a komplex rendszereket kisebb egységekre, objektumokra bontva kezeli, ami a programok szerkezetét világossá és rugalmassá teszi. Ez különösen hatékony nagy méretű szoftverfejlesztés során a fejlesztési költségek és ráfordítások szabályozásában, valamint a karbantartás során felmerülő problémák csökkentésében. ### 2. Szintaktikai cukor és kifejezésalapú szintaxis A modern nyelvek a kód olvashatóságának és a fejlesztési termelékenységnek a növelése érdekében számos szintaktikai cukrot és kifejezésalapú szintaxist kínálnak. A ternáris operátor, a lambda-kifejezések és a mintaillesztés (pattern matching) ilyen funkciói csökkentik a sablonkód (boilerplate) mennyiségét, előre jelezhetővé teszik a kódot, és javítják a fejlesztők termelékenységét. ### 3. Modulrendszer A modern nyelvek modulrendszeren keresztül teszik lehetővé a program több egységre bontását és kezelését. Ez megkönnyíti a kód újrafelhasználhatóságát és a függőségek kezelését, valamint a projekt méretének növekedése esetén is egyszerűvé teszi a karbantartást. Jellemző példák erre a Java Maven/Gradle, a Rust Cargo és a TypeScript npm/yarn rendszere. ### 4. Köztes nyelvek és virtuális gépek A modern nyelvek platformfüggetlenség, teljesítményoptimalizálás és biztonság érdekében köztes nyelveket és virtuális gépeket alkalmaznak. Jellemző példák erre a JVM, az LLVM, a WASM és a GraalVM. ## Fejlesztés az AI korszakában és a modern nyelvek korlátai A modern nyelvek abból a feltevésből születtek, hogy a kód nagy részét emberek írják. Természetesen a modern nyelvek célja a ismétlődő munka csökkentése, a termelékenység növelése, valamint az a struktúra, amely lehetővé teszi a fejlesztők együttműködését és a nagy méretű szoftverek hatékony megvalósítását. Az AI korszakban azonban ez a feltevés fokozatosan megdől. Az olyan AI-alapú eszközök, mint a Copilot vagy 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 nő. Ennek következtében a modern nyelvek korábban előnyösnek érzett jellemzői fokozatosan elavult hátrányokká válnak. ### Objektumorientált tervezés Az AI könnyen és pontosan elemzi azokat a struktúrákat, amelyekben egy függvényen vagy modulon belül minden információ explicit módon szerepel. Ezzel szemben minél nagyobb a kontextus, annál több a következtetendő szakasz, ezért az AI termelékenysége és pontossága csökken. Az OOP alapú kód a logikát nem egy helyen kezeli, hanem több objektum között szétosztja, ami végeredményben több kontextust tesz szükségessé az AI számára. Nézzük az alábbi kódot. ```java public class AnimalHandler { public void handle(Animal animal) { animal.speak(); } } public class Main { public static void main(String[] args) { AnimalHandler handler = new AnimalHandler(); Animal a1 = new Dog(); Animal a2 = new Cat(); Animal a3 = new Horse(); handler.handle(a1); handler.handle(a2); handler.handle(a3); } } ``` A fenti kódban az AI-nak, hogy megértse, valójában mit csinál a speak() metódus, ismételten a következő következtetéseket kell levonnia: 1. Az animal melyik konkrét osztály példánya? 2. Az adott osztályban felülírt speak() metódus hol van definiálva? 3. A Dog és a Cat osztályok definíciói hol találhatók, és mi a működésük belsőleg? 4. Nincs-e lehetőség arra, hogy a Dog és a Cat osztályokat más osztályok felülírják? Ezek az információk nincsenek egy fájlban vagy egy függvényben összegyűjtve, hanem az osztályfájlok közötti kapcsolatok és az öröklődési szerkezet követésével érthetők meg. Ráadásul a futásidőben eldőlő elemek, mint a reflexió vagy a dinamikus betöltés, az AI szemszögéből fekete dobozhoz hasonlítanak, így gyakorlatilag elemezhetetlenek. ### Szintaktikai cukor és kifejezésalapú szintaxis Az AI a implicit működés helyett az explicit működést részesíti előnyben, és a komplex szerkezetek 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 sokféle kifejezést tesz lehetővé úgy, hogy belső működésük gyakran azonos vagy hasonló. Az AI-nak ezeknek a különböző kifejezéseknek a jelentését egyesével kell megtanulnia, és nehézzé válhat annak eldöntése, hogy adott helyzetben melyik szintaxist érdemes javasolnia. ### Köztes nyelv és virtuális gép Az AI többnyire forráskód alapján tanul. Ezzel szemben a köztes nyelv (bytecode) fordítási folyamat során elveszíti a változónevekhez hasonló jelentéstartalmakat, és futtatáskor a virtuális gépnek kell újraértelmeznie. Ez az AI számára rendkívül nehezen megérthető vagy átalakítható feladat. Például az AI számára a TypeScriptből Go nyelvre történő átalakítás lehetséges, ugyanakkor a V8 engine bytecode-jának JVM bytecode-ra vagy gépi kódra történő átalakítása gyakorlatilag lehetetlen. ## Az AI korszak igazi modern nyelve A fentiekből kiderül, hogy a modern nyelvek jellemzői valójában az AI korszakban nem alkalmasak, elavult elemek. Melyik nyelv lehet tehát az AI korszak legmegfelelőbb modern nyelve? Ennek megválaszolásában támpontot adhatnak azok az elemek, amelyeket a korábbi modern nyelvek elutasítottak. Az AI korszak modern nyelvének 1. explicit szintaxissal és természetes folyamatszerkezettel kell rendelkeznie; 2. a túlzott OOP struktúrát elhagyva síkszerű és egyszerű szerkezettel kell rendelkeznie; 3. a szükségtelen szintaktikai cukor és implicit minták helyett korlátozott számú alapkulcsszóval kell több funkciót megvalósítania; 4. összetett build rendszer helyett egyszerű és előre jelezhető build rendszerrel kell rendelkeznie. Ezeknek a szempontoknak a legjobban a Golang felel meg. A Go nyelvet úgy tervezték, hogy a legkevesebb alapvető kulcsszóval és egyszerű szintaktikai kombinációkkal is a gyakorlatban hasznos funkciók nagy részét megvalósíthassuk, és következetesen kizárja a szükségtelen absztrakciókat és az implicit működést. Ez nemcsak a fejlesztők számára, hanem az AI számára is előnyös szerkezet a kód értelmezése és generálása során. A kiszámítható és síkszerű struktúra, az explicit folyamatok és a következetes szintaxis felé törekvő Go jellemzői az emberi fejlesztőkre tervezett hagyományos modern nyelvekkel szemben jobban illeszkednek az olyan fejlesztési környezetekhez, ahol az AI aktívan részt vesz a munkában. A Go egykor elavultnak tartott konzervatív tervezési filozófiája így az AI korszakban éppen a legelőrehaladottabb választássá válik.