GoSuda

Moderne taal in het AI-tijdperk

By Rabbit Princess
views ...

Moderne Talen

Moderne talen verwijzen naar talen die een hogere productiviteit, stabiliteit, security en maintainability bieden in vergelijking met talen uit het verleden. Deze talen omarmen actief de nieuwste technieken en concepten en bieden ontwikkelaars efficiëntere en veiligere ontwikkelingstools. Representatieve moderne talen zijn onder andere Java, Rust, Python, TypeScript, en deze bezitten de volgende kenmerken.

1. Objectgeoriënteerd Ontwerp ( OOP )

Moderne talen zijn grotendeels ontworpen op basis van objectgeoriënteerde concepten. Objectgeoriëntatie ondersteunt principes zoals encapsulation, inheritance en polymorphism, en maakt de structuur van een programma duidelijk en flexibel door complexe systemen op te splitsen en te beheren in objecten van kleinere eenheden. Dit is met name effectief bij de ontwikkeling van grootschalige software voor het beheersen van ontwikkelingskosten en inspanningen, en voor het verminderen van problemen die kunnen optreden tijdens maintainability.

2. Syntax Sugar en Expressies

Moderne talen bieden diverse vormen van syntax sugar en expression-based syntax om de leesbaarheid van code en de ontwikkelproductiviteit te verhogen. Functies zoals ternary operator, lambda expression, en pattern matching verminderen boilerplate code, maken code voorspelbaar en verbeteren de productiviteit van de ontwikkelaar.

3. Module System

Moderne talen maken het mogelijk om programma's op te splitsen in meerdere eenheden en te beheren via een module system. Dit vergemakkelijkt code reuse en dependency management, en maakt maintainability eenvoudiger, zelfs naarmate de projectomvang toeneemt. Representatieve voorbeelden zijn Java's Maven/Gradle, Rust's Cargo, TypeScript's npm/yarn, etc.

4. Intermediate Language en Virtual Machine

Moderne talen introduceren intermediate language en virtual machine ten behoeve van platform independence, performance optimization en security. Representatieve voorbeelden zijn JVM, LLVM, WASM, GraalVM, etc.

Ontwikkeling in het AI Tijdperk en Beperkingen van Moderne Talen

Moderne talen ontstonden onder de aanname dat mensen het grootste deel van de code schrijven. Het doel van moderne talen is dan ook vanzelfsprekend om repetitieve taken te verminderen, de productiviteit te verhogen, en grootschalige software effectief te implementeren via structuren die samenwerking tussen ontwikkelaars mogelijk maken. In het AI tijdperk wordt deze aanname echter steeds meer ondermijnd. AI-gebaseerde tools zoals Copilot en Cody automatiseren veel aspecten van het schrijven van code, en de hoeveelheid code die één ontwikkelaar kan produceren, neemt exponentieel toe. Hierdoor veranderen de kenmerken van moderne talen, die voorheen als voordelen werden ervaren, geleidelijk in achterhaalde nadelen.

Objectgeoriënteerd Ontwerp

AI kan structuren waarin alle informatie binnen één functie of module is gespecificeerd, snel en nauwkeurig analyseren. Aan de andere kant neemt de productiviteit en nauwkeurigheid van AI af naarmate de context toeneemt, omdat het aantal inferentiegebieden toeneemt. Code geschreven in OOP verspreidt de logica over meerdere objecten in plaats van deze op één plek te beheren, wat er uiteindelijk toe leidt dat AI meer context nodig heeft. Beschouw de onderstaande code.

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

In de bovenstaande code moet AI de volgende inferenties herhalen om te weten welk gedrag de speak() method daadwerkelijk zal uitvoeren:

  1. Welke concrete klasse is de instantie van animal?
  2. Waar is de speak() method die in die klasse is overridden gedefinieerd?
  3. Waar zijn de definities van de Dog en Cat klassen, en wat is hun interne gedrag?
  4. Is er een mogelijkheid dat de Dog en Cat klassen worden overridden door andere klassen?

Deze informatie is niet verzameld in één bestand of één functie, en kan alleen worden begrepen door de relaties tussen klassebestanden en de inheritance structuur te volgen. Bovendien zijn elementen die tijdens runtime worden bepaald, zoals reflection of dynamic loading, voor AI als een black box, waardoor analyse feitelijk onmogelijk is.

Syntax Sugar en Expressies

AI geeft de voorkeur aan expliciet gedrag boven impliciet gedrag, en geeft er de voorkeur aan om eenvoudige structuren te combineren om tot één correct antwoord te komen, in plaats van complexe structuren te gebruiken. Daarentegen staat syntax sugar verschillende uitdrukkingen toe, terwijl het interne gedrag vaak hetzelfde of vergelijkbaar is. AI moet de betekenis van deze diverse uitdrukkingen één voor één leren, en het kan moeilijk worden om te bepalen welke syntax in een specifieke situatie moet worden aanbevolen.

Intermediate Language en Virtual Machine

AI leert meestal op basis van source code. Intermediate language (bytecode) daarentegen, verliest betekenis zoals variabelenamen tijdens het compilation proces, en moet tijdens execution time opnieuw worden geïnterpreteerd door de virtual machine. Dit is een zeer moeilijke taak voor AI om te begrijpen of te converteren. Bijvoorbeeld, voor AI is conversie van TypeScript naar Go mogelijk, maar conversie van de bytecode van de V8 engine naar de bytecode van de JVM of machine code is feitelijk bijna onmogelijk.

De Echte Moderne Taal in het AI Tijdperk

Door de bovenstaande inhoud kunnen we zien dat de kenmerken van moderne talen feitelijk achterhaalde elementen zijn die niet geschikt zijn voor het AI tijdperk. Welke taal kan dan de meest geschikte moderne taal zijn voor het AI tijdperk? We kunnen hints vinden in de elementen die moderne talen in het verleden hebben verworpen. De moderne taal van het AI tijdperk zou moeten:

  1. Een expliciete syntax en een natuurlijke flow hebben.
  2. Een platte en eenvoudige structuur hebben, die verder gaat dan buitensporige OOP structuren.
  3. Diverse functies creëren met een beperkt aantal basis keywords, in plaats van onnodige syntax sugar of impliciete patronen.
  4. Een eenvoudig en voorspelbaar build system hebben, in plaats van een complex build system.

De taal die het best aan deze criteria voldoet, is Golang. De Go taal is ontworpen om de meeste praktische functies te implementeren met slechts een minimum aan kern keywords en eenvoudige syntax combinaties, en vermijdt strikt onnodige abstraction en impliciet gedrag. Dit is een structuur die niet alleen gunstig is voor ontwikkelaars, maar ook voor AI bij het interpreteren en genereren van code.

De kenmerken van Go, die gericht zijn op een voorspelbare en platte structuur, expliciete flow en consistente syntax, passen beter in een ontwikkelomgeving waarin AI actief deelneemt, in tegenstelling tot bestaande moderne talen die zijn ontworpen met menselijke ontwikkelaars als uitgangspunt. De conservatieve ontwerpfilosofie van Go, die ooit als ouderwets werd beschouwd, blijkt in het AI tijdperk juist de meest geavanceerde keuze te zijn.