Skip to content

Components for Product Consolidation

Christian Wende edited this page Feb 20, 2015 · 3 revisions

KoPL UI Component

The KoPL UI Component encapsulates all user interactions with the KoPL tool chain. It contributes

  • Editors for users to enter data to configure the tool chain components or to communicate design decisions in the product-line consolidation process
  • Wizards/Workflows to guide users through steps of the consolidation process (to request the required configuration data or decisions in a guided way
  • Views to allow for inspecting analysis results and the SPL design The UI component does not contain any logic or functionally to actually implement the consolida-tion process. Instead, it uses services of components for the various steps of the consolidation process.

Implementation

The implementation of all UI Components can be found at: UI Components

Extension Points
The UI component exposes extension points that can be bound by service components

  • for contributing consolidation services and
  • for contributing technology specific visualizations.

These UI extension points are used to call and parameterize all service components that implement functional requirements and require manual interaction. All other communication between tools is to be handled using component interfaces.

Implementation

The implementation of all UI Extension Points is part of the UI Components and can be found at: UI Components

Extraction Component

The Extraction Component integrates technology-specific logic to derive a model from the input code for the product copies. It exposes its results as general EMF Resources, so technology-specifics are hidden to all components that call the extractors and components that are using extraction results.

Input Data: Software artifacts for product copies

Output Data: EMF-based model for software artifacts

Extension: Extensible with programming-language-specific extractors

Implementation

The generic implementation of all Extraction Components can found at: Extraction

This generic implementation is implemented by technology specific extensions. For example, the extraction components for Java are part of the JaMoPP Cartridge and can be found at: JaMoPPCartridge

Diffing Component

The Diffing Component provides services for the difference analysis of software models. It generates a difference model from the software artifact models of two product copies. It encapsulates technol-ogy specific artifacts through an extension point. For model comparison it uses EMF Compare used as general difference infrastructure, so no technology-specifics are visible to components that call the diffing component and components that are using diffing results.

Input Data: Models of software artifacts for two product copies

Output Data: Difference model

Extension: Extensible with programming-language-specific software artifacts elements

Implementation

The generic implementation of all Diffing Components can found at: Diffing

This generic implementation is implemented by technology specific extensions. For example, the diffing components for Java are part of the JaMoPP Cartridge and can be found at: JaMoPPCartridge

VPM Component

The VPM Component contributes the Variation Point Model specification. This model allows de-scribing variability, variation points, variants, their implementing software elements as well as their characteristics and clustering. It encapsulates technology specific data (software artifact elements) using wrappers, i.e. model elements that generically refer to technology specific ones and, thus, hide them. Additional technology support can be contributed through an extension point. The software element wrappers can be accessed technology independently, so technology-specifics can be abstracted by all components that are using the VPM.

Extension:
Extensible with language-specific software artifact elements

VPM Builder Component

The VPM Builder Component derives an initial fine-grained variation point model from a difference model. It abstracts from technology-specific software elements using the wrappers in the VPM.

Input Data: Difference model

Output Data: Variation point model

Extension: Extensible with programming-language-specific software artifact elements (via VPM)

Implementation

The generic implementation of the VPM Components can found at: VPM

This generic implementation is implemented by technology specific extensions. For example, the extraction VPM extensions for Java are part of the JaMoPP Cartridge and can be found at: JaMoPPCartridge

VPM Analyzer Component

The VPM Analyzer Component computes relations between variation points. Using the detected relationships the component provides refinement recommendations for merging and grouping of variation points. The Analyzer component allows for contributing additional analysis logics by an extension point. Such analysis logics can be technology-specific (e.g., programming-language-specific analyzers like the Java program dependency analyzer) or domain-specific (e.g., semantic analyzer being adapted to specific terms occurring in the business field addressed by the software). Furthermore, the analyzers can provide technology-specific extension points by themselves (e.g., the JaMoPP semantic content provider extracts terms from Java programs to be analyzed by the generic semantic analyzer component, see Variability Design Component). In addition to detecting relationships, the Analyzer component provides an extension point for merge deciders to identify variation points, which can be merged with each other. Such merge de-ciders can be technology-specific but do not have to. For performance optimization, analysis runs can be parallelized. Analysis results will be combined in the end. Within the component itself, all VPMs are treated in a generic way. Thus, no technology-specifics are visible to components that call the analyzer and components that are using the resulting VPMs.

Input Data: Variation point model

Output Data: Variation point model with potentially related variation points

Extension: Extensible with additional analyzers and merge detectors

The generic implementation of the VPM Analyzer Components can found at: VPM Analyzer

This generic implementation is implemented by technology specific extensions. For example, the VPM analyzer extensions for Java are part of the JaMoPP Cartridge and can be found at: JaMoPPCartridge

VPM Refinement Component

The VPM Refinement Component provides tools for applying VPM refinements. It, therefore, re-structures (refactors) the initial VPM. VPMs are handled generically. Thus, no technology-specifics are visible to components that call the refinement component and components that are using refined VPMs.

Input Data: VPM with potentially related variation points

Output Data: Refined VPM

Implementation

The generic implementation of all Refinement Components can found at: Refinement

This generic implementation is implemented by technology specific extensions. For example, the refinement components for Java are part of the JaMoPP Cartrige and can be found at: JaMoPPCartridge

Refactoring Component

The Refactoring Component transforms the variation point model of product copies to a variation point model of the product line with systematic variability. It includes a recommender to decide which variability mechanism to use for specific variation points according to the SPL profile given by the software architect and variation point characteristics. It provides a user interface for the coor-dination of refactorings to restructure the product copies into a single code base including the vari-ability mechanisms. The Refactoring component introduces extension points for contributing specific variability mechanisms for technology-specific software artifacts (e.g., Java Refactorings with JaMoPP)

Input Data: Merged and grouped VPM, product-line profile

Output Data: Refactored VPM and software artifacts

Extension: Extensible with technology-specific refactorings

Implementation

The generic implementation of all Refactoring Components can found at: Refactoring

This generic implementation is implemented by technology specific extensions. For example, the refactoring components for Java are part of the JaMoPP Cartrige and can be found at: JaMoPPCartridge

Clone this wiki locally