Technische Samenvatting: Voordelen van het toepassen van softwareontwerppatronen op backend Rust-applicaties

Probleemstelling

Hoewel de programmeertaal Rust garanties biedt voor compile-time veiligheid, geheugenveiligheid zonder garbage collection en een uitgesproken typesysteem, is er een gebrek aan empirisch onderzoek naar de effectiviteit van softwareontwerppatronen binnen deze context. De meeste bestaande ontwerppatronen zijn afkomstig uit Object-Georiënteerde Programmeerparadigma's (bijv. de Gang of Four-patronen), die niet direct vertaalbaar zijn naar de multi-paradigma natuur van Rust. Bovendien hebben eerdere studies naar ontwerppatronen controversiële resultaten opgeleverd met betrekking tot hun impact op codekwaliteit, waarbij vaak een gebrek was aan contextspecifieke data. Deze thesis adresseert de kloof in het begrip van hoe specifieke ontwerppatronen de softwarekwaliteit en de handhaving van invarianten in productie-waardige Rust backend-applicaties beïnvloeden.

Methodologie

De studie maakt gebruik van een mixed-method benadering die kwantitatieve metrieken combineert met kwalitatieve expertanalyse om de impact van ontwerppatronen te evalueren op drie representatieve use cases van productie backend-applicaties bij Otto GmbH & Co. KGaA.

Case Studies

Drie verschillende use cases werden geselecteerd om veelvoorkomende architecturale patronen in Rust backends te representeren:

1. Use Case 1 (FT9 Detailview Service): Een service met een lange, lineaire sequentie van operaties die betrokken zijn bij meerdere afhankelijkheden en conditionele logica.
2. Use Case 2 (FT9 Tag Component Handler): Een handler die zich bezighoudt met de inputvalidatie van domein-specifieke expressies ("Dreson") met behulp van raw strings.
3. Use Case 3 (Boxfish Lambda Handler): Een serverless functie die betrokken is bij gedeelde mutabele staat, diepe functiehiërarchieën en impliciete foutafhandeling.

Refactoring Strategie

Twee specifieke ontwerppatronen werden toegepast om geïdentificeerde 'code smells' aan te pakken:

• Typestate Pattern: Toegepast op Use Case 1 en 3. Dit patroon codeert de staat van een object in de type, wat ervoor zorgt dat operaties alleen worden uitgevoerd in geldige staten. Het maakt gebruik van Rust's ownership en typesysteem om de uitvoeringsvolgorde af te dwingen en ongeldige staten tijdens compile-time te voorkomen.
• Newtype Pattern: Toegepast op Use Case 2. Dit patroon omhult primitieve types (bijv. String) in een nieuwe struct om domein-specifieke invarianten (bijv. validatie) onmiddellijk bij constructie af te dwingen, conform het "Parse, don't validate" principe.

Evaluatiekader

De gerefactorde code werd beoordeeld aan de hand van criteria afgeleid van het ISO/IEC 25010 SQuaRE kwaliteitsmodel:

• Kwantitatieve Metrieken:
  • Time Behaviour: Gemeten via micro-benchmarking met criterion-rs om prestatie-regressies te detecteren.
  • Static Code Analysis: Metrieken omvatten Cyclomatic Complexity (CyC), Cognitive Complexity (CoC), Halstead's Difficulty (HDiff) en de Maintainability Index (MI).
• Kwalitatieve Analyse: Er werden semi-gestructureerde interviews gehouden met vier senior Rust-ontwikkelaars (6+ jaar ervaring, 2+ jaar in Rust) om Modulairiteit, Herbruikbaarheid, Analyseerbaarheid, Aanpasbaarheid, Testbaarheid en Foutloosheid te evalueren.

Belangrijkste Resultaten

1. Prestatie-impact

Over alle drie de use cases resulteerde de toepassing van ontwerppatronen in geen statistisch significante degradatie van de runtime-prestaties.

• Use Case 1: Toonde een lichte verbetering (1,86%) binnen de ruis-drempelwaarde.
• Use Case 2: Toonde een verwaarloosbare toename (1,25%) binnen de ruis-drempelwaarde.
• Use Case 3: Toonde een niet-significante verandering door hoge variantie in de testomgeving, maar geen bewijs van prestatieverlies.
  De structurele overhead geïntroduceerd door de patronen (bijv. extra structs) bleek in de praktijk een zero-cost abstractie te zijn.

