Supporting collaborative grid application development within the escience community

The systemic representation and organisation of software artefacts, e.g. specifications, designs, interfaces, and implementations, resulting from the development of large distributed systems from software components have been addressed by our research within the Practitioner and AMES projects [1,2,3,4]. Without appropriate representations and organisations, large collections of existing software are not amenable to the activities of software reuse and software maintenance, as these activities are likely to be severely hindered by the difficulties of understanding the software applications and their associated components. In both of these projects, static analysis of source code and other development artefacts, where available, and subsequent application of reverse engineering techniques were successfully used to develop a more comprehensive understanding of the software applications under study [5,6]. Later research addressed the maintenance of a component library in the context of component-based software product line development and maintenance [7]. The classic software decompositions, horizontal and vertical, proposed by Goguen [8] influenced all of this research. While they are adequate for static composition, they fail to address the dynamic aspects of composing large distributed software applications from components especially where these include software services. The separation of component co-ordination concerns from component functionality proposed in [9] offers a partial solution

Abstract delta modeling : software product lines and beyond

To prevent a large software system from collapsing under its own complexity, its code needs to be well-structured. Ideally we want all code related to a certain feature to be grouped together __called feature modularization__ and code belonging to different features not to mix __ called separation of concerns. But many concerns are known as 'cross-cutting concerns'. By their very nature their implementation needs to be spread around the code base. The software engineering discipline that has the most to gain from those properties is Software Product Line Engineering. It is concerned with the development and maintenance of multiple software systems at the same time, each possessing a different (but often overlapping) set of features. This gives rise to an additional need: The code for a given feature must not only be separated and modular; it also needs to be composable and able to deal gracefully with the presence or absence of other features. This thesis presents Abstract Delta Modeling, a formal framework developed to achieve these goals in software. The thesis is a product of the European HATS project. It formalizes the techniques of delta modeling, the main approach to variability used by HATSAlgorithms and the Foundations of Software technolog

The Feature-Architecture Mapping Method for Feature-Oriented Development of Software Product Lines

Software Produktlinien sind die Antwort von Software Engineering auf die zu-nehmende Komplexität und kürzerenProdukteinführungszeiten von heutigen Softwaresystemen. Nichtsdestotrotz erfordern Software Produktlinien einefortgeschrittene Wartbarkeit und hohe Flexibilität. Das kann durch die angemessene Trennung der Belange erreicht werden.Merkmale stellen die Hauptbelange im Kontext von Software Produktlinien dar. Demzufolge sollte ein Merkmal idealerweise ingenau einer Architekturkomponente implementiert werden. In der Praxis ist das jedoch nicht immer machbar. Deshalb solltezumindest ein starkes Mapping zwischen Merkmalen und der Architektur bestehen. Die Methoden zur Entwicklung von SoftwareProduktlinien, die dem Stand der Technik entsprechen, führen zu bedeutender Verstreutheit und Vermischung von Merkmalen. Indieser Arbeit wird die Feature-Architecture Mapping (FArM) Methode entwickelt, um ein stärkeres Mapping zwischen Merkmalenund der Produktlinien-Architektur zu erzielen. Der Input für FArM besteht in einem initialen Merkmalmodell, das anhand einerMethode zur Domänenanalyse erstellt wurde. Dieses initiale Merkmalmodell wird einer Serie von Transformationen unterzogen.Die Transformationen streben danach, ein Gleichgewicht zwischen der Sichtweise von Kunden und Softwarearchitekteneinzustellen. Die Merkmalinteraktionen werden während der Transformationen ausdrücklich optimiert. Von jedem Merkmal destransformierten Merkmalmodells wird eine Architekturkomponente abgeleitet. Die Architekturkomponenten implementieren dieApplikationslogik der entsprechenden Merkmale. Die Kommunikation zwischen den Komponenten spiegelt die Interaktion zwischenden Merkmalen wider. Dieser Ansatz führt im Vergleich zu den Produktlinien-Entwicklungsmethoden des Stands der Technik zueinem stärkeren Mapping zwischen Merkmalen und der Architektur und zu einer höheren Variabilität auf Merkmalebene. DieseEigenschaften haben eine bessere Wartbarkeit und eine vereinfachte generative Produktinstanzierung zur Folge, was wiederumdie Flexibilität der Produktlinien steigert. FArM wurde durch ihre Anwendung in einigen Domänen evaluiert, z.B. in denDomänen von Mobiltelefonen und Integrierten Entwicklungsumgebungen (IDEs). Diese Arbeit wird FArM anhand einer Fallstudie inder Domäne von Künstlichen Neuronalen Netzwerken präsentieren.Software product lines are the answer of software engineering to the increasing complexity and shorter time-to-market ofcontemporary software systems. Nonetheless, software product lines demand for advanced maintainability and high flexibility.The latter can be achieved through the proper separation of concerns. Features pose the main concerns in the context ofsoftware product lines. Consequently, one feature should ideally be implemented into exactly one architectural component. Inpractice, this is not always feasible. Therefore, at least a strong mapping between features and the architecture mustexist. The state of the art product line development methodologies introduce significant scattering and tangling offeatures. In this work, the Feature-Architecture Mapping (FArM) method is developed, to provide a stronger mapping betweenfeatures and the product line architecture. FArM receives as input an initial feature model created by a domain analysismethod. The initial feature model undergoes a series of transformations. The transformations strive to achieve a balancebetween the customer and architectural perspectives. Feature interaction is explicitly optimized during the feature modeltransformations. For each feature of the transformed feature model, one architectural component is derived. Thearchitectural components implement the application logic of the respective features. The component communication reflectsthe feature interaction. This approach, compared to the state of the art product line methodologies, allows a strongerfeature-architecture mapping and for higher variability on the feature level. These attributes provide highermaintainability and an improved generative approach to product instantiation, which in turn enhances product lineflexibility. FArM has been evaluated through its application in a number of domains, e.g in the mobile phone domain and theIntegrated Development Environment (IDE) domain. This work will present FArM on the basis of a case study in the domain ofartificial Neural Networks

