This paper proposes a methodology for software factory design guided by DSMLs (Domain Specific Modeling Languages) in the context of the SPL (Software Product Line) area. In order to guide the engineer in the design of the generative process, we propose a transformation allowing to transform the annotated metamodel of a DSML into an Feature Model that can be used later as a decision tree to help the engineer in the choice of the best implementation tactics for the variants. The article presents and illustrates the transformation based on an industrial example.

Software Product Line (SPL) field is meant to engineer families of related products to reduce development cost. Leveraging feature models for capturing variable and common aspects inside of a product family omits crucial concepts that need to be considered through designing system domain perimeter. At this level, Model Driven Engineering was integrated in SPL to facilitate variability implementation and management. MDE techniques rely on the DSML meta-model that describes the main concepts of the domain and their relations which allow system designers to work closer to the system domain as they can manipulate real concepts.The current work proposes a Methodology for Software Factories that aggregates both of the two aforementioned techniques to cover a large number of code generation strategies to derive products branching from a domain portfolio. The first phase consists in configuring a possible product line by transforming the domain metamodel DSML into a generic feature diagram. Secondly, the client uses the DSML to configure, by the guidances of the founded product line, the desired product. Hence, the Methodolgy Software Factory provides the engineer guidelines to derive the target product according to the configured product line.In this work in progress paper, we propose to extend metametamodel inspired from MOF in order to integrate crucial FD semantics element into the DSML metamodel and by the way facilitate their conversion. Besides, in this regard, a transformation method is presented to handle the extended DSML metamodel.

Hidden behind the Internet of Things (IoT), many actors are activelly filling the market with devices and services. From this profusion of actors, a large amount of technologies and APIs, sometimes proprietary, are available, making difficult the interoperability and configuration of systems for IoT technicians. In order to define and manipulate devices deployed in domestic environments, we propose IoTDSL, a Domain-Specific Language meant to specify, assemble and describe the behaviour of interconnected devices. Relying on a high-level rule-based language, users in charge of the deployment of IoT infrastructures are able to describe and combine in a declarative manner structural configurations as well as event-based semantics for devices. This way, language users are freed from technical aspects, playing with high-level representations of devices, while the complexity of the concrete implementation is handled in a dedicated layer where high-level rules are mapped to vendor’s API.

Software architectures are often abstracted as a combination of reusable components connected to each other by various means. Specifications of components' semantics have been widely studied and many modeling languages have been proposed from coarse-grained loosely-defined elements to operational objects with behavioral semantics that may be generated and executed in a dedicated framework. All these modeling facilities have proven their advantages in many domains through either case studies or real-world applications. However, most of those approaches either consider a subset of composition facilities, i.e. The available types of bindings between components, or do not even consider communication properties at all, staying at behavioral-related compatibility between components. Verifications of communication-related properties are then postponed to the hand of software developers and finally considered at deployment-time only. Part of a general architecture framework, we propose an abstraction formalism to specify communication paths between components. This modeling facility relies on a taxonomy of types of links and the specifications of communication protocols. This protocol serves as a reification element between abstract component compositions, architecture instances and deployment infrastructure, making explicit communication-related constraints and properties.

Software architecture design is a critical task as lots of requirements can be taken into account on which many decisions can be made. The maintenance and evolution of resulting models often become tricky, even impracticable when their rationale is lost. In a previous work, we introduced a set of languages used in a transformation-centric design method meant to tackle this scattering of requirements and to facilitate further model evolutions. But, we did not provided a formal validation of our proposal yet. The present work depicts a comparative case study we conducted on a group of students. The participants were asked to develop an online book store in two phases, the second one simulating an evolution of the system. We evaluated the functional completeness of the created software as well as the traceability of design decisions and rationale. The participants were also asked to criticize the design method and language they used in a textual report and through a questionnaire. Even if the size of the case study is rather limited, it clearly highlighs the advantages of our approach regarding, among others, its expressiveness and decisions traceability.

Detection of composite operations enhances users understanding about modifications performed by other users. This lets users reason about modifications on higher level operations than primitive atomic operations like create, update, and delete. As a result, conflict detection, reconciliation, and merging of modeling artifacts will be improved. Besides, composite operations can be used to generate model migration instructions that can automatically migrate instance models.

