Service-based technology is becoming widespread, and many service oriented platforms are available with different characteristics and constraints, making them incompatible. Consequently, designing, developing and executing an application using services running on different platforms is a challenging task if not impossible. A first challenge is to provide an ideal and virtual SOC platform; ideal because it subsumes the actual real SOA platforms, virtual because it delegates the execution to these real platforms. But since ldquoidealrdquo depends on the domain; the second challenge is to provide extensibility mechanisms allowing to define what ideal means in a given domain and to provide the engineering support for the design and development of service-based application dedicated to such domains. The paper describes how we addressed these challenges, and to what extent they have been met.

.Design and development scalability, in any engineering, requires information hiding and a specific composition mechanism in which composite items are made-up of other items. This paper shows that scalability is currently ill supported and that software engineering composites are rather special with respect to other engineering disciplines. Indeed, a software engineering composite is simultaneously a model element, an engineering artifacts and a real object, which is unprecedented in the history of engineering. This paper analyzes the requirements that composites must satisfy in order to support scalability in software engineering. We have developed CADSE (Computer Aided Domain Specific Environment) in which composites are first class elements from which workspaces, concurrent engineering and view point support are provided. The paper discusses our experience with using the proposed system over the last years.

Computer aided software engineering tools represent one the main successes of software engineering in the past decades. They however need to be improved along several dimensions in order to face new challenges due to ever more complex applications, more heterogeneous technologies and more stakeholders involved. In this paper, we present an approach based on the concept of domain. We define a domain as an area in which a number of stakeholders is repeatedly performing similar activities. In a project, an arbitrary number of domains can be identified, being business, technical, or related to life cycle activities. In our metamodel-based approach, any domain can be easily modelled and the corresponding computer aided domain specific engineering environment (CADSE) can be generated. Using CADSE composition, complete and wide scope engineering environments can be built as a composition of an arbitrary number of domains. The paper presents the approach, the technology and draws a few lessons of the first years of use in a number of real projects.

Product Data Management (PDM) and Software Configuration Management (SCM) are the disciplines of building and controlling the evolution of a complex artifacts; either physical or software. Surprisingly, these two fields have evolved independently; their respective solutions to the same problems are incompatible and their properties are different. PDM is good at modeling while SCM is good at building and supporting concurrent engineering. From a software engineering perspective, the challenge is to take the full potential of strong modeling capabilities, while preserving good concurrent engineering support. The paper shows that rich modeling, flexible evolution, and concurrent engineering supports have conflicting requirements and that a solution requires rethinking the concepts of evolution, versioning and modeling. We have developed a system, called CADSE (Computer Aided Domain Specific Environment), in which a product (software, physical or both) is modeled in a way similar to PDM and in which concurrent engineering and evolution is supported in the SCM way. To that end, the system is driven by models; evolution alone being defined through different models. The paper describes our system and discusses the early lessons of its first years of practical use.

The evolution of software engineering methodology, from waterfall to spiral, from spiral to agile, indicates that high concurrency, iterative development and short cycles are key factors for effective software engineering. It is widely accepted that supporting (i.e., formalizing controlling, automating and optimizing) concurrent engineering processes is needed to increase predictability of cost, quality and development time. Unfortunately, current systems (e.g., workflows, software configuration management, ...) are too simple and deterministic; they do not include real support for concurrent engineering. We claim this shortcoming is one of the major reasons why current workflow and process support do not significantly help in the support of software engineering. In this paper we present the Celine system, which extends workflows with the definition of high-level executable description of concurrent engineering and therefore contributes to provide effective control over cost, quality and development time

Reuse has always been a major goal in software engineering, since it promises large gains in productivity, quality and time to market reduction. Practical experience has shown that substantial reuse has only successfully happened in two cases: libraries, where many generic and small components can be found; and product lines, where domains-specific components can be assembled in different ways to produce variations of a given product.In this paper we examine how product lines have successfully achieved reuse of coarse-grained components, and the underlying factors limiting this approach to narrowly scoped domains. We then build on this insight to present an approach, called software federation, which proposes a mechanism to overcome the identified limitations, and therefore makes reuse of coarse-grained components possible over a larger range of applications. Our approach extends and generalizes the product line approach, extending the concepts and mechanisms available to manage variability. The system is in use in different companies, validating the claims made in this paper.

Software Configuration Management (SCM) is an important discipline in professional software development and maintenance. The importance of SCM has increased as programs have become larger, more long lasting, and more mission and life critical. This article discusses the evolution of SCM technology from the early days of software development to the present, with a particular emphasis on the impact that university and industrial research has had along the way. Based on an analysis of the publication history and evolution in functionality of the available SCM systems, we trace the critical ideas in the field from their early inception to their eventual maturation in commercially and freely available SCM systems. In doing so, this article creates a detailed record of the critical value of SCM research and illustrates how research results have shaped the functionality of today's SCM systems.

Software configuration management (SCM) is an important discipline in professional software development and maintenance. The importance of SCM has increased as programs have become larger, more complex, and more mission/life-critical. This paper presents a brief summary of a full report that discusses the evolution of SCM technology from the early days of software development to present, and the specific impact university and industrial research has had along the way.

Building large software applications from Commerical Off The Shelf tools (COTS) is not an industrial reality so far. This work presents a new approach to solve the different problems found when building a federation of COTS.

Abstract Software maintenance is responsible for approximately 80% of the total cost of software. In order to reduce maintenance costs by improving both software productivity and quality, several software engineering environments have been built. In this paper, we present the main characteristics of Adele system, showing how this system is able to take account of software maintenance problems. We concentrate on the ability of this system to accept the specification of project‐specific policies and how these policies can be enforced automatically. We illustrate this with examples which with software maintenance. The second example is presented in the annexe and shows an example of cooperative work in an aerospace company. We conclude this article by presenting the lessons learned using our approach and our projects for the future.

A discussion is presented of the solutions proposed by the Nomade project: a language-independent kernel and a specialized tool. The kernel manages coarse-grained objects (from files to abstractions such as modules or subsystems), while the tool manages fine-grained objects (basically the external objects of modules: procedures types, etc.). Concepts and properties of variants and revisions are defined. The kernel, enforcing these properties, allows tools to work safely in a monoversioned context. One of these tools, mainly dedicated to interface control, is then presented.>