Towards Multi-View Feature-based Configuration

Abstract. [Context & motivation] Variability models, feature diagrams ahead, have become commonplace in software product line engineering as a means to document variability early in the lifecycle. Over the years though, their appli-cation span has been extended to aid stakeholders in the configuration of soft-ware products. [Question/problem] However, current feature-based configura-tion techniques hardly support the tailoring of configuration views to the profiles of heterogeneous stakeholders. [Principal ideas/results] In this paper, we intro-duce a lightweight mechanism to leverage multidimensional separation of con-cerns in feature-based configuration. [Contribution] We propose a technique to specify concerns in feature diagrams and to build automatically concern-specific configuration views, which come with three alternative visualisations.

MUSA: A Scalable Multi-Touch and Multi-Perspective Variability Management Tool

Variability management is one of the main activities in the Software Product Line Engineering process. Common and varied features of related products are modelled along with the dependencies and relationships among them. With the increase in size and complexity of product lines and the more holistic systems approach to the design process, managing the ever- growing variability models has become a challenge. In this paper, we present MUSA, a tool for managing variability and features in large-scale models. MUSA adopts the Separation of Concerns design principle by providing multiple perspectives to the model, each conveying different set of information. The demonstration is conducted using a real-life model (comprising of 1000+ features) particularly showing the Structural View, which is displayed using a mind-mapping visualisation technique (hyperbolic trees), and the Dependency View, which is displayed graphically using logic gates

Integrating the common variability language with multilanguage annotations for web engineering

Web applications development involves managing a high diversity of files and resources like code, pages or style sheets, implemented in different languages. To deal with the automatic generation of custom-made configurations of web applications, industry usually adopts annotation-based approaches even though the majority of studies encourage the use of composition-based approaches to implement Software Product Lines. Recent work tries to combine both approaches to get the complementary benefits. However, technological companies are reticent to adopt new development paradigms such as feature-oriented programming or aspect-oriented programming. Moreover, it is extremely difficult, or even impossible, to apply these programming models to web applications, mainly because of their multilingual nature, since their development involves multiple types of source code (Java, Groovy, JavaScript), templates (HTML, Markdown, XML), style sheet files (CSS and its variants, such as SCSS), and other files (JSON, YML, shell scripts). We propose to use the Common Variability Language as a composition-based approach and integrate annotations to manage fine grained variability of a Software Product Line for web applications. In this paper, we (i) show that existing composition and annotation-based approaches, including some well-known combinations, are not appropriate to model and implement the variability of web applications; and (ii) present a combined approach that effectively integrates annotations into a composition-based approach for web applications. We implement our approach and show its applicability with an industrial real-world system.Universidad de Málaga. Campus de Excelencia Internacional Andalucía Tech

Towards an aspect weaving BPEL engine

This position paper proposes the use of dynamic aspects and the visitor design pattern to obtain a highly configurable and extensible BPEL engine. Using these two techniques, the core of this infrastructural software can be customised to meet new requirements and add features such as debugging, execution monitoring, or changing to another Web Service selection policy. Additionally, it can easily be extended to cope with customer-specific BPEL extensions. We propose the use of dynamic aspects not only on the engine itself but also on the workflow in order to tackle the problems of Web Service hot deployment and hot fixes to long running processes. In this way, composing aWeb Service "on-the-fly" means weaving its choreography interface into the workflow

Towards Product Lining Model-Driven Development Code Generators

A code generator systematically transforms compact models to detailed code. Today, code generation is regarded as an integral part of model-driven development (MDD). Despite its relevance, the development of code generators is an inherently complex task and common methodologies and architectures are lacking. Additionally, reuse and extension of existing code generators only exist on individual parts. A systematic development and reuse based on a code generator product line is still in its infancy. Thus, the aim of this paper is to identify the mechanism necessary for a code generator product line by (a) analyzing the common product line development approach and (b) mapping those to a code generator specific infrastructure. As a first step towards realizing a code generator product line infrastructure, we present a component-based implementation approach based on ideas of variability-aware module systems and point out further research challenges.Comment: 6 pages, 1 figure, Proceedings of the 3rd International Conference on Model-Driven Engineering and Software Development, pp. 539-545, Angers, France, SciTePress, 201

Early aspects: aspect-oriented requirements engineering and architecture design

This paper reports on the third Early Aspects: Aspect-Oriented Requirements Engineering and Architecture Design Workshop, which has been held in Lancaster, UK, on March 21, 2004. The workshop included a presentation session and working sessions in which the particular topics on early aspects were discussed. The primary goal of the workshop was to focus on challenges to defining methodical software development processes for aspects from early on in the software life cycle and explore the potential of proposed methods and techniques to scale up to industrial applications