Technical White Paper Variantenmanagement mit pure::variants - pure-systems GmbH
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
Technical White Paper
Variantenmanagement mit pure::variants
pure-systems GmbH
Copyright © 2003 - 2006 pure-systems GmbH
Agnetenstr. 14
39106 Magdeburg
http://www.pure-systems.comInhaltsverzeichnis
1 Einleitung....................................................................................................................................................3
2 pure::variants Technologie.....................................................................................................................3
3 pure::variants-unterstütztes Entwickeln mit Varianten.....................................................................4
4 Variantenbildung mit pure::variants......................................................................................................7
4.1 pure::variants Merkmalmodelle.....................................................................................................8
4.2 pure::variants Familienmodell......................................................................................................10
4.3 Module.............................................................................................................................................11
5 Produkte...................................................................................................................................................12
5.1 Developer Edition...........................................................................................................................12
5.2 Integration Edition..........................................................................................................................12
5.3 Server Edition..................................................................................................................................12
5.4 Erweiterungsmodule......................................................................................................................13
6 Zusammenfassung.................................................................................................................................13
2Einleitung
1 Einleitung
Die pure::variants Technologie bietet die umfassendste und flexibelste verfügbare Techno-
logie zum Variantenmanagement. Eigenschaften wie die durchgängige Werkzeugunter-
stützung aller Schritte in der Softwareentwicklung, die hervorragende Integrationsfähigkeit
und Anpassungsfähigkeit erlauben es, in nahezu allen Bereichen der Softwareentwicklung
von den Vorzügen der Produktlinienbasierten Softwareentwicklung zu profitieren. Insbeson-
dere die auf die besonderen Interessen der Softwareentwicklung für eingebettete Systeme
abgestimmten Module erlauben eine bisher noch nicht mögliche Kombination von Flexibilität
mit einem Höchstmaß an Ressourceneffizienz.
2 pure::variants Technologie
Die Basistechnologie pure::variants verfügt über alle Eigenschaften, die für eine erfolgreiche,
werkzeuggestützte Entwicklung und Realisierung von Produktlinien erforderlich sind.
Sie ist durchgängig während aller Phasen der Entwicklung, angefangen bei der Anforderungs-
analyse und dem Softwaredesign, über die Implementierung bis hin zur Erstellung, Testen,
Nutzung und Wartung einsetzbar.
Alle grundlegenden Mechanismen sind unabhängig von Programmiersprachen.
Abbildung 1: pure::variants Integrationsmöglichkeiten
Die pure::variants Technologie verfügt über herausragende Integrationsfähigkeiten. Sie kann
leicht in bestehende Entwicklungsprozesse und -umgebungen eingebunden werden
(Abbildung 1). Durch die Kopplung mit unterschiedlichen, bereits beim Anwender vorhandenen
Werkzeugen zum Configuration Management, Requirements Engineering, Modellierung und
Testen ergibt sich eine einheitliche Lösung. Die Anbindung an beliebige Werkzeuge ist durch
das XML-basierte Austauschformat jederzeit möglich. Durch den Import bestehender
Softwareprojekte ist der Einstiegsaufwand gering. Für spezifische Anforderungen ist
pure::variants durch Integration zusätzlicher Module flexibel erweiterbar. Dabei haben alle
Module vollständigen Zugriff auf das Variantenwissen.
3pure::variants Technologie
Das flexible Grundgerüst erlaubt die Verwaltung und Auswertung aller für eine Produktlinie
relevanter Informationen, wie z.B. Dokumentation, Quelltext, Abhängigkeiten, und
Testergebnisse. Dem Benutzer können unterschiedliche Sichten auf diese Informationen
präsentiert werden. Dies ermöglicht eine Anpassung der Visualisierung entsprechend der
organisatorischen Struktur (Entwickler, Projektleiter, Vertrieb, Kunde).
Gerade die Durchgängigkeit, die hohe Integrationsfähigkeit und die flexible Erweiterbarkeit
der pure::variants Technologie ist als einzigartig anzusehen.
3 pure::variants-unterstütztes Entwickeln mit Varianten
Die Nutzung der auf pure::variants basierenden Werkzeuge (zu Produkten siehe Kapitel 5)
erfolgt in verschiedenen Phasen des Softwareentwicklungsprozesses. Bei der Entwicklung
von Produktlinien teilt sich die Entwicklung in 2 Abschnitte, zum einen die Entwicklung der
gemeinsamen Anteile und zum anderen in der nachfolgenden Ableitung der einzelnen
Produkte aus der Produktlinie.
Der prinzipielle Ablauf einer solchen Entwicklung wird im folgenden dargestellt, beginnend mit
der Erstellung der gemeinsamen Anteile:
1. Analyse der Anforderungen:
Basierend auf einer inhaltlichen Analyse der umzusetzenden Anforderungen werden
Merkmalmodelle (engl. feature models, siehe auch Abschnitt 4.1) entworfen, in denen
insbesondere die Abhängigkeiten der einzelnen Merkmale der Produktlinie untereinander
erfasst werden. Merkmalmodelle lassen sich gut grafisch darstellen und sind leicht
verständlich.
Basierend auf den Erkenntnissen aus der praktischen Anwendung von Merkmalmodellen
ist die Ausdrucksmöglichkeit bei pure::variants Merkmalmodellen erheblich erweitert
worden. Insbesondere die Unterstützung von Modellhierarchien ermöglicht die
unterschiedliche Repräsentation der Probleme abhängig vom Betrachter (Kunde,
Entwickler, Vertrieb, ...)
2. Entwurf der Lösungen:
Ausgehend vom Merkmalmodell und anderen Anforderungen für die einzelnen
abzuleitenden Softwaresysteme wird das Design der Softwarelösung(en) durchgeführt.
Dabei werden die Elemente der Softwarelösung mit ihren Beziehungen, Einschränkungen
und Anforderungen im Familienmodell erfasst und stehen damit einer automatischen
Verarbeitung zur Verfügung.
Das Familienmodell gliedert sich in mehrere Ebenen. Die oberste Ebene wird durch die
sogenannten Komponenten gebildet. Diese repräsentieren jeweils ein oder mehrere
funktionale Merkmale der Lösungen. Jede Komponenten setzt sich aus den logischen
Bestandteilen der Software zusammen (Klassen, Objekte, Funktionen, Variablen, Dokumen-
tation). Die physischen Bestandteile einer Lösung werden dann in einer weiteren Ebene
den logischen zugeordnet. Dies sind sowohl bereits existierende Dateien als auch jeweils
4pure::variants-unterstütztes Entwickeln mit Varianten
basierend auf Variantenwissen neu zu erzeugende Dateien oder durchzuführende
Aktionen.
Im Gegensatz zu den bisherigen Ideen im Bereich Merkmalmodell basierter Techniken setzt
die pure::variants Technologie auf eine separate und unabhängige Erfassung und
Handhabung der umzusetzenden Anforderungen (Merkmalmodell) und deren Lösungen
(Familienmodell). Dies ermöglicht eine vereinfachte Wiederverwendung sowohl der Lösung
als auch der Merkmalmodelle in neuen Projekten.
3. Realisierung der Lösungen:
Unter Einsatz der durch die gewählten Programmiersprachen und -werkzeuge verfügbaren
Programmiermöglichkeiten, und der durch pure::variants zur Verfügung gestellten
zusätzlichen Möglichkeiten zur Variantenbildung, werden die Lösungen erstellt.
Abbildung 2: Ablauf der Erstellung einer Problemlösung mit pure::variants
Während des oben beschriebenen Entwicklungsprozesses dient die pure::variants
Technologie zur Erfassung und Verwaltung aller Modelle und Informationen. Das Resultat ist
eine auf Basis des Merkmalmodells flexibel anpassbare Softwarefamilie bzw. Produktlinie.
Darauf aufbauend ermöglicht pure::variants die automatische Erstellung maßgeschneiderter
5pure::variants-unterstütztes Entwickeln mit Varianten
Lösungen eines konkreten Problems. Einen Überblick über diesen Erstellungsprozess gibt
Abbildung 2. Die innovativen Aspekte dieses Prozesses sind hinterlegt.
Der prinzipielle Ablauf ist:
1. Ermittlung einer gültigen Kombination von Merkmalen:
Der Anwender (Kunde, Vertrieb) wählt aus dem Merkmalmodell die für ihn relevanten
Merkmale des zu lösenden Problems aus. Die Überprüfung der gewählten Merkmals-
kombination auf Gültigkeit (d.h. die Untersuchung aller Abhängigkeitsregeln) sowie
gegebenenfalls die automatische Auflösung von Abhängigkeitskonflikten erfolgt durch
pure::variants unter Einsatz von Methoden und Werkzeugen der künstlichen Intelligenz.
Dadurch kann sichergestellt werden, dass auch komplexe Abhängigkeitsszenarien korrekt
und effizient umgesetzt werden. Das Ergebnis ist eine Kombination von Merkmalen, die das
zu lösende Problem in einer von den Entwicklern der Modelle vorgesehenen Weise
beschreibt.
2. Auswahl einer passenden Lösung:
Auf der Basis der gewählten Merkmale wird nun das Familienmodell genutzt, um eine
passende Lösung zu finden. Anhand der im Familienmodell gespeicherten Informationen
wird die ermittelte Merkmalskombination durch jede Komponente und ihre logischen und
physischen Bestandteile analysiert. Dies geschieht ebenfalls mit Methoden der künstlichen
Intelligenz. Für jeden Bestandteil wird entschieden, ob und in welcher Form er zu der
Lösung gehört. Eventuell dabei auftretende Probleme durch weitergehende Abhängigkeiten
werden ebenfalls, soweit möglich, automatisch aufgelöst oder dem Anwender zur Lösung
übergeben.
Das Ergebnis ist eine Beschreibung der ausgewählten Lösung in Form einer Lösungsbe-
schreibung.
3. Erzeugen der Lösung:
Gesteuert durch die Komponentenbeschreibung wird ein Transformationsprozess durchge-
führt, dessen Ergebnis die fertige Softwarelösung in der vom Anwender gewünschten Form
ist. Im Verlauf dieses Prozesses werden die jeweils notwendigen Transformationsmodule
aktiviert und führen die in der Lösungsbeschreibung spezifizierte Umsetzung durch.
Nicht nur die Neuerstellung von Produktlinien, sondern insbesondere auch die Einbindung
existierender Software (Reengineering) in die Produktlinienbasierte Entwicklung ist mit
pure::variants einfach möglich. Dazu beginnt der Prozess statt mit der Entwicklung der
gemeinsamen Teile mit der (teil-) automatischen Erstellung des Familienmodells auf der Basis
der bereits erstellten Software und mit dem schrittweisen Aufbau des zugehörigen Merkmal-
modells durch die Nutzer. Der weitere Ablauf ist dann analog zu der oben skizzierten
Vorgehensweise.
6Variantenbildung mit pure::variants
4 Variantenbildung mit pure::variants
Die pure::variants Werkzeugkette wurde für die Entwicklung und Erstellung von Software-
Produktlinien konzipiert. Sie unterstützt die Verwaltung und Erstellung der unterschiedlichen
Varianten einer solchen Produktlinie. Die Basis der Werkzeuge bilden die unterschiedlichen
Modelle, welche für die Beschreibung des Problembereiches der Produktlinie, für die
Beschreibung der Umsetzung, sowie für die Auswahl eines spezifischen Produktes genutzt
werden.
Die zentrale Rolle spielen dabei Merkmalmodelle. Sie erlauben eine einheitliche Darstellung
der Gemeinsamkeiten und Unterschiede zwischen den Produkten der gesamten Produktlinie.
Im Vergleich zu in anderen Methoden genutzten Merkmalmodellen verwendet pure::variants
eine erweiterte Variante der Merkmalmodelle. Eine genaue Beschreibung erfolgt im Abschnitt
4.1.
Eine spezifische Implementierung der Produktlinie wird durch das Familienmodell
beschrieben. Es ermöglicht die Abbildung der Benutzeranforderungen auf Implementierungen
variabler Familienelemente. Hierzu gehört ebenfalls die Anpassung von Komponenten für eine
bestimmte Anwendung. Dieses Modellart wurde extra für die pure::variants Technologie
entwickelt, da existierende Modellierungsmodelle wie UML oder SDL dafür nicht geeignet
sind. Das Familienmodell ist in Abschnitt 4.2 im Detail beschrieben.
Die Merkmalsauswahl (feature selection) wird zur Beschreibung eines bestimmten Produktes
genutzt. Sie beschreibt, welche Eigenschaften und damit verbundene Werte das zu
erzeugende Produkt haben soll und wird für die Steuerung der Erzeugung verwendet.
Abbildung 3: pure::variants Transformationsprozess
Abbildung 3 gibt einen Überblick über den grundlegenden Variantenbildungsprozess mit
pure::variants. Sind die unterschiedlichen Modelle erst einmal erstellt, so werden alle
weiteren Schritte automatisch durchgeführt. Die Entwickler der Produktlinie sind für das
Erstellen des Merkmalmodells sowie der Familienbeschreibung mittels Familienmodell
verantwortlich. Die Auswahl der Merkmale erfolgt durch den Benutzer. Dies kann sowohl ein
Mensch, als auch ein Werkzeug sein, welches anhand einer Anwendung automatisch die
benötigten Merkmale ermittelt. Die Verarbeitung erfolgt dann in zwei Schritten. Zuerst
analysiert pure::variants die unterschiedlichen Modelle. Dabei wird ein Konstruktionsplan
7Variantenbildung mit pure::variants
erstellt, anhand dessen im zweiten Schritt die angepassten Lösungselemente für das
Zielprodukt erzeugt werden.
Der wesentliche Unterschied zwischen pure::variants und vergleichbaren Ansätzen besteht
darin, daß die in pure::variants verwendeten Modelle nur beschreiben, was zu tun ist, aber
nicht wie es zu tun ist. pure::variants stellt nur die benötigten Mechanismen zur Verfügung.
Diese können durch den Benutzer einfach entsprechend seinen Bedürfnissen durch (eigene)
Module erweitert werden. Damit ist die pure::variants Technologie weder auf einen
bestimmten Entwicklungsprozess noch auf eine bestimmte Sprache oder Methode festgelegt,
und kann somit in jeden beliebigen Entwicklungsprozess integriert werden. Dieser hohe Grad
an Flexibilität wird durch die Kombination zweier sehr leistungsfähiger Sprachen innerhalb
pure::variants erreicht.
Ein weiterer wichtiger Unterschied liegt innerhalb des Konfigurationsprozesses. Hier kommen
neuartige Algorithmen zur Überprüfung der Modelle und Zusammenstellung der Transforma-
tionsbeschreibung zum Einsatz. Dabei wird auf die aus dem Bereich der Künstlichen
Intelligenz stammende logische Programmiersprache Prolog zurückgegriffen. Nach der
Umwandlung der Modelle in sogenannte Prolog-Fakten erfolgt die Prüfung der Auswahl
bezüglich Gültigkeit und Vollständigkeit. Im ersten Schritt wird die Korrektheit in Bezug auf das
Merkmalmodell geprüft. Anschließend erfolgt die Überprüfung der zusätzlichen Anforder-
ungen, die sich aus dem Familienmodell ergeben. Konflikte, die zum Beispiel durch implizite
Abhängigkeiten von Merkmalen und Familienelementen entstehen, werden erkannt. Zur
automatischen Auflösung dieser Konflikte kommen durch pure-systems entwickelte
heuristische Verfahren zum Einsatz. Bei nicht automatisch lösbaren Problemen werden diese
angezeigt und der Konfigurationsvorgang unterbrochen. Ist die Auswahl gültig und vollständig,
wird eine Transformationsbeschreibung in XML erzeugt, welche für den weiteren
Erstellungsvorgang genutzt wird.
Für den Transformationsprozess wurde die XML-basierte Sprache XMLTS entwickelt. Mittels
dieser Sprache wird der Anpassungs- bzw. Transformationsprozess durch die Definition der
einzelnen durchzuführenden Aktionen beschrieben. Die einzelnen Aktionen werden auf
Grundlage der durch den vorherigen Schritt erzeugten Transformationsbeschreibung
ausgelöst. Alle Aktionen werden durch Transformationsmodule implementiert. Sind die
vordefinierten Transformationen nicht ausreichend, können jederzeit neue Transformationen
erstellt und durch die Nutzer integriert werden. In vielen Fällen kann dabei direkt auf XMLTS
zur Beschreibung einer neuen Transformation zurückgegriffen werden. Für komplexere
Aktionen sind speziell erstellte Module notwendig. Zur Steuerung des Ablaufs der
Transformationen können sowohl XMLTS als auch alle Module auf die kompletten
Informationen innerhalb von pure::variants zugreifen (Merkmalmodell, Merkmalsauswahl,
Familienmodell, Quellen, u.v.m.). Dadurch können Transformationen durchgeführt werden, die
mit herkömmlichen Technologien nicht möglich sind, da diese nur begrenzte Informationen
über einzelne Elemente einer Softwarelösung haben.
4.1 pure::variants Merkmalmodelle
Das Merkmalmodell beinhaltet die Gemeinsamkeiten und Unterschiede der Produktlinie. Dabei
repräsentiert ein Merkmal eine für den Benutzer sichtbare Systemeigenschaft. Diese wird
8Variantenbildung mit pure::variants
durch die zugehörige Merkmalsbeschreibung näher charakterisiert. Aus dieser Erläuterung
muss deutlich erkennbar sein, welche Auswirkungen die Auswahl dieses Merkmales hat.
Abbildung 4: Merkmalmodell
Innerhalb des Modells sind die einzelnen Merkmale in Form eines azyklischen Graphen
dargestellt. Die Knoten entsprechen den Merkmalen. Die Kanten beschreiben die
Basisbeziehung (zwingend, optional, alternativ, oder) zwischen den einzelnen Merkmalen.
Abbildung 4 zeigt die grafische Darstellung eines einfachen Merkmalmodells.
Merkmale mit Wertzuweisungen
Für die Beschreibung komplexer Probleme ist es erforderlich, dass Werte unterschiedlichen
Typs an Merkmale zugewiesen werden können. Die pure::variants Merkmalmodelle unter-
stützen diesen Sachverhalt, indem jedem Merkmal eine beliebige Anzahl von Attributen
(benannte Typ/Wert-Paare) zugewiesen werden kann. Der gespeicherte Wert kann sowohl zur
Entscheidungsfindung, als auch während der Transformation genutzt werden.
Merkmale mit Restriktionen
Zusätzlich zu den oben genannten Basisbeziehungen zwischen den Merkmalen ermöglicht
das pure::variants Modell die Beschreibung von weiteren komplexen Restriktionen zwischen
beliebigen Merkmalen. Sie werden durch logische Regeln ausgedrückt und stellen Querver-
bindungen innerhalb des Graphen dar. Durch diesen flexiblen Mechanismus können
Abhängigkeiten der Merkmale wie Konflikte zwischen Merkmalskombinationen oder die
implizite Einbeziehung eines weiteren Merkmals einfach dargestellt werden.
Hierarchien von Merkmalmodellen
Im Unterschied zu anderen Ansätzen die auf Merkmalmodellen beruhen, erlaubt pure::variants
den Einsatz von beliebig vielen, miteinander durch Abbildungsvorschriften verbundenen
Merkmalmodellen. Alle anderen bekannten Ansätze verwenden lediglich ein einzelnes
Merkmalmodell. Die Nutzung mehrerer Merkmalmodelle erlaubt die konsistente Einbindung
verschiedener Sichtweisen auf die Gemeinsamkeiten und Unterschiede einer Produktlinie.
Dadurch sind zum Beispiel Modelle mit unterschiedlichem Detaillierungsgrad möglich (Kunde:
geringer Detaillierungsgrad, Vertrieb: mittlerer Detaillierungsgrad, Entwicklung: maximaler
Detaillierungsgrad). Durch die hierarchische Verbindung der verschiedenen Modelle ist in
jedem Fall die Konsistenz der Merkmalskombinationen gewahrt. Auch die Kombination von
9Variantenbildung mit pure::variants
verschiedenen Produktlinien(-teilen) zu einer neuen Produktlinie kann dadurch vereinfacht
werden. Hierzu ist nur ein übergeordnetes Modell zu erstellen, welches Bezug auf die bereits
existierenden Modelle der zu integrierenden Produktlinien nimmt.
4.2 pure::variants Familienmodell
Das pure::variants Familienmodell beschreibt die interne Struktur der einzelnen
Familienelemente einer Produktlinie und ihre Abhängigkeiten von den Merkmalen. Mittels
dieser Beschreibung werden die unterschiedlichen Familienelemente an die Merkmale
gebunden. Der Begriff Familienelement ist hierbei sehr weit gefasst. Im Sinne von
pure::variants umschließt ein Familienelement eine Menge konfigurierbarer Funktionalitäten.
Die Abbildung 5 gibt einen Überblick über die hierarchische Struktur des Familienmodells.
Abbildung 5: Familienmodell
Im folgenden Abschnitt werden die Elemente des Familienmodells kurz vorgestellt:
Komponente: Die grundlegenden Elemente im Modell stellen die Komponenten dar. Sie sind
eindeutig benannt und bestehen aus mindestens einem Bestandteil (Part), welcher
weiterhin durch seine Quellen (Source) definiert ist.
Eine Komponente kapselt eine oder mehrere Funktionalitäten, die Merkmale aus dem
Merkmalmodell der Produktlinie realisieren.
Bestandteil: Ein Bestandteil ist ein benanntes, typisiertes Element, welches genau einer
Komponente zugeordnet ist. Es wird durch mindestens eine Quelle definiert.
Bestandteile können logische Elemente einer Programmiersprache sein, wie z.B. Klassen,
Funktionen oder Objekte. Aber auch jedes sonstige Element der internen oder externen
Struktur einer Komponente wird durch ein Bestandteil beschrieben. Hierzu gehören
beispielsweise Schnittstellen, Spezifikationen und Grafiken. pure::variants verfügt über eine
Reihe vordefinierter Typen (class, object, flag, classalias, variable). Die Einführung weiterer
Typen entsprechend den Anforderungen des Nutzers sind jederzeit durch benutzer-
definierte Erweiterungen möglich.
Quellen: Die Beschreibung der physischen Repräsentation eines Bestandteils erfolgt mittels
seiner Quelle(n). Eine Quelle ist ein getypter Eintrag. Anhand des Typs wird entschieden,
welche Transformationsmodule während der Transformation zur Erstellung des Bestand-
teils auszuführen sind. Eine einfache Aktion eines Transformationsmoduls stellt z.B. das
10Variantenbildung mit pure::variants
Kopieren einer Datei an ein spezifiziertes Ziel dar. Es ist ebenso möglich, neue Dateien zu
generieren, wie es von den Transformationsmodulen zur Erstellung eines „classalias“ oder
„flag“ erfolgt. Durch die Einführung eines neuen Quellentyps können beliebige neue
Transformationsmodule mit eigenen Aktionen integriert werden.
Alle Elemente des Familienmodells lassen sich mit Restriktionen versehen. Durch diese
Restriktionen erfolgt die Bindung an ein Merkmal bzw. eine Kombination von Merkmalen. Es ist
damit ebenfalls möglich spezifische Eigenschaften der Implementierung auszudrücken. Zum
Beispiel die Unverträglichkeit von zwei Komponenten in bestimmten Merkmalskombinationen.
4.3 Module
Die Fähigkeiten der pure::variants Technologie lassen sich mittels verschiedenartiger Module
variabel erweitern. Sie kommen an unterschiedlichen Stellen zum Einsatz. Zum einen
erweitern Transformationsmodule die ausführbaren Aktionen während der Produkterstellung.
Zum anderen dienen integrierende Module zur Anbindung an externe Prozesse und Werk-
zeuge.
Die bereits vorhandenen Module decken folgende Bereiche ab:
Modell - und Programmiersprachen
Standard Transformation: Bereitstellung typischer Familienelementtypen und zugehöriger
Transformationsmuster für gängige Programmiersprachen wie C/C++ und Java. Die
Standardtransformation kann durch kundenspezifische Transformationen ergänzt werden.
Connector für Simulink: Ermöglicht die Verwaltung von Variabilitätsinformationen für
Matlab/Simulink Modelle in Familienmodellen.
Integration in Entwicklungsprozesse
Transformer für Versionsverwaltungssysteme: Der Transformer bindet existierende Konfigu-
rationsmanagementsysteme in die Lösungstransformation ein. Erst die Integration von
Variantenmanagement und Konfigurationsmanagement in eine gemeinsame Lösung erlaubt
eine effiziente Zusammenarbeit bei der Entwicklung und Nutzung von komplexer Software
in größeren Teams.
Synchronizer für Anforderungsmanagement: Klassische Anforderungsmanagementwerkzeuge
werden um die Fähigkeit zur Verwaltung von Variabilitätsinformationen in Merkmal-
modellen erweitert. pure::variants Merkmalmodelle werden direkt mit den Anforderungen
im externen Anforderungsmanagementwerkzeug verbunden. Damit können Varianten von
Anforderungsdokumenten schnell erstellt werden und die Merkmalmodelle auch im
weiteren Softwaredesign genutzt werden.
11Produkte
5 Produkte
Ausgehend von der Basistechnologie ergeben sich unterschiedliche Produkte für verschie-
dene Einsatzszenarien.
5.1 Developer Edition
Die pure::variants Developer Edition dient der Unterstützung der Softwareentwickler bei
Entwurf, Erstellung und Einsatz von Softwarefamilien. Sie ermöglicht den Nutzern, die
pure::variants Technologie bei der Realisierung von eigenen Softwareprojekten einzusetzen.
Sie ist als eigenständiges Werkzeug oder als sogenanntes PlugIn zur nahtlosen Einbindung in
integrierte Entwicklungsumgebungen (Eclipse, Rational Software Architect, ...) verfügbar und
ergänzt damit die anderen Entwicklungswerkzeuge wie CASE Tools, Editoren, Compiler und
Debugger.
5.2 Integration Edition
Die pure::variants Integration Edition erlaubt es den Kunden die pure::variants Technologie in
eigene Softwareprodukte zu integrieren. So kann zum Beispiel die Konfigurierung eines
eingebetteten Betriebssystems durch den Kunden mit einem vom Hersteller des Betriebs-
systems entwickelten Programm auf Basis der Integration Edition realisiert werden.
Durch die Nutzung der Integration Edition können Kunden auf eine sonst notwendige
komplette Eigenentwicklung im Bereich Variantenmanagement verzichten. Durch die
universelle Auslegung der Integration Edition sind alle benötigten Grundfunktionen bereits
vorhanden und erprobt. Es ist nur noch die Anpassung der graphischen Oberfläche und des
Transformationsablaufs nötig. Damit ergeben sich Qualitätsvorteile und natürlich auch
verkürzte Entwicklungszeiten.
5.3 Server Edition
Die pure::variants Server Edition ermöglicht eine zentralisierte Verwaltung von
Softwareproduktlinien, zum Beispiel in Entwicklungsabteilungen, oder auch den Vertrieb von
kundenspezifischen Konfigurationen einer Software über das Internet, ohne dass beim
Entwickler/Kunden eine Installation von pure::variants vorhanden sein muss. Ein wesentlicher
Effekt beim Einsatz der Server Edition ist die zentralisierte Verwaltung der Varianten in einer
Organisation analog zum meist ebenfalls zentralisierten Softwarekonfigurationsmanagement.
Dadurch ergeben sich Einsparpotentiale bei den Personalkosten, da eine zentrale Wartung in
der Regel günstiger ist als eine dezentrale. Für Vertriebslösungen auf Basis der Server Edition
spricht die Möglichkeit, ohne das Risiko von Weitergabe des unternehmensinternen Wissens
über die Gesamtstruktur einer Softwarelösung kundenspezifische Lösungen durch den
Kunden selbst erstellen zu lassen. Dies kann zu einer Kostenreduktion auf beiden Seiten
führen, da einerseits der Kunde selbst sehr genau bestimmen kann, was er wirklich braucht
(und bezahlen muss) und andererseits der Betrieb einer Serverlösung sehr kostengünstig ist.
12Produkte
5.4 Erweiterungsmodule
Die pure::variants Module dienen der flexiblen Erweiterung der verschiedenen pure::variants
Editionen um zusätzliche Funktionalitäten. Die Module decken unterschiedliche Bereiche und
Aufgaben innerhalb der Softwareentwicklungsprozesse ab. Beispiele für Module sind die
Einbindung einer Software Configuration Management Lösung zur Versionsverwaltung oder
die Erweiterung der Möglichkeiten zur Umsetzung von Variantenbildung für ausgewählte
Programmiersprachen.
6 Zusammenfassung
Bei immer kürzer werdenden Innovationszyklen steigt die Anforderung an heutige Software-
systeme bezüglich ihrer Langlebigkeit stark an. Wesentliche Grundlage für eine lange Lebens-
dauer von Softwaresystemen ist deren Anpassungsfähigkeit für unvorhergesehene bzw. nicht
berücksichtigte (Kunden-)Anforderungen. Ein erfolgversprechender Lösungsansatz sind
Produktlinien, bei denen Software nicht nur für ein Produkt, sondern für eine Klasse von
Produkten entwickelt wird. Durch die einmalige Erstellung gemeinsamer Anteile (Assets)
werden Synergien ausgenutzt, die in klassischen Ansätzen der Softwaretechnik nicht zum
Tragen kommen. Damit sich Produktlinien realistisch in der Softwareentwicklung einsetzen
lassen, sind Werkzeuge notwendig, die den gesamten Prozess ausgehend vom Entwurf bis hin
zur Umsetzung unterstützen. Speziell die effiziente Verwaltung und Realisierung der
Variantenbildung innerhalb der gemeinsamen Anteile stellt eine technologische Heraus-
forderung dar. Die pure-systems GmbH unterstützt mit ihren auf der pure::variants-Techno-
logie basierenden Variantenmanagement-Werkzeugen diesen Gesamtprozess.
13Sie können auch lesen