Stakeholders have to face requirements in increasing number and complexity. Their translations to system functionalities are often diluted into the overall architecture so that it becomes tricky to undertake future changes. Since information systems are intended to evolve in terms of functionalities and underlying technologies, the link between requirements and design artifacts is primordial. Agile design methods and documentation techniques have emerged in the past years in order to deal with the amount of requirements and to trace the decision process and the rationale sustaining a software model. Also, it is not unusual that numerous technologies with similar purpose are confronted to each other during the design phase. In the present work, we propose an integrated framework combining system requirement definitions, a component-based modeling language and model transformations. Architecturally-significant requirements are explicitly linked to software architecture elements and iteratively refined or implemented by model transformations. Any transformation must be documented, even briefly, and the framework retains the transformations tree. This way, the iterative decision and design processes are completely documented for future reference or modification, i.e, designers can (i) see the mapping between a system requirement and its implementation in the architecture model, (ii) explore design alternatives or apply structural modifications without losing previous versions of the model, and finally (iii), depending on the level of documentation, at least understand partially the reasons why the model is how it is.

Despite the fact that Domain Specific Models tools become very powerful and more frequently used, the support for their cooperation has not reached its full strength and demand for model management is growing. In cooperative work, the decision agents are semi-autonomous and therefore a solution for reconciliating DSM after a concurrent evolution is needed. Conflict detection and reconciliation are important steps for merging of concurrently evolved (meta)models in order to ensure collaboration. In this work, we present a conflict detection, reconciliation and merging framework for concurrently evolved DSM models. Besides, we formally specify the EMF Ecore metamodel into set construct that helps to analyze the (meta)model and operations performed on it.

Domain Specific Modeling (DSM) tools have matured and became powerful over the past few years and are now used more frequently to model complex systems. Consequently, the demand for model management and collaboration among DSM tools becomes more important. In collaborative modeling, domain specific models are mostly edited and elaborated concurrently by different semi-autonomous users. Hence, there is a need for reconciliating these parallely evolved models so as to seamlessly work together. CSCW community proposes tools or techniques to ensure collaboration among general purpose modeling languages, but they do not give functionalities to support reconciliation and merging for asynchronous modification. In addition, management of communications among members of collaborative group could also help to facilitate collaboration in the group. In this paper, we propose a communication framework to manage exchanges of concurrently edited DSM models among users. Besides, we present a reconciliation framework to merge concurrently evolved DSM models.

This paper aims to show the usefulness of attaching attributes to pieces of software architectures, in order to direct a transformation and refinement process. These attributes are properties that can be considered as abstract ways to express architectural structures, and characteristics that constrain the refinement process. Then we define a methodology that consists in refining and transforming an architecture on the basis of the attributes attached to it. The methodology will be illustrated on a case study.

Abstract The efficient implementation of generic abstract interpretation algorithms for Prolog is reconsidered after References 1 and 2. Two new optimization techniques are proposed and applied to the original algorithm of Reference 1: dependency on clause prefixes and caching of operations. The first improvement avoids re‐evaluating a clause prefix when no abstract value which it depends on has been updated. The second improvement consists of caching all operations on substitutions and reusing the results whenever possible. The algorithm and the two optimization techniques have been implemented in C (about 8000 lines of code each), tested on a large number of Prolog programs, and compared with the original implementation on an abstract domain containing modes, types and sharing. In conjunction with refinements of the domain algorithms, they produce an average reduction of more than 58 per cent is computation time. Extensive experimental results on the programs are given, including computation times, memory consumption, hit ratios for the caches, the number of operations performed, and the time distribution. As a main result, the improved algorithms exhibit the same efficiency as the specific tools of References 3 and 4, despite the fact that our abstract domain is more sophisticated and accurate. The abstract operations also take 90 per cent of the computation time, indicating that the overhead of the control is very limited. Results on a simpler domain are also given and show that even extremely basic domains can benefit from the optimizations. The general‐purpose character of the optimizations is also discussed.