Modularizing Advanced Transaction Management - Tackling Tangled Aspect Code

Student thesis: Doctoral Thesis

Abstract

Grootschalige gedistribueerde systemen, bijvoorbeeld internet-applicaties zoals webwinkels en online banktoepassingen, moeten verzekeren dat gelijktijdig gebruik door meerdere personen de consistentie van de gegevens van het systeem bewaart. De defacto standaard hiervoor is het gebruik van transacties. Transacties zijn echter ontwikkeld voor één specifiek geval van het benaderen van gegevens: kortstondige benaderingen die weinig gegevens omvatten en geen interne structuur hebben. Bovenvermelde systemen willen echter vaak de gegevens op een gestructureerde wijze of voor een lange tijd benaderen en worden dan ook geconfronteerd met de beperkingen van transacties.Structurele oplossingen voor de beperkingen van transacties zijn reeds gekend onder de naam van `geavanceerde transacties', maar we zien dat geen enkele van deze oplossingen momenteel in gebruik is. Een belangrijke reden hiervoor is het feit dat deze geavanceerde mechanismen moeilijk te gebruiken zijn, m.a.w. dat het moeilijk is voor een programmeur om de code voor het gebruik van deze systemen te schrijven en te onderhouden.In deze thesis bieden wij een oplossing aan voor de programmeur door software-engineering-technieken toe te passen op het gebruik van geavanceerde transactiemechanismen. Meer bepaald passen we de technieken van aspectgeoriënteerd programmeren en domein-specifieke talen toe om de programmeur toe te staan op een hoog abstractieniveau met geavanceerde transactiemechanismen om te gaan.Aspectgeoriënteerd programmeren (AOP) laat toe om de code voor bekommernissen die verspreid zijn over het systeem, zoals het gebruik van transacties, te verzamelen in één module. Deze module wordt aspect genoemd en de code in deze module wordt meestal geschreven in een specifieke aspect-programmeertaal. Het belangrijkste voordeel van een aspect is dat de aspect-code gemakkelijker te schrijven en te onderhouden is. Dit is omdat de programmeur zich volledig kan concentreren op die ene bekommernis en niet meer gestoord wordt door andere bekommernissen die dezelfde code doorweven. AOP is reeds gebruikt om het gebruik van transacties te vereenvoudigen maar werd nog niet toegepast op geavanceerde transacties.Als eerste deel in dit onderzoek hebben we dan ook een aspect gemaakt voor geavanceerde transacties. Hier hebben we geobserveerd dat de code voor een aspect zelf ook kan bestaan uit verschillende door elkaar geweven bekommernissen. Specifiek voor het aspect van geavanceerde transacties hebben we hiervoor een oplossing ontwikkeld: de aspect-programmeertaal KALA. KALA is gebaseerd op een bestaand formeel model voor geavanceerde transacties, genaamd ACTA, en laat toe om het aspect op te splitsen in de verschillende bekommernissen en deze volledig apart neer te schrijven. Dit geeft de programmeur niet alleen de mogelijkheid om een grote verscheidenheid van geavanceerde modellen te gebruiken als een aspect maar ook om nieuwe mechanismen te creëren als dit nodig is.De programmeertaal KALA is dus een krachtige aspect-taal voor het beschrijven van geavanceerde transactiemechanismen die ook toelaat om nieuwe mechanismen te creëren als het nodig is. Maar deze kracht heeft ook een kostprijs en die is dat programma's in KALA complex en langdradig zijn omdat ze werken met elementen van de onderliggende implementatie van een model. Programmeurs die echter enkel bestaande mechanismen willen gebruiken hebben geen boodschap aan deze kracht en wensen de complexiteit en langdradigheid te vermijden. Hiervoor hebben we een tweede abstractielaag uitgewerkt, met behulp van domeinspecifieke talen.Het gebruik van domeinspecifieke talen laat toe programma's te schrijven die werken met de concepten fundamenteel aan het domein, die dus abstractie maken van de implementatie van het domein. Toegepast op geavanceerde transactiemechanismen betekent dit dat we een aantal domeinspecifieke talen hebben ontwikkeld voor een aantal geavanceerde mechanismen. Er is een taal per mechanisme, en programma's in elke taal worden vertaald naar equivalente KALA-code. Code in elke domeinspecifieke taal behandelt de concepten inherent aan het model in kwestie. Dit zorgt voor een hoger abstractieniveau van de code en maakt de code ook summier. Daarenboven vormen de verschillende talen een familie: concepten die gedeeld worden door verschillende modellen, en dus ook door verschillende talen, worden telkens op dezelfde wijze neergeschreven.Als resultaat van onze combinatie van aspectgeoriënteerd programmeren en domeinspecifieke talen is het nu ook mogelijk voor een programmeur het gebruik van een geavanceerd transactiemechanisme op een summiere wijze neer te schrijven, en dit volledig apart van de code van het systeem zelf. Naast deze bijdrage in het onderzoeksgebied van geavanceerde transactiemechanismen hebben we ook bijgedragen aan het onderzoeksgebied van AOP. Dit is eerst en vooral de observatie dat een aspect zelf kan lijden aan het probleem van verschillende door elkaar geweven bekommernissen. Onze tweede bijdrage is de verwezenlijking van het volledig apart specificeren van de code van een aspect.
Date of Award2005
Original languageEnglish
SupervisorTheo D'Hondt (Promotor), Viviane Jonckers (Jury), Tom Tourwe (Co-promotor), Olga De Troyer (Jury), Peter Van Roy (Jury) & Awais Rashid (Jury)

Cite this

'