Lehrstuhl Praktische Informatik. Softwaretechnik 2. Variabilitätsmodellierung im Lösungsraum

Transkript

1 Lehrstuhl Praktische Informatik Softwaretechnik 2 Variabilitätsmodellierung im

2 Einordnung Software-Produktlinienentwicklung Entwicklungsprozess von Software-Produktlinien Variabilitätsmodellierung und Produktkonfiguration im Problemraum Formalismus und Analyse von Feature-Modellen Variabilitätsmodellierung im Modellbasierte Produktlinien Delta-basierte Variabilitätsmodellierung 2

3 Lernziele Variabilitätsmechanismen in Programmiersprachen kennen Zusätzliche (alternative) Variabilitätsansätze im Detail verstehen Unterschiede sowie Vor- und Nachteile der jeweiligen Ansätze erläutern können Einsatzmöglichkeiten einschätzen können Verschiedene Ansätze praktisch einsetzen und anwenden können 3

4 Application Eng. Domain Eng. Einordnung Feature-Modell Wiederverwendbare Implementierungsartefakte Feature-Auswahl Generator Fertiges Program 4

5 Lehrstuhl Praktische Informatik PRÄPROZESSOREN 5

6 Präprozessoren Präprozessoren transformieren den Quelltext vor dem eigentlichen Compileraufruf Funktionsumfang: von einfachen #include Befehlen und bedingter Übersetzung bis zu komplexen Makrosprachen und Regeln Grundlage für generische Programmierung / konfigurierbare Programme / Meta-Programmierung / Fester Bestandteil vieler Programmiersprachen C, C++, Fortran, Erlang mit eigenem Präprozessor C#, Visual Basic, D, PL/SQL, Adobe Flex Java: externe Tools 6

7 Beispiel: #ifdef in Berkley DB static int rep_queue_filedone(dbenv, rep, rfp) 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; #endif // over 100 lines of additional code #endif 7

