pure::variants in a nutshell(转 www.software-acumen.com)

pure::variants simplifies the production of sets of related systems. It works by letting you specify the features that are shared by your end-products and the features that differbetween them, and then relating this model to your asset base (e.g.components, files, headers, requirements, tests, documentation etc.).
Once this has been done you specify the desired configuration of features for each end-product, and then use pure::variants to automatically select and configure the right assets to build the end-product.
Read more aboutusing pure::variants.
Why use pure::variants?
Benefits of using pure::variants include:
It makes it easier to specify which features go into which variant
It can give you confidence that you‘ve created an error-free variant configuration
It supports requirements traceability - saying which requirements are satisfied by which variants, and conversely, which variants satisfy which requirements
It can help you to share software between variants by managing dependencies and constraints
It can help untangle complex configuration management branching schemes
Read more aboutusing pure::variants ordownload pure::variants to give it a try.
------------------------------
pure::variants - usage overview
pure::variantsmanages your variants by letting you specify what is common to each ofyour variants and what differs between them. This information iscaptured in feature models and family models.
Step 1 - Build Feature and Family Models
Feature models capture what is the same or different about your products as seen from the customer or marketing perspective.For example, if your product has features that the customer can chooseas options then these would be detailed in your feature model.
Family models capture what is the same or different about your products as seen from engineering perspective.For example, if two different components are used to implement twoalternative product features (e.g. network protocols), then thesealternatives would be captured in your family model.
Step 2 - Specify products
Once these models have been set up, any number of individual product variants may be derived from them. This is done byspecifying the features you‘d like for the product variant.
pure::variants assists in this process by automatically resolving any conflicting choices that are made or highlighting them if it cannot resolve them automatically.
Step 3 - Assemble products
Once you‘ve specified the feature for a product variant, pure::variants is used toautomatically assemble software and/or other assets (e.g. bills of materials, documentation, test assets) for the variant.
This can involve selecting softwarecomponents, files, or file fragments from a configuration management orfile system, but can can also involve some amount of automaticcode generation, depending on the nature of your Product Line.
----------------------------------
pure::variants - Key Capabilities

pure::variants provides comprehensive support for managing your product variants:
Purpose-built variant management tools and editors
Validates product configurations and so ensures integrity of finished products. Automatically resolves problems if possible, or highlights them when user-intervention is needed
What gets generated, including code, is completely under user-control
Programming-language independent
Integrates with leading third-party software life cycle tools throughadd-on modules
Offers a wealth of customization and extension mechanisms if you need to to adapt or extend the toolset‘s capabilities to meet your specific requirements
Supports group working through amulti-user Server Edition
Integrated into Eclipse - no need to change your processes or tools or to learn a new GUI
Read howFeature Models capture the customer or marketing view of your Product Line.
Read howFamily Models capture the engineering view of your Product Line.
Technical Specifications
Read aboutpure::variants‘ supported platforms and interfaces.
----------------------------------------------
Feature Modelling with pure::variants
Feature models specify the features of your products i.e. the properties of your products that are meaningful to your customers and marketing people.
Feature models also specify relationships between features. In the feature tree below, for example, there are mandatory, optional and alternative features:

Different icons indicate different feature relations. So, the ‘Brakes‘, ‘Engine‘ and ‘Gear Box‘ features are mandatory, but the ‘Safety Functions‘ feature is optional and the ‘Engine‘ feature has two alternative sub-features - ‘Diesel‘ and ‘Gasoline‘.
In addition to these simple relations, pure::variants also allows constraints between features (e.g. mutual dependency) to be expressed.
Read aboutspecifying products using these Feature Models.
Read howFamily Models capture the engineering view of your Product Line.
Read aboutgenerating products once you have specified them.
-----------------------------------------------
Family Modelling with pure::variants
Family models represent the engineering view of how your products are built. Each Family model consists of components, parts and source elements.

