Josep M. Ribó

Using UML for modelling the static part of a software process

We study in this paper the use of UML as a tool for modelling the process of software construction. As a case study, we deal with the process of building a library of software components. UML is used in order to define the static part of the process, i.e., the elements that take part on it and their structural relationships. We think that our approach supports some interesting properties in the field of software process modelling (e.g.: modularity; expressivity in model construction; sound formal basis; and flexibility in model enactment). Besides showing the adequacy of UML for modelling the static part, the paper outlines also some drawbacks concerning the description of the dynamic behaviour of the process using only UML, and some possible solutions to them.

Improving the accuracy of UML metamodel extensions by introducing induced associations

In the process of extending the UML metamodel for a specific domain, the metamodel specifier introduces frequently some metaassociations at MOF level M2 with the aim that they induce some specific associations at MOF level M1. For instance, if a metamodel for software process modelling states that a “Role” is responsible for an “Artifact”, we can interpret that its specifier intended to model two aspects: (1) the implications of this metaassociation at level M1 (e.g., the specific instance of Role “TestEngineer” is responsible for the specific instance of Artifact “TestPlans”); and (2) the implications of this metaassociation at level M0 (e.g., “John Doe” is the responsible test engineer for elaborating the test plans for the package “Foo”). Unfortunately, the second aspect is often not enforced by the metamodel and, as a result, the models which are defined as its instances may not incorporate it. This problem, consequence of the so-called “shallow instantiation” in Atkinson and Kühne (Procs. UML’01, LNCS 2185, Springer, 2001), prevents these models from being accurate enough in the sense that they do not express all the information intended by the metamodel specifier and consequently do not distinguish metaassociations that induce associations at M1 from those that do not. In this article we introduce the concept of induced association that may come up when an extension of the UML metamodel is developed. The implications that this concept has both in the extended metamodel and in its instances are discussed. We also present a methodology to enforce that M1 models incorporate the associations induced by the metamodel which they are instances from. Next, as an example of application we present a quality metamodel for software artifacts which makes intensive use of induced associations. Finally, we introduce a software tool to assist the development of quality models as correct instantiations of the metamodel, assuring the proper application of the induced associations as required by the metamodel.

A UML-Based Approach to Enhance Reuse within Process Technology

Process reuse (the ability to construct new processes by assembling already built ones) and process harvesting (the ability to build generic processes that may be further reused, from existing ones) are two crucial issues in process technology. Both of them involve the definition of a set of mechanisms, like abstraction, adaptation, composition, etc., which are appropriate to achieve their goals. In this article, we define a general framework to process reuse and harvesting that proposes a complete set of mechanisms to deal with both activities. This general framework is particularized to the context of the PROMENAE software process modelling language. A process reuse case study which composes various reuse mechanisms is presented in the context of PROMENADE.

A precedence-based approach for proactive control in software process modelling

We present the proactive behavioural features of PROMENADE, a process modelling language for formalizing the construction of software process models. PROMENADE aims at improving expressiveness, standardization, flexibility and reuse in software process modelling. In this article we focus on expressiveness, which is achieved by means of a declarative (instead of imperative) proactive control-flow based on precedence relationships. Different families of such precedences have been defined within the language (namely, basic, derived and dynamic). Also, PROMENADE provides (1) a comprehensive parameter task-binding mechanism to keep track of document-flow between tasks; (2) a high level notation to define new precedence relationships, which may be used to tailor the language to the specific needs of each user and process; (3) the definition of flexible models by leaving some parts undefined until enactment time. The specific concepts necessary to model a software process are defined and integrated into the UML metamodel. The extended metamodel is converted into a UML profile using stereotypes, constraints and tag definitions.

A structured approach to software process modelling

