The Feature-Oriented Requirements Modelling (FORM) combines the requirement engineering style structuring of requirements documents with the feature-orientation of the Feature Oriented Software Development, resulting in a feature-oriented model of the functional requirements of a system-under-development (SUD). A feature is a distinguishable unit of added value to the SUD. The objectives of FORM are to model features as independent modules, to allow the addition of new features with minimal changes to the existing features, and to enable automatic generation and checking of properties like correctness, consistency, and non-determinism. FORM structures requirements into three models: a domain model, a collection of behavioural models, and a collection of functional models. A feature is modelled by a distinct behavioural model. This dissertation evaluates FORM by applying it to a new application that can be thought of in terms of features, namely an online trading system (OTS) that receives requests from customers about buying or selling securities on a stock market. The OTS offers variability in terms of the types of orders that customers can request, (e.g. market order, limit order and stop order). The case study revealed six deficiencies of the FORM notation, three of which were easily overcome. The dissertation presents the results of the case study, resolutions to three of the six deficiencies, and an outline of an approach to resolve the other three deficiencies.

<p> Identifying design pattern instances within an existing software system can support understanding and reuse of the system functionality. Moreover, incorporating behavioral features through task scenario into the design pattern recovery would enhance both the scalability of the process and the usefulness of the design pattern instances. In this context, we present a novel method for recovering design pattern instances from the implementation of system behavioral features through a semi-automatic and multi-phase reverse engineering process.</p> <p> The proposed method consists of a feature-oriented dynamic analysis and a two-phase design pattern detection process. The feature-oriented dynamic analysis works on the software system behavioral features' run-time information and produces a mapping between features and their realization at class level. In the two-phase design pattern detection process, we employ an approximate matching and a structural matching to detect the instances of the target design pattern described in our proposed Pattern Description Language (PDL), which is an XML-based design pattern description language. The correspondence between system features and the identified design pattern instances can facilitate the construction of more reusable and configurable software components. Our target application domain is an evolutionary development of software product line which emphasizes on reusing software artifacts to construct a reference architecture for several similar products. We have implemented a prototype toolkit and conducted experimentations on three versions of JHotDraw systems to evaluate our approach.</p> / Thesis / Master of Applied Science (MASc)

"The essence of software design is to construct well-defined, encapsulated modules that are composed together to build the desired software application. There are several design paradigms in use today, including traditional Object-Oriented Programming (OOP), Feature-Oriented Programming (FOP), Aspect-Oriented Programming (AOP) and Instance-Oriented Programming (IOP). FOP studies the modularity of features in product lines, where a feature is an increment in program functionality. AOP aims to separate and modularize aspects when an aspect is a crosscutting concern. IOP, as an extension to FOP, makes the layers work like object factories. While each is good at solving different types of problems, they are closely related. The composition of modules is complicated because modules have (often hidden) dependencies on other modules. This thesis aims to better understand the way dependencies are managed by each approach. Based on this, we focus on the precedence issue in AOP and FOP, that is, how designers are able to specify the order by which modules are composed together. Different precedence means different semantics, but the current tools can not guarantee the correct precedence is adopted. We first solve the precedence issue separately for AOP and FOP, then based on this, we come up with a unified model to solve the precedence issue by using source code annotations to specify the precedence. We evaluate our technique with use cases. "