8 Beispiel: Graph SPL in Java class Graph { Vector nv = new Vector(); Vector ev = new Vector(); Edge add(node n, Node m) { Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); if (Conf.WEIGHTED) e.weight = new Weight(); return e; Edge add(node n, Node m, Weight w) if (!Conf.WEIGHTED) throw RuntimeException(); Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); e.weight = w; return e; void print() { for(int i = 0; i < ev.size(); i++) { ((Edge)ev.get(i)).print(); class Conf { public static boolean COLORED = true; public static boolean WEIGHTED = false; class Node { int id = 0; Color color = new Color(); void print() { if (Conf.COLORED) Color.setDisplayColor(color); System.out.print(id); class Edge { Node a, b; Color color = new Color(); Weight weight; Edge(Node _a, Node _b) { a = _a; b = _b; void print() { if (Conf. COLORED) Color.setDisplayColor(color); a.print(); b.print(); if (Conf.WEIGHTED) weight.print(); class Color { static void setdisplaycolor(color c) {... class Weight { void print() {... 8

9 C-Präprozessor Präprozessor-Direktiven sind spezielle Instruktionen im Programm- Code, die nicht Teil des endgültigen (durch den Compiler übersetzten) Programms sind, sondern vom Präprozessor vor der Kompilierung verarbeitet (und dabei möglicherweise entfernt) werden. Der C-Präprozessor (CPP) wird vor der eigentlichen Kompilierung aufgerufen und transformiert das Programm gemäß der im Programm enthaltenen Direktiven CPP ist Teil des ANSI C Standards Für Präprozessor-Direktiven in C gilt bestehen aus Zeilen beginnend mit # gefolgt vom Namen und (optionalen) weiteren Argumenten für die Direktive dürfen sich nicht über eine Zeile hinaus erstrecken 9

10 Bestandteile von CPP Der CPP umfasst vier Mechanismen Auslagern von Code und Einbinden durch Header-Files Makros zum Definieren/Verwenden und Finden/Ersetzen (Expandieren) von Namen für beliebige Code-Fragmente Bedingte Kompilierung: optionale/alternative Code- Fragmente vor der Kompilierung einblenden/ausblenden bzw. auswählen. Generische Programmierung Explizite Deklaration und Kennzeichnung von Programmzeilen, z.b. für Tracing, Debugging etc. 10

11 Definition von Makros Direktive Makro-Name Fragment Expansionsstelle Expansionsstelle #define SIZE foo = (char *) xmalloc (SIZE);... #define NEWSIZE SIZE Definition von Namen für beliebige Code-Fragmente Jedes Auftreten des Namens im nachfolgenden Programmtext wird durch das Fragment ersetzt (expandiert) Fragmente können selbst wieder Makro-Namen enthalten Fragmente werden nicht interpretiert, sondern als einfache Strings kopiert 11

12 Makros mit Argumenten Deklaration von Argumentnamen Vorkommen von Argumentnamen im Fragment #define min(x,y) ((X) < (Y)? (X) : (Y))... min(1,2) ((1) < (2)? (1) : (2))... min(x+42,*p) ((x+42) < (*p)? (x+42) : (*p))... min(min(a,b),c)... // => Übung Argumente können an jeder Expansionsstelle neu gesetzt werden Genau wie Fragmente sind Argumente uninterpretierte Strings Schachtelung von Makro-Expansionen und/oder Argumenten beliebig möglich 12

13 Bedingte Kompilierung Markieren von Quelltextabschnitten, die beim Kompilieren unter bestimmten Bedingungen ignoriert werden, d.h. nicht in das Zielprogramm übersetzt werden Bedingungen müssen zur Kompilierzeit auswertbar sein Mögliche Bedingungen: Prüfen, ob ein Name als Makro definiert/undefiniert ist (eingeschränkte) Boole sche Ausdrücke über Makro-Namen und Konstanten 13

14 #if Direktive #if expression // conditional code #endif #if SIZE < 1020 foo = (char *) xmalloc(size); #endif Der conditional code kann weitere Makros enthalten In der expression dürfen vorkommen: Literale vom Typ Integer und Character Makro-Namen Arithmetische, relationale und logische Operatoren Namen, die keine Makros sind, werden als Konstante 0 interpretiert 14

15 #else Direktive #if expression #else // conditional code // alternative conditional code #endif #if SIZE < 1020 foo = (char *) xmalloc(size); #else foo = (char *) xmalloc(1020) #endif Auswahl zwischen zwei alternativen Quelltext-Abschnitten Es wird immer genau einer der beiden conditional code Abschnitte kompiliert 15

16 #elif Direktive #if expression // 1. alternative conditional code #elif expression // 2. alternative conditional code #elif expression // n. alternative conditional code #else // default conditional code #endif Auswertungsreihenfolge Auswahl zwischen n alternativen Quelltextabschnitten Die expressions müssen sich nicht zwangsläufig gegenseitig ausschließen (ähnlich zu switch-case) 16

17 #ifdef und #ifndef #ifdef makro-name // conditional code #endif #ifndef makro-name // conditional code #endif #ifdef SIZE foo = (char *) xmalloc(size); #endif #ifndef SIZE foo = (char *) xmalloc(1020); #endif Der conditional code wird kompiliert, wenn ein Makro-Name definiert / nicht definiert (bzw. undefiniert) ist 17

18 SPL Implementierung mit CPP 1. Feature Modell erstellen Funktion zum Verdoppeln einer Ganzzahl x TWICE MAXVAL : int PLUS TIMES MAXBOUND Verdoppeln von x durch Addition mit x Verdoppeln von x durch Multiplikation mit 2 Falls der verdoppelte Wert von x größer als der Wert MAXVAL ist, dann MAXVAL zurückgeben 18

19 SPL Implementierung mit CPP 2. Feature-Modell als Makro kodieren TWICE MAXVAL : int PLUS TIMES MAXBOUND Mandatory Root Feature Feature- Makros Alternativ- Gruppe #if ( defined (TWICE) && ((defined (PLUS) &&! defined (TIMES)) (defined (TIMES) &&! defined (PLUS) )) && (defined (MAXVAL)! defined (MAXBOUND) ) #define VALIDCONFIG #endif Makro gesetzt, falls Konfiguration valide Attributwert für MAXVAL gesetzt, wenn MAXBOUND gewählt 19

20 SPL Implementierung mit CPP 3. Parametrisierter C-Code TWICE Nur für valide Konfigurationen wird ein Programmvariante erzeugt PLUS TIMES MAXBOUND #ifdef VALIDCONFIG int twice(int x) { int y = #ifdef PLUS x+x; #elif TIMES 2*x; #endif #endif #ifdef MAXBOUND if (y > MAXVAL) return MAXVAL; else #endif return y; MAXVAL : int 20

21 SPL Implementierung mit CPP 4. Konfigurationen kodieren TWICE MAXVAL : int Beliebiger Wert PLUS TIMES MAXBOUND P1 = { TWICE, PLUS #define TWICE 1 #define PLUS 1 P2 = { TWICE, TIMES #define TWICE 1 #define TIMES 1 P3 = { TWICE, PLUS, MAXBOUND, MAXVAL=1020 #define TWICE 1 #define PLUS 1 #define MAXBOUND 1 #define MAXVAL 1020 P4 = { TWICE, TIMES, MAXBOUND, MAXVAL=1020 #define TWICE 1 #define TIMES 1 #define MAXBOUND 1 #define MAXVAL

22 SPL Implementierung mit CPP 5. Programmvarianten twice_spl.c #ifdef VALIDCONFIG int twice(int x) { int y = #endif #ifdef PLUS x+x; #elif TIMES 2*x; + #endif #ifdef MAXBOUND if (y > MAXVAL) return MAXVAL; else #endif return y; config1.h #define TWICE 1 #define PLUS 1 config2.h #define TWICE 1 #define TIMES 1 config3.h #define TWICE 1 #define PLUS 1 #define MAXBOUND 1 #define MAXVAL 1020 config4.h #define TWICE 1 #define TIMES 1 #define MAXBOUND 1 #define MAXVAL 1020 int twice(int x) { int y = x+x; return y; int twice(int x) { int y = 2*x; return y; int twice(int x) { int y = x+x; if (y > 1020) return 1020; else return y; int twice(int x) { int y = 2*x; if (y > 1020) return 1020; else return y; 22

23 Präprozessoren für Java Nicht nativ vorhanden Bedingte Kompilierung im Java-Compiler nur auf Statement-Ebene, nicht für Klassen, Methoden und Felder class Example { public static final boolean DEBUG = false; void main() { System.out.println( immer ); if (DEBUG) System.out.println( debug info ); Dead Code wird durch Java-Compiler entfernt Externe Tools vorhanden, z.b. CPP, Munge, Antenna, XVCL, Gears, pure::variants 23

24 MUNGE Einfacher Präprozessor für Java Code Ursprünglich für Swing in Java 1.2 eingeführt class Example { void main() { System.out.println( immer ); /*if[debug]*/ System.out.println( debug info ); /*end[debug]*/ > java Munge DDEBUG DFEATURE2 Datei1.java Datei2.java... Zielverzeichnis Konfiguration: Feature-Auswahl aus Feature-Modell 24

25 Beispiel: Graph SPL class Graph { Vector nv = new Vector(); Vector ev = new Vector(); Edge add(node n, Node m) { Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); e.weight = new Weight(); return e; Edge add(node n, Node m, Weight w) Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); e.weight = w; return e; void print() { for(int i = 0; i < ev.size(); i++) { ((Edge)ev.get(i)).print(); class Node { int id = 0; Color color = new Color(); void print() { Color.setDisplayColor(color); System.out.print(id); class Edge { Node a, b; Color color = new Color(); Weight weight; = new Weight(); Edge(Node _a, Node _b) { a = _a; b = _b; void print() { Color.setDisplayColor(color); a.print(); b.print(); weight.print(); class Color { static void setdisplaycolor(color c) {... class Weight { void print() {... 25

26 Graph SPL mit MUNGE class Graph { Vector nv = new Vector(); Vector ev = new Vector(); Edge add(node n, Node m) { Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); /*if[weight]*/ e.weight = new Weight(); /*end[weight]*/ return e; /*if[weight]*/ Edge add(node n, Node m, Weight w) Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); e.weight = w; return e; /*end[weight]*/ void print() { for(int i = 0; i < ev.size(); i++) { ((Edge)ev.get(i)).print(); /*if[weight]*/ class Weight { void print() {... /*end[weight]*/ class Edge { Node a, b; /*if[color]*/ Color color = new Color(); /*end[color]*/ /*if[weight]*/ Weight weight; /*end[weight]*/ Edge(Node _a, Node _b) { a = _a; b = _b; void print() { /*if[color]*/ Color.setDisplayColor(color); /*end[color]*/ a.print(); b.print(); /*if[weight]*/ weight.print(); /*end[weight]*/ /*if[color]*/ class Color { static void setdisplaycolor(color c) {... /*end[color]*/ class Node { int id = 0; /*if[color]*/ Color color = new Color(); /*end[color]*/ void print() { /*if[color]*/ Color.setDisplayColor(color); /*end[color]*/ System.out.print(id); 26

27 Antenna Präprozessor-Direktive #ifdef wie in cpp Sammlung von Ant-Tasks für Java ME In vielen Java ME Projekten eingesetzt Bedingte Kompilierung objektorienter Programm- Elemente in Java Klassen und Interfaces Methoden und Member- Variablen Klassenvariablen und statische Methoden Statements 27

28 Antenna - Beispiel //#ifdef midp20 //# import javax.microedition.lcdui.game.sprite; //#endif //#ifdef siemens //# import com.siemens.mp.game.sprite //#endif <wtkpreprocess srcdir="src destdir="siemens symbols="siemens verbose="true" /> (build.xml) //#ifdef midp20 //# import javax.microedition.lcdui.game.sprite; //#endif //#ifdef siemens import com.siemens.mp.game.sprite //#endif 28

29 Vorteile von Präprozessoren In vielen Sprachen bereits enthalten / einfach verwendbare Tools Den meisten Entwicklern bereits bekannt Sehr einfaches Programmierkonzept: markieren und entfernen Sehr flexibel / ausdrucksstark, beliebige Granularität Nachträgliche Einführung von Variabilität in bestehendes Projekt einfach 29

30 Nachteile: Unleserlicher Code 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 Vermischung von syntaktischer Variation und Programmsemantik Alternativ: Feature-Code separieren/modularisieren? class Stack { void push(object o #ifdef SYNC, Transaction txn #endif ) { if (o==null #ifdef SYNC txn==null #endif ) return; #ifdef SYNC Lock l=txn.lock(o); #endif elementdata[size++] = o; #ifdef SYNC l.unlock(); #endif firestackchanged(); 30

31 Weitere Nachteile Hohe Komplexität durch beliebige Schachtelung Fehleranfälligkeit durch Komplexität und unstrukturierten ( undisziplinierten ) Einsatz Beispiele: Variabler Rückgabetyp => Typanalyse? Edge/*if[WEIGHT]*/Weight/*end[WEIGHT]*/ add(node n, Node m /*if[weight]*/, int w/*end[weight]*/) { return new Edge/*if[WEIGHT]*/Weight/*end[WEIGHT]*/ (n, m /*if[weight]*/, w/*end[weight]*/ ); Derivate -Kommata bei Separierung variabler Parameter Edge set(/*if[weight]*/int w/*if[color]*/, /*end[color]/*end[weight]*/ /*if[color]*/int c/*end[color]*/) { 31

32 Weitere Nachteile Feature-Code ist komplett verstreut Feature-Traceability-Problem Beispiel Graph-SPL: Wie findet man einen Fehler in der Implementierung des Weight Features? Verhindert/erschwert Tool Support Negative Erfahrungen bereits bekannt von der Analyse von C/C++ (Refactoring, Typ-Analyse, ) MUNGE und andere: Definition in Kommentaren 32

33 Kritik an Präprozessoren Designed in the 70 th and hardly evolved since #ifdef considered harmful #ifdef hell maintenance becomes a hit or miss process incomprehensible source texts is difficult to determine if the code being viewed is actually compiled into the system programming errors are easy to make and difficult to detect CPP makes maintenance difficult preprocessor diagnostics are poor source code rapidly becomes a maze 33

34 Traceability-Problem class Graph { Vector nv = new Vector(); Vector ev = new Vector(); Edge add(node n, Node m) { Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); e.weight = new Weight(); return e; Edge add(node n, Node m, Weight w) Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); e.weight = w; return e; void print() { for(int i = 0; i < ev.size(); i++) { ((Edge)ev.get(i)).print(); class Node { int id = 0; Color color = new Color(); void print() { Color.setDisplayColor(color); System.out.print(id); class Edge { Node a, b; Color color = new Color(); Weight weight; = new Weight(); Edge(Node _a, Node _b) { a = _a; b = _b; void print() { Color.setDisplayColor(color); a.print(); b.print(); weight.print(); class Color { static void setdisplaycolor(color c) {... class Weight { void print() {... 34

35 Verstreute Feature-Implementationen Feature verschwinden in der Implementierung Was gehört direkt/indirekt zu einem Feature? Welche Features interagieren zur Laufzeit? Bei Wartungsaufgaben muss schlimmstenfalls der komplette Quelltext durchsucht werden Schwierige Arbeitsteilung Für unterschiedliche Features kann es unterschiedliche Experten geben; alle müssen an den gleichen Code-Fragmenten arbeiten Geringere Produktivität, schwierige Evolution Beim Hinzufügen neuer Features muss sich der Entwickler um viele andere Belange kümmern, die von der eigentlichen SPL-Evolution ablenken (Lesbarkeit, Erfassbarkeit) 35

36 Feature-Traceability Ziel: Zusammenhang zwischen Code und Features explizit machen Im Idealfall: pro Feature ein (virtuelles) Modul Andernfalls sind Umwege und Notlösungen unausweichlich, wenn Modularisierung nicht möglich Kommentare oder Annotationen im Quelltext (z. B. jeglicher Authentifizierungscode wird mit //auth markiert) Namenskonventionen (z. B. alle Authentifizierungsmethoden fangen mit auth_ an) Zusätzliche Werkzeuge, z. B. IDE-Unterstützung (Highlightning, Views, Filter, Abhängigkeitsgraphen etc.) 36

37 CIDE 37

38 Lehrstuhl Praktische Informatik VARIABILITÄTSMECHANISMEN 38

39 Ziele von Programmierparadigmen für SPL Entwurf neuartiger Implementierungskonzepte und Sprachkonstrukte für Variabilität auf Programmebene Lösungsansätze für Feature Traceability Querschneidende Belange (Crosscutting Concerns) Unflexible Vererbungshierarchien Feature-orientiert: Modulare Feature-Implementierung (zumindest Kohäsion) 39

40 Feature Traceability Problem Idee: Alle Feature-spezifischen (syntaktischen) Implementierungseinheiten einer Produktlinie an einer bestimmten Stelle im Quelltext lokalisieren Features als explizites Element im Programmcode (Feature- Module) Features als Abstraktionskonzept der Programmiersprache Lösung: Abhängig vom Programmierparadigma und der konkreten Programmiersprache bzw. der Programmierumgebung Virtuelle vs. physische Trennung Statische vs. dynamische Variabilität 40

41 Problem-Space Syntaktisches Feature Mapping Feature-Modell n:m Feature-Mapping (z.b. CPP) Solution Space Implementierungseinheiten (Klassen, Methoden, ) 41

42 Problem-Space Semantische Feature Traceability Feature-Modell 1:1 Mapping (oder zumindest 1:n) Solution Space Feature-orientierte Implementierungseinheiten 42

43 Lehrstuhl Praktische Informatik FEATURE-ORIENTIERTE PROGRAMMIERUNG 43

44 Feature-oriented Programming (FOP) Kompositionsbasierter Ansatz zur Lösung des Feature Traceability Problems Jedes Feature wird durch ein Feature-Modul implementiert Ermöglicht 1:n Feature Traceability Syntaktische Trennung und Modularisierung von Feature-Code Einfache Feature-Komposition auf Basis der objektorientierten Programmkomposition Features als explizites Design-Konzept im 44

45 Implementierung von Feature-Modulen Grundlage: Objektorientierte Dekomposition von Programmen durch Klassenstruktur Ansatz: Klassenartefakte Features zuordnen Problem: Features sind Querschnittsbelange Mehrere Klassen tragen zur Implementierung eines Features bei Eine Klasse trägt zur Implementierung mehrerer Features bei Tools: AHEAD (Algebraic Hierarchical Equations for Application Design) FeatureHouse 45

46 Features Beispiel: Aufteilen von Klassenartefakten auf Features Klassen Graph Edge Node Weight Color Search Directed Weighted Colored 46

47 Kollaborationen und Rollen Eine Menge von Klassen, die miteinander interagieren, um ein Feature zu implementieren, bilden eine Kollaboration Jede Klasse in einer Kollaboration übernimmt eine bestimmte Rolle innerhalb der Kollaboration Eine Klasse kann Teil mehrerer Kollaborationen sein und in diesen verschiedene Rollen einnehmen (Rollenpolymorphie) Eine Rolle kapselt das Verhalten/die Funktionalität einer Klasse, welche(s) für eine Kollaboration (ein Feature) relevant ist 47

48 Kollaborationen Beispiel: Kollaborationen und Rollen Klassen Graph Edge Node Weight Color Search Directed Weighted Colored Rollen 48

49 Beispiel: Graph SPL Die Kollaboration Weighted umfasst alle Rollen, die nötig sind, um gewichtete Kanten zu implementieren (Graph, Edge und Weight) Die Klasse Edge hat eine Rolle, die den relevanten Teil für gewichtete Kanten implementiert, z. B. das Feld weight, die Methoden getweight und setweight und die Erweiterung der Methode print. Die Klasse Edge hat eine weitere Rolle für gerichtete Kanten 49

50 FOP Implementierung in JAK Erweiterung von Java 1.4 mit neuen Schlüsselwörtern für Verfeinerungen refines für Klassenverfeinerungen Super für Methodenverfeinerungen Aus technischen Gründen müssen hinter Super die erwarteten Typen der Methode angegeben werden, z. B. Super(String, int).print('abc', 3) refines class Edge { private int weight; void print() { Super().print(); System.out.print(' weighted with' + weight); 50

51 Kollaborationen in FOP/JAK class Graph { Vector nv = new Vector(); Vector ev = new Vector(); Edge add(node n, Node m) { Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); return e; void print() { for(int i = 0; i < ev.size(); i++) ((Edge)ev.get(i)).print(); class Edge { Node a, b; Edge(Node _a, Node _b) { a = _a; b = _b; void print() { a.print(); b.print(); class Node { int id = 0; void print() { System.out.print(id); refines class Graph { Edge add(node n, Node m) { Edge e = Super(Node,Node).add(n, m); e.weight = new Weight(); Edge add(node n, Node m, Weight w) Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); e.weight = w; return e; refines class Edge { Weight weight = new Weight(); void print() { Super().print(); weight.print(); class Weight { void print() {... 51

52 Methodenverfeinerung (JAK) Methoden können in jeder Verfeinerung eingeführt oder erweitert werden Überschreiben von Methoden Aufruf der Methode aus vorheriger Verfeinerung mit Super Ähnlich zu Vererbung class Edge { void print() { System.out.print( " Edge between " + node1 + " and " + node2); refines class Edge { private Node start; void print() { Super().print(); System.out.print( " directed from " + start); refines class Edge { private int weight; void print() { Super().print(); System.out.print( " weighted with " + weight); 52

53 Produktlinien mit Feature-Modulen Feature-Modell 1:1 Mapping von Features zu Feature-Modulen Feature-Module Feature-Auswahl als Eingabe Feature-Auswahl Kompositions-Algorithmus Fertiges Program 53

54 Beispiel: Komposition Base Search Directed Graph Edge Node Weight Color Graph Edge Node Weighted Colored Feature-Auswahl in Textdatei (Feature-Namen in Zeilen) 54

55 Komposition mit AHEAD Eine Basisklasse + beliebige Verfeinerungen (Rollen) Klassenverfeinerungen können Felder einführen Methoden einführen Methoden verfeinern Feature-Modul (Kollaboration): Verzeichnis mit Basisklassen und/oder Verfeinerungen Beim Übersetzen werden Basisklasse + Verfeinerungen der ausgewählten Feature-Module zusammengebaut 55

56 FOP: Zusammenfassung Feature-orientierte Programmierung löst u.a. das Feature-Traceability-Problem durch Kollaborationen und Rollen (1:1 Mapping) Implementierung mittels Klassenverfeinerungen Prinzip der Uniformität Modell auf Basis von Feature Structure Trees Implementierung von querschneidenen Belangen kann in bestimmten Fällen sehr aufwendig sein Aspektorientierung 56

57 Lehrstuhl Praktische Informatik ASPEKT-ORIENTIERTE PROGRAMMIERUNG 57

58 Produktlinien mit Aspekten Feature-Modell 1:n Mapping von Features zu Aspekten Java-Programm + Aspekte Feature-Auswahl als Eingabe AspectJ-Compiler Feature-Auswahl Kompiliert mit ausgewählten Aspekten Fertiges Program 58

59 AOP: Grundidee Ein Programm hat zur Laufzeit eine Sicht auf sich selbst Objekte werden durch Klassen beschrieben, Klassen durch Metaklassen und Metaklassen durch Metametaklassen Quelltext eines Programmes wird durch Metaklassen-Instanz repräsentiert Das Programm kann sich selbst anpassen, indem seine eigenen Metaklassen-Instanzen anpasst 59

60 Meta Object Protocols (MOP) Programme können auf Meta-Ebene manipuliert werden, um ihre Struktur und ihr Verhalten zu ändern Verhaltensänderungen erfolgt Ereignis-basiert: wenn das Ereignis X eintritt (z. B. Methode Y wird aufgerufen), führe Code Z aus Bekannt aus LISP; in Standard-Java nur sehr eingeschränkt möglich (Reflection-API) 60

61 Aspect-Oriented Programming (AOP) Entwicklung aus Metaobjektprotokollen Ziel: Modularisierung von querschneidenden Belangen Erlaubt statische und dynamische Anpassungen Deklarativ mittels Quantifizierung Hinweis: Es gibt viele verschiedene AOP-Ansätze; auch Mixins usw. werden gelegentlich als AOP klassifiziert. Wir folgen dem Pointcut/Advice-Ansatz populärer AOP-Sprachen wie AspectJ 61

62 AOP: Grundidee Modularisierung von querschneidenen Belangen in einem Aspekt Ein Aspekt beschreibt die Änderungen dieses Belangs in der restlichen Software Interpretation als Programmtransformation, als Meta- Objekt-Protokoll oder als Feature-Modul möglich Klassen Aspekt Graph Edge Node Weighted Erweiterungen 62

63 AspectJ AspectJ ist eine AOP-Erweiterung für Java Aspekte werden ähnlich wie Klassen implementiert, aber es gibt ein Reihe neuer Sprachkonstrukte Der Basiscode wird weiterhin in Java implementiert Aspekte werden von einem speziellen Aspekt-Compiler in den Basiscode gewebt (weaving) 63

64 Was kann ein Aspekt? Ein Aspekt in Programmiersprachen wie AspectJ kann Klassenhierarchien manipulieren Methoden und Felder zu einer Klasse hinzufügen Methoden mit zusätzlichem Code erweitern Ereignisse wie Methodenaufrufe oder Feldzugriffe abfangen und zusätzlichen oder alternativen Code ausführen 64

65 Beispiel: Statischer Aspekt Statische Erweiterungen mit Inter-Typ-Deklarationen z. B. füge Methode X in Klasse Y ein aspect Weighted { private int Edge.weight = 0; public void Edge.setWeight(int w) { weight = w; 65

66 Beispiel: Dynamischer Aspekt Dynamische Erweiterungen auf Basis von Join-Points Ein Ereignis in der Programmausführung, wie ein Methodenaufruf, ein Feldzugriff o.a., wird als (dynamischer) Join-Point bezeichnet Ein Pointcut ist ein Prädikat um Join-Points (JPs) auszuwählen Advice ist Code, der ausgeführt wird, wenn ein JP von einem Pointcut ausgewählt wurde aspect Weighted {... pointcut printexecution(edge edge) : execution(void Edge.print()) && this(edge); after(edge edge) : printexecution(edge) { System.out.print(' weight ' + edge.weight); 66

67 Quantifikation Eine wichtige Eigenschaft von Pointcuts ist, dass sie deklarativ Join-Points quantifizieren und somit auf mehrere Join-Points matchen können Beispiele: Führe Advice X immer aus, wenn die Methode setweight in Klasse Edge aufgerufen wird Führe Advice Y immer aus, wenn auf irgendein Feld in der Klasse Edge zugegriffen wird Führe Advice Z immer aus, wenn irgendwo im System eine öffentliche Methode aufgerufen wird, und vorher die Methode initialize aufgerufen wurde 67

68 AspectJ Join Point Model Join Points treten auf bei(m) Aufruf einer Methode Ausführung einer Methode Aufruf eines Konstruktors Ausführung eines Konstruktors Zugriff auf ein Feld (lesend oder schreibend) Fangen einer Exception Initialisierung einer Klasse oder eines Objektes Ausführen von Advice 68

69 Beispiel: Join Points field access (set) field access (get) class Test { MathUtil u; public void main() { u = new MathUtil(); int i = 2; i = u.twice(i); System.out.println(i); class MathUtil { public int twice(int i) { return i * 2; method-execution constructor call method-call method-call method-execution 69

70 Advice Zusätzlicher Code vor (before), nach (after) oder anstelle (around) des Join-Points Beim around-advice ist es möglich, den originalen Join-Point mittels des Schlüsselworts proceed fortzusetzen 70

71 Aspekt: Beispiel Logging, Tracing, Profiling Fügt identischen Code zu sehr vielen Methoden hinzu aspect Profiler { /** record time to execute my public methods */ Object around() : execution(public * com.company..*.* (..)) { long start = System.currentTimeMillis(); try { return proceed(); finally { long end = System.currentTimeMillis(); printduration(start, end, thisjoinpoint.getsignature()); // implement recordtime... 71

72 Weaving Wie werden Aspekte ausgeführt? Meta-Objekt-Protokolle und interpretierte Sprachen: zur Laufzeit ausgewertet AspectJ/AspectC++/ : einweben des Aspektes durch den Compiler Einweben: Inter-Typ-Deklarationen werden in die entsprechenden Klassen eingefügt Advice wird in Methoden umgewandelt Pointcuts: Methodenaufruf von den Join-Points zum Advice hinzugefügen Dynamische Erweiterungen: an allen potentiellen Join-Points Quelltext einfügen, der dynamische Bedingung prüft und ggf. Methodenaufruf zum Advice ausführt 72

73 AJDT 73

74 Features als Aspekte Aspekte sind sehr ähnlich zu Kollaborationen Können Code statisch einfügen Können Methoden erweitern Können darüber hinaus sogar homogene Erweiterungen und Erweiterungen auf Basis des dynamischen Kontrollflusses durchführen Aspekte können ein und ausgeschaltet werden, indem man sie mit dem Programm kompiliert, oder nicht Manuell in Eclipse: Rechtsklick auf Aspekt und Exclude from Buildpath FeatureIDE in Kombination mit AJDT 74

75 Features als Aspekte Pro Feature ein Aspekt? Aspekte können sehr groß und unübersichtlich werden Aspekte können neue Klassen nur als statische innere Klassen einfügen Daher: Bündelung von mehreren Aspekten und Klassen in Feature-Modulen Mischung von Kollaborationen und Aspekten: Aspectual Feature Modules 75

76 Lehrstuhl Praktische Informatik ASPECTUAL FEATURE MODULES 76

77 AOP vs. FOP AOP und FOP implizieren keine konkreten Implementierungstechniken Unterscheiden sich in ihrer Philosophie AOP fokussiert auf querschneidende Belange FOP fokussiert auf Domänenabstraktionen Dennoch werden oft konkrete Implementierungstechniken mit beiden Ansätzen in Verbindung gebracht AOP Pointcuts & Advice, Inter-Typ-Deklarationen FOP Klassen, Refinements, Mixin/Jampack-Komposition 77

78 Feature Module in Jak Basic Graph class Graph { Vector nv = new Vector(); Vector ev = new Vector(); Edge add(node n, Node m) { Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); return e; void print() { for(int i = 0; i < ev.size(); i++) ((Edge)ev.get(i)).print(); class Edge { Node a, b; Edge(Node _a, Node _b) { a = _a; b = _b; void print() { a.print(); b.print(); class Node { int id = 0; void print() { System.out.print(id); 78

79 Feature Module in Jak Basic Graph class Graph { Vector nv = new Vector(); Vector ev = new Vector(); Edge add(node n, Node m) { Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); return e; void print() { for(int i = 0; i < ev.size(); i++) ((Edge)ev.get(i)).print(); class Edge { Node a, b; Edge(Node _a, Node _b) { a = _a; b = _b; void print() { a.print(); b.print(); class Node { int id = 0; void print() { System.out.print(id); Weight refines class Graph { Edge add(node n, Node m) { Edge e = Super(Node,Node).add(n, m); e.weight = new Weight(); Edge add(node n, Node m, Weight w) Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); e.weight = w; return e; refines class Edge { Weight weight = new Weight(); void print() { Super(),print(); weight.print(); class Weight { void print() {... 79

80 Aspects in AspectJ Basic Graph class Graph { Vector nv = new Vector(); Vector ev = new Vector(); Edge add(node n, Node m) { Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); return e; void print() { for(int i = 0; i < ev.size(); i++) ((Edge)ev.get(i)).print(); class Edge { Node a, b; Edge(Node _a, Node _b) { a = _a; b = _b; void print() { a.print(); b.print(); class Node { int id = 0; void print() { System.out.print(id); 80

81 Aspects in AspectJ Basic Graph class Graph { Vector nv = new Vector(); Vector ev = new Vector(); Edge add(node n, Node m) { Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); return e; void print() { for(int i = 0; i < ev.size(); i++) ((Edge)ev.get(i)).print(); class Edge { Node a, b; Edge(Node _a, Node _b) { a = _a; b = _b; void print() { a.print(); b.print(); class Node { int id = 0; void print() { System.out.print(id); Color aspect ColorAspect { static class Colored { Color color; declare parents: (Node Edge) extends Colored; before(colored c) : execution(void print()) && this(c) { Color.setDisplayColor(c.color); static class Color {... 81

82 Heterogene vs. Homogene Extensions Heterogen: unterschiedlicher Code an unterschiedlichen Stellen Homogen: gleicher Code an unterschiedlichen Stellen class Graph { Edge add(node n, Node m) { Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); e.weight = new Weight(); return e; Edge add(node n, Node m, Weight w) Edge e = new Edge(n, m); nv.add(n); nv.add(m); ev.add(e); e.weight = w; return e; class Edge { Weight weight = new Weight(); Edge(Node _a, Node _b) { a = _a; b = _b; void print() { a.print(); b.print(); weight.print(); class Node { int id = 0; Color color = new Color(); void print() { Color.setDisplayColor(color); System.out.print(id); class Edge { Node a, b; Color color = new Color(); Edge(Node _a, Node _b) { a = _a; b = _b; void print() { Color.setDisplayColor(color); a.print(); b.print(); 82

83 Static vs. Dynamic Extensions Statisch: verändern die statische Struktur (syntaktische Struktur) Dynamisch: ändern das Verhalten (Ereignis und Aktion) class Node { int id = 0; Color color = new Color(); void print() { System.out.print(id); class Node { int id = 0; void print() { Color.setDisplayColor(color); System.out.print(id); 83

84 Beispiel: Dynamic Extension class Edge { int weight = 0; void setweight(int w) { weight = w; int getweight() { return weight; refines class Edge { void setweight(int w) { Super(int).setWeight(2*w); Jak int getweight() { return Super().getWeight()/2; AspectJ aspect DoubleWeight { void around(int w) : args(w) && execution(void Edge.setWeight(int)) { proceed(w*2); int around() : execution(void Edge.getWeight()) { return proceed()/2; 84

85 Vergleich FOP vs. AOP statisch FOP gute Unterstützung Attribute, Methoden, Klassen AOP eingeschränkte Unterstützung Attribute, Methoden dynamisch schlechte Unterstützung einfach dynamisch (Erweiterung von Methoden) gute Unterstützung erweitert dynamisch heterogen gute Unterstützung Verfeinerungen und Kollaborationen eingeschränkte Unterstützung keine expliziten Kollaborationen homogen Keine Unterstützung Eine Verfeinerung pro Join-Point (Code- Replikation) gute Unterstützung Wildcards und logische Verknüpfung von Pointcuts 85

86 Symbiose von FOP und AOP OOP FOP + AOP AOP FOP 86

87 Aspectual Feature Modules Integration von Aspekten, Klassen und Verfeinerungen Verfeinerung auf Basis von Rollen und Kollaborationen Basic Graph Graph Edge Node Weight Weight Graph Edge Color ColorAspect Color Aspektweben 87

88 Referenzen Richard M. Stallman: The C Preprocessor. Last Revised July 1992 for GCC v.2. Tom Ball: Munge: Swing's Secret Preprocessor. Jörg Pleumann, Omry Yadan, Erik Wetterberg: Antenna An Ant-To-End Solution for Wireless Java. Version C. Kästner: CIDE: Decomposing Legacy Applications into Features. Proceedings of the 11st International Software Product Line Conference, pp , Don Batory: Feature-Oriented Programming and the AHEAD Tool Suite. In Proceedings of the 26th International Conference on Software Engineering (ICSE '04), Christian Prehofer: Feature-Oriented Programming: A fresh Look at Objects. In ECOOP'97 Object-Oriented Programming, Lecture Notes in Computer Science Volume 1241, 1997, pp Gregor Kiczales, John Lamping, Anurag Mendhekar, Chris Maeda, Cristina Lopes, Jean-Marc Loingtier, John Irwin: Aspect-oriented programming. In ECOOP'97 Object-Oriented Programming Lecture Notes in Computer Science Volume 1241, 1997, pp