![](bg2.png)
must also be considered as the building blocks for
larger software processes and then apprehended
through an architectural view.
With this respect, a number of Architecture
Description Languages (ADLs) have been proposed
in the software architecture community, with several
competing notations, each of them bringing its own
body of specification languages and analysis
techniques (Garlan, 1995), (Garlan et al., 1995),
(Magee and Perry, 1998), (Wolf, 1996). The aim of
all is to reduce the costs of error detection and repair
while providing adequate abstractions for modelling
large software-intensive systems and establishing
properties of interest. However, there now exists a
large consensus to standardise on notations and
methods for software analysis and design as
standardisation provides an economy of scale that
results in various and better tools, better
interoperability between tools, more available
developers skilled in using the standard notation,
and lower training costs. Therefore software-
intensive process architectures can be relevantly
described using a standard-compliant design
notation.
Among such notations, the UML modelling
language UML (OMG, 2001) that on one side makes
use of visual notations (class and object diagrams,
use case diagrams, sequence diagrams, collaboration
diagrams, state-chart diagrams, activity diagrams,
implementation diagrams) and on the other side, is
an emerging standard software design language and
a starting point for bringing architectural modelling
into industrial use. UML provides a large, useful,
and extensible set of predefined constructs and has
the potential for substantial tool support. As such, it
imposes itself as a relevant candidate to be extended
with the necessary architectural concepts and
customisation to model software-intensive
processes.
Our approach is to provide users (i.e. process
designers) with an architecture-centred UML-based
notation to describe software process architectures.
The architectural concepts have already been
formally defined in the ArchWare/ADL textual
language (Oquendo et al., 2002). Thus this paper
presents the ArchWare/ADL UML-based concrete
syntax. Section 2 describes the background and
concepts of ArchWare/AD and explains the
ArchWare/ADL UML-notation. The conclusion
summarises the main contribution of this work and
presents ongoing work.
2 ARCHWARE/ADL UML-BASED
CONCRETE SYNTAX
The ArchWare/ADL is a formal language for
modelling evolvable software architectures . It is
part of the ArchWare Architectural Languages,
which are: (a) the Architecture Description
Language (ADL), (b) the Architecture Analysis
Language (AAL), (c) the Architecture Refinement
Language (ARL), (d) the Architecture eXchange
Language (AXL). In the remaining of this section is
briefly introduced the UML-based concrete syntax
of the ArchWare/ADL. The goal behind the p-ADL
UML concrete syntax is to: (a) provide the users’
with a visual notation dedicated to the software
(process) architecture domain; (b) to support
different stakeholders in an architecture-based
software engineering process (style designers,
software (process) designers, software (process)
developers, software (process) maintainers, etc.).
2.1 UML-based ADL Approach and
concepts
UML as a proven standard notation with powerful
extension mechanisms has been chosen as the basis
for the ADL concrete syntax. Stereotyping is used to
extend a base modelling element by new properties
and restricting it by new constraints: properties are
added by the tagged value mechanism; constraints
are added by a formal language (e.g. OCL). Profiles
are used to define model elements that have been
customised for a specific domain by using UML
stereotypes, tagged definitions, and constraints.
Using such mechanisms, we propose a two-steps
approach in the design of our UML-based concrete
syntax, consisting in the definition of:
– a layered meta-model of the ArchWare/ADL
independent from the UML meta-model;
– the UML profiles for the ADL: (a) mapping the
ADL meta-models to the UML meta-model; (b)
defining appropriate icons.
The first defined profile is that related to the
“component-connector” architectural style. Indeed
architectural styles allowed by the ArchWare/ADL
style mechanisms (Cimpan et al., 2002) are designed
as profiles in the UML-based notation.
2.2 ArchWare/ADL meta-model
The architecture of the UML-based syntax is based
on a two threads layered meta-model structure that
consists of the following layers (see Fig. 1):
ICEIS 2004 - INFORMATION SYSTEMS ANALYSIS AND SPECIFICATION
202