Information Technology Reference
In-Depth Information
mechanism based on a natural language processor to identify functional and non-
functional crosscutting concerns from requirements documents. However, this
approach is focused only on requirements phases, while our approach can be applied
throughout the software life cycle.
The papers described above lack the application of their identification of
crosscutting to consecutive levels. We used our formalization to trace crosscutting
concerns across levels of a software development process, as shown by the cascading
operation.
A definition of crosscutting similar to ours can be found in [23] and [25]. Our
definition is less restrictive as explained in [8]. Moreover, our definition can be
applied to consecutive levels of abstractions in software development, such as
requirements, design and implementation. This can be achieved through the cascading
of dependency matrices as shown in Sect. 4.
Knethen and Paech [19] present a survey about tracing approaches. In this survey,
the authors sum up the main relationships which can be used in order to trace
elements in software engineering. They also explain the different entities we should
consider to be traced and the tools used to represent such trace relationships. The
authors establish three kinds of relationships: between documentation entities on the
same abstraction, between documentation entities at different abstractions and
between documentation entities of different versions of a software product.
According to this taxonomy of relationships, we can classify our mappings between
source and target within the second kind of relationships (between different
abstractions). For instance, the two different abstractions could refer to concerns and
representation of concerns in a particular phase (as we stated in Sect. 2.1). However,
these different abstractions could also refer to refinements within a same level. For
instance, we can consider trace dependencies in requirements between textual
requirements and use cases.
Finally, there are several tools to show or represent the mappings between entities.
In [32] we find tools based on traceability matrices, graphical models and cross
references. We have used traceability matrices to show the mappings. By means of an
extension to such matrices we are able to represent both the mappings between source
and target elements and scattering and tangling in the system.
8 Conclusions
We proposed a definition of crosscutting based on an extension to traceability
matrices, formalized in a crosscutting pattern. In a dependency matrix, we show the
mappings between source and target. As an extension, we used this matrix to derive a
crosscutting matrix and to identify crosscutting. This can be applied to any phases or
abstraction levels in a software development process, including early phases. In [10]
we applied the framework to modeling phases. The approach can be applied to
systems where well known crosscutting concerns exist, but also in systems where
crosscutting concerns should be identified. Obviously, the earlier we identify
crosscutting in system development, the easier it is to cope with crosscutting in order
to improve the quality of the system. Important properties of software such as
Search WWH ::
Custom Search