-
Notifications
You must be signed in to change notification settings - Fork 1
Components for Product Consolidation
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
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
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
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
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
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
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
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
Contact
KoPL Project
http://www.kopl-project.org
Project Lead: DevBoost GmbH
-
User Guide
-
Demonstrations
-
- Getting Started
- Recommended Tools
- Coding Conventions
- Architecture
- Variation Point Model
- UI
- Quality Assurance (QS)