Wiederverwendung von Software

Transkript

1 Lehrstuhl Praktische Informatik Wiederverwendung von Software Dennis Reuling

2 Lehrstuhl Praktische Informatik WIEDERVERWENDUNG Wiederverwendung von Software 2

3 Grundidee Produkte möglichst weitgehend aus vorhandenen / vorgefertigten Standard- Komponenten konstruieren Vorteile: Kostensenkung, weniger Neuentwicklung Erhöhung der Qualität Keine neue Idee, passiert tausendfach: Benutzung von Bibliotheken Muster,... Wiederverwendung von Software 3

4 WV vs Regeln/Erfahrung Nach Größe der Artefakte sortiert: 1. Programmstrukturen, Konzepte der Programmiersprache 2. Entwurfsmuster, Analysemuster 3. Architekturmuster 4. Standardarchitekturen Sind Gestaltungsregeln, d.h. keine Komponenten, die man i.w. unverändert einbaut überlappt thematisch mit Wiederverwendung Wiederverwendung von Software 4

5 WV vs Arbeitsteilung (1) Fremdherstellung von Komponenten ist in klassischen Industrien üblich: ggf. eigenes, umfangreiches Know-How (Domänenwissen) erforderlich, das nicht zu den Kernkompetenzen des Anbieters gehört Ausnutzung von Skaleneffekten bei kleinen Produktionsmengen Wiederverwendung von Software 5

6 WV vs Arbeitsteilung (2) Allgemeines Prinzip der industriellen Arbeitsteilung: spezialisierte Marktteilnehmer geringe Fertigungstiefe Konzentration auf Kernkompetenzen Wichtig: nicht zu viele Modelle, Normen Keine offene Spezifikationen Wiederverwendung von Software 6

7 WV vs Arbeitsteilung (3) Besonderheiten in der Informatik: Größe der Produktionsmengen irrelevant für SW- Produkte Versteckte technologische Arbeitsteilung durch Benutzung von: Netzwerkprotokollen mathematische Bibliotheken Technologische Arbeitsteilung in der Informatik selbstverständlich Ist auch ohne Wiederverwendung sinnvoll (zugekaufte Komponenten werden nur 1* verwendet) Wiederverwendung von Software 7

8 Definition Wiederverwendung: Fälle, wo mehrere einander ähnliche Systeme in der gleichen Technologie entwickelt werden: ggf. in verschiedenen Zeiträumen insb. bei Systemen, die nicht Varianten voneinander sind, sondern unabhängig voneinander entwickelt werden sofern gleichzeitig: Entwicklung einer Systemfamilie Besonderheit: gemeinsame, wiederverwendbare Komponenten können gezielt bestimmt werden Wiederverwendung von Software 8

9 Typen Im Prinzip gibt es beliebige wiederverwendbare Typen: Anforderungen, Testfälle Quelltexte von Programmen Modul-/API-Spezifikationen Architekturen bzw. Architekturfragmente Datenbankschemata Gestaltungselemente von GUIs Dokumentation: Bedien-, Installationshandbücher, Glossare Gegebenfalls auch (zusammenhängende) Gruppen dieser Typen, z.b. GUI besteht aus Code, Manual, Schwerpunkt in der Praxis: Quelltexte, Architekturen, Modelle Wiederverwendung von Software 9

10 Arten der Wiederverwendung Ungeplant (Reaktiv/Extraktiv): Komponente wird nach ihrer Entwicklung für Wiederverwendung entdeckt Muss i.d.r. abgeändert / verbessert / nachdokumentiert werden Geplant (Proaktiv) : Komponente von vornherein zwecks Wiederverwendung entwickelt und gestaltet a) Bibliotheksfunktionen b) Teile eines konkreten Systems, die vermutlich später noch einmal verwendet werden können Wiederverwendung von Software 10

11 Lehrstuhl Praktische Informatik SOFTWARE-PRODUKTLINIEN Wiederverwendung von Software 11

12 Produktlinien als Methode A software product line is an explicit specification of commonality and variability between [product] variants in a family of similar [software] products by means of features. (Pohl et al., 2005) Wiederverwendung von Software 12

13 Development Effort Aufwand/Kosten Konventionelle Entwicklung Produktlinienentwicklung # Produkte Wiederverwendung von Software 13

14 SPLE Ziel: Entwicklung einer Produktfamilie als Produktlinie statt als einzelne Produkte Produktlinie deckt Anforderungen (Features) der ganzen Domäne ab Abweichung vom klassischen Entwicklungsprozess und Lebenszyklus, Unterscheidung in Domain Engineering Application Engineering Wiederverwendung von Software 14