Here “System” is the top-level component and it has one sub-component - “Memory”. This has two parts, a class, and a flag. The class has two source elements – files in this case.
Parts could be elements of aprogramming language, such as a class or an object, but they can alsobe any other element of the internal or external structure of acomponent.
Parts are realized by sourceelements, these are unnamed but typed elements. Their type is used todetermine how they is processed.
Different types of source elements are supported, such as ps:file, that simply copies a file from one place to a specified destination.
Read howFeature Models are used to capture the customer or marketing view of your Product Line.
Find outhow product variants are specified once you have completed your Feature and Family Models.
Find out how products are generated once they have been specified.
---------------------------------------------
Specifying product variants with pure::variants
OnceFeature andFamily models have been created, pure::variants can be used to produce individual product variants.
This is done by creating a variant model, and populating this model with feature selections- i.e. decisions as to which of several alternative features are to bepresent in the variant, or what values are to be assigned to featureattributes for the variant.

pure::variants Variant Description Model
As feature selections are made, pure::variants checks their validity and, if necessary, automatically resolves dependency conflicts or highlights conflicts if they cannot be resolved automatically.
Any choices that remain to be madeare also highlighted. This guided support means that withpure::variants the time taken to specify a product variant issignificantly lower than if done manually.
Read how pure::variants uses this specification togenerate products.
Read about using pure::variants withConfiguration Management orRequirements Management tools.
Download pure::variants to see how it works in practice.
--------------------------------------------------------
Generating product variants
Asfeature selections are made, pure::variants checks their validity and,if necessary, automatically resolves dependency conflicts or highlightsconflicts if they cannot be resolved automatically. Once a validselection has been made, an evaluation of the Family models, containingcomponent definitions, is performed.
This evaluation process produces anabstract (XML) description of the variant in terms of softwarecomponents (components, modules, files etc.). This description is usedto control a transformation process that in-turn generates the finishedproduct variant (source code and other artefacts).
The precise workings ofthis transformation process can be easily customized and extended byend-users through a variety of customization and extension points ifthe standard capabilities need to be modified.
Information from other development tools may also be incorporated into the transformation process.
-----------------------------------
Configuration Management (CM) and pure::variants
Traditionalapproaches to managing configurations for multiple variants includebranching and hand-crafted configuration code. However, such approachesoften lead to problems such as:
failure to merge branched code
increased maintenance effort
difficulty in creating an error-free configuration
problems building variants when the configuration expert is unavailable
a lack of understanding as to why a variant has been configured in a particular way
pure::variants offers a solution to these problems.
pure::variants - variant Configuration Management
Using pure::variants powerful configuration language you describe the rules for building your variants. These rules can then be used to specify individual variants and to automatically extract the right configuration elements directly from your CM tools or from your file-system to be fed into your build process or other downstream development processes.
pure::variants also simplifies the configuration process by automatically resolving any problems that arise where possible or highlighting them to you otherwise.
Furthermore,since you have now explicitly captured what is common and what differsbetween variants, it becomes possible to perform variant management inother parts of the software life cycle such asRequirements Management, Quality Assurance, Defect Tracking, Documentation etc.
Read how pure::variants works withSubversion,CVS,other Version Control Systems and withfile-based source code.
----------------------------------------------
Requirements Management (RM) and pure::variants
Managing requirements for multiple product variants is a problem due to the difficulty of sharing requirements between variants.
For example, you may find itdifficult to specify that some requirements are common to all or somevariants, or it may be difficult to say that some requirements are optional, alternative or mutually exclusive.
pure::variants offers a solution to these problems.
pure::variants - variant Requirements Management
With pure::variants powerful feature modelling tools you can specifywhich requirements are common to which product variants, whichrequirements vary between product variants and how those requirementsvary.
Once thisis done pure::variants assists in the process of creating subsets ofyour requirements that correspond to individual product variants givingyou full requirements traceability.
Thesespecifications can then be used in your downstream development processor can be passed to your suppliers if you outsource development.Furthermore, since you have now explicitly captured what is common andwhat varies between products, it becomes possible to perform variantmanagement in other parts of the software life cycle such asConfiguration Management, Quality Assurance, Defect and Feature Tracking and Documentation etc.
Read how pure::variants works withDOORS® and Borland® CaliberRM™.
Download pure::variants now to see how this works in practice.
DOORS is a registered trademark of Telelogic AB.
Borland is a registered trademark of Borland Software Corporation. CaliberRM™ is a trademark of Borland Software Corporation.
------------------------------------------------------
pure::variants Server Edition for multi-user working
pure::variants Server Edition offers comprehensive support for collaborative development.
With Server Edition, the organisation‘s Product Line models are developed in a shared, central repository.
Access to models is controlled through roles to ensure that confidential data is kept secure, and to allow changes to models to be be made only by authorised users.
Furthermore, all modifications madeby a user to a model are immediately available to other users workingwith the model. This supports effective collaborative development bothwithin the organisation and across organisations in the supply chain.
Using Server Edition for Collaborative Development
pure::variants Server Edition supports a number of collaborative scenarios including:
Development Unit - A single business unit is responsible for all software development. Server Edition can help partition the work of the department into different roles and responsibilities.
Multiple Development Units - Multiple business units share responsibility for all software development. Server Edition can help divide up the work of core asset development and application development across the different units.
Core Asset Unit - A single business unit is responsible for producing the core assets of the Product Line. One or more other units are responsible for using these assets to create specific product variants. Server Edition can limit the ability to change the core Product Line models to the Core Asset unit while making the models available to the units building the product variants.
Hierarchical Units - Multiple departments or multiple organisations collaborate on parts of the product lines. Server Edition can support effective collaboration by limiting access to different models and model elements to specific departments or organisations.
--------------------------------
Technical Specifications
Supported Platforms
Windows 2000 and XP
Linux
Supported Extensibility Interfaces
XSLT
Eclipse extension point interface
SOAP
COM / OLE (Windows only)
Supported import/export formats
XML-based native data formats
XMI
MSR-SW, MSR-FR
Other formats via user-definable import/export modules
Extension modules
Configuration Management (Subversion,CVS,other Version Control Systems,file-based source code)
Requirements Management (DOORS®,Borland® CaliberRM™)
Simulink®
Database access
Build Manager
----------------------------------
Evaluating pure::variants
To give you confidence thatpure::variantsis right for your organisation we recommend that you perform anevaluation of the software. Evaluation versions of pure::variants areavailable from ourdownloads section.
Thinking about the following points can help you get more from your evaluation:
Make sure you have a clear idea of the goals of the evaluation. In what circumstances would you consider the evaluation to have succeeded?
Base the evaluation around a non-critical but meaningful piece of work. This will give you results that are credible without risking knock-on effects on other projects.
Consider how you will resource the evaluation - who has the right skills and experience? Is that person available for the duration of the evaluation or is there a risk that they‘ll be diverted to higher-priority work?
pure::variants can import and export data in a variety of formats, this can help get you started faster and see results in your desired format sooner. More information on this is available in the user documentation that comes with the product download.
Software Acumen has specialist skills and knowledge in Software Product Line Engineering.  We can work with you during your evaluation e.g. by helping you develop your pure::variantsFeature orFamily Models.
-------------------------------------------
Licensing pure::variants
Licenses for pure::variants can be bought or rented.If you buy a license for pure::variants you may use the toolsetindefinitely. Alternatively you may rent the toolset for a number ofmonths or on a pay-per-use basis.
Different pricing options are available for floating licenses or named users.
Floating licenses may be appropriate where a numberof people are working on the product line but only need access topure::variants now and again. Named user licenses are appropriate ifyou have specific individuals who spend a large part of their timeusing the toolset.
pure::variantsadd-on modules are licensed in the same way.
Pleasecontact us for a quote or if you have further queries prior to licensing pure::variants.
Product Upgrades
Separate agreements covering product upgrades andtechnical support are available to registered purchasers on an annualbasis. These entitle you to free product upgrades.
-------------------------------------------------
pure::variants - add-on modules
pure::variants add-on modules for leading software life cycle tools.
Requirements Management
Integrate pure::variants with your Requirements Management system.
Read aboutSynchronizer for DOORS® or Synchronizer for Borland® CaliberRM™.
Quality Management
Integrate pure::variants with your Quality Management System.
Read aboutConnector for IBM® Rational® ClearQuest®.
Contact us for information about pure::variants Connector for Bugzilla.
Configuration Management
Integrate pure::variants with your Configuration Management system.
Read aboutSubversion orCVS add-ons.
Connector for Version Control Systems integrates pure::variants with any Configuration Management system.
Simulink® / Stateflow®
Integrate pure::variants with Simulink® / Stateflow®.
Read aboutConnector for Simulink®.
Reporting
Integrate pure::variants with BIRT (Business Intelligence and Reporting).
Read aboutConnector for BIRT.
Other add-on modules
Connector for Source Code Management provides an easy way of importing file-based projects into pure::variants.
------------------------------------------------------------
Connector for IBM® Rational® ClearQuest®
pure::variantsConnector for IBM® Rational® ClearQuest® simplifies the management oftests and defects in the development and maintenance of variant-richproducts and software product lines.
pure::variantsConnector for ClearQuest offers a connection between variant managementand test management/defect tracking. The focus is on visualizing thestatus of a ClearQuest element.
Defects and test cases recorded in ClearQuest canbe linked to specific elements in pure::variants. This makes itpossible to retrieve the last state of each ClearQuest item. Where anerror such as a not yet fixed defect or a failed test exists,pure::variants reports an appropriate warning.
Connections are made by means of the ID of therespective entry in the ClearQuest database and stored in a specialattribute in the corresponding element in pure::variants.
pure::variants Connector for ClearQuest keeps theconnection to the ClearQuest database open and updates its statusinformation at regular intervals. Therefore changes are directlyvisible in pure::variants and the information may be used to supportthe deployment process.
The whitepaperEfficient Management of Tests and Defects in Variant-Rich Systems with pure::variants and IBM Rational ClearQuest(PDF) describes the integration between pure::variants and ClearQuestin more detail with examples of test-management and defect tracking.
Supported Platforms
IBM® Rational® ClearQuest® v7
(Other releases available on request)
-------------------------------------------
Connector for BIRT
BIRT(Business Intelligence and Reporting Tools) is a full-featured opensource reporting system based on the popular Eclipse developmentenvironment.
BIRT has two main components: a report designer and a runtime componentthat you can add to your application server. BIRT offers users a hugevariety of data sources, presentation formats and customizationopportunities.
Connector for BIRT enables systems developers tomix and match data from pure::variants and other sources in real-timeto enable them to get an accurate and up-to-date snapshot of key management indicatorsfor their product line. Overviews such as these are essential inplanning and operating the complex multi-team projects typically foundin software product line development.
Reporting on portfolios of software product lines becomes significantly easier with the addition of this module.
Supported Platforms
Eclipse 3.2 or newer
Java 1.5 or Java 1.6
---------------------------------------------
pure::variants - Integration Edition
Doyou want your products to have a sophisticated configurationcapability? Are your end-users pressing you to provide such acapability?
Suchconfiguration is of particular relevance in the embedded domain whereit is usually necessary for end-users to configure your product toinclude precisely only those facilities that are essential to support their own product e.g. to minimize memory usage.
Products requiring such configuration could include:
Vendors of real-time operating systems
Providers of real-time databases

