One aspect that has received little attention in COTS selection is what we call conceptual fit, which we evaluate in terms of the existing misfits. We define the notion of conceptual misfit and we present an approach that determines the conceptual misfits between the user requirements and a set of candidate systems. The approach consists in defining a superschema, the mapping of the conceptual schemas of the candidate systems and of the user requirements to that superschema, and the automatic computation of the existing conceptual misfits. We believe that conceptual fit could be taken into account by almost all existing COTS selection methods.
Nowadays, many organizations build many of their information systems by customizing and/or integrating Commercial-off-the-shelf (COTS) systems. Selecting the most convenient COTS system for a particular situation has become a critical activity in information systems engineering.
COTS system selection essentially consists in evaluating user requirements with
respect to characteristics of candidate systems. The evaluation is performed by
defining a set of criteria, assessing the importance of each criterion for the users and
the degree to which the criterion is satisfied by a system. One kind of criterion that
has received little attention is what we call conceptual fit. It is similar to what is called
domain compatibility in OTSO [
This paper analyzes the conceptual fit between user requirements and COTS
systems. We define the notion of conceptual misfit and we present an approach to the
determination of the existing conceptual misfits between a set of user requirements
and a system. The absence of conceptual misfits indicates a perfect conceptual fit. Our
notion of conceptual misfit has been inspired in the ontological expressiveness
analysis [
The structure of the paper is as follows. Next section identifies the different kind of conceptual misfits that may exist between a set of user requirements and a COTS system. Section 3 formalizes the general problem of evaluating the conceptual fit. In section 4 we describe the approach we propose for solving that problem. Finally, section 5 summarizes the conclusions.
By conceptual fit we mean the fit between two structural conceptual schemas. In our
context, one conceptual schema is that of the user requirements and the other one is
that of a particular COTS system. For the purposes of this paper, we will assume
simple structural conceptual schemas consisting only of entity types, ISA hierarchies,
attributes and binary associations. This can be easily extended, if desired [
In the UML metamodel M (see Fig. 1) of the schemas that we consider in this paper, entity types have a name, may be abstract or concrete, may be a singleton or be unconstrained, and may have sub/supertype associations between them. Entity types may have attributes, which are properties. Properties have a minimum and a maximum cardinality, and a type. Cardinalities may be zero, one or unconstrained. Associations have two ordered participants, each of which is a property, as before.
Assume now that we have two instances of M that we call Ui (for user requirements) and Sj (for COTS system). We are interested in knowing how well Ui and Sj fit each other. To this end, we try to see whether there are misfits between them. Based on the simple metamodel M we identify three kinds of misfits in the schema elements, called deficits, incompatibilities and excesses, which we define in the following. The idea is that the degree of fit of Ui and Sj is inversely proportional to the number of misfits, the maximum being the absence of them.
We say that there is an entity type deficit between Ui and Sj with respect to (wrt) E if E is a concrete entity type of Ui but E is not an entity type of Sj. Note that we consider only the concrete entity types of Ui because these are the ones of interest to the users. Abstract entity types in Ui are unions of concrete ones.
There is an entity type cardinality incompatibility between Ui and Sj wrt E if E is a concrete entity type of Ui and an entity type of Sj, but E is unconstrained (not a singleton) in Ui and a singleton in Sj. Both Ui and Sj have the entity type E but, in Ui, E may have several instances while only one instance is allowed in Sj.
We say that there is an entity type excess between Ui and Sj wrt E if E is a concrete entity type of Sj but E is not an entity type of Ui. In this case, Sj includes an entity type that is not of interest to Ui.
There is an induced attribute deficit between Ui and Sj wrt A if A is an attribute of the concrete entity type E in Ui and there is an entity type deficit between Ui and Sj wrt E. In this case, the deficit is induced by the entity type deficit.
There is an attribute deficit between Ui and Sj wrt A if A is an attribute of the concrete entity type E in Ui, Sj includes E, but Sj does not include A.
There is an attribute cardinality incompatibility between Ui and Sj wrt A if A is an attribute of the concrete entity type E in Ui, Sj includes A, but the cardinalities are incompatible. An incompatibility arises when the minimum cardinality in Ui is zero and one in Sj, or when the maximum cardinality is unconstrained in Ui and one in Sj.
There is an induced attribute excess between Ui and Sj wrt A if A is an attribute of the concrete entity type E in Sj and there is an entity type excess between Ui and Sj wrt E. In this case, the excess is induced by the entity type excess.
There is an attribute excess between Ui and Sj wrt A if A is an attribute of the concrete entity type E in Sj, Ui includes E, but Ui does not include A. In this case, Sj includes an attribute that is not of interest to Ui.
There is an induced association deficit between Ui and Sj wrt R if R is an association between the concrete entity types E1 and E2 in Ui, and there is an entity type deficit between Ui and Sj wrt E1 or E2. In this case, the deficit is induced by the entity type deficits.
There is an association deficit between Ui and Sj wrt R if R is an association between the concrete entity types E1 and E2 in Ui, Sj includes E1 and E2, but Sj does not include R.
There is an association cardinality incompatibility between Ui and Sj wrt R if R is an association between the concrete entity types E1 and E2 in Ui, Sj includes E1 and E2, but the cardinalities of one of its participants are incompatible. An incompatibility arises when the minimum cardinality in Ui is zero and one in Sj, or when the maximum cardinality is unconstrained in Ui and one in Sj.
There is an induced association excess between Ui and Sj wrt R if R is an association between the concrete entity types E1 and E2 in Sj, and there is an entity type excess between Ui and Sj wrt E1 or E2. In this case, the excess is induced by the entity type excess.
There is an association excess between Ui and Sj wrt R if R is an association of the concrete entity types E1 and E2 in Sj, Ui includes E1 and E2, but Ui does not require R.
The general problem of evaluating the conceptual fit criterion can be defined as follows:
The conceptual misfits (deficits, misfits and excesses as defined in the previous section) between Ui and each of the S1,…,Sn.
Conceptual fit analysis can be performed considering the complete set of user requirements Ui and of the candidate systems S1,…,Sn, or considering only a fragment of them. The latter possibility is likely to be of much more practical interest in most cases.
The set of conceptual misfits found can be used as a basis for selection. If there are no misfits between Ui and Sj, then there is a perfect fit between them.
If there are one or more deficits or incompatibilities between Ui and Sj, then the selection of Sj would require either the change of the user requirements Ui (changing their intended way-of-working) or a customization of Sj for the user (customizing existing systems to accommodate users’ requirements).
If there are one or more excesses between Ui and Sj, then the selection of Sj would imply dealing with the unneeded features related to those excesses, and the need of the corresponding resources.
A straightforward approach to the solution of the general problem of determining the conceptual fit would be to consider each Sj (j = 1,…,n) separately, and determine the conceptual misfits between Ui and Sj as indicated in Sect. 2. When the number n is large and/or the conceptual schemas are large, the evaluation effort may be large too.
However, in a context where the selection process must be performed several times with the same set of candidate systems S1,…,Sn, with different user requirements Ui, then a better solution would be to build an intermediate superschema S. That superschema S should integrate S1,…,Sn in a way such that Ui and each of the S1,…,Sn could be mapped to S, and such that the conceptual misfits of Ui and each of the S1,…,Sn could then be computed automatically.
Based on the above idea, the method we propose consists of four parts: 1. A superschema S that is a union of all schemas S1,…,Sn and all possible user requirements U1,…,Um in a given domain. 2. The definition of the schemas S1,…,Sn in terms of S. 3. The definition of user requirements Ui in terms of S.
4. The (automatic) computation of the misfits between Ui and S1,…,Sn.
We describe these parts in the following.
In our method, the superschema S is an instance of the metamodel M for a domain D such that: S includes the schemas of all possible COTS systems S1,…,Sn in D. S includes all possible conceptual user requirements U1,…,Um in D. By inclusion of schemas here we mean that: S comprises all concrete entity types, attributes and associations that may be required by U1,…,Um. On the other hand, the cardinalities of the attributes and associations in S must not be incompatible with those that may be required by U1,…,Um. S comprises all concrete entity types, attributes and associations that are implemented in S1,…,Sn. On the other hand, the cardinalities of the attributes and associations in S must not be incompatible with those that are implemented in S1,…,Sn.
For the purposes of conceptual fit analysis we need to know for each Sj (j = 1,…,n) in D: The entity types of S implemented in Sj and their corresponding cardinalities.
We are interested only in the entity types that are concrete in Sj. If Sj implements all subtypes of an abstract entity type E in S, then Sj also implements E. The attributes and associations of S implemented in Sj and their corresponding cardinalities.
Figure 1 shows the metamodel M and the extension needed to represent the part of S that is implemented by Sj. A COTS system is assumed to implement a set of concrete entity types (with a cardinality that may be Singleton or Unconstrained), a set of attributes and a set of associations.
Note that if S includes an abstract entity type E with subtypes E1,…, Em and E has an attribute A, then a system Sj that implements two or more of those subtypes could implement A differently in each case. Our metamodel of Fig. 1 takes this possibility into consideration by indicating in AttributeImplementation the implemented entity type. A similar reasoning applies to the association participants.
The mapping process can be superschema-driven or system-driven. In the former, the elements of S are taken in some convenient order, and for each of them it is checked whether or not it is implemented by the system. If the element is a concrete entity type that is not implemented by Sj then there is no need to check the implementation of its attributes and associations. To use this process, the conceptual schema of Sj needs not to be explicit; what is needed to know is what entity types, attributes and associations of S are implemented in Sj.
In the system-driven process, the elements of the conceptual schema of Sj are taken in some convenient order, and each of them is mapped to S. To use this process the conceptual schema of Sj must be explicit.
The entity types of S required by Ui and their corresponding cardinalities. We need to know only the entity types that are concrete in Ui. If Ui requires all subtypes of an abstract entity type E in S, then Ui also requires E. The attributes and associations of S required by Ui and their corresponding cardinalities.
Figure 2 shows the extension of the metamodel M needed to represent the user requirements in terms of S. User requirements are assumed to consist of concrete entity types (with a cardinality that may be Singleton or Unconstrained), a set of attributes and a set of associations.
Note that similarly to the previous case, if S includes an abstract entity type E with subtypes E1,…, Em and E has an attribute A, then if Ui requires two or more of those subtypes, it could require A differently in each case. The same applies to association participants.
As in the mapping of systems, the definition of user requirements can be superschema-driven or requirements-driven.
In our method, once we have defined the instance of M corresponding to the superschema S for a domain D, the instances of the candidate COTS systems S1,…,Sn in D and their mapping to S (Fig. 1), and the instance of the user requirements Ui and its mapping to S (Fig. 2) we can then automatically compute the misfits between Ui and S1,…,Sn. In what follows we explain the details of the computation in terms of the UML schemas shown in Figs. 1 and 2.
Entity type deficit. Let E be an entity type required by Ui. There is a deficit of E in Sj if E is not implemented in Sj. E can be implemented in Sj directly or by exclusion. There is a direct implementation when E is also an entity type of Sj. There is an implementation by exclusion when there is an entity type E’ implemented by Sj such that E’ is a supertype of E, E1,…, Ep (p > 0) and E1,…, Ep are not required by Ui. The exclusion of E1,…, Ep by Ui implies that the population of E and E’ will always be the same, and therefore E’ can implement E in Sj.
Entity type incompatibility. Let E be an unconstrained entity type required by Ui. There is an incompatibility when E is implemented by a singleton entity type in Sj. Entity type excess. Let E be an entity type in Sj. There is a misfit of this kind when E does not implement any entity type in Ui.
Induced attribute deficit. This happens when Ui requires an attribute of entity type E and there is an entity type deficit between Ui and Sj wrt E.
Attribute deficit. This happens when Ui requires an attribute A of an entity type E that is implemented in Sj, but that implementation does not include A. Attribute cardinality incompatibility. This happens when the cardinalities of an attribute required by Ui are incompatible with those of its implementation in Sj. Induced attribute excess. Let A be an attribute of a concrete entity type E in Sj. There is a misfit of this kind when E is an entity type excess for Ui. In OCL: Attribute excess. Let A be an attribute of a concrete entity type E in Sj. There is a misfit of this kind when E is an implementation of an entity type required by Ui but A is not implemented.
Induced association deficit. There is misfit of this kind when Ui requires an association R between the concrete entity types E1 and E2 and there is an entity type deficit between Ui and Sj wrt E1 or E2.
Association deficit. There is misfit of this kind when Ui requires an association R between the concrete entity types E1 and E2 that are implemented in Sj, but Sj does not include R.
association required by Ui are incompatible with those of the implemented association in Sj.
Induced association excess. Let R be an association between the concrete entity types E1 and E2 in Sj. There is a misfit of this kind when E1 and E2 are an entity type excess for Ui.
Association excess. Let R be an association between the concrete entity types E1 and E2 in Sj. There is a misfit of this kind when E1 and E2 are implementations of entity types in Ui but R is not.
We have proposed a new aspect for COTS system selection, which we call conceptual fit, which assesses the fit between the conceptual structure of a given system and of the user requirements. We have identified three kinds of misfits in the schema elements, called deficits, incompatibilities and excesses. The idea is that the degree of conceptual fit is inversely proportional to the number of misfits, the maximum being the absence of them.
We have formally defined the general problem of evaluating the conceptual fit between the user requirements and a set of COTS systems, and we have proposed a new method for its solution. The method consists in defining a superschema, the mapping of the conceptual schemas of the candidate systems and of the user requirements to that superschema, and the computation of the conceptual misfits.
The main effort required by our method is the development of the superschema and the mapping of the candidate systems to it. However, this must be done only once per domain and the result could be reused in all COTS selections of a domain. Acknowledgments. This work has been partly supported by the Ministerio de Economía y Competitividad and FEDER under project TIN2008-00444, Grupo Consolidado.