Softwareproduktlinien Teil 11: Verbesserte Präprozessoren

Transkript

1 Softwareproduktlinien Teil 11: Verbesserte Präprozessoren Christian Kästner (Universität Marburg) Sven Apel (Universität Passau) Gunter Saake (Universität Magdeburg)

2 Agenda Wiederholung: Probleme von Präprozessoren Verbesserungen Integration mit Feature-Modell Sichten Visuelle Darstellung Disziplinierte Annotationen Typsystem Von Präprozessoren zu Features/Aspekten

3 Application Eng. Domain Eng. Produktlinien mit Präprozessoren Feature-Modell Programm mit Präprozessor-Anweisungen static int _rep_queue_filed DB_ENV *dbenv; REP *rep; rep_fileinfo_arg #ifndef HAVE_QUEUE COMPQUIET(rep COMPQUIET(rfp, return ( db_no_ #else Feature-Auswahl als Eingabe Feature-Auswahl Präprozessor Fertiges Program

4 Komposition vs. Präprozessor Aufteilung in Module Varianten durch Komposition Verstreute Annotationen Varianten durch löschen von Fragmenten class A { void class push(object Lock { o) { #ifdef void LOCKING class push(object Lock l LFU = lock(o); { o) { #ifdef void class LOCKING elementdata[size++] Lock push(object Base { void l = lock(o); o) { = o #ifdef LOCKING Lock push(object l = lock(o); o) { #ifdef class l.unlock(); elementdata[size++] elementdata[size++] LOCKING Stack { void = #ifdef #ifdef Lock push(object LOCKING LOCKING l = lock(o); o) { #ifdef WIN l.unlock(); l.unlock();... elementdata[size++ Lock l = lock(o); #ifdef #ifdef LOCKING STATISTICS l.unlock(); elementdata[size+... #ifdef WIN l.unlock(); #ifdef... STATISTICS... #ifdef STATISTICS #ifdef DYNAMIC...

5 Problem: Trennung von Belangen Verstreuter und vermischter Quelltext Verstehen eines Features erfordert Suche im gesamten Quelltext Selbst Löschen eines Features wird zur Herausforderung Arbeitsteilige Entwicklung wird erschwert Schwierige Wiederverwendung

6 Eine Frage der Größe Beispiel: Zeitmanagement von Sessions Example: Session expiration in im Apache Tomcat Server the Apache Tomcat Server (Bestandteil der Session-Verwaltung) 6

7 Problem: Unlesbarer Quelltext Vermischung von zwei Sprachen (C und #ifdef, oder Java und Munge, ) Kontrollfluss schwer nachvollziehbar Lange Annotationen schwer zu finden Zusätzliche Zeilenumbrüche zerstören Layout Features lieber modularisieren? 7 class Stack { void push(object o #ifdef SYNC, Transaction txn ) { if (o==null #ifdef SYNC txn==null ) return; #ifdef SYNC Lock l=txn.lock(o); elementdata[size++] = o; #ifdef SYNC l.unlock(); firestackchanged();

8 Präprozessor in Femtoos

9 Problem: Fehleranfällig Syntaxfehler Typfehler static int _rep_queue_filedone(...) DB_ENV *dbenv; REP *rep; rep_fileinfo_args *rfp; { #ifndef HAVE_QUEUE COMPQUIET(rep, NULL); COMPQUIET(rfp, NULL); return ( db_no_queue_am(dbenv)); #else db_pgno_t first, last; u_int32_t flags; int empty, ret, t_ret; #ifdef DIAGNOSTIC DB_MSGBUF mb; // over 100 lines of additional code 9 #ifdef TABLES class Table { void insert(object data, Txn txn) { storage.set(data, txn.getlock()); class Storage { #ifdef WRITE boolean set( ) {...

10 Typfehler bei mehreren Features class Database { #ifdef WRITE void insert(object data, Txn txn) { storage.set(data, txn.getlock()); class Storage { #ifdef PERSISTENT boolean set(object data, Lock lock) { /* implementation A */ #ifdef INMEMORY boolean set(object data, Lock lock) { /* implementation B */ DB Storage Persistent Write InMemory

11 Vorteile von Präprozessoren In vielen Sprachen bereits enthalten / simple Tools Den meisten Entwicklern bereits bekannt Sehr einfaches Programmierkonzept: markieren und entfernen Sehr flexibel / ausdrucksstark Sprachunabhängig / Uniformität Einfache Lösung für Feature-Interaktion (verschachtelte #ifdefs) Nachträgliche Einführung von Variabilität in bestehendes Projekt einfach

12 Feature-Interaktionen add power eval print statt:

13 Verbesserungen

14 Integration mit Feature-Modell Präprozessor erfordert Feature-Modell Fehler wenn zu #ifdef X X nicht im Feature-Modell Werkzeug verwaltet Annotationen Linux Kernel: mindestens 321 undefinierte Features (Tippfehler etc.)

15 Sichten Sicht zeigt Ausschnitt des Quelltextes Irrelevanter Quelltext wird ausgeblendet Ganze Dateien ausblenden In Datei manche Zeilen ausblenden Sicht auf ein Feature Zeigt Feature und nötigen Kontext Sicht auf eine Variante Zeigt generierten Quelltext (Vorschau) für Feature-Auswahl

16 Sicht auf Variante Add und Eval Datei Power wird komplett ausgeblendet Funktion print in Add wird ausgeblendet (* +) Nicht-annotierter Quelltext bleibt sichtbar

17 Sicht auf Feature Eval Zeigt alle Dateien mit Quelltext von Eval, egal wo Kontextinformationen bleiben erhalten (kursiv) Nicht-annotierter Quelltext wird ausgeblendet

18 Visuelle Darstellung: NetBeans Hintergrundfarbe für Annotation

19 Visuelle Darstellung: CIDE Hintergrundfarben statt #ifdef class Stack { void push(object o #ifdef SYNC, Transaction txn ) { if (o==null #ifdef SYNC txn==null ) return; #ifdef SYNC Lock l=txn.lock(o); elementdata[size++] = o; #ifdef SYNC l.unlock(); firestackchanged();

20 Visuelle Darstellung: Spotlight class Database { List locks; void lock() { /*...*/ void unlock() { /*...*/ void put(object key,object data){ lock(); /*...*/ unlock(); Object get(object key) { lock(); /*...*/ unlock(); int getopenlocks() { return locks.size(); int getdbsize() { return calculatedbsize(); static int calculatedbsize() { lock(); /*...*/ unlock();

21 FeatureCommander

22 Experiment (Passau, Juni 2009) #ifdef vs. Farben 43 Probanden in 2 Gruppen S1-2: Suchaufgaben Farben schneller (43% & 23%) M1-3: Fehlersuche kein Einfluss M4: Suche in rotem Quelltext -37% Generell kein Einfluss auf Korrektheit Probanden bevorzugen Farben

23 Experiment (Magdeburg, Jan. 2010) Probanden können frei zwischen #ifdef und Farben wechseln Wie nutzen sie das? Farben zum Suchen, #ifdef zum Verstehen?

24 Disziplinierte Annotationen Syntaxfehler durch Annotationen auf beliebigen Zeichenfolgen Lösung: Struktur des Codes nutzen Disziplinierte Annotationen auf ganzen Klassen, Methoden oder Statements Annotationen auf einzelnen Klammern oder Schluesselwörtern verboten (undizipliniert) class Foo { class Foo { ClassDeclaration Name=C MethodDeclaration Name=m class C { void m(int p) { s1(); s2(p, true); ReturnType Type-void Parameter Name=p MethodInvk Name=s1 Parameter Name=p Block MethodInvk Name=s2 Parameter Name=true

25 Varianten generieren durch AST-Transformation ClassDeclaration Name=C ClassDeclaration Name=C MethodDeclaration Name=m MethodDeclaration Name=m ReturnType Type-void Parameter Name=p Block ReturnType Type-void Parameter Name=p Block MethodInvk Name=s1 Parameter Name=p MethodInvk Name=s2 Parameter Name=true parsen generieren MethodInvk Name=s1 drucken/ unparse class C { void m(int p) { s1(); s2(p, true); class C { void m(int p) { s1(); Bei der Generierung können keine Syntaxfehler entstehen!

26 Ausdrucksfähigkeit von disziplinierten Annotationen Nicht mehr alle Annotationen sind möglich Teilweise werden Workarounds benötigt In der Praxis: keine deutliche Einschränkung, typische Annotationen weiterhin möglich Ca. 84% der Annotationen in C-Code bereits diszipliniert hohe Flexibilität keine Flexibilität Beliebige Annotationen auf Zeichenfolgen Disziplinierte Annotationen (berücksichtigt Struktur) nur Klassen keine Annotationen

27 Ausblick: Analysen für Produktlinien Softwareproduktline FAME-DBMS OS BufferMgr Debug Logging Storage Nut/OS Win Persistent InMemory API B + Tree MemAlloc PageRepl. get put delete Static Dyn. LRU LFU Unindexed Typprüfung Generierung Variante A Correct Compile and test Variante B Correct Compile and test Variante C Typsysteme, Statische Analyse, Model Checking, Parsing, Correct Compile and test

28

29 Implementierung: CIDE

30 Implementierung: FeatureMapper

31 Zusammenfassung Probleme: Traceability Trennung von Belangen Lesbarkeit Fehleranfällig Vorteile: Einfache Benutzung Uniformität Verbesserungen: Integration mit Featuremodell Sichten Visualisierung Disziplinierte Annotationen Typsystem Virtuelle Trennung von Belangen

32 Von Präprozessoren zu Features/Aspekten

33 Undo Top Base Automatische Transformation Feature Module Annotationen class Stack { int[] data; void push(int o) { int pop() { /*...*/ class Stack { int[] data; #ifdef UNDO int backup; void undo() { /*...*/ #ifdef TOP refines class Stack { Equivalentes Verhalten int top() { /*...*/ int top() { /*...*/ in allen Varianten void push(int o) { refines class Stack { #ifdef UNDO int backup; backup = top(); void undo() { /*...*/ void push(int o) { /*...*/ backup = top(); original(v); int pop() { /*...*/

34 Refactorings Kleine Refactorings im Spektrum zwischen Feature Modulen und Annotationen nur Annotationen Annotationen und Verfeinerungen gemischt nur Verfeinerungen class Stack { #ifdef UNDO void undo() { refines class Stack{ #ifdef UNDO void undo() { refines class Stack{ void undo() {... original();

35 Automatische Transformationen in CIDE Implementiert als Import und Export Munge AHEAD Java ME Antenna Feature- House CPP XML AspectJ incomplete

36 Fazit Präprozessoren typisch in Praxis Viele Probleme bekannt Werkzeugunterstützung kann viele Probleme lindern Vielleicht keine langfristige Lösung aber Verbesserung bis Feature-Orientierung oder Aspektorientierung allgemein akzeptiert

37 Literatur Christian Kästner. Virtual Separation of Concerns: Toward Preprocessors 2.0. PhD thesis, University of Magdeburg, May Logos Verlag Berlin, isbn [Gesamtkonzept, listet weitere Literatur]