The solution is pure::variants Integration edition.
WithIntegration edition, you incorporate the powerful pure::variantsproduct configuration toolset into your own products to allow you tosatisfy these demands.
Furthermore, when you integrate pure::variants with your own tools you can decide how this integration happens.
Forexample, you may decide only to adopt the pure::variants configurationengine and present your own user interface e.g. a web-based interface.Alternatively, you could decide to integrate the pure::variantsuser-interface too - but rebadge it according to your corporate image.Other integration scenarios are also possible.
By incorporating pure::variants inthis way you not only include a best-in-class configuration capabilityyou also eliminate the need to divert your own development resources toimplementing such a capability and thereby allow these resources to befocussed on what you do best.
Contact us if you would like to find out more about how Integration Edition is used and licensed - including options for royalty-free licensing.
----------------------------------------------------------
pure::variants - Frequently Asked Questions
Can you demonstrate pure::variants over the web?
Is pure::variants a configuration management tool?
Is it practical to adopt pure::variants if I have an existing code base?
What programming languages does pure::variants work with?
At what stage of the software life cycle is pure::variants used?
Can I download pure::variants to evaluate it?
Can I import existing data into pure::variants?
Does pure::variants work with Visual Studio®?
How much does pure::variants cost?
Can you demonstrate pure::variants over the web?
Yes, we do this a lot! pure::variants andpure::variants add-ons can be demonstrated over the web. Please let usknow what you would like to talk about.
If you prefer, it is also possible to arrange an on-site visit to discuss pure::variants in more detail.
You can also see pure::variants demonstrated attrade shows and conferences.
Pleasecontact us with your requirements.
Is pure::variants a configuration management tool?
No, pure::variants is a variant management tool.
Configuration management tools record differencesbetween software assets as they evolve in time. For example, aconfiguration management tool could be used to track bug fixes betweenreleases of the same software. Configuration management tools typicallywork at the level of bytes and files.
pure::variants manages differences between softwareassets in terms of the functional or non-functional features of thoseassets. For example, pure::variants could be used to track the factthat one software product is targetted at low-end users but another istargetted at high-end users. pure::variants works in terms of features.
See the section onFeature Modelling for more information.
Is it practical to adopt pure::variants if I have an existing code base?
Yes. Most if not all pure::variants customers havebought the toolset when they have already had an existing code base inplace. It is not necessary to use pure::variants right from the startof your development.
Our experiencedconsultants can help you minimize the time and effort required to gain benefits from using pure::variants.
What programming languages does pure::variants work with?
pure::variants can be used with any programming language(s).
At what stage of the software life cycle is pure::variants used?
Variant management can be important across the whole software life cycle so pure::variants can be used at any stageof the software life cycle. However, it is still possible to getbenefit from pure::variants by using it only in specific life cyclestages, and this is how people typcially start with pure::variants.
More information on add-on modules that allow pure::variants to work with other life cycle tools is availablehere.
Pleasecontact us to discuss how pure::variants could best fit into your software life cycle.
Can I download pure::variants to evaluate it?
Two Editions of pure::variants are available for free download, a Community Edition and a Developer Evaluation Edition.
If you simply want to take a quick look at thetoolset then the Community Edition is adequate. If you want to explorethe full capabilities of the toolset then you will need the DeveloperEvaluation Edition.
See ourDownloads page for more details.
Can I import existing data into pure::variants?
Yes. Any existing data or models (including UMLmodels) that correspond to the feature or family models ofyour software variants can be imported directly into pure::variants bycreating either an XSLT or a Java import extension depending upon howyour existing data is represented.
This is described in more detail the pure::variants Extensibility Manual and examples are also provided with the toolset.
Does pure::variants work with Visual Studio®?
Yes. Although pure::variants is deployed onEclipseit can inter-operate to access and update projects stored in VisualStudio®. A number of tutorials have been included on this topic in thedocumentation we include with the toolset.
How much does pure::variants cost?
pure::variants is licensed on a per-user basis. Different pricing options are available for concurrent users or named users. pure::variants may also be bought or rented. The range of options means that pure::variants can be introduced into an organisation in a low-cost, low-risk manner.
For competitive reasons we don‘t publish license costs on the web but if you contact us we will send you up to date pricing information.
Separate agreements covering product upgrades and technical support are also available to registered purchasers.
Visual Studio is a registered trademark of Microsoft Corporation in the United States and/or other countries.
---------------------------------------------------------
pure::variants tutorials - step-by-step examples to get you started
Eachof these tutorials shows how pure::variants addresses some commonproblem. By working through these you will quickly learn howpure::variants is used in practice.
Most of the tutorials have a complete projectavailable for download so that you can see the finished results withoutfollowing all the steps.
Overview of Software Product Line Engineering with pure::variants
This tutorial shows how to design a pure::variantsSoftware Product Line to generate product variants using an easy to understand, practical example.
Download the tutorial (PDF).
Generating program variants with Text Transformation
This tutorial shows the use of text transformationsto configure a simple C++ application that prints intermediatecalculation results in different formats depending on how it isconfigured. When the application is started the application version andbuild date are also shown.
Download the tutorial (PDF).Download the Eclipse project.
Generating Variants Using XSLT
This tutorial shows how variants can be generatedusing XSLT transformations. The tutorial use the example of laptops,consisting of the same components in different combinations, being soldin a shop. Each time an order is placed, an order form is created thatlists the components, the price of each component, and the total cost.The order form is an HTML document is generated using an XSLT script.
Download the tutorial (PDF).Download the Eclipse project.
Generating C/C++ style flags
This tutorial shows how C/C++ style flags may be generated using pure::variants. We model the flags in a Family Model and set up a transformation to generate the defines for the selected features.
Download the tutorial (PDF).Download the Eclipse Project.
Generating variable makefiles
This tutorial shows how makefiles variantscan be generated. The generated makefiles include the files needed fora build and for different compiler options (Debug, Release, withProfiling).
Download the tutorial (PDF).Download the Eclipse project.
Generating Microsoft Visual Studio® Projects
This tutorial shows how to generate Visual Studio®project file variants for an application. Different variants arecreated with different project options, debug and release features, andwith different code included in the project files.
Download the tutorial (PDF).Download the Eclipse project.
Creating a pure::variants Feature Model from a CSV File
In this more advanced tutorial we show how aFeature Model can be created and updated using data held outside pure::variants in CSV files. The tutorial uses the pure::variants Synchronization Framework - a general framework for creating and synchronizing pure::variants models from external data sources.
Download the tutorial (PDF).
The resulting project is distributed as part of thepure::variants Extensibility SDK. After this SDK has been installedthis project can be installed by navigating to"File->New->Example->Variant Management SDK" and selectingcom.ps.pvesdk.examples.import.csv.plugin from the"Extensibility Example Plugins" list. The example project can beinstalled into the eclipse runtime by selectingcom.ps.pvesdk.examples.import.csv.pvproject fromthe "Extensibility Example Projects" list.
Developing a new model validation test
Model validation tests are applied in order to validate pure::variants models. If a test detects a problem in a model a quick fixcan be used to solve the problem automatically. In this advancedtutorial we show how a new test and quick fix may be added topure::variants using the pure::variants Model Validation Framework.
Download the tutorial (PDF).
The resulting project is distributed as part of thepure::variants Extensibility SDK. After this SDK has been installedthis project can be installed by navigating to"File->New->Example->Variant Management SDK" and selectingcom.ps.pvesdk.examples.modelvalidation.plugin fromthe "Extensibility Example Plugins" list.
Visual Studio is a registered trademark of Microsoft Corporation in the United States and/or other countries.
----------------------------------------------------
About pure-systems
pure-systems GmbH is a leader in the provision of innovative Software Product Line development tools.
The company was spun-off from Otto-von-Guericke-Universität Magdeburg and the Fraunhofer Instituts Rechnerarchitektur und Softwaretechnik in 2001 and is based in Magdeburg, Germany.
The company‘s flagshippure::variantsproduct was first released in 2004. Software Acumen has distributed andsupported pure::variants in the UK and Ireland since August 2005.
Visit thepure-systems website for more information about the company.
-----------------------------------------------------------------
pure::variants and Eclipse

Variant Management perspective
Eclipseis an open-source software development platform that is rapidly gainingin popularity and is backed by many of the biggest names in softwaredevelopment.
The pure::variants Eclipse plug-in provides users with a Variant Managementperspective which includes a number of specialised editors, views etc.to allow users to effectively and simply develop and manage theirSoftware Product Lines.
The plug-in uses Eclipse‘s richextensibility framework to ensure a seamless integration of the variousvariant management editors and tools into the Eclipse environment. Thistight integration eliminates the need to learn a new User Interfaceparadigm to use pure::variants and thereby reduces the adoption barrierfor the tool.
Visiteclipse.org to learn more about Eclipse or to download the Eclipse development platform.