Article

Component-based product line development: The KobrA approach

Authors:
  • Lufthansa Systems, Budapest, Hungary
To read the full-text of this research, you can request a copy directly from the authors.

No full-text available

Request Full-text Paper PDF

To read the full-text of this research,
you can request a copy directly from the authors.

... Since the advent of reuse techniques, component-based development is increasingly applied by organizations [Sharp 1998, Tischer et al. 2007] to build highly configurable software products, e.g., through software product lines (SPL) [Pohl et al. 2005]. Similarly, the literature introduces component-based SPLs as configurable sets of software products that share common and varying components [Atkinson et al. 2000]. To support flexible SPL product configuration, each component has to follow three criteria Larsson 2002, Krueger 2006]: encapsulate SPL functionalities, restrict data access, and be replaceable. ...
... Component-based SPLs consist of multiple software products that share components [Atkinson et al. 2000]. They aim at providing flexible SPL product configuration. ...
... For instance, a functionality often used by others may be critical for maintaining and evolving. Previous work [Atkinson et al. 2000, Her et al. 2007] mention these components as critical components, but they do not properly characterize such components [Gill 2006, Vale et al. 2016]. They associate SPL critical component with metrics like as the number of concentrated SPL functionalities and the number of dependencies with other components. ...
Conference Paper
Full-text available
In component-based software product lines (SPL), each component has to encapsulate features, restrict data access, and be replaceable. For critical components, with multiple features and dependencies, these criteria are fundamental for flexible product configuration. Previous work assume that coupling metrics help characterize critical components, but we lack empirical evidence for that assumption. By characterizing critical components, we could help developers identify components that require careful maintenance and evolution. This paper relies on five well-known coupling metrics to compose a strategy for characterizing critical components in component-based SPLs. Our results suggest reasonable strategy's accuracy but the need for using additional metrics.
... After the introduction of FODA method, there were different proposals for SPL development methodologies [5][6][7] where feature models are utilized and extended to better manage variability of SPL. Besides the FODA-based approaches, Korba [8] and Pulse [9,10] approaches proposed a decision model [11,12] where the variability of SPL is managed by specifying possible decisions on variability and the associated dependencies between them. These approaches have pioneered the field of software product line and provided adequate ways to manage variability and configure a product. ...
... The decision model constructed as above takes various structural forms depending on the implementation choices. For example, decisions are represented as table of check lists in some approaches [8,11] whereas they are represented as elements of an XML document in other approaches [12,23]. In the proposed approach, a decision model can be constructed as a tree structure in an XML format where decisions, resolutions, and effects are organized using the hierarchical parentchild relationships. ...
Article
Full-text available
The wide adaptation of product line engineering in software industry has enabled cost effective development of high quality software for diverse market segments. In software product line (SPL), a family of software is specified with a set of core assets representing reusable features with their variability, dependencies, and constraints. From such core assets, valid software products are configured after thoroughly analysing the represented features and their properties. However, current implementations of SPL lack effective means to configure a valid product as core assets specified in SPL, being high-dimensional data, are often too complex to analyse. This paper presents a time and cost effective methodology with associated tool supports to design a SPL model, analyse features, and configure a valid product. The proposed approach uses eXtensible Markup Language (XML) to model SPL, where an adequate schema is defined to precisely specify core assets. Furthermore, it enables automated product configuration by (i) extracting all the properties of required features from a given SPL model and calculating them with Alloy Analyzer; (ii) generating a decision model with appropriate eXtensible Stylesheet Language Transformation (XSLT) instructions embedded in each resolution effect; and (iii) processing XSLT instructions of all the selected resolution effects.
... The variants in this functional variation family correspond to different elaborations of a ballot-casting subprocess that are invoked in specific higher-level election process execution contexts. Note that each elaboration of the ballot-casting subprocess can be thought of 1 A direct parallel can be drawn between agents in a process and service providers in a system built using Service-Oriented Architecture principles. Hence, we also use the term Service Variation. ...
... Fea-tures closely correspond to the functional variation presented here. There are several approaches that focus on the problem-level specification of variation through features, such as using domain-specific feature graphs [9] or decision models [1]. Feature graphs and decision models tend to explicitly enumerate mandatory and optional features. ...
Conference Paper
A process model, namely a formal definition of the coordination of agents performing activities using resources and artifacts, can aid understanding of the real-world process it models. Moreover, analysis of the model can suggest improvements to the real-world process. Complex real-world processes, however, exhibit considerable amounts of variation that can be difficult or impossible to represent with a single process model. Such processes can often be modeled better, within the restrictions of a given modeling notation, by a family of models. This paper presents an approach to the formal characterization of some of these process families. A variety of needs for process variation are identified, and suggestions are made about how to meet some of these needs using different approaches. Some mappings of different needs for variability to approaches for meeting them are presented as case studies.
... A software component can be deployed independently and is subject to composition by third parties. There are several component-based methodologies Catalysis [41], KobrA [16], Fusion (Coleman 1993), OPEN process framework [54]. Flex-eWare [81] is model-driven solution for designing and implementing embedded distributed systems. ...
Thesis
Full-text available
Nowadays most organizations depend on Information and Communication Technologies (ICT) to perform their daily tasks (sometimes highly critical). However, in most cases, organizations and particularly small ones place limited value on information and its security. In the same time, achieving security in such systems is a difficult task because of the increasing complexity and connectivity in ICT development. In addition, security has impacts on many attributes such as openness, safety and usability. Thus, security becomes a very important aspect that should be considered in early phases of development. In this work, we propose an approach in order to secure ICT software architectures during their development by considering the aforementioned issues. The contributions of this work are threefold: (1) an integrated design framework for the specification and analysis of secure software architectures, (2) a novel model- and pattern-based methodology and (3) a set of supporting tools. The approach associates a modeling environment based on a set of modeling languages for specifying and analyzing architecture models and a reuse model repository of modeling artifacts (security pattern, threat and security property models) which allows reuse of capitalized security related know-how. The approach consists of the following steps: (a) model-based risk assessment performed on the architecture to identify threats, (b) selection and instantiation of security pattern models towards the modeling environment for stopping or mitigating the identified threats, (c) integration of security pattern models into the architecture model, (d) analysis of the produced architecture model with regards to other non-functional requirements and residual threats. In this context, we focus on real-time constraints satisfaction preservation after application of security patterns. Enumerating the residual threats is done by checking techniques over the architecture against formalized threat scenarios from the STRIDE model and based on existing threat references (e.g., CAPEC). As part of the assistance for the development of secure architectures, we have implemented a tool chain based on SEMCO and Eclipse Papyrus to support the different activities based on a set of modeling languages compliant with OMG standards (UML and its profiles). The assessment of our work is presented via a SCADA system (Supervisory Control And Data Acquisition) case study.
... Subsumed by C-iEPCs. The initial incarnation of the KobrA (Component-based Application Development) method [Atkinson et al. 2000] provides a mechanism to capture a family of process variants via a customizable process model. The purpose is that of customizing component-based software systems. ...
Article
Full-text available
It is common for organizations to maintain multiple variants of a given business process, such as multiple sales processes for different products or multiple bookkeeping processes for different countries. Conventional business process modeling languages do not explicitly support the representation of such families of process variants. This gap triggered significant research efforts over the past decade, leading to an array of approaches to business process variability modeling. In general, each of these approaches extends a conventional process modeling language with constructs to capture customizable process models. A customizable process model represents a family of process variants in a way that a model of each variant can be derived by adding or deleting fragments according to customization options or according to a domain model. This survey draws up a systematic inventory of approaches to customizable process modeling and provides a comparative evaluation with the aim of identifying common and differentiating modeling features, providing criteria for selecting among multiple approaches, and identifying gaps in the state of the art. The survey puts into evidence an abundance of customizable process-modeling languages, which contrasts with a relative scarcity of available tool support and empirical comparative evaluations.
... Figure 6 shows a comparison between FX-MAN and component models that define parametrised architectural templates. These models include: ADLARS [6], MontiArch HV [18], ∆MontiArc [19], KobrA [5], Mae [30],Plastic Partial Components [28], xADL2 [13], Koala [35], Com [27], and Kumbang [4]. Some of these models do not define variation points explicitly, and express variability by other means. ...
... Figure 6 shows a comparison between FX-MAN and component models that define parametrised architectural templates. These models include: ADLARS [6], MontiArch HV [18], ΔMontiArc [19], KobrA [5], Mae [30],Plastic Partial Components [28], xADL2 [13], Koala [35], Com [27], and Kumbang [4]. Some of these models do not define variation points explicitly, and express variability by other means. ...
Article
In software product line engineering, the construction of an ADL architecture for a product family is still an outstanding engineering challenge. An ADL architecture for a product family would define the architectures for all the products in the family, allowing engineers to reason at a higher level of abstraction. In this paper, we outline a component model that can be used to define architectures for product families, by incorporating explicit variation points.
... With its ability to reuse, this concept has recently been introduced in the field of engineering methods (Ralyté, 2001). • Product line: This approach aims at consolidating key software assets within a high-quality, reusable software core, and concentrate their resources on adapting this core to meet the changing needs of customers (Catkinson et al., 2000). ...
Article
Purpose – The purpose of this paper is to consider the method engineering perspective for service-oriented system engineering (SOSE). A number of SOSE methods have been proposed in both academia and industry. Given this, many intuitive, common questions arise. To answer these questions, many comparison frameworks have been developed. Each of which has considered certain methodological perspectives. However, less attention has been given to the method engineering (ME) perspective. The authors argue that this perspective would answer the question “what ME to apply in order to produce SOSE methods that themselves produce quality services at different levels of abstraction and SBAs”. This research question is further decomposed into other questions; the main one is “whether the existing ME do apply to service orientation”. Answering such a question would lead to either developing SOSE methods by using the existing ME or developing a new ME or framework for the specifics of SOSE. Design/methodology/approach – This work first provides a literature review on ME approaches and techniques; then, it compares a sample of existing SOSE methods with respect to their ME within a comparison framework that comprises a set of relevant properties of a solution that would be provided by an SOSE method, namely, service-oriented architecture (SOA) adoption, quality of services and ME; and finally, it discusses the applicability of the existing ME to SOSE. Findings – Strengths and weaknesses of the existing methods with respect to the aforementioned criteria, in addition to SOSE methodology open issues, were identified. The comparison has shown that while the existing SOSE methods have proved their success in a specific task, they still present some weaknesses. Therefore, it is better to benefit from the advantages of the existing ME techniques, notable method fragments, even if they need some alteration. Research limitations/implications – While this work has many open issues related to SOSE methods with respect to ME, it could be further developed in many directions by exploring the open issues. For instance, the generation of a new ME technique and application of this new ME technique to the existing SOSE methods to see to what extent the existing methods may be situational. Practical implications – This work has practical implications, as it provides a better understanding of different views of SOSE methods, and assists the method engineers in deciding which ME technique is most suitable to their situation. Social implications – The produced artifact provides a research roadmap toward SOSE ME. Originality/value – None of the existing comparison frameworks for SOSE methods has considered the criteria such as SOA adoption and ME techniques. Indeed, ME techniques and approaches would allow better reuse of the existing proven fragments of methods.
... Kobra is a component-oriented approach to develop a product line based on the UML features. This method integrated the two paradigms into a semantic, unified approach to software development and maintenance [15]. This method can be used to support the Model Driven Architecture [12]. ...
... Our tool for FX-MAN is implemented using a model driven approach [34]. Its implementation consists of a set of Eclipse plug-ins based on a powerful stack of model driven technologies, namely EMF [30], Xcore 2 , Graphiti 3 , Spray 4 and CDO. 5 The meta-model for FX-MAN was defined using EMF and its extended syntax Xcore; the latter being designed to overcome the inability of the EMF editor to implement behaviour. Instances of the model were created and edited using Graphiti, a modelling infrastructure for EMF. ...
Research
A Component Model for Defining Software Product Families with Explicit Variation Points.
... Various methodologies and approaches have been proposed to support the development of software systems based on product line development. Examples of these methodologies and approaches are FeatuRSEB [6], FAST [14], FORM [10], FODA [9], PuLSE [2], and KobrA [1]. ...
Article
Software product line has been recognised as an important paradigm for software systems engineering. In the last years, a large number of methodologies and approaches have been proposed to support the development of software systems based on product line development. However, its context leads difficulties to software product line engineering in practical. It has been quested whether software product line-based approach is more productive and flexible than traditional software development model i.e. waterfall model. This research thus examines the qualitative and quantitative aspects of software development which applies software product line and waterfall. The paper presents the study on empirical projects based on software product line and waterfall processes. In particular, we conducted the survey and interview to capture the satisfaction of stakeholders and measured the effort spent during software development and maintenance.
... The amalgamated approach proposes to augment the metamodel with variability concepts. In [Atkinson et al. 2000, Gomaa 2004, Ziadi and Jézéquel 2006, the authors extend the UML metamodel for modeling variability in multiple UML diagrams like Class or Sequence diagram. In [Morin et al. 2009b, Perrouin et al. 2010, the authors propose a more generic solution that can be applied to any kind of metamodel and fully supported by a tool. ...
... Product Line: Instead of continually "reinventing the wheel", or incorporating parts of "old" systems in an ad-hoc manner, organizations following a product line approach can consolidate their key software assets within a high-quality, reusable software core, and concentrate their resources on adapting this core to meet the changing needs of customers [19]. ...
... The testing capabilities of the testable component are turned off in the normal mode and they are turned on in the maintenance mode. Atkinson and Gross [9] proposed a BIT method integrated with the KobrA approach [19] to validate contracts between components and their users during deployment time. Lima et. ...
Conference Paper
Component-based applications can be composed by in-house or COTS (Commercial off-the-shelf) components. In many situations, reused components should be tested before their integration into an operational environment. Testing components is not an easy task because they are usually provided as black boxes and have low testability. Built-in Testing (BIT) is an approach devised to improve component testability by embedding testing facilities into software components usually to support specification-based testing.Such components are called testable components. There are situations, however, in which combining specification and program-based testing is desirable. This paper proposes a BIT technique designed to introduce testing facilities into software components at the provider side to support structural testing at the user side, even when the source code is unavailable. An implementation to generate testable components written in Java is also presented. The approach was firstly evaluated by an exploratory study conducted to transform COTS components into testable components.
... This encapsulation avoids some problems of annotation-based approaches, such as tangled and scattered feature code, and enables code reuse [6,21]. Composition-based approaches employ advanced programming concepts (such as component frameworks, plug-in architectures, aspect-oriented programming (AOP)) [8,17,47,48] or extend existing programming languages with featureoriented constructs (such as feature-oriented programming (FOP), delta-oriented programming (DOP)) [9,37,44]. Compared to annotation-based approaches, composition-based approaches require more learning effort [22]. ...
Conference Paper
Full-text available
In the context of single software systems, refactoring is commonly accepted to be the process of restructuring an existing body of code in order to improve its internal structure without changing its external behavior. This process is vital to the maintenance and evolution of software systems. Software product line engineering is a paradigm for the construction and customization of large-scale software systems. As systems grow in complexity and size, maintaining a clean structure becomes arguably more important. However, product line literature uses the term "refactoring" for such a wide range of reengineering activities that it has become difficult to see how these activities pertain to maintenance and evolution and how they are related. We improve this situation in the following way: i) We identify the dimensions along which product line reengineering occurs. ii) We derive a taxonomy that distinguishes and relates these reengineering activities. iii) We propose definitions for the three main branches of this taxonomy. iv) We classify a corpus of existing work.
... III. RELATED WORK In our knowledge, Feature-Oriented [3] [6] and Component-Based [4] [7] are the most cited approaches in product line architecture development. Both, Feature-oriented and Component-based develop their domain architecture differently, in the context of interaction between components. ...
Conference Paper
Full-text available
Product Line Architecture is the key success of Software Product Line Engineering. Product Line Architecture prepares the design of architectures for members of product line. Architecture design is the most essential activities of a Product Line Architecture development. It prepares the corner stone of variability decision. The architecture design need to produce specific architecture from product members' assets in a Software Product Line. Representing variability explicitly is the most challenging one. Moreover, the architecture must cope to the diversity of products, and take the behaviour into account. This paper introduces some approaches to address the architecture design problems. Features' grouping with specific concern is the starting point. Then, models the component and interaction element composition, based on its capability. This paper also introduces logics that link the interaction element and component. Using layers, the product line architecture can be established. Keywords— Software Architecture, Software Product Line, Product Line Architecture, Architecture Design. I. INTRODUCTION
... KobrA (KOmponentenBasieRte Anwendungsentwicklung) [32] is a general-purpose software engineering method for the development of component-based application frameworks. It is also a hierarchical component model in which every component, regardless of its position in the hierarchy, is treated using the same set of concepts -a complete system is a component and every component, if it has appropriate properties, can be considered a system. ...
... Decision models have been proposed to reduce the gap (e.g. [2,14,24]); they gather the links between variants and software assets. ...
Book
Many approaches to creating Software Product Lines have emerged that are based on Model-Driven Engineering. This book introduces both Software Product Lines and Model-Driven Engineering, which have separate success stories in industry, and focuses on the practical combination of them. It describes the challenges and benefits of merging these two software development trends and provides the reader with a novel approach and practical mechanisms to improve software development productivity. The book is aimed at engineers and students who wish to understand and apply software product lines and model-driven engineering in their activities today. The concepts and methods are illustrated with two product line examples: the classic smart-home systems and a collection manager information system.
Thesis
Le modèle économique du Cloud Computing, plus précisément dans sa couche applicative de services SaaS, a évolué vers une nouvelle approche basée sur l’exploitation des économies d’échelle. Ceci a pu être réalisé en offrant en même temps une unique instance d’application à plusieurs clients dénommés locataires, suivant le principe de mutualisation. L’objectif principal de ce principe à un niveau applicatif est de réduire les coûts opérationnels du service proposé et de capitaliser sur l’expérience cumulée à travers son partage. Cependant, sa mise en œuvre nécessite de relever un certain nombre de défis liés à sa structure organisationnelle, au sein de laquelle chaque locataire doit avoir l’impression d’utiliser une application qui lui est pleinement dédiée. Cela implique une gestion dynamique de la variabilité des besoins de locataires et une isolation stricte de leurs données. Dans cette thèse, nous nous intéressons à ce principe de mutualisation et aux principaux défis qui en découlent avant de proposer nos contributions. Celles-ci se résument en trois axes : (i) le premier concerne la spécification d’un méta-modèle de variabilité introduisant de nouveaux concepts de modélisation pour mieux traiter la variabilité et externaliser sa gestion sous forme d’un service. Nous avons pour cela introduit la notion de VaaS (Variability as a Service) comme un nouveau membre de la famille des services du Cloud. (ii) Le second axe consiste à étendre la politique de gestion par externalisation, initialement adoptée pour gérer la variabilité, afin de l’appliquer au niveau des données en proposant un système d’isolation de données sous forme d’un service. Le principal avantage de ce système est d’isoler les données de locataires d’une manière quasi-transparente aux développeurs, sans introduire de changements majeurs sur les architectures des applications existantes. (iii) Le dernier axe concerne le regroupement des deux premières contributions ainsi que d’autres services liés à l’administration et à la sécurité des applications mutualisées dans une plateforme dédiée, vers une approche globale de gestion de ce type d’applications par externalisation.
Thesis
Full-text available
Our society has become more dependent on software-intensive systems, such as Information and Communication Technologies (ICTs) systems, to perform their daily tasks (sometimes critical). However, in most cases, organizations and particularly small ones place limited value on information and its security. In the same time, achieving security in such systems is a difficult task because of the increasing complexity and connectivity in ICT development. In addition, security has impacts on many attributes such as openness, safety and usability. Thus, security becomes a very important aspect that should be considered in early phases of development. In this work, we propose an approach in order to secure ICT software architectures during their development by considering two visions to formulate security statements using the negative view, as the study of threats (e.g., usurpation) and positive view as the study of the security objectives (e.g., confidentiality). The contributions of this work are threefold: (1) an integrated design framework for the specification and analysis of reusable (formal) model libraries for secure software architectures; (2) a novel model-based methodology for developing secure software architecture by reuse; and (3) a set of supporting tools. The approach associates Model-Driven Engineering (MDE) and formal techniques to design a set of modeling languages for specifying and analyzing architecture and property models which allows reuse of capitalized security-related know-how. The results are provided as two complementary artifacts: (a) a process of development of reusable formal model libraries for the specification and verification of security threats and objectives by a security expert; and (b) a process of secure architectural design and analysis by an architect reusing the libraries specified in the process (a). Process (a) includes the following activities: (1) the formal specification of the security threats and objectives as the properties of a model using technology-independent specification language; (2) the interpretation of the resulted model libraries in a tooled formal language; and (3) the definition of security policies as abstract security countermeasures to ensure security properties. Process (b) includes the following activities: (1) security analysis of a concrete architecture model to verify the security requirements and identify security issues reusing the property models; [...]
Conference Paper
Full-text available
ASELSAN'da gerçekleştirilen bir Yazılım Ürün Hattı Alan Mühendisliği Çalışması
Thesis
Full-text available
The work presented in this thesis takes place in the component-based development domain, it is a contribution to the specification,adaptation and verification of component-based systems. The main purpose of this thesis is the proposition of a formal approach tobuild incrementally complex systems by assembling and adapting a set of components, where their structure and behaviour are modelledusing SysML diagrams. In the first stage, we have defined a meta-model driven approach which is based on meta-modelling and modelstransformation, to verify the compatibility of blocks having their interaction protocols modelled using SysML sequence diagrams. To verifytheir compatibility, we perform a transformation into interface automata (IAs), and we base on the optimistic approach defined on IAs. Thisapproach consider that two components are compatible if there is a suitable environment with which they can interact correctly. Afterthat, we have proposed to benefit from the hierarchy, that may be present in the interaction protocol models of the blocks, to alleviate theverification of blocks compatibility. In the next stage, we have taken into consideration the problem of names mismatches of type one2onebetween services of blocks. At this stage, an adapter is generated for a set of reused blocks which have their interaction protocols modelledformally by interface automata. The generation of the adapter is guided by the specification of the parent block which is made initiallyby the designer. Our approach is completed by a verification phase which allows us to verify SysML requirements, expressed formallyby temporal properties, on SySML blocks. In this phase, we have exploited only the generated adapters to verify the preservation of therequirements initially satisfied by the reused blocks. Thus, our approach intends to give more chance to avoid the state space explosionproblem during the verification. In the same context, where we have a set of reused blocks and the specification of their parent blocks, wehave proposed to use coloured Petri nets (CPNs) to model the blocks interactions and to generate adapters that solve more type of problems.In this case the adapter can solve the problem of livelock by enabling the reordering of services calls.
Conference Paper
The development of cyber-physical systems such as highly integrated, safety-relevant automotive functions is challenged by an increasing complexity resulting from both customizable products and numerous soft- and hardware variants. In order to reduce the time to market for scenarios like these, a systematic analysis of the dependencies between functions, as well as the functional and technical variance, is required (cf. ISO 26262). In this paper we introduce a new approach which allows for a compact representation and analysis of failure mechanisms of systems marked by numerous variants, also: Product Line Fault Tree (PLFTs), in a unified data structure based on Multi-valued Decision Diagram (MDDs). Therefore, instead of analyzing the Fault Tree (FT) of each variant separately, the proposed method enables one to analyze the FT in a single step. Summing up, this article introduces a systematic modeling concept to analyze fault propagation in variant-rich systems.
Conference Paper
Full-text available
Software architecture derivation and evaluation are complex and error prone activities that still represent an open problem with many challenges and opportunities where model-driven software development can play a leading role. In software product line development, the use of model-driven principles could help by providing a richer semantic representation of a product line and by capturing the architectural design decisions and its impact on the product quality attributes. In this chapter, we analyze the main challenges and opportunities surrounding the product architecture derivation and evaluation and introduce QuaDAI, a method for the derivation, evaluation, and improvement of product architectures in model-driven software product line development environments. The method comprises a multimodel, which represents the different viewpoints of a software product line, and a process conducted by model transformations that automate the derivation, evaluation, and improvement of product architectures.
Chapter
Green specifications provide a foundation for reducing the environmental impact of computing applications and improving the consumption behavior of users by providing a clear and precise specification of the environmental impact of specific services. They can either be used to specify the actual behavior and environmental impact of existing services or to define the requirements that a to-be-built service must fulfill. Green specifications describe the properties of a service from distinct viewpoints such as a structural viewpoint which describes the data types and external components that the service uses, a functional viewpoint which describes the effects of the service's operations using pre- and post- conditions and a behavioral viewpoint which describes the externally visible states and transitions exhibited by the service. These are augmented with non-functional information describing the environmental properties of, or constraints on, the service. In this chapter we provide an introduction to green specifications and give a concrete example of their use to specify a Video on Demand (VoD) service.
Conference Paper
The HATS project aims at developing a model-centric engineering methodology for the design, implementation and verification of distributed, concurrent and highly configurable systems. Such systems also have high demands on their dependability and trustworthiness. The HATS approach is centered around the Abstract Behavioural Specification modelling language (ABS) and its accompanying tools suite. The HATS approach allows the precise specification and analysis of the abstract behaviour of distributed software systems and their variability. The HATS project measures its success by applying its framework not only to toy examples, but to real industrial scenarios. In this paper, we evaluate the HATS approach for modelling an industrial scale case study provided by the eCommerce company Fredhopper. In this case study we consider Fredhopper Access Server (FAS). We model the commonality and variability of FAS’s replication system using the ABS language and provide an evaluation based on our experience.
Conference Paper
Full-text available
According to state of the art literature, software product lines are an effective way to achieve economies of scale through reusability while coping with the problem of variability in related software systems. Fundamentals of variability management and product lines have been available in the software engineering research field for several decades. Nevertheless, projects to cope with variability in practice tend to fall short of target. The reason for this gap between sound theories and poor practice, common in multiple software engineering subfields, remains unclear. Therefore, an empirical study was conducted in a large-scale software dependent multinational. The results of this case study show a number of factors that impact successful variability practice. These factors can be abstracted into general hypotheses useful for bridging the gap between theory and practice. Based on the sources of discrepancy, this research suggests a practical way to overcome the obstacles on the road towards successful variability management.
Conference Paper
Product line engineering a very new engineering method evolved in few past years has proven a very best technique of producing products at rapid way using the concept Reuse of assets, artifacts, and components. Software Product Lines and Software Architectures combined to form a Product Line Architecture (PLA). Many researchers have work on PLA producing different views and experiences. Architectural smells a way of accessing the PLAs, means the identification of bad smells in context of architectures formed using product line. 'Why these smells occur' is briefly described and also identification has also been shown using analytical and manual analysis. These smells can be remedied but the process is too large to follow, though small systems can be easily remedied or re-factored using various techniques. Architectural smells are remedied by changing the structure and the behaviors of the internal system elements without changing the external behavior of the system. This paper describes MobileMedia Feature Model creation, Component Model creation as PLA for the assessment of Bad smells.
Article
Software products are rarely developed without providing different sets of features to better meet varying user needs, whether through tiered products as part of a product line or different subscription levels for software as a service (SaaS). Software product line approaches for generating and maintaining a family of different variants of software products address such needs for variation quite well. Real-world human-intensive systems (HISs) display similar needs for families of variants. A key contribution of this paper is to show how many of these needs can be rigorously and systematically addressed by adapting established techniques from system and software product line engineering (SPLE). In this paper, we present an approach for creating such families by explicitly modeling variation in HISs. We focus on two kinds of variation we have previously described in other work---functional detail variation and service variation. We describe a prototype system that is able to meet the need for these kinds of variation within an existing modeling framework and present a case study of the application of our prototype system to generate a family in an HIS from the domain of elections. Our approach also demonstrates how to perform model-checking of this family to discover whether any variants in the family may violate specified system requirements.
Article
Many tools have been developped in order to manage the complexity of the software and of the software development projects. However, using these tools is the source of manual recurrent tasks that are error prone and time consuming. Automating these tasks enables to improve the productivity. But the difficulties are i) to determine when the automation of a manual recurrent task must be used, and ii) to create automations that are reusable across their different use cases. We propose a tool-supported approach that drives the reuse of the automations of the manual recurrent tasks by software processes. A software process defines the sequence of steps to perform in order to realize a software engineering project. This approche consists of capitalizing on a set of software processes and of reusing processes from this set according to projects' requirements and independently of the formalism used to define the processes. The automations of the manual recurrent tasks are bound to the processes' steps they automate. This binding enables to know which automations to reuse for a specific project and when to reuse these automations during the project. This binding also enables to explicit the different use cases of each automation. We use this information to create automations that are reusable across their different use cases. We applied this tool-supported approach on a family of Java development processes coming from the industry as well as on a family of processes consisting of designing and implementing a modeling language.
Conference Paper
The emergence of the paradigms Service Orientation (SO) and Service Oriented Computing (SOC) has resulted in new types of applications, referred to as Service Based Applications. This has entailed many service oriented methods for developing such kinds of applications. In this paper, we first present most of the well-known methods from academia and industry, focusing on their engineering approaches and comparison frameworks. Then we highlight their strengths and weaknesses. Finally, we introduce the elements of a comprehensive framework to guide the engineering of new methods or benchmarking the existing ones.
Thesis
Full-text available
Una arquitectura de referencia es un instrumento que influye en el diseño de los modelos arquitectónicos en que se basa la construcción de nuevos sistemas y que permite conservar y transmitir las mejores prácticas de la organización en aspectos de ingeniería de software. En esta investigación se propone una metodología que permite generar una arquitectura de software que una vez que ha probado ser útil se generaliza y enriquece para establecer un modelo arquitectónico de referencia que sirve como base para la creación de nuevos sistemas dentro del mismo dominio. La metodología constituye un proceso iterativo de ingeniería hacia adelante que sirve para construir modelos arquitectónicos de referencia que evolucionan de manera permanente y extienden sus beneficios a diferentes soluciones. Así mismo, mediante la extracción de arquitecturas de referencia se aprovecha la retroalimentación que se obtiene de la aplicación de modelos arquitectónicos en la construcción de sistemas. Se considera que los sistemas conceptualizados bajo esta metodología por lo general se integran a ambientes computacionales heterogéneos en los que se cuenta con programas de software diseñados bajo diferentes tecnologías y enfoques, sometidos a fuerzas evolutivas que les han transformado a lo largo del tiempo. En la investigación se ha reconocido que algunos de los sistemas que se encuentran en una gran cantidad de organizaciones son heredados, por lo que su adaptación para satisfacer nuevas necesidades es costosa y difícil; sin embargo, son sistemas que la metodología toma en cuenta como parte de una situación real en la que las nuevas soluciones de software deben desempeñarse. Al tomar en cuenta la integración de sistemas heredados se establece un marco de trabajo que facilita su evolución y reemplazo gradual, además de disminuir el re-trabajo manual que actualmente es requerido para transportar la información entre sistemas que requieren interactuar.
Article
Full-text available
In the e-learning systems the usage of web services and software agents are very promising. E-learning systems are often not addressing fundamental business objectives and are not being rigorously evaluated. E-learning is being approached as a technical solution rather than a business solution. In this contribution we investigate and implement a methodology for web service execution measurement from an educational organization perspective. In nearest future in the web will exist a lot of web services and it will be common that we have to choose one or some from them. In this case we need a framework that enables the definition of web services from performance measurement perspective. This framework uses web service concepts and software agent's technologies to enable feedback on the educational organization's performance measures through the analysis of the web services.
Article
Current approaches for reducing IT's environmental impact typically are generic and rarely take into account services' actual functionality. To develop more powerful, service-specific strategies for reducing IT's carbon footprint, we need more complete and widely understandable specifications that describe exactly a service's functionality, the level of quality it achieves, and its environmental consequences. Such green specifications will allow more stakeholders involved in the delivery and consumption of IT services to understand their detailed functionality and the tradeoffs between quality of service and environmental impact entailed in their use. This will not only increase the opportunities for optimizing the delivery of services but also provide the foundation for new business models that encourage users to make greener consumption choices.
Conference Paper
Configurable process models can be used to provide information on business processes for different user groups in an appropriate and efficient manner. It promotes the reuse of proven practices by providing analysts with a generic modeling artifact from which to derive individual process models. Before a configurable business process being configured into a concrete business process model, the variability points of the configurable business process need to be identified. The decision on how to bind these variation points boils down to the users' requirements and needs. Given the specified requirements of the users, the configurable business process can be configured. In the paper, we propose a framework for carrying out automatic service-based business process configuration by using SWRL based business rules. We design and implement a variation point ontology, in which the guidelines of variable points are presented by SWRL rules. We also summarize a set of domain-specific business rules too, thus we can use these domain-specific rules to get the specific rules needed to meet users' requirements. We exploit domain ontology as knowledge base and rules as guideline to configure business process, for the purpose of individual configuration. Then we employ a configuration algorithm to configure a configurable business process depending on the reference result we obtain. The approach is validated by a case study from the domain of the urban logistics distribution.
Article
Full-text available
Economies of scale can be seen as some kind of holy grail in state of the art literature on the development of sets of related software systems. Software product line methods are often mentioned in this context, due to the variability management aspects they propose, in order to deal with sets of related software systems. They realize the sought-after reusability. Both variability management and software product lines already have a strong presence in theoretical research for several decades, but in real-life software product line projects trying to obtain economies of scale still tend to fall short of target. The objective of this paper is to study this gap between theory and reality through an empirical case study in order to see why such gap exists, and to find a way to bridge this gap. Through analysis of the causes of failure identified by the stakeholders in the case study, the underlying problem, which is found to be located in the requirements engineering phase, is crystallized. The identification of a framework describing the problems will provide practitioners with a better focus for future endeavors in the field of software product lines, so that economies of scale can be achieved.
Conference Paper
Software product lines (SPL) processes are gradually being adopted by many companies in several domains. A particular domain where the adoption of such processes may bring relevant benefits is the mobile applications domain given the big diversity of handsets, although the characteristics of this domain usually create barriers to apply these processes in practice, such as, restrictions of memory size and processing power and different API implementations by different manufacturers. In this context, this work presents briefly a practical approach to implement core assets in a SPL applied to the mobile game domain combining the good practices from the already published processes and describes in details a case study performed with the application of this approach, based on three different adventure mobile games. The results of the case study have shown the approach can be suitable for the domain in question.
Conference Paper
Domain engineering is the first phase of product line engineering. The key artefact created by domain engineering for product engineering is a reference architecture for all possible systems or products in the domain. In existing domain engineering techniques, there are no well-defined methods for constructing reference architectures. Existing domain engineering tools mostly stop short of constructing reference architectures. In this paper, we show how a component-based approach to domain engineering can provide a remedy.
Conference Paper
The software product line (SPL) engineering aims at producing reusable software-intensive systems at lower cost, in shorter time and with high quality. Modeling SPLs is a key concept for reuse: It allows stakeholders to describe commonalities and differences within a family of products. However modeling large-scale SPLs is complex and tedious. Therefore we advocate distributing the modeling task among different teams, each working on a partial model. At the end, it is obviously necessary to merge models designed by different team members in order to obtain the global model. In this paper, we propose a signature-based approach to merge UML composite structures of software product lines. UML2 composite structures are good alternative for modeling SPLs. They provide mechanisms for defining reusable "pieces" of the design. We also specify a set of significant properties to be considered when merging the SPL models and show how to preserve them.
Article
Software product line engineering practices offer desirable characteristics such as rapid product development, reduced time-to-market, and more affordable development costs as a result of systematic representation of the variabilities of a domain of discourse that leads to methodical reuse of software assets. The development lifecycle of a product line consists of two main phases: domain engineering, which deals with the understanding and formally modeling of the target domain, and application engineering that is concerned with the configuration of a product line into one concrete product based on the preferences and requirements of the stakeholders. The work presented in this paper focuses on the application engineering phase and builds both the theoretical and technological tools to assist the stakeholders in (a) understanding the complex interactions of the features of a product line; (b) eliciting the utility of each feature for the stakeholders and hence exposing the stakeholders’ otherwise implicit preferences in a way that they can more easily make decisions; and (c) dynamically building a decision model through interaction with the stakeholders and by considering the structural characteristics of software product line feature models, which will guide the stakeholders through the product configuration process. Initial exploratory empirical experiments that we have performed show that our proposed approach for helping stakeholders understand their feature preferences and its associated staged feature model configuration process is able to positively impact the quality of the end results of the application engineering process within the context of the limited number of participants. In addition, it has been observed that the offered tooling support is able to ease the staged feature model configuration process.
Article
Full-text available
The Internet has radically changed the way in which we learn and teach. E-learning systems are often not addressing fundamental business objectives and are not being rigorously evaluated. E-learning is being approached as a technical solution rather than a business solution. In this paper we investigate and implement a methodology for web service execution measurement from an educational organization perspective. In nearest future in the web will exist a lot of web services and it will be common that we have to choose one or some from them. For example in the case of tutorial systems we have to choose among various tutorial services according to the profile of the learner. In this case we need a regular component for the multi-criteria decision analysis of the learner profile. This component can be adaptive and have also some learning features.
Article
One of the challenges of the Software Product Line Architecture design is how to model and present the differences of the member products. Many approaches have been introduced, such as FORM, FODA, KobrA etc. In this paper, we propose an approach to transform feature models into architecture models. This iterative approach explicitly models the variability presented in the feature model into architectural artifacts and transfers the feature dependencies into the interactions between the architectural artifacts in the architecture model. The approach improves the traceability between the feature models and architecture models, thus provide better guidance for the architecture development of the member product in Software Product Lines.
Article
Full-text available
Modern software systems must support a high degree of variability to accommodate a wide range of requirements and operating conditions. This paper introduces the Abstract Behavioural Specification (ABS) language and tool suite, a comprehensive platform for developing and analysing highly adaptable distributed concurrent software systems. The ABS language has a hybrid functional and object- oriented core, and comes with extensions that support the development of systems that are adaptable to diversified requirements, yet capable to maintain a high level of trustworthiness. Using ABS, system variability is consistently traceable from the level of requirements engineering down to object behaviour. This facilitates temporal evolution, as changes to the required set of features of a system are automatically reflected by functional adaptation of the system’s behaviour. The analysis capabilities of ABS stretch from debugging, observing and simulating to resource analysis of ABS models and help ensure that a system will remain dependable throughout its evolutionary lifetime. We report on the experience of using the ABS language and the ABS tool suite in an industrial case study.
Conference Paper
Full-text available
Development of Web-based Geographical Information Systems (WebGIS) is mainly done by Small Enterprises which usually employ Open Source Software (OSS) components. The number and complexity of requirements for these Information Systems has exploded during the last years due to the technological advances. In addition, enterprises working on WebGIS must carry out intensive software development within short time frames. This situation is claiming for an improvement of their software development processes so that both the time to market and costs can be reduced. In this paper, we present the situation of a research-in-progress performed by one of these SMEs working on WebGIS. Software Product Line approach has emerged as a promising solution to face the problems due to the situation in the WebGIS domain. We have also detected that modeling tools can help WebGIS developers to reduce the time to market and cost of their developments and, at the same time, offer a quality warranty and more robust ISs. We have started a Software Process Improvement and its first steps have been taken whose results are presented here.
Conference Paper
Reuse of fault trees helps in reducing costs and effort when conducting Fault Tree Analyses (FTAs) for a set of similar systems. Some approaches have been proposed for the systematic reuse of fault trees along with the development of a product line of systems. Nevertheless, these approaches are not longer effective when FTAs are performed after systems have been put into operation. This is mainly due to the lack of product line information required to make fault trees reusable. The model proposed in this paper is a step towards systematically reusing fault trees in the aforementioned context. It acts as an intermediate model between the specification of a system and its corresponding Component Fault Tree (CFT). In particular, it abstracts from the implementation details of a CFT, allowing the integration of variability inherent of product line systems as well as the one obtained from performing fault tree analyses incrementally over time. The model is part of a systematic reuse approach. KeywordsComponent Fault Trees-Variability Management-Fault Tree Analysis-Product Line Engineering-Safety and Reliability
Conference Paper
The idea of building software systems from semi-autonomous components that can be reused in numerous applications is intuitively appealing. However, simply organizing software systems in terms of components does not by itself ensure that the components will be reusable, or that significant levels of reuse will actually occur. In practice, to achieve meaningful levels of reuse the scope and generality of components must be carefully analyzed and optimized. In this paper we make the case that one of the most effective and systematic ways of achieving this is to complement component-based development with product line engineering techniques. Product line engineering not only provides concrete criteria for maximizing the reusability of components, but also provides enhanced mechanisms for reusing them within new applications. After first outlining the pertinent features of component-based development and product line engineering, the paper explains how they can be integrated under the umbrella of a model-driven architecture (MDA) approach to software development.
Conference Paper
Software Product Line (SPL) approaches motivate the development and implementation of a flexible and adaptable architecture to enable software reuse in organizations. The SPL architecture addresses a set of common and variable features of a family of products. Based on this architecture, products can be derived in a systematic way. A multi-agent system product line (MAS-PL) defines a SPL architecture, whose design and implementation is accomplished using software agents to address its common and variable features. This paper presents the evolutionary development of a MAS-PL from an existing web-based system. The MAS-PL architecture developed is composed of: (i) the core architecture represented by the web-based system that addresses the main mandatory features; and (ii) a set of software agents that extends the core architecture to introduce in the web system new optional and alternative autonomous behavior features. We report several lessons learned from this exploratory study of definition of a MAS-PL.
Conference Paper
A major challenge for software reuse is developing components that can be reused in several applications. This paper describes a systematic method for providing components that can be extended through variation points, as initially specified in the software requirements. Allowing the reuser or application engineer to extend components at pre-specified variation points creates a more flexible set of components. The existing variation point methods do not provide enough design detail for the reuser. This paper introduces a method called the Variation Point Model (VPM), which models variation points at the design level, beginning with the common requirements.
ResearchGate has not been able to resolve any references for this publication.