Systematic formulation of software process models (SPM) is currently a challenging problem in software engineering. We present an approach to define such models that encourages: reuse of both elements and models; modularity and incrementality in model construction; simplicity and naturality of the resulting model; and a high degree of concurrence in their enaction. We focus on model definition, distinguishing as usual its static and dynamic parts. We define the static part by means of formally defined hierarchies introducing the categories of elements that take part in SPM definition. Such hierarchies may be constructed and enlarged according to the requirements of any specific SPM. We present as an example a hierarchy for component programming that takes into account non-functional aspects of software (efficiency, etc.). The dynamic part of the SPM is defined by means of precedence relationships between tasks that take part in the model. These precedence relationships are represented with precedence graphs. Development strategies are defined by encapsulating new precedence relationships in modules, that can be combined and reused.

A MOF-compliant approach to software quality modeling

Software quality is a many-faceted concept that depends on the kind of artifact to be measured, the context where measurement takes place, the quality framework used, and others. Furthermore, there is a great deal of standards, white papers, and in general proposals of any kind related to software quality. Consequently, a unified software quality framework seems to be needed to compare, combine or select these proposals and to define new ones. In this paper we propose a MOF-compliant approach for structuring quality models in order to formalise software quality issues and deal with quality information modelling. We propose two types of models: a generic model, situated in the M2 MOF layer; and a hierarchy of reference models, defined in the Ml and M0 MOF layers. The generic model elements are derived from the UML meta-model by specialization. Then, we can instantiate them to get reference models that formalise (combinations of) existing proposals which may be further refined for defining quality frameworks to be used in different experiences. Each of these models is divided into three parts, namely fundamental concepts, metrics and context. We illustrate our proposal providing a multi-level reference model in the context of collection libraries quality evaluation.

Inducing Metaassociations and Induced Relationships

In the last years, UML has been tailored to be used as a domain-specific modelling notation in several contexts. Extending UML with this purpose entails several advantages: the integration of the domain in a standard framework; its potential usage by the software engineering community; and the existence of supporting tools. In previous work, we explored one particular issue of heavyweight extensions, namely, the definition of inducing meta-associations in metamodels as a way to induce the presence of specific relation-ships in their instances. Those relationships were intended by the metamodel specifier but not forced by the metamodel itself. However, our work was restricted to the case of induced associations. This paper proposes an extension to the general case in which inducing metaassociations may force the existence of arbitrary relationships at M1. To attain this goal, we provide a general defini-tion of inducing metaassociation that covers all the possible cases. After revisi-ting induced associations, we show the inducement of the other relationship types defined in UML: association classes, generalization and dependencies.

QUINST: A Metamodeling Tool

We present a metamodeling tool to support a modeling methodology which we have succesfully applied in the field of software quality. As a distinguishing and general purpose functionality, it implements the concept of induced associations, which are introduced by the tool when the user instantiates metaclasses related by inducing metaassociations in the metamodel.

A multi-version algorithm for cooperative edition of hierarchically-structured documents

Several approaches do exist to solve the problem of editing a text document cooperatively in real time. We believe that those approaches could be improved in two ways: (1) preserving the intention of the participants in a better manner and (2) benefiting from a hierarchical document structure (as in XML). This article presents an algorithm for cooperative edition of documents that (1) achieves intention preservation by keeping different versions of the concurrently accessed document fragments and that (2) reduces concurrency conflicts by restricting them to hierarchically dependent fragments.

Software process modelling as relationships between tasks

Systematic formulation of software process models is currently a challenging problem in software engineering. We present an approach to define models covering the phases of specification, design, implementation and testing of software systems in the component programming framework, taking into account non-functional aspects of software (efficiency, etc.), automatic reusability of implementations in systems and also prototyping techniques involving both specifications and implementations. Our proposal relies on the identification of a catalogue of tasks that appear during these phases which satisfy some relationships concerning their order of execution. A software process model can be defined as the addition of more relationships over these tasks using a simple, modular process language. We have developed also a formal definition of correctness of a software development with respect to a software process model, based on the formulation of models as graphs.