Background: A key idea of feature orientation is to decompose a software product line along the features it provides. Feature decomposition is orthogonal to object-oriented decomposition it crosscuts the underlying package and class structure. It has been argued often that feature decomposition improves system structure (reduced coupling, increased cohesion). However, recent empirical findings suggest that this is not necessarily the case, which is the motivation for our empirical investigation. Aim: In fact, there is little empirical evidence on how the alternative decompositions of feature orientation and object orientation compare to each other in terms of their association with observable properties of system structure (coupling, cohesion). This motivated us to empirically investigate and compare the properties of three decompositions (object-oriented, feature-oriented, and their intersection) of 28 feature-oriented software product lines. Method: In an exploratory, observational study, we quantify internal attributes, such as import coupling and cohesion, to describe and analyze the different decompositions of a feature-oriented product line in a systematic, reproducible, and comparable manner. For this purpose, we use three established software measures (CBU, IUD, EUD) as well as standard distribution statistics (e.g., Gini coefficient). Results: First, feature decomposition is associated with higher levels of structural coupling in a product line than a decomposition into classes. Second, although coupling is concentrated in feature decompositions, there are not necessarily hot-spot features. Third, the cohesion of feature modules is not necessarily higher than class cohesion, whereas feature modules serve more dependencies internally than classes. Fourth, coupling and cohesion measurement show potential for sampling optimization in complex static and dynamic product-line analyses (product-line type checking, feature-interaction detection). Conclusions: Our empirical study raises critical questions about alleged advantages of feature decomposition. At the same time, we demonstrate how the measurement of structural attributes can facilitate static and dynamic analyses of software product lines. (authors' abstract) / Series: Technical Reports / Institute for Information Systems and New Media

Background: A key idea of feature orientation is to decompose a software product line along the features it provides. Feature decomposition is orthogonal to object-oriented decomposition it crosscuts the underlying package and class structure. It has been argued often that feature decomposition improves system structure (reduced coupling, increased cohesion). However, recent empirical findings suggest that this is not necessarily the case, which is the motivation for our empirical investigation. Aim: In fact, there is little empirical evidence on how the alternative decompositions of feature orientation and object orientation compare to each other in terms of their association with observable properties of system structure (coupling, cohesion). This motivated us to empirically investigate and compare the properties of three decompositions (object-oriented, feature-oriented, and their intersection) of 28 feature-oriented software product lines. Method: In an exploratory, observational study, we quantify internal attributes, such as import coupling and cohesion, to describe and analyze the different decompositions of a feature-oriented product line in a systematic, reproducible, and comparable manner. For this purpose, we use three established software measures (CBU, IUD, EUD) as well as standard distribution statistics (e.g., Gini coefficient). Results: First, feature decomposition is associated with higher levels of structural coupling in a product line than a decomposition into classes. Second, although coupling is concentrated in feature decompositions, there are not necessarily hot-spot features. Third, the cohesion of feature modules is not necessarily higher than class cohesion, whereas feature modules serve more dependencies internally than classes. Fourth, coupling and cohesion measurement show potential for sampling optimization in complex static and dynamic product-line analyses (product-line type checking, feature-interaction detection). Conclusions: Our empirical study raises critical questions about alleged advantages of feature decomposition. At the same time, we demonstrate how the measurement of structural attributes can facilitate static and dynamic analyses of software product lines. (authors' abstract) / Series: Technical Reports / Institute for Information Systems and New Media

Thesis (M.S.) -- Worcester Polytechnic Institute. / Keywords: conflict; precedence; dependency; feature-oriented programming; object-oriented design; aspect-oriented programming. Includes bibliographical references (p.76-78).

Some mechanisms to enable an effective transition from domain models to web service descriptions are developed. The introduced domain modeling support provides verification and correction on the customization part. An automated mapping mechanism from the domain model to web service ontologies is also developed. The proposed approach is based on Feature-Oriented Domain Analysis (FODA), Semantic Web technologies and ebXML Business Process Specification Schema (ebBP). Major contributions of this work are the conceptualizations of a feature model for web services and a novel approach for knowledge-based elicitation of domain-specific outcomes in order to allow designing and deploying services better aligned with dynamically changing business goals, stakeholders&#039 / concerns and end-users&#039 / viewpoints. The main idea behind enabling a knowledge-based approach is to pursue automation and intelligence on reflecting business requirements into service descriptions via model transformations and automated reasoning. The proposed reference variability model encloses the domain-specific knowledge and is formalized by using Web Ontology Language (OWL). Adding formal semantics to feature models allows us to perform automated analysis over them such as the verification of model customizations through exploiting rule-based automated reasoners. This research was motivated due to the needs for achieving productivity gains, maintainability and better alignment of business requirements with technical capabilities in engineering service-oriented applications and systems.

Frames sind parametrisierte Elemente zur Erzeugung von Programmen in einer beliebigen Zielprogrammiersprache. Ihre Handhabung ist einfach und schnell zu erlernen. Allerdings findet bei Verwendung von Frames eine “Verunreinigung” des Programmcodes, der als Basis für die Generatorentwicklung dient, mit Befehlen der Generatorsprache statt. Dies erschwert die Weiterverwendung der gewohnten Entwicklungsumgebung für die Zielprogrammiersprache. Eine eventuelle Weiterentwicklung der Programmbasis muss anschließend in Form von Frames erfolgen. Im Rahmen dieser Arbeit erfolgt die Beschreibung noninvasiver Frames, bei denen Informationen zur Position der Frames getrennt vom Programmcode aufbewahrt werden. Ihre Vermischung erfolgt in einem separaten Schritt zur Darstellung oder zur eigentlichen Codeerzeugung. Der Prozess der Generatorentwicklung auf der Basis noninvasiver Frames passt sich gut in die Prozesse von Merkmal-orientierter (FOSD) und Generativer Softwareentwicklung (GSE) ein, weil noninvasive Frames die automatisierte Prüfung aller mit dem Generator erzeugbaren Programme hinsichtlich Syntax und bestimmter semantischer Eigenschaften unterstützen und die Generierung durch Auswahl der gewünschten Programmeigenschaften ermöglichen. Die Machbarkeit der Entwicklung von Softwaregeneratoren mit noninvasiven Frames wird anhand zweier Fallstudien demonstriert.

Modern business applications are getting increasingly distributed as multi-tenant software as a service (SaaS). This leads to new challenges in terms of quality assurance, because all customers are directly affected by software changes. The resulting problem is to proactively determinate evolutionary effects. Because SaaS applications are often realized in the sense of a software product line, this thesis examines ways of using feature models to face the mentioned problem. For this purpose, two approaches are analyzed: extended feature models with quality attributes annotated per feature and the analysis of structural aspects of feature models and corresponding concrete configurations. The presented attributed feature model approach measures the quality of concrete configurations to make configurations comparable according to specific quality goals. Criteria are elicited for when configurations can be compared to draw helpful conclusions. The structural approach focuses economic questions that are quality assurance related, such as identifying features that none of the tenants selected in their application configurations. Furthermore, three algorithms are presented that demonstrate the structural analysis approach to gather information relevant to quality assurance.

Feature-based formalisms provide an elegant way to specify families of systems that share a base functionality and differ in certain features. They can also facilitate an all-in-one analysis, where all systems of the family are analyzed at once on a single family model instead of one-by-one. This paper presents the basic concepts of the tool ProFeat, which provides a guarded-command language for modeling families of probabilistic systems and an automatic translation of family models to the input language of the probabilistic model checker PRISM. This translational approach enables a family-based quantitative analysis with PRISM. Besides modeling families of systems that differ in system parameters such as the number of identical processes or channel sizes, ProFeat also provides special support for the modeling and analysis of (probabilistic) product lines with dynamic feature switches, multi-features and feature attributes. By means of several case studies we show how ProFeat eases family-based modeling and compare the one-by-one and all-in-one analysis approach.