15 Application Eng. Domain Eng. Übersicht Feature-Modell Wiederverwendbare Implementierungsartefakte Feature-Auswahl Generator Fertiges Program Wiederverwendung von Software 15

16 Domain Engineering [...] is the activity of collecting, organizing, and storing past experience in building systems [...] in a particular domain in the form of reusable assets [...], as well as providing an adequate means for reusing these assets (i.e., retrieval, qualification, dissemination, adaptation, assembly, and so on) when building new systems. (K. Czarnecki and U. Eisenecker) Wiederverwendung von Software 16

17 Application Engineering [ ] has the goal of developing a specific product for the needs of a particular customer.it corresponds to the process of single application development in traditional software engineering, but reuses artifacts from domain engineering where possible. [ ] is repeated for every product of the product line that is to be derived. (Apel et al.) Wiederverwendung von Software 17

18 Feature-Oriented SPLE (FOSD) Idee: Feature als ganzheitliches Abstraktionskonzept Feature als Domänen-Abstraktion im Problemraum der Anwendungsdomäne => Spezifikation von Produktkonfigurationen (Feature-Auswahl als Eingabe für die Produktkonfiguration) Feature als Implementierungskonzept im Lösungsraum der Produktlinie => Spezifikation von Produktvarianten (Feature-Auswahl als Eingabe für die Programmgenerierung) Wiederverwendung von Software 18

19 Lehrstuhl Praktische Informatik FEATURE-MODELLE Wiederverwendung von Software 19

20 Application Eng. Domain Eng. Einordnung Feature-Modell Wiederverwendbare Implementierungsartefakte Feature-Auswahl Generator Fertiges Program Wiederverwendung von Software 20

21 Übersicht (1) Feature-Modelle spezifizieren den Konfigurationsraum einer Produktlinie: Menge der konfigurierbaren Produktparameter: relevante Domain Features im Problemraum der Produktlinie Einschränkung der Kombinierbarkeit von Features in validen Produktkonfigurationen durch Abhängigkeiten zwischen Features Wiederverwendung von Software 21

22 Übersicht (2) Darstellungsformen Explizite Auflistung aller validen Konfigurationen: Konfigurationstabellen Graphisch: Entscheidungsbäume, FODA Feature-Diagramme, Orthogonal Variability Model (OVM), Mathematisch: Aussagenlogische Terme (SAT), Constraint Satisfiability Problems (CSP), Binary Decision Diagrams (BDD), Wiederverwendung von Software 22

23 FODA Feasibility Study [Kang et al., 1990] Wiederverwendung von Software 23

24 Feature-Diagramm Gruppe Feature (Cross-Tree)Constraint Wiederverwendung von Software 24

25 Feature-Hierarchie Die Feature-Hierarchie bildet einen Wurzelbaum auf der Menge der Features Das Wurzel-Feature ist per Konvention obligatorisch (engl.mandatory) und bezeichnet den Namen der Produktlinie (Konzept-Feature) Jedes einzelne Kind-Feature ist entweder obligatorisch oder optional => Abhängigkeiten zwischen Nachbar-Features durch Feature- Gruppen Wiederverwendung von Software 25

26 Feature-Gruppen Unter einem Eltern-Feature können mehrere Gruppen und Einzel-Features hängen Zwei Arten von Gruppen: Alternativ (XOR) und Oder (OR) Einzel-Features und Feature-Gruppen dürfen sich nicht überlappen Häufig auch: Mandatory-Gruppen und Optional-Gruppen Abhängigkeiten zwischen hierarchisch unkorrelierten Features durch Cross-Tree-Constraints Wiederverwendung von Software 26

27 Cross-Tree Constraints Cross-Tree Kanten können beliebig quer zur Feature-Hierarchie verlaufen Verallgemeinerung auf beliebige Cross-Tree Constraints in Form von aussagenlogischen Termen über Features Wiederverwendung von Software 27

28 Feature-Modell Editor: FeatureIDE [Leich et al., 2005] Erstellung von Feature-Diagrammen in FODA-ähnlicher Notation Semantische Analysen: Anzahl Produktkonfiguration, Anomalien, Mapping in den Lösungsraum (CPP, FOP, AOP, ) Wiederverwendung von Software 28

29 Lehrstuhl Praktische Informatik PRÄPROZESSOREN Wiederverwendung von Software 29

