- Een abstracte syntactische boom (AST) representeert de logische structuur van een programma, waarbij irrelevante syntactische details worden geëlimineerd.
- AST's worden opgebouwd uit alfabetten met ariteitsfuncties en boomgrammatica's die definiëren welke knooppunten en structuren geldig zijn.
- De Dewey-notatie en operatoren zoals "." of "/" maken een precieze verwijzing naar subbomen en paden binnen deze structuren mogelijk.
- Compilers, interpreters en codeanalyseprogramma's gebruiken AST om programma's betrouwbaar te optimaliseren, transformeren en begrijpen.
Abstracte syntactische bomen in de programmeertaal zijn een van die concepten die in eerste instantie erg theoretisch klinken, maar zodra je ze doorhebt, realiseer je je dat ze overal aanwezig zijn: compilers, interpreters , codeanalyse, refactoringtools, zelfs in gestructureerde dataquerytalen. Ze vormen in wezen de manier waarop een machine de structuur van een programma "begrijpt", voorbij de platte tekst.
Hoewel abstracte syntactische bomen (AST's) soms verward worden met klassieke parsebomen, hebben ze hun eigen regels. Een abstracte syntactische boom is niet zomaar een mooie tekening: het is een compacte en goed ontworpen datastructuur die alles wat overbodig is in de concrete syntaxis (haakjes, komma's, redundante trefwoorden, enz.) elimineert en zich concentreert op de essentie: welke bewerkingen worden uitgevoerd, op welke waarden en in welke volgorde.
Wat is een abstracte syntaxisboom (AST) precies?
In de programmeertaaltheorie is een abstracte syntaxisboom (AST) een boomachtige structuur die de syntaxis van een programma weergeeft, maar in een vereenvoudigde vorm vergeleken met een concrete parseboom. Het bevat dezelfde essentiële informatie als een parseboom, maar dan op een compactere en beter beheersbare manier georganiseerd.
Een parseboom bevat alle grammaticaproducties en alle eindsymbolen, inclusief haakjes, komma's, puntkomma's en andere puur syntactische elementen. Een AST (Abstract Syntax Tree) daarentegen verwijdert deze details die geen semantische betekenis toevoegen en behoudt alleen de logische structuur van uitdrukkingen en zinnen.
Qua implementatie bestaat een AST meestal uit knooppuntobjecten met een type dat aangeeft wat voor soort syntactische constructie het is (constante, identificator, functie-applicatie, binaire operator, enz.), en aanvullende eigenschappen die de inhoud beschrijven: waarde, naam, kinderen, argumentenlijst, enzovoort.
Het mooie van de AST is dat het latere fasen van de compiler of interpreter, zoals typecontrole, optimalisaties of codegeneratie , vergemakkelijkt , omdat het een helder beeld geeft van de programmastructuur zonder syntactische ruis.
Verschil tussen een concrete syntaxisboom en een abstracte syntaxisboom
Om volledig te begrijpen wat een AST bijdraagt, is het nuttig om eerst de concrete parseboom te vergelijken met de abstracte. Stel je een eenvoudige grammatica voor die rekenkundige uitdrukkingen herkent zoals "a + 4 * 5" . De concrete parseboom weerspiegelt nauwkeurig de toepassing van elke grammaticaregel: niet-terminale symbolen, terminale symbolen, haakjes, operatoren, enzovoort.
Deze specifieke boom is meestal diep en heeft veel tussenliggende knooppunten die alleen dienen om de formele structuur van de grammatica te behouden. Zo kunnen er bijvoorbeeld knooppunten zijn voor "Expressie", "Term", "Factor", en vervolgens eindsymbolen zoals "+" , "*" , identificatoren en getallen. Elke productie wordt een tak van de boom, waardoor de structurele complexiteit toeneemt.
De abstracte syntactische boom voor diezelfde expressie is daarentegen beperkt tot het weergeven van de feitelijke bewerkingen en operanden . In plaats van meerdere niveaus van "Expressie" en "Term" zouden we dus een wortelknooppunt kunnen hebben dat optellen vertegenwoordigt, met twee kinderen: links een identificator a en rechts een vermenigvuldigingsknooppunt waarvan de kinderen de waarden 4 en 5 zijn. Puur grammaticale knooppunten verdwijnen en delen van de structuur worden herschikt of gecondenseerd.
Dit betekent dat de AST en de concrete syntaxisboom dezelfde semantische informatie bevatten , maar dat de AST deze in een veel directere en compactere vorm presenteert. Deze condensatie is essentieel voor efficiënt werken met code in analyse- of uitvoeringsprogramma's.
Bomen en alfabetten met een ariteitsfunctie
Om deze bomen vanuit wiskundig oogpunt te formaliseren, wordt meestal het idee van een alfabet met een ariteitsfunctie gebruikt . In plaats van een eenvoudige verzameling symbolen wordt een alfabet gedefinieerd waarin elk symbool is gekoppeld aan een getal dat aangeeft hoeveel kinderen het in de boom kan hebben.
Een alfabet met een ariteitsfunctie is, informeel gezegd, een paar bestaande uit een eindige verzameling symbolen en een functie die aan elk symbool een natuurlijk getal toekent (inclusief nul). Dit getal geeft de ariteit van het symbool aan: als het 0 is, gedraagt het symbool zich als een blad; als het 1 is, gedraagt het zich als een unaire knoop; als het 2 is, is het binair; enzovoort. Het is ook gebruikelijk om symbolen met een variabele ariteit toe te staan voor operatoren als argumentenlijsten.
Symbolen met ariteit 0 corresponderen met bladeren van de boom (bijvoorbeeld constanten of identificatoren). Symbolen met ariteit 1 worden gebruikt voor constructies die een enkele kindexpressie bevatten. Symbolen met ariteit 2 vertegenwoordigen klassieke binaire bewerkingen zoals optellen, vermenigvuldigen, toewijzen, enzovoort. En symbolen met variabele ariteit maken het mogelijk om constructies te modelleren die een onbepaald aantal subbomen accepteren, zoals een functieaanroep met meerdere parameters.
Vanuit dit alfabet met ariteit kan de verzameling van alle mogelijke bomen worden gedefinieerd: beginnend met de lege boom (indien aanwezig), door alle symbolen met ariteit 0 en variabele toe te voegen, en inductief uit te breiden: als een symbool k-air is, kan het als ouderknooppunt worden geplaatst in k reeds geconstrueerde deelbomen. Dit levert de boomtaal (of term) op die bij het alfabet hoort.
Boomstructuur en het begrip knooppunt
De verzameling van alle bomen die gevormd worden met een alfabet en de bijbehorende ariteitsfunctie wordt in deze context een boomtaal of termentaal genoemd . Het is het equivalent, maar dan voor boomstructuren, van wat de Kleene-sluiting is voor strings.
Net zoals we bij het analyseren van strings de term ' tokens' gebruiken om te verwijzen naar het voorkomen van alfabetische symbolen binnen een reeks, gebruiken we bij het werken met bomen meestal de term ' knooppunten' . Een knooppunt is in wezen een specifiek voorkomen van een alfabetisch symbool met een bepaalde ariteit, gelegen op een specifieke positie in de boom.
Vanuit dit perspectief verhoudt deze boomstructuur zich tot knooppunten zoals een reeks tekenreeksen zich verhoudt tot afzonderlijke symbolen. Elke boom wordt geïnterpreteerd als een structuur die stap voor stap is opgebouwd uit het alfabet, en de knooppunten zijn de individuele onderdelen die de symbolen fysiek gestalte geven.
Deze manier van kijken is erg nuttig bij het ontwerpen van parsers en AST-generatoren , omdat het redeneren over de constructieregels van deze bomen mogelijk maakt op een manier die analoog is aan stringgrammatica, maar dan direct werkend op hiërarchische structuren.
Ariteit van knooppunten in een specifieke AST: het geval van Egg
Van theorie naar een praktisch voorbeeld: veel lesmaterialen gebruiken de Egg -taal om de constructie en manipulatie van AST's te illustreren. In deze context worden verschillende hoofdtypen knooppunten gebruikt, elk met een goed gedefinieerde ariteit , waardoor ze zeer gemakkelijk te manipuleren zijn.
In een typische Egg AST worden VALUE- knooppunten beschouwd als bladeren: ze representeren letterlijke waarden zoals strings of getallen. Ze hebben geen kinderen; ze slaan alleen een waarde op. Op dezelfde manier worden WORD-knooppunten , die worden gebruikt voor identificatoren (variabelnamen, functienamen, enz.), ook behandeld als bladeren met een eigenschap die de naam opslaat.
Het belangrijkste knooppunt in Egg is het APPLY- type , dat de toepassing van een functie of operator vertegenwoordigt. Dit knooppunttype heeft twee conceptuele kinderen: een OPERATOR -kind dat verwijst naar de expressie die wordt toegepast; en een ARGS- kind , dat feitelijk een speciaal ARRAY-knooppunt is dat verantwoordelijk is voor het bijhouden van een verzameling subbomen, één voor elk argument.
Arrays zijn daarom een natuurlijke manier om variabele ariteit in de AST te introduceren: een APPLY heeft altijd twee componenten (operator en argumentenlijst), maar die interne lijst kan nul, één of meerdere subbomen bevatten, afhankelijk van de specifieke aanroep die wordt weergegeven.
Gedetailleerde anatomie van de AST-knopen in Egg
Op implementatieniveau worden de AST-nodes van Egg doorgaans weergegeven als objecten met eigenschappen , wat perfect aansluit bij talen zoals JavaScript. Alle nodes delen een gemeenschappelijke eigenschap: `type` , die het nodetype identificeert (VALUE, WORD, APPLY, ARRAY, enz.) en daarmee de structuur van de rest van het object.
VALUE-nodes worden gebruikt voor letterlijke constanten . Ze bevatten een eigenschap, vaak 'value' genoemd , waarin het getal of de tekenreeks die ze vertegenwoordigen, is opgeslagen. Ze hebben geen extra kinderen omdat hun inhoud volledig wordt beschreven door die letterlijke waarde.
Woordknooppunten zijn gereserveerd voor identificatoren : variabelnamen, functienamen, parameternamen en dergelijke. Ze hebben doorgaans een eigenschap `name` die de identificator als een tekenreeks opslaat. Net als VALUE-knooppunten fungeren ze als bladeren in de boom, aangezien hun enige doel is om die naam te leveren.
Apply-knooppunten vertegenwoordigen toepassingen of aanroepen. Ze bevatten een operator- eigenschap , die verwijst naar de expressie (een ander knooppunt) die wordt toegepast, en een args- eigenschap , die verwijst naar een ARRAY-knooppunt. Dit laatste is een specifiek knooppunt binnen de AST, dat bedoeld is om de argumentenlijst van de toepassing op te slaan.
Het ARRAY-knooppunt kan worden gezien als een gestructureerde container voor andere knooppunten, die een reeks subbomen vertegenwoordigt. Vanuit het oogpunt van ariteit introduceert het flexibiliteit, omdat het aanroepen mogelijk maakt zonder argumenten, met één argument of met meerdere argumenten binnen dezelfde APPLY-instructie, zonder dat de definitie van het hoofdknooppunttype hoeft te worden gewijzigd.
Voorbeeld van een AST: een eenvoudige applicatie met één waarde.
Om dit alles te visualiseren, laten we eens kijken naar de weergave van een eenvoudige instructie, zoals het aanroepen van een functie X met één argument 5. De door de parser gegenereerde AST komt overeen met een term die is opgebouwd uit VALUE-, WORD- en APPLY-knooppunten , volgens de regels van Egg.
Op conceptueel niveau zouden we een APPLY- node aan de root hebben. De operator-eigenschap ervan zou verwijzen naar een WORD-node met de naam X, en de args-eigenschap zou verwijzen naar een ARRAY-node met één element: een VALUE-node met de numerieke waarde 5. Op deze manier weerspiegelt de structuur duidelijk op wie en waarop de toepassing van toepassing is.
Als we alle attributen expliciet wilden maken, zouden we een meer gedetailleerde notatie kunnen schrijven met het type, de operator, de argumenten, de naam en de waarde. Deze uitgebreidere notatie is erg handig voor het debuggen van de parser of om te begrijpen hoe een tekstuele expressie wordt vertaald naar een boomstructuur binnen de interpreter.
In de praktijk wordt deze boom doorgaans geserialiseerd als JSON voor eenvoudige opslag, verzending of inspectie. Er bestaan zelfs tools en modules, zoals het evm2term- pakket in het npm-ecosysteem, die compacte representaties van deze AST's bieden voor eenvoudigere analyse of transformatie.
Voorbeeld van een AST: geneste optelling en vermenigvuldiging
Een ander typisch geval is een iets complexere expressie, zoals "+(a, *(4, 5))" . Hier hebben we een optelbewerking waarbij het eerste argument de identifier a is en het tweede argument het resultaat van de vermenigvuldiging van 4 met 5. De AST die uit deze expressie voortkomt, weerspiegelt die geneste structuur.
Aan de basis van de boomstructuur zouden we opnieuw een APPLY-knooppunt hebben dat de optelbewerking vertegenwoordigt. De operator zou een WORD-knooppunt zijn met de naam "+", terwijl de argumenten zich in een ARRAY-knooppunt met twee elementen zouden bevinden: het eerste, een WORD met de naam "a"; het tweede, een ander APPLY-knooppunt dat de vermenigvuldiging vertegenwoordigt.
Die tweede APPLY-aanroep zou als operator een WORD genaamd "*" hebben en als argumenten een ARRAY met twee VALUE-nodes: één met een waarde van 4 en de andere met een waarde van 5. Als geheel bekeken, laat de structuur duidelijk zien dat de evaluatievolgorde bestaat uit het vermenigvuldigen van 4 met 5 en vervolgens het optellen van het resultaat bij a.
Als we de notatie uitbreiden met alle attributen, zien we de typen van alle knooppunten, hun namen of specifieke waarden en de relaties ertussen. Deze expliciete beschrijving komt overeen met de daadwerkelijke implementatie in de Egg-interpreter, waar elk knooppunt een object is met de bovengenoemde eigenschappen.
Boomgrammatica en parsergrammatica
De manier waarop deze AST's worden gegenereerd is niet willekeurig: ze is gebaseerd op wat een boomgrammatica wordt genoemd . In een typische formulering wordt zo'n grammatica gedefinieerd als een viervoud bestaande uit een alfabet met ariteit , een eindige verzameling syntactische (niet-terminale) variabelen, een eindige verzameling productieregels en een startsymbool.
In elke productieregel wordt een variabele vervangen door een boom waarvan de wortel een symbool van het alfabet met ariteit is, en waarvan de kinderen op hun beurt variabelen of reeds gedefinieerde bomen zijn. Deze structuur doet denken aan klassieke reguliere of contextvrije grammatica's, maar is aangepast aan het direct genereren van bomen in plaats van reeksen symbolen.
Gerelateerd aan die meer formele definitie is de specifieke grammatica die de parser van Egg gebruikt om zijn bomen te produceren. Deze grammatica, die meestal informeel in de documentatie wordt gepresenteerd, beschrijft precies welke combinaties van trefwoorden, operatoren, haakjes, enzovoort in de taal worden geaccepteerd en hoe ze worden vertaald naar knooppunten van het type VALUE, WORD, APPLY en ARRAY.
Deze boomgrammatica kan worden gezien als een speciaal geval van wat in de literatuur bekend staat als een reguliere boomgrammatica . Het idee is om goed gedefinieerde regels te hebben voor het omzetten van een reeks invoertokens in een gestructureerde AST die vervolgens kan worden geïnterpreteerd of gecompileerd.
Dewey-notatie: coördinaten binnen een boomstructuur
Zodra we de AST hebben, moeten we vaak verwijzen naar specifieke subbomen : bijvoorbeeld het tweede argument van een functie, de operator van een expressie, enzovoort. Een zeer elegante manier om dit te doen is de zogenaamde Dewey Decimal-notatie, die gebruikmaakt van het schema dat wordt gebruikt om secties en subsecties in documenten te nummeren.
In deze notatie wordt, uitgaande van een boom t, een subboom aangeduid door een reeks getallen gescheiden door punten . Elk getal geeft de positie van een kind aan (meestal beginnend bij 1) en de reeks loopt door de boom naar beneden. Een uitdrukking zoals t/2.1.3 verwijst dus naar het derde kind van het eerste kind van het tweede kind van t.
De inductieve definitie van deze notatie is eenvoudig: de lege tekenreeks verwijst naar de hele boom zelf; als een tekenreeks bestaat uit een getal gevolgd door meer getallen gescheiden door punten, wordt deze geïnterpreteerd door eerst de kind-subboom te nemen die overeenkomt met de aangegeven index en vervolgens dezelfde logica recursief toe te passen op de rest van de tekenreeks.
Stel, we hebben een boom t die een uitdrukking voorstelt zoals "+(a, *(4,5))", met een wortelknooppunt APPLY voor optellen, een kindknooppunt WORD genaamd "+" en een ander kindknooppunt APPLY voor vermenigvuldigen. We kunnen dan specifieke posities identificeren. Zo zou t/1 het WORD-knooppunt met de operator "+" kunnen zijn, t/2.1 de identifier "a", en t/2.2.2.1 het VALUE-knooppunt met de waarde 4, mits we de kinderen op de juiste manier nummeren.
Deze manier om "coördinaten" binnen een AST te geven is erg handig om specifieke locaties aan te wijzen bij het rapporteren van fouten, het navigeren door de boomstructuur of het ondubbelzinnig toepassen van lokale transformaties op specifieke knooppunten.
Gelijkwaardige notaties in programmeren en tools
Het idee achter Deweys notatie is niet exclusief voor de boomtheorie; sterker nog, het duikt herhaaldelijk op in veel praktische notaties die we dagelijks gebruiken bij het programmeren en het verwerken van gestructureerde gegevens, zelfs als we ons daar niet altijd van bewust zijn.
Wanneer we in een programmeertaal expressies schrijven met de puntoperator , zoals object.property.subproperty, doen we iets vergelijkbaars: we doorlopen een boomstructuur van geneste objecten en selecteren bij elke stap een kind op basis van de naam in plaats van het positienummer. Beginnend bij een wortelknooppunt dalen we af naar meer interne knooppunten.
Hetzelfde patroon zien we terug in Unix-achtige bestandssystemen, waar de schuine streep (/) wordt gebruikt om mappen te scheiden: /src/js/tutu.js beschrijft een pad vanaf de root van het bestandssysteem naar een specifieke bron, waarbij opeenvolgende niveaus van een boomstructuur worden doorlopen.
In de wereld van gestructureerde documenten gebruiken talen zoals XPath zeer vergelijkbare notaties om knooppunten binnen een XML-boomstructuur te selecteren. Een query zoals "A//B/*" selecteert het eerste kind (ongeacht de naam) van elk element B dat een afstammeling is van een element A op de juiste positie ten opzichte van de huidige context, waarbij enkele en dubbele schuine strepen worden gebruikt om de diepte aan te geven.
Een andere bekende tool, de jq- taal , gebruikt een parallel systeem om door JSON-structuren te navigeren, waardoor subobjecten kunnen worden geselecteerd via samengestelde paden, filters en expressies. Al deze notaties zijn simpelweg verschillende manieren om paden in een boomstructuur uit te drukken , vergelijkbaar met de Dewey Decimal-notatie, maar aangepast aan hun respectievelijke domeinen.
Parsebomen in de taalkunde en programmering
Buiten de wereld van compilers worden syntactische bomen ook in de taalkunde gebruikt om de zinsstructuur weer te geven. Daar worden ze afleidingsbomen of parsebomen genoemd, die laten zien hoe een zin is opgedeeld in zinsdelen, woorden en grammaticale categorieën.
Net als in programmeren vinden we in deze bomen drie basistypen knooppunten: een wortelknooppunt , dat de volledige zin of de globale structuur vertegenwoordigt; interne of vertakkende knooppunten, die fungeren als ouderknooppunten en subsets van de zin groeperen; en bladknooppunten, die meestal overeenkomen met de specifieke woorden die in de invoerreeks voorkomen.
Het wortelknooppunt is uniek: de gehele boomstructuur is eraan verbonden. Vertakkingsknooppunten bevinden zich direct onder het wortelknooppunt of andere bovenliggende knooppunten en dienen om de onderdelen van de zin of het programma hiërarchisch te ordenen . Bladknooppunten daarentegen bevinden zich op het laagste niveau van de boom en hebben geen kinderen, waardoor de vertakkingsstructuur wordt gesloten.
Deze bomen worden beschouwd als krachtige pedagogische hulpmiddelen omdat ze helpen complexe zinnen op te splitsen in beheersbare elementen. Hetzelfde geldt voor programmeren: een goed opgebouwde AST laat je in één oogopslag zien welke bewerkingen aan elkaar gekoppeld zijn, welke expressies genest zijn en hoe de evaluatie verloopt.
Afhankelijk van het doel van de analyse kunnen we verschillende soorten analysebomen vinden . Sommige benadrukken afhankelijkheden tussen woorden of componenten (bijvoorbeeld wie van wie afhankelijk is in een zin), terwijl andere zich richten op groepering in zinsdelen of constituenten, wat resulteert in twee hoofdfamilies.
Syntaxisbomen op basis van afhankelijkheid en op basis van samenstelling
Een van de bekendste typen is de op afhankelijkheden gebaseerde syntactische boom . In deze variant worden alle woorden in de zin of alle relevante elementen als bladknoppen beschouwd, en de verbindingen ertussen geven directe afhankelijkheidsrelaties aan (bijvoorbeeld een hoofdwerkwoord en het bijbehorende onderwerp). Hierdoor ontstaan vaak bomen met minder knooppunten dan bij andere schema's.
Deze eenvoud maakt ze bijzonder geschikt voor beginners en voor bepaalde taken op het gebied van taalverwerking, omdat de structuur zich richt op wie van wie afhankelijk is, zonder al te veel tussenliggende knooppunten te introduceren. Toegepast op programmeren is het idee om je te beperken tot de essentiële relaties en grammaticale versieringen weg te laten.
Aan het andere uiterste hebben we syntactische bomen gebaseerd op constituenten, die wel onderscheid maken tussen wortelknooppunten, interne vertakkingsknooppunten en bladknooppunten, en alle relevante groeperingen zichtbaar maken. Deze bomen bevatten meestal meer knooppunten en weerspiegelen de hiërarchische structuur van de zin of het programma in meer detail.
Veelvoorkomende sjablonen voor constituentenbomen tonen lange zinnen met talrijke bladknooppunten, verschillende vertakkingsniveaus en een duidelijk gedefinieerd wortelknooppunt. Ze zijn vooral handig voor het ontleden van complexe zinnen of programma's met meerdere lagen van geneste structuren.
Zowel in afhankelijkheids- als in constituentiebomen zijn voorbeelden en visuele hulpmiddelen beschikbaar als sjablonen, waardoor u de knooppunten eenvoudig kunt invullen met de gewenste informatie. Dit bespaart tijd en voorkomt dat u het diagram telkens helemaal opnieuw moet ontwerpen wanneer u een structuur wilt illustreren.
Praktische toepassingen en hulpmiddelen met betrekking tot AST
Abstracte syntactische bomen (AST's) zijn niet zomaar een theoretisch concept: ze worden actief gebruikt in talloze dagelijkse tools door iedereen die met code werkt. Compilers, interpreters, minifiers, codeformatters en statische analyseprogramma's vertrouwen bijna altijd op een AST om hun functie uit te voeren.
Een typische compiler neemt de broncode, tokeniseert deze, parseert deze en genereert een abstracte syntactische boom. Van daaruit voert hij semantische controles uit (typen, variabele scope, onjuist gebruik van constructies) en past hij codeoptimalisatie toe door de AST te doorlopen en te transformeren voordat hij machinecode, oftewel bytecode, produceert.
Tools zoals linters of formatters werken ook met AST: ze analyseren de structuur om problematische patronen, slechte praktijken of inconsistenties te detecteren en stellen wijzigingen voor die de semantische structuur van de boom behouden, maar de presentatie van de code aanpassen.
Binnen het JavaScript-ecosysteem zijn er bijvoorbeeld diverse bibliotheken die de AST (Abstract Syntax Tree) in JSON-formaat beschikbaar stellen. Dit maakt het voor andere tools gemakkelijker om hierop te vertrouwen voor refactoring, het genereren van automatische documentatie of het visualiseren van de structuur van complexe programma's.
Zelfs in meer gespecialiseerde gebieden, zoals instrumentatie voor het meten van testdekking of het omzetten van broncode naar andere talen, vormt AST de basis voor veel moderne oplossingen, omdat het werken op een zeer comfortabel abstractieniveau tussen ruwe tekst en machinecode mogelijk maakt.
Samengevat vormen abstracte syntactische bomen de sleutel tot de verbinding tussen de formele grammatica van een taal, de interne representatie ervan in de compiler of interpreter, en de geavanceerde tools die we gebruiken om code veilig en efficiënt te schrijven, analyseren en transformeren. Inzicht in hoe ze zijn opgebouwd, hoe je erin kunt navigeren (met concepten zoals de Dewey Decimal-notatie) en welke soorten knooppunten erbij betrokken zijn (VALUE, WORD, APPLY, structuren met vaste of variabele ariteit, enz.) helpt ons veel beter te begrijpen wat de machine daadwerkelijk doet wanneer deze een programma verwerkt.
