Architecture-Centric Derivation of Products in a Software Product Line
This document explores architecture-centric software development, focusing on software architecture as a core element. It discusses the integration of architecture-centric development with product line development, emphasizing the customization of product line architecture. Strategies for product derivation and challenges faced in aligning architecture with product code are also highlighted.
Download Presentation
Please find below an Image/Link to download the presentation.
The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author.If you encounter any issues during the download, it is possible that the publisher has removed the file from their server.
You are allowed to download the files provided on this website for personal or commercial use, subject to the condition that they are used lawfully. All files are the property of their respective owners.
The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author.
E N D
Presentation Transcript
Architecture-Centric Derivation of Products in a Software Product Line Cuong Cu and Yongjie Zheng Department of Computer Science and Electrical Engineering University of Missouri Kansas City 1
Outline 2 Introduction Architecture-Centric Product Derivation (Existing Solutions) Approach (Tool Demo) Implementation & Preliminary Experience Conclusion
Introduction 3 Architecture-centric software development emphasizes that software architecture should be the focus of software development. The architecture model is automatically processed to drive other development activities (e.g. implementation, testing, evolution). Manual implementation can still exist. Enabling technologies: metamodeling, model transformation, architecture- implementation mapping. Software product line development is about development of a family of software products that have substantial commonality. Domain engineering develops reusable product line artifacts (e.g. product line architecture, product line code). Application engineering reuses and customizes the artifacts developed in domain engineering to derive product instances.
Introduction, cont. 4 Architecture-centric product line development combines architecture- centric development and product line development. Focuses on product line architecture (PLA) that includes both core elements and variation points. Rationale: software architecture plays an important role in software extensibility and reusability. Challenges: enabling architecture centrality in the activities specific to product line development architecture-centric product derivation. Focuses on customization of the PLA only. Pending on a mechanism to reuse and enforce the result of PLA customization (e.g. decisions on the variation points, selected features) to derive product code. No repetitive or conflicting decisions will be made to derive product code.
Architecture-Centric Product Derivation (Existing Solutions) 5 Strategy 1: Model Transformation + Full Code Generation. Often used together with Model- Driven Architecture: PLA as PIM and PSA as PSM. Addresses differences in platform. Strategy 2: Generation of Code Modifications + Program Transformation (Metaprogramming) Architecture and code are disconnected. Addresses differences in function. Model Transformation Product Line Architecture Product-Specific Architecture PLA Generation of Code Modifications Customization Full Code Generation Metaprogramming Product Line Code Product-Specific Code Program Transformation
Architecture-Centric Product Derivation (Existing Solutions), cont. 6 An appropriate PLA implementation mechanism is missing. The first strategy solely relies on code generation - fails to support manual implementation. The second strategy uses general-purpose programming techniques, such as inheritance, C++ templates difficult to synchronize the PLA with either product line code or product-specific code. As a result, a pragmatic architecture-centric product derivation mechanism is still missing. The key is the capability of automatically mapping the result of PLA customization to the derived product-specific code. In other words, both product line code and product-specific code can be automatically generated from the PLA.
Approach: a pragmatic mechanism of architecture-centric product derivation 7 A three-step derivation process Architecture Pruning 1. Feature selection and variability resolution for the PLA. Product Line Architecture Product-Specific Architecture 2 2. Processing both the PLA and the user-defined product line code. Decisions on Variation Points Platform-Specific Code Generation PLA 3 Customization 1 Generating code from product- specific architecture. Enables architecture-centric product derivation in two aspects. 3. Product-Specific Code (Generated) Product Line Code (Generated) product code is generated from product architecture. Annotation Processing Product-Specific Code (User-Defined) Product Line Code (User-Defined) Same decisions are reused to customize product line code. 2
Approach: a PLA Implementation Mechanism 8 A code generation and separation technique that divides the code of a PLA component into two intendent classes. The generated code encapsulates architectural variations (e.g. platform). An architecture-based code annotation used in the user-defined code to identify feature-related code. Definition: /*@Optional(Feature.<feature name>)*/ Can be attached to different code fragments, including class, method, variable, a line of code. Feature is a Java enum containing the list of features automatically extracted from the PLA specification. All the annotations and the corresponding code fragments can be automatically maintained (e.g. updated, removed).
rcvMsg saveHistory rcvMsg Server Server fwdMsg loadHistory fwdMsg Product Line Architecture Product-Specific Architecture 01 class ServerArch extends MyxComponent{ 02 public IFwdMsg out1; 03 public IHistory out2; 04 public IServer _imp; 05 public void init(){ 06 out1= MyxUtils.getService( FwdMsg ); 07 out2= MyxUtils.getService( History ); 08 } 09 public void destroy(){ } 10 public void rcvMsg(String msg){ 11 _imp.rcvMsg(msg); 12 } 13 public String loadHistory(){ 14 return _imp.loadHistory(); 15 } 16 } 01 class ServerArch extends C2Brick{ 02 public IFwdMsg out1; 03 public IServer _imp; 04 public void begin(){ 05 out1= C2.initRequired( FwdMsg ); 06 } 07 public void end(){ } 08 public void rcvMsg(String msg){ 09 _imp.rcvMsg(msg); 10 } 11 } 01 interface IServer{ 02 public void rcvMsg(String msg); 03 public String loadHistory(); 04 } 01 interface IServer{ 02 public void rcvMsg(String msg); 03 } 01 class ServerImp implements IServer{ 02 public ServerArch _arch; 03 public void rcvMsg(String msg){ 04 _arch.out1.fwdMsg(msg); 05 /*@optional(Features.History)*/ 06 _arch.out2.saveHistory(msg); 07 } 08 /*@optional(Features.History)*/ 09 public String loadHistory(){ 10 11 } 12} 01 class ServerImp implements IServer{ 02 public ServerArch _arch; 03 public void rcvMsg(String msg){ 04 _arch.out1.fwdMsg(msg); 05 } 06} 9 Product Line Code Product-Specific Code An Example
Implementation & Preliminary Experience 10 Implementation environment: ArchStudio an Eclipse-based open-source architecture development toolset. We developed a toolset called xLineMapper that includes Product line selector is adapted and extended from an existing prototype included in ArchStudio. Code generator is based on the Eclipse JET2 code generation engine. Annotation processor is developed based on the ANTLR open-source project. Development and derivation of a text-based chat application. The application was developed in an architecture-centric way. Includes an architecture model, a list of optional features, and a code base.
Future Work 11 Support for feature relationships and additional architecture models. Automatically resolving feature dependencies (e.g. mutual exclusion) plays an important role in automatic product derivation. Variations in behavioral architecture models that capture product differences in control flow. Case study with an industrial product line application. Applicability, scalability, and affordability.