2. Verbeteringen in Kwaliteitseigenschappen

• Foutloosheid: Beide patronen verbeterden de foutloosheid aanzienlijk. Het Typestate patroon dwong de uitvoeringsvolgorde af en voorkwam ongeldige staten (bijv. het lezen van een gesloten bestand) tijdens compile-time. Het Newtype patroon zorgde ervoor dat ongeldige data niet door het systeem kon propageren, waardoor foutdetectie verschoof van runtime naar compile-time.
• Testbaarheid: Het Typestate patroon verbeterde de testbaarheid aanzienlijk door logica te isoleren in kleinere staatsovergangen, waardoor de noodzaak voor complexe mocking van afhankelijkheden afnam. Het Newtype patroon maakte het mogelijk om validatielogica in isolatie te testen.
• Analyseerbaarheid: Het Typestate patroon verminderde de Cognitive Complexity van grote functies door logica te verdelen over kleinere eenheden. Experts merkten echter op dat de toegenomen hoeveelheid boilerplate code (structs en functiesignaturen) de leesbaarheid voor ontwikkelaars die niet bekend zijn met het patroon aanvankelijk kon bemoeilijken.
• Aanpasbaarheid: Wijzigingen werden veiliger dankzij de garanties tijdens compile-time. Echter, het wijzigen van de structuur van een state machine vereiste het bijwerken van meerdere afhankelijke staten, wat sommige experts als een verhoogde inspanning zagen, hoewel anderen het zagen als een positieve handhaving van correctheid.
• Modulairiteit & Herbruikbaarheid: De resultaten waren gemengd. Hoewel het Newtype patroon de modulariteit verbeterde door de validatielogica te ontkoppelen, creëerde het Typestate patroon nauw gekoppelde staten die moeilijk herbruikbaar waren in andere contexten zonder significante refactoring.

3. Expert Consensus

Experts waren het erover eens dat de patronen een hoge waarde boden voor specifieke scenario's:

• Newtype: Sterk aanbevolen voor primitieve datatypes die validatie vereisen, met een hoog rendement tegen lage kosten.
• Typestate: Het meest voordelig voor code met uitgebreide branching-logica en een hoog aantal invarianten. Experts merkten op dat voor lineaire flows de boilerplate overhead mogelijk de voordelen overtreft.

Betekenis en Bijdragen

Dit werk levert de eerste empirische beoordeling van softwareontwerppatronen specifiek binnen de context van Rust backend-applicaties. De primaire bijdragen zijn:

1. Empirisch Bewijs: Het gaat verder dan theoretische discussies door datagestuurd bewijs te leveren over hoe Typestate en Newtype patronen de codekwaliteit en runtime-prestaties in real-world systemen beïnvloeden.
2. Methodologisch Kader: De studie stelt een herbruikbaar evaluatiekader vast dat benchmarking, statische analyse en expertinterviews combineert, afgestemd op de unieke beperkingen van Rust (zoals het erkennen van de beperkingen van statische metrieken bij het vangen van cognitieve belasting).
3. Contextuele Aanbevelingen: Het papier formuleert specifieke richtlijnen voor wanneer deze patronen toe te passen:
   • Gebruik Newtype voor het afdwingen van invarianten op primitieve types ("Parse, don't validate").
   • Gebruik Typestate voor complexe state machines met branching-logica, in plaats van eenvoudige lineaire flows, om de structurele overhead te rechtvaardigen.
   • Pas het Functional Core - Imperative Shell (FC-IS) principe toe in combinatie met Typestate om testbaarheid en zuiverheid te maximaliseren.

De thesis concludeert dat hoewel ontwerppatronen in Rust niet universeel alle kwaliteitsaspecten verbeteren, ze krachtige instrumenten zijn om het typesysteem van de taal te benutten voor het afdwingen van correctheid en het verbeteren van onderhoudbaarheid, mits ze worden toegepast met een begrip van hun trade-offs met betrekking tot boilerplate en koppeling.