💻 computer science

Watts This Smell: A Comprehensive Taxonomy of Software Energy Smells

Dit artikel introduceert een uitgebreide, taal-agnostische taxonomie van 12 software energy smells en 65 oorzaken, die empirisch wordt gevalideerd door de analyse van meer dan 21.000 Python-codeparen om aan te tonen dat energie-optimalisatie onderscheidend is van prestatie-optimalisatie en om een fundamentele bron te bieden voor green software engineering.

Oorspronkelijke auteurs: Mohammadjavad Mehditabar, Saurabhsingh Rajput, Tushar Sharma

Gepubliceerd 2026-07-09

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Mohammadjavad Mehditabar, Saurabhsingh Rajput, Tushar Sharma

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een chef-kok bent die een enorm, 24-uurs restaurant runt. Je hebt een menu van duizenden gerechten (softwareprogramma's) die je elke dag aan miljoenen klanten serveert.

Een lange tijd gaf je alleen om één ding: Snelheid. "Hoe snel krijg ik dit gerecht uit de keuken?" vroeg je. Als een gerecht 10 seconden in plaats van 12 seconden duurde, was je tevreden.

Maar onlangs besefte je iets engs: Snelheid is niet het hele verhaal. Soms komt een gerecht dat sneller klaar is, eigenlijk een enorme hoeveelheid elektriciteit verbruiken omdat de chef koortsachtig heen en weer rent, de oven aan en uit zet, of een gigantische, inefficiënte blender gebruikt. Dit is het probleem dat dit artikel aanpakt. Het gaat over het vinden van de "energiegeuren" in de code van je keuken—de slechte gewoontes die elektriciteit verspillen, zelfs als het eten prima smaakt.

Hier is een eenvoudige uitsplitsing van wat de onderzoekers hebben gedaan:

1. Het Grote Probleem: Snelheid vs. Energie

Het artikel begint met het ontkrachten van een veelvoorkomende mythe: "Sneller betekent altijd groener."

De Analogie: Stel je voor dat je in een auto rijdt. Je kunt in 5 minuten bij de winkel zijn door te racen en hard te remmen (hoge snelheid, hoog brandstofverbruik). Of je kunt in 7 minuten rijden door rustig te cruisen (iets langzamer, maar veel minder brandstofverbruik).
De Realiteit: In software betekent het schrijven van code die snel draait niet altijd dat het energie bespaart. Soms maakt het versnellen van code de processor van de computer juist harder aan het werk en trekt het meer stroom, waardoor er in totaal energie wordt verspild.

2. De Oplossing: Een "Geur"-Taxonomie

De onderzoekers wilden een woordenboek maken voor deze slechte gewoontes. Ze noemden ze "Energiegeuren" (Energy Smells). Net zoals een vieze geur in een huis aangeeft dat er iets rot, geeft een "codegeur" een ontwikkelaar aan dat er iets inefficiënt is.

Ze hebben niet zomaar geraden; ze gingen op een enorme schattenjacht:

De Jacht: Ze lazen 60 verschillende wetenschappelijke artikelen en screenden meer dan 400 andere documenten om elke mogelijke manier te vinden waarop code energie verspilt.
Het Sorteren: Ze vonden 320 verschillende slechte gewoontes. Vervolgens organiseerden ze deze in een nette, twee-niveau familieboom:
- Niveau 1 (De Categorie): Het algemene type geur (bijv. "Verspilde Arbeid" of "Slecht Geheugengebruik").
- Niveau 2 (De Grondoorzaak): Het specifieke ding dat je fout deed (bijv. "Je hebt twee keer dezelfde wiskundige berekening uitgevoerd" of "Je hield een zwaar object in het geheugen terwijl je het niet meer nodig had").

Het Resultaat: Ze creëerden een kaart met 12 hoofdcategorieën en 65 specifieke grondoorzaken. Dit is voor het eerst dat een dergelijk uitgebreid, taal-onafhankelijk (werkt voor Python, Java, C++, etc.) overzicht is gemaakt.

3. Het Bewijs: Testen in de echte wereld

Een lijst is nutteloos als deze niet overeenkomt met de realiteit. Daarom bouwden de onderzoekers een enorme testkeuken.

De Dataset: Ze namen 21.000 paren code. In elk paar was één versie de "slechte" manier en de andere de "goede" manier, maar ze deden allebei exact hetzelfde werk.
De Meting: Ze maten exact hoeveel elektriciteit, tijd en geheugen elke versie gebruikte.
De AI-Detective: Ze gebruikten een superintelligente AI (een LLM) om naar de top 3.000 slechtste overtreders te kijken en te vragen: "Welke van onze 65 geuren veroorzaakt deze verspilling?"

Wat ze vonden:

De AI had gelijk: De AI koppelde de slechte code in 85% van de gevallen succesvol aan hun nieuwe kaart. Dit bewees dat hun kaart echt en nuttig is.
Meerdere Geuren: De meeste slechte code (71%) bestond niet uit slechts één geur; het was een cocktail van verschillende slechte gewoontes die tegelijkertijd optraden.
De Grote Winnaars: De grootste energiebesparingen kwamen niet altijd van de snelste code. Het oplossen van geheugenproblemen (zoals het vasthouden van gegevens die je niet meer nodig hebt) leverde de meeste energie op.
De Verrassing: Soms maakte het repareren van een probleem de code langzamer, maar bespaarde het juist meer energie. Dit bewijst dat je niet alleen naar snelheid kunt kijken; je moet ook naar de energierekening kijken.

4. Waarom dit ertoe doet

Beschouw dit artikel als het geven van een universele "Check Engine"-lamp voor energie aan ontwikkelaars.

Voorheen zouden ontwikkelaars een traag programma kunnen repareren zonder te beseffen dat ze eigenlijk elektriciteit verspillen.
Nu hebben ze een gedeelde vocabulaire. Als een ontwikkelaar een "Redundante Berekening"-geur ziet, weten ze precies wat ze moeten repareren om energie te besparen.

De Kern van het Verhaal

De onderzoekers hebben niet alleen een paar slechte gewoontes gevonden; ze hebben een complete encyclopedie van energieverspilling in software gebouwd. Ze hebben bewezen dat om de planeet te redden (en geld te besparen), we niet alleen moeten kijken naar hoe snel software draait, maar ook naar hoe efficiënt het stroom verbruikt. Ze hebben zelfs hun "testkeuken"-data en de kaart vrijgegeven voor iedereen om te gebruiken, zodat de hele wereld met groenere software kan gaan koken.

Technische Samenvatting: Watts This Smell: Een Uitgebreide Taxonomie van Software Energiegeuren

Probleemstelling

Nu software zich over steeds meer domeinen verspreidt, is de geaggregeerde energievoetafdruk ervan een kritiek milieuprobleem geworden. Hoewel "code smells" (codegeuren) goed gevestigd zijn als structurele anti-patronen die de onderhoudbaarheid verslechteren, bestaat er een parallel evenclass "energiegeuren": implementaties in broncode, ontwerpkeuzes of programmeerpraktijken die leiden tot inefficiënt gebruik van hardwarebronnen en onnodig energieverbruik.

Een belangrijke misvatting in software engineering is het behandelen van executieprestaties en energieverbruik als uitwisselbare metrieken. Hoewel ze gecorreleerd zijn, meten ze verschillende verschijnselen. Prestaties reflecteren primair de executietijd ( $T$ ), terwijl energieverbruik ( $E$ ) het product is van het vermogen ( $P$ ) en de tijd ( $E = P \times T$ ). Snellere executie garandeert niet automatisch een lager energieverbruik; een codeverandering die de tijd vermindert, kan tegelijkertijd het vermogensverbruik verhogen, wat resulteert in een hogere totale energieconsumptie. Bovendien zijn bestaande catalogi van anti-patronen vaak domeinspecifiek (bijv. alleen gericht op Android), beperkt tot prestatie-metrieken, missen fijnmazige classificatie van de grondoorzaken, of blijven onverifieerd tegen gemeten energiegegevens. Er is behoefte aan een uitgebreide, taal-agnostische taxonomie die de kloof overbrugt tussen het identificeren van inefficiënties en actiegerichte refactoring.

Methodologie

De auteurs ontwikkelden een twee-niveau taxonomie via een rigoureus, meerfasig proces dat een systematische literatuurstudie, grounded theory coding en empirische validatie combineert.

1. Constructie van de Taxonomie

Literatuuronderzoek: De auteurs voerden een systematische zoekopdracht uit in Scopus en voerden een uitgebreide forward en backward snowballing uit. Dit proces selecteerde meer dan 400 werken, waarbij uiteindelijk 60 relevante studies werden behouden (inclusief 15 uit de initiële zoekopdracht en 45 uit de snowballing) die code-niveau prestatie- of energie-inefficiënties identificeerden.
Data-extractie: Uit deze studies werden aanvankelijk 431 verschillende anti-patronen geïdentificeerd.
Filtering en Codering: Twee onafhankelijke annotatoren pasten inclusie-/exclusiecriteria toe om te filteren op taal-agnostische constructen, waarbij 320 relevante patronen werden behouden. Vervolgens pasten zij een grounded theory coding-proces toe (Open, Axial en Selective coding) om te:
- Open Coding: Fundamentele grondoorzaken te isoleren door de applicatie-specifieke context te strippen.
- Axial Coding: Redundante codes samen te voegen en samengevoegde mechanismen te splitsen.
- Selective Coding: Verfijnde codes te abstraheren naar hoogwaardige categorieën op basis van hun overkoepelende impact.
Finalisering: Door middel van collaboratieve resolutie finaliseerde het team een taxonomie bestaande uit 12 primaire energiegeur-categorieën en 65 grondoorzaken (subcategorieën).

2. Empirische Validatie

Om de taxonomie te valideren, construeerden de auteurs een gelabelde dataset en pasten zij een geautomatiseerde classificatie-pipeline toe:

Dataset: Zij maakten gebruik van de Python-splits van de Pie-Perf dataset (afgeleid van IBM CodeNet), waarbij 36.857 instanties werden gefilterd tot 21.428 functioneel equivalente codepaartjes met geverifieerde tijd- en geheugenmetrieken.
Energieprofilering: Zij maten het energieverbruik voor deze paren empirisch met behulp van Linux perf en time tools, waarbij CPU/RAM-energie en piekgeheugengebruik werden vastgelegd.
Steekproefselectie: De top 3.000 paren met de hoogste absolute energieverschillen werden geselecteerd voor diepgaande analyse, waarbij 98,4% van de totale energievariantie in de dataset werd meegenomen.
LLM Classificatie: Een multi-step pipeline met het DeepSeek-V3.2 (685B) reasoning model classificeerde de 3.000 paren. De pipeline bestond uit drie stappen:
1. Grondoorzaakanalyse: Het identificeren van inefficiënties zonder voorafgaande blootstelling aan de labels van de taxonomie.
2. Categorie Triage: Het mappen van oorzaken naar hoogwaardige categorieën.
3. Subcategorie Classificatie: Verfijning naar specifieke grondoorzaken.
Evaluatie: Er werd een door mensen geannoteerde ground truth vastgesteld op een willekeurige subset van 100 monsters. De pipeline behaalde een exact-match nauwkeurigheid van 94% en een micro F1-score van 0,97, wat de toepasbaarheid van de taxonomie op echte code bevestigt.

Belangrijkste Bijdragen

Uitgebreide Taxonomie: Een taal-agnostische, twee-niveau taxonomie van 12 energiegeur-categorieën en 65 grondoorzaken. De categorieën variëren van laag-niveau hardware-effecten (bijv. slechte hardware-lokaliteit) tot hoog-niveau algoritmische keuzes (bijv. suboptimale algoritmen).
Gelabelde Dataset: Een publiekelijk beschikbare dataset van 21.428 codepaartjes met geverifieerde energie-, geheugen- en tijdmetingen. Dit omvat een handmatig gevalideerde subset van 3.000 paren die zijn geannoteerd met multi-label energiegeur-classificaties en stapsgewijze redeneerpaden.
Empirische Analyse: Een analyse van de prevalentie, co-occurrence en energie-impact van elke categorie energiegeur, wat bewijs levert dat energie-optimalisatie niet gereduceerd kan worden tot louter prestatie-optimalisatie.

Belangrijkste Resultaten

Prevalentie: De taxonomie bracht succesvol 84,6% (55 van de 65) van de grondoorzaken in kaart voor de 3.000 geclassificeerde codepaartjes. De meest voorkomende categorieën waren Suboptimaal Algoritmisch (C7, 41,6%), Onnodig Geheugengebruik (C6, 38,9%) en Inefficiënte Iteratiepatronen (C3, 33,3%).
Co-occurrence: 71% van de monsters vertoonde meerdere co-occurrerende geuren. Multi-label gevallen vertoonden aanzienlijk meer energieverspilling (mediaan besparing van 1.659 J) vergeleken met single-label gevallen (549 J), wat aangeeft dat inefficiënties cumulatief werken.
Impact vs. Frequentie: Er is een mismatch tussen de frequentie van een geur en de energie-impact ervan. Hoewel Suboptimale Algoritmen (C7) het meest voorkwamen, leverden geheugen-gerelateerde geuren (C5 en C6) de hoogste mediane energiebesparingen per fix op (respectievelijk 3.989 J en 3.670 J). Dit komt doordat geheugen-inefficiënties zowel de executietijd als het vermogensverbruik verhogen, terwijl algoritmische inefficiënties primair de tijd beïnvloeden.
Vermogensvariantie: Het vermogensverbruik varieerde aanzienlijk tussen de patronen (60,5 W tot 147,3 W). In 69,1% van de monsters overschreed de energi ratio de tijd ratio, wat bewijst dat naïeve schatting ( $E = \text{constante} \times T$ ) het energieverlies systematisch onderschat.
Design vs. Implementatie: Design-niveau geuren (bijv. keuze van datastructuur) produceerden hogere mediane energiebesparingen (1.537 J) dan implementatie-niveau geuren (1.146 J), wat het idee ondersteunt dat diepere architecturale fixes grotere winsten opleveren.

Betekenis en Claims

Het artikel stelt dat een goed gedefinieerde taxonomie van energiegeuren een gedeelde vocabulaire en actiegerichte refactoring-richtlijnen biedt voor de software engineering gemeenschap. Door energie-efficiëntie te onderscheiden van louter prestatie-optimalisatie, maakt dit werk mogelijk:

Green Software Engineering: Ontwikkelaars kunnen code refactoren om energie-efficiëntie te verbeteren naast onderhoudbaarheid en prestaties.
Tooling Ontwikkeling: De taxonomie dient als fundament voor statische analyse-tools, IDE linters en CI/CD safeguards om energieverspilling te detecteren en te voorkomen.
AI-gestuurde Optimalisatie: De gelabelde dataset en redeneerpaden kunnen generatieve AI-modellen trainen om energie-efficiënte code te synthetiseren en automatische refactoring uit te voeren.

De auteurs benadrukken dat hun taxonomie geen vervanging is voor prestatie-anti-patronen, maar een noodzakelijke uitbreiding, aangezien optimaliseren voor snelheid alleen niet garandeert dat men energie-efficiënt is. Het werk beoogt energiebewustzijn te operationaliseren in standaard softwareontwikkelingsworkflows, waarbij de focus verschuift van het meten van verspilling naar het actief elimineren ervan.