Pattern-Based Development of Domain-Specific Modelling Languages

Personal use of this material is permitted. Permission from IEEE must be obtained for all other uses, in any current or future media, including reprinting/republishing this material for advertising or promotional purposes, creating new collective works, for resale or redistribution to servers or lists, or reuse of any copyrighted component of this work in other works. A. Pescador, A. Garmendia, E. Guerra, J. Sánchez Cuadrado and J. de Lara, "Pattern-based development of Domain-Specific Modelling Languages," Model Driven Engineering Languages and Systems (MODELS), 2015 ACM/IEEE 18th International Conference on, Ottawa, ON, 2015, pp. 166-175. doi: 10.1109/MODELS.2015.7338247Model-Driven Engineering (MDE) promotes the use of models to conduct all phases of software development in an automated way. Models are frequently defined using Domain- Specific Modelling Languages (DSMLs), which many times need to be developed for the domain at hand. However, while constructing DSMLs is a recurring activity in MDE, there is scarce support for gathering, reusing and enacting knowledge for their design and implementation. This forces the development of every new DSML to start from scratch. To alleviate this problem, we propose the construction of DSMLs and their modelling environments aided by patterns which gather knowledge of specific domains, design alternatives, concrete syntax, dynamic semantics and functionality for the modelling environment. They may have associated services, realized via components. Our approach is supported by a tool that enables the construction of DSMLs through the application of patterns, and synthesizes a graphical modelling environment according to them.Work supported by the Spanish MINECO (TIN2011-24139 and TIN2014-52129-R), the R&D programme of the Madrid Region (S2013/ICE-3006), and the EU commission (FP7-ICT-2013-10, #611125)

Conceptual development of custom, domain-specific mashup platforms

Despite the common claim by mashup platforms that they enable end-users to develop their own software, in practice end-users still don't develop their own mashups, as the highly technical or inexistent user bases of today's mashup platforms testify. The key shortcoming of current platforms is their general-purpose nature, that privileges expressive power over intuitiveness. In our prior work, we have demonstrated that a domainspecific mashup approach, which privileges intuitiveness over expressive power, has much more potential to enable end-user development (EUD). The problem is that developing mashup platforms - domain-specific or not - is complex and time consuming. In addition, domain-specific mashup platforms by their very nature target only a small user basis, that is, the experts of the target domain, which makes their development not sustainable if it is not adequately supported and automated. With this article, we aim to make the development of custom, domain-specific mashup platforms costeffective. We describe a mashup tool development kit (MDK) that is able to automatically generate a mashup platform (comprising custom mashup and component description languages and design-time and runtime environments) from a conceptual design and to provision it as a service. We equip the kit with a dedicated development methodology and demonstrate the applicability and viability of the approach with the help of two case studies. © 2014 ACM

A Three-level Component Model in Component Based Software Development

International audienceComponent-based development promotes a software development process that focuses on component reuse. How to describe a desired component before searching in the repository? How to find an existing component that fulfills the required functionalities? How to capture the system personalization based on its constitutive components' customization? To answer these questions, this paper claims that components should be described using three different forms at three development stages: architecture specification, configuration and assembly. However, no architecture description language proposes such a detailed description for components that supports such a three step component-based development. This paper proposes a three-level ADL, named Dedal, that enables the explicit and separate definitions of component roles, component classes, and component instances

Specifying Reuse Interfaces for Task-Oriented Framework Specialization

Reuse of existing carefully designed and tested software improves the quality of new software systems and reduces their development costs. Object-oriented frameworks provide an established means for software reuse on the levels of both architectural design and concrete implementation. Unfortunately, due to frame-works complexity that typically results from their flexibility and overall abstract nature, there are severe problems in using frameworks. Patterns are generally accepted as a convenient way of documenting frameworks and their reuse interfaces. In this thesis it is argued, however, that mere static documentation is not enough to solve the problems related to framework usage. Instead, proper interactive assistance tools are needed in order to enable system-atic framework-based software production. This thesis shows how patterns that document a framework s reuse interface can be represented as dependency graphs, and how dynamic lists of programming tasks can be generated from those graphs to assist the process of using a framework to build an application. This approach to framework specialization combines the ideas of framework cookbooks and task-oriented user interfaces. Tasks provide assistance in (1) cre-ating new code that complies with the framework reuse interface specification, (2) assuring the consistency between existing code and the specification, and (3) adjusting existing code to meet the terms of the specification. Besides illustrating how task-orientation can be applied in the context of using frameworks, this thesis describes a systematic methodology for modeling any framework reuse interface in terms of software patterns based on dependency graphs. The methodology shows how framework-specific reuse interface specifi-cations can be derived from a library of existing reusable pattern hierarchies. Since the methodology focuses on reusing patterns, it also alleviates the recog-nized problem of framework reuse interface specification becoming complicated and unmanageable for frameworks of realistic size. The ideas and methods proposed in this thesis have been tested through imple-menting a framework specialization tool called JavaFrames. JavaFrames uses role-based patterns that specify a reuse interface of a framework to guide frame-work specialization in a task-oriented manner. This thesis reports the results of cases studies in which JavaFrames and the hierarchical framework reuse inter-face modeling methodology were applied to the Struts web application frame-work and the JHotDraw drawing editor framework

Provisioning of customizable pattern-based software artifacts into Cloud environments

Software architects and engineers frequently face reoccurring problems, when implementing cloud computing applications, leading towards reduced productivity and an increased time to market factor. These issues can be faced by the commonly known concept of patterns. Thus, researchers identified and documented patterns for the cloud computing domain, to preserve gained knowledge about cloud application architectures and service offerings [FLMS11, FLR+12]. These patterns can be used to from the foundation of aggregated cloud computing applications. Dependent on the corresponding cloud service model, such applications require different provisioning steps, which can be performed by individually implemented actions or can be executed by pre-provided cloud services. Yet, these cloud computing patterns are offered in non-technical, written form, which does not allow to aggregate corresponding implementation binaries to pattern-based applications. Therefore, this thesis combines software product line engineering methods, open source build management tools, and open source infrastructure management tools to implement a software product line for cloud computing patterns, which allows to reduce human-driven efforts to implement aggregated cloud computing applications. This approach enables the possibility to create, aggregate and customize cloud computing pattern implementations; and store them in a so-called pattern template catalogue. Hence, each pattern, stored in such a catalogue, is associated with so-called customization points, which allow to adapt instantiated patterns to individual needs. To accomplish these challenges, Apache Maven [Mava], an open source build management tool, is extend with means to create, customize and aggregate pattern-based cloud computing applications. Corresponding provisioning tasks are accomplished, by combining PuppetLabs’ Puppet [Pup] and pre-offered cloud provisioning services. Pattern-specific customization points are stored within a serialized, so-called variability model, embedded in each pattern. Moreover, the presented structure model allows to decouple direct pattern dependencies through common interfaces, which allows to switch pattern implementations transparently, without adapting dependent patterns. Furthermore, combinable reference patterns are presented and discussed, to provide a proof of concept of the implemented software product line approach