Softwareproduktlinien - Versionsverwaltungs- und Buildsysteme

Transkript

1 Softwareproduktlinien - Versionsverwaltungs- und Buildsysteme Christian Kästner (Carnegie Mellon University) Sven Apel (Universität Passau) Gunter Saake, Martin Kuhlemann (Universität Magdeburg) 1

2 Application Eng. Domain Eng. Wie Variabilität implementieren? Feature-Modell Wiederverwendbare Implementierungsartefakte 2 Feature-Auswahl Generator Fertiges Program

3 Wiederholung: Variabilität zur Laufzeit Parameter Globale Konfiguration vs. propagierte Parameter Design Patterns Observer (Observer und Subject) Template Method (Vererbung) Strategy Pattern (Context + Interface für alternative Algorithmen) Decorator Pattern (Delegation + Interface) 3

4 Variabilität zur Übersetzungszeit Ziel: Nur benötigter Quelltext wird mit übersetzt Kleine, optimierte Varianten Quelltext wird passend ausgewählt und zusammengebaut Wie Optionen oder Alternativen implementieren? Hier einfache Mittel für wenig Varianten 4

5 5 Versionsverwaltungssysteme

6 Versionsverwaltung Teil des Konfigurationsmanagments Versionierung von Quelltextdateien Gemeinsame Entwicklung Archiv alter Quelltextversionen Zeitstempel und Benutzerkennung Änderungen als Delta Prozess: Checkout Change Commit Update Change Commit - Beispielsysteme: CVS, SVN, Visual SourceSafe, Perforce, SCCS, Git, Mercurial 6

7 Branching & Merging 7

8 Release-Planung 8

9 Varianten Graph-Bibliothek Variante 3 ohne Gewichte und ohne Farben Schnellere Suche Variante 2 ohne Gewichte Basis-Variante (mit Farben und Gewichten) 9 NullPointer- Exception abgefangen

10 Code und Nicht-Code Dateien Java Code Dokumentation Modelle Build-Scripte: Ant/Makefile Lizenzen Grammatiken Kompilierte Dateien HTML, JavaScript, CSS Bei Binärdateien ist Konfliktbehandlung und Mischen schwieriger 10

11 Varianten vs. Revisionen 11 [Staples&Hill, APSEC 04]

12 Varianten vs. Revisionen Revisionen V1.0 V1.1 V2.0 V3.0 Varianten Sensor-DB (Auto) Sensor-DB (Habitat Monitoring) Sensor-DB (Erdbeben) SmartCard-DB GPS-DB X X X X X X X X X X X X X X 12

13 Application Eng. Domain Eng. Produktlinien mit Versionsverwaltung Entwicklung von Varianten in Branches Mergen von Änderungen zwischen Branches Mapping von Variante zu Branch Varianten-Liste Sensor-DB (Auto) Sensor-DB (Habitat Monitoring) Sensor-DB (Erdbeben) SmartCard-DB GPS-DB Versionsverwaltung mit Branches Sensor-DB (Auto) Sensor-DB (Habitat Monitoring) Sensor-DB (Erdbeben) SmartCard-DB GPS-DB Variante als Eingabe 13 Varianten-Auswahl Checkout des passenden Branches Fertiges Program

14 Produktlinien mit Versionsverwaltung Diskussion Vorteile Etablierte, stabile Systeme Bekannter Prozess Gute Werkzeugintegration Nachteile Vermischen von Revisionen und Varianten Entwicklung von Varianten, nicht Features: flexible Kombination von Features nicht direkt möglich Keine strukturierte Wiederverwendung (Copy & Edit) Hoher Aufwand für Wartung (Merging) 14

15 15 Build-Systeme

16 Build-Systeme Automatisierung des Build-Prozesses Kopiert Dateien, ruft Compiler auf, startet weitere Tools Mehrere Schritte mit Abhängigkeiten/Bedingungen Werkzeuge: make, ant, maven, 16

17 Produktlinien mit Build-Systemen Pro Variante eine Konfigurationsdatei/ein Build-Skript Dateien beim Übersetzen einbeziehen/ausschließen Dateien mit produktspezifischen Varianten überschreiben 17

18 Beispiel: Graph-Bibliothek Basis- Implementierung build.xml src Graph.java class Edge { Node a, b; Edge(Node _a, Node _b) { a = _a; b = _b; } void print() { a.print(); b.print(); } } Edge.java Variante mit Gewichten 18 build.xml src Edge.java class Edge { Node a, b; Weight weight; Edge(Node _a, Node _b) { a = _a; b = _b; } void print() { a.print(); b.print(); weight.print(); } }

19 Alternatives Beispiel: Graph-Bibliothek Basis- Implementierung build.xml src Graph.java class Edge { Node a, b; Edge(Node _a, Node _b) { a = _a; b = _b; } void print() { a.print(); b.print(); } } Edge.java Variante mit Gewichten 19 build.xml src WEdge.java class WEdge extends Edge { Weight weight; void print() { super.print(); weight.print(); } } und alle new-aufrufe anpassen; ggf. Factory Pattern verwenden

20 Application Eng. Domain Eng. Produktlinien mit Build-Systemen Feature-Modell Basis-Implementierung Sensor-DB (Auto) Sensor-DB (Habitat Monitoring) Sensor-DB (Erdbeben) SmartCard-DB GPS-DB Build-Skript pro Variante + spezifische Dateien Standard Build (make, ant, ) Fertiges Program 20

21 Produktlinien mit Build-Systemen Bewertung Relativ einfacher Mechanismus Hohe Flexibilität beliebige Änderungen für Varianten Wenig Vorplanung nötig Entwicklung für jede Variante getrennt, ggf. hoher Aufwand im Application Engineering Änderungen nur auf Dateiebene (überschreiben ganzer Dateien) Änderungen an der Basisimplementierung schwierig 21

22 Ausblick Weitere Methoden zur Implementierung von Variabilität zur Übersetzungszeit Aber: Features statt Varianten entwickeln 22

23 Literatur S. Apel, D. Batory, C. Kästner, and G. Saake. Feature- Oriented Software Product Lines - Concepts and Implementation. Springer, Section 5.1/5.2: Version Control Systems, Build Systems M. Staples, D. Hill. Experiences adopting software product line development without a product line architecture. Proceedings APSEC, pp , 2004 [Industrielle Erfahrung zu Versionsverwaltung und Build-Systemen für die Produktlinienentwicklung] T. Dhaliwal, F. Khomh, Y. Zou, A. Hassan. Recovering commit dependencies for selective code integration in software product lines. Proceedings ICSM, , 2012 [Zuordnung von Commits zu Features; Abhängigkeitsanalyse] 23

24 Quiz Sollte man Branches zur Entwicklung von ganzen Produktvarianten benutzen oder zur Entwicklung individueller Features? Nenne Vor- und Nachteile. Wie spielen Versionsverwaltung, Build-System und Laufzeitparameter zusammen? Welche Rolle spielen die Granularität von Änderungen in Versionsverwaltungsund Build-Systemen? 24