1st Workshop on Unifying Software Reuse
The 1st 1-Week Workshop on Unifying Software Reuse at the Bellairs Research Institute of McGill University in Holetown, Barbados, is taking place Friday, February 16th, 2018, to Friday, February 23rd, 2018. In essence, we want to gather ~10-15 researchers that are active in domain-specific language engineering, model-driven engineering, software product lines, component-based software engineering, and software reuse in general to investigate a common conceptual model for language and language fragment reuse.
Workshop Details
Already during the first NATO conference on software engineering (SE) in 1968, software reuse (or "mass-produced software components" according to McIlroy) was recognized as crucial for the future of software development. Reuse has the potential of increasing the quality of software, while at the same time reducing software development time and cost. This is even more essential nowadays, where software needs to cope with ever the increasing complexity of systems and systems of systems, as well as new emerging paradigms, e.g., the Internet of Things (IoT), Cloud computing, and 5G networks.
A long list of reuse techniques exist, each with its own unit of reuse. Many of them are considered success stories and are currently mainstream, starting with isolated classes managed in libraries to sophisticated components (i.e., component-based software engineering (CBSE)) and services and finally to large reusable entities such as frameworks and Software Product Lines (SPL). Successful reuse also includes development artifacts, such as analysis and design models describing interactions, patterns, function, data, or architecture. In recent years, it has been shown that even crosscutting software artifacts can be reused and combined with application-specific artifacts by means of feature-oriented and aspect-based software composition techniques. Instead of concrete artifacts, it is also possible to reuse domain-specific reuse knowledge by embedding it in domain-specific (modelling) languages, model transformations tools, and code generators following the philosophy of Model-Driven Engineering (MDE) and Software Language Engineering (SLE).
Thanks to a Bellairs workshop on modularity, interfaces and reuse that took place several years ago, a canonical set of reuse interfaces for units of reuse has been identified: the variation, customization, and usage interfaces (VCU) [1]. The variation interface exposes the variations a reusable unit encapsulates, together with their impacts on non-functional qualities. The customization interface designates the generic elements within the reusable unit, and how to customize them to a specific context. The usage interface details how to use the structure and behaviour offered by the reusable unit for a specific purpose. In [1], Concern-Oriented Reuse (CORE), a novel paradigm that defines units of reuse called concerns that are based on VCU, is used to present concrete examples of VCU, and to outline a VCU-based reuse process. While it is shown in [1] how interfaces of existing units of reuse, e.g., components and services, map to the VCU interfaces, reuse approaches that do not have clearly defined units of reuse, e.g., approaches based on model transformations or DSLs, are not considered.
DSLs are in some way the ultimate form of reuse, as the usually small and intuitive language concepts capture a particular domain knowledge precisely and allow a user to reuse that knowledge and express his needs in the most concise way. Then, by using model checkers, model transformations, and code generators, solution knowledge is reused and applied to the particular problem at hand. Last year's Bellairs workshop focused on Language Reuse, i.e., how to exploit reuse based on CORE and VCU for the definition of (domain-specific) languages, as well as the creation of tools and methods related to these DSLs.
Similarly to the unifying M-theory in physics (i.e., theory that unifies all consistent versions of superstring theory), the objective of this 1st Workshop on Unifying Software Reuse is to elaborate a theory of reuse that aligns the strengths of existing reuse technologies (OO, CBSE, SPL, MDE, SLE) within a unifying framework. Concretely, we suggest to start from the current CORE metamodel, which combines ideas from MDE with best practices from advanced modularization and separation of concerns techniques (SoC) as well as goal modelling, and evolve it to encompass components, multi-view modelling, model transformations, and in particular DSLs. If successful, the resulting concerns would be ultimate units of reuse, as they would allow to encapsulate not only internally consistent implementation, design, architecture, and requirements artifacts, but also domain-specific languages that capture the problem domain that the concern addresses concisely. As a result, reuse is maximized at all levels of abstraction, and concern application is simplified (even for non-experts) thanks to provided DSLs. Such units would expose relevant interfaces to support the various reuse scenarios, and would also provide a native mechanism to promote an existing unit of reuse from a library to a construct of a language.