30 Application Eng. Domain Eng. Einordnung Feature-Modell Wiederverwendbare Implementierungsartefakte Feature-Auswahl Generator Fertiges Program Wiederverwendung von Software 30

31 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 Wiederverwendung von Software 31

32 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 Wiederverwendung von Software 32

33 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() {... Wiederverwendung von Software 33

34 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 Wiederverwendung von Software 34

35 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. Wiederverwendung von Software 35

36 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 Wiederverwendung von Software 36

37 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 Wiederverwendung von Software 37

38 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 Wiederverwendung von Software 38

39 #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 Wiederverwendung von Software 39

40 #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 Wiederverwendung von Software 40

41 #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) Wiederverwendung von Software 41

42 #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 Wiederverwendung von Software 42

43 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 Wiederverwendung von Software 43

44 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 Wiederverwendung von Software 44

45 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 Wiederverwendung von Software 45

46 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 1020 Wiederverwendung von Software 46

47 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; Wiederverwendung von Software 47

48 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 Wiederverwendung von Software 48

49 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 Wiederverwendung von Software 49

50 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() {... Wiederverwendung von Software 50

51 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); Wiederverwendung von Software 51

52 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 Wiederverwendung von Software 52

53 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 Wiederverwendung von Software 53

54 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 Wiederverwendung von Software 54

55 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(); Wiederverwendung von Software 55

56 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]*/) { Wiederverwendung von Software 56

57 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 Wiederverwendung von Software 57

58 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 preprocessor diagnostics are poor CPP makes maintenance difficult source code rapidly becomes a maze Wiederverwendung von Software 58

59 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) ST2 Unflexible Vererbungshierarchien Feature-orientiert: Modulare Feature-Implementierung (zumindest Kohäsion) Wiederverwendung von Software 59

60 Lehrstuhl Praktische Informatik HAUSAUFGABE Wiederverwendung von Software 60

61 Aufgabenestellung Implementierung des PONG Projekts als (reaktive) Produktlinie Domänenentwicklung Feature-Modell: FODA / FeatureIDE Präprozessor-Implementierung: Java + MUNGE Applikationsentwicklung Konfiguration(en): FeatureIDE Produktgeneration: FeatureIDE Wiederverwendung von Software 61

62 Übersicht Pong Einzelprodukt Pong SPL Wiederverwendung von Software 62

63 Arbeitsschritte Abbildung von gegebenem Feature-Modell in Feature IDE Erweiterungen in der Implementierung (auf Basis der Features im Modell) Sinnvolle Abbildung von Features zu Implementierungsartefakten Änderungen der (Aufrufer/Klassen)Struktur, falls notwendig Generierung aller Varianten Testweise Ausführung jeder Variante Wiederverwendung von Software 63

64 Literatur Apel et al.: Feature-Oriented Software Product Lines, Hauptliteratur zu SPLE Exemplar in der UB verfügbar ISBN Wiederverwendung von Software 64

65 Literatur Pohl et al.: Software Product Line Engineering, Frei im Uni-Netz verfügbar (Springer Link) ISBN Wiederverwendung von Software 65

66 Literatur P. Clements, L. M. Northup: Software Product Lines: Practices and Patterns, Weiterführende Literatur ISBN: Wiederverwendung von Software 66

67 Referenzen Kyo C. Kang, Sholom G. Cohen, James A. Hess, William E. Novak, and A. Spencer Peterson. Feature-Oriented Domain Analysis (FODA) Feasibility Study. Technical report, Carnegie-Mellon University Software Engineering Institute, November Thomas Leich, Sven Apel, Laura Marnitz, and Gunter Saake. Tool Support for Feature-oriented Software Development: FeatureIDE: an Eclipse-based Approach. In Proceedings of the OOPSLA workshop on Eclipse technology exchange, eclipse 05, pages 55 59, New York, NY, USA, ACM. David Benavides, Sergio Segura, and Antonio Ruiz-Cortés. Automated Analysis of Feature Models 20 Years Later: A Literature Review. Advanced Information Systems Engineering, 35: , September Pierre-Yves Schobbens, Patrick Heymans, and Jean-Christophe Trigaux. Feature Diagrams: A Survey and a Formal Semantics. In Requirements Engineering, 14th IEEE International Conference, pages , sept Don Batory. Feature Models, Grammars, and Propositional Formulas. In SPLC, pages Springer, Arnaud Hubaux: Feature-based Configuration: Collaborative, Dependable, and Controlled. PhD thesis, University of Namur, Belgium, 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 Wiederverwendung von Software 67