UML-based Notation Research Articles

A model specification for the design of trust negotiations

Trust negotiation is a type of trust management model for establishing trust between entities by a mutual exchange of credentials. This approach was designed for online environments, where the attributes of users, such as skills, habits, behaviour and experience are unknown. Required criteria of trust negotiation must be supported by a trust negotiation model in order to provide a functional, adequately robust and efficient application. Such criteria were identified previously. In this paper we are presenting a model specification using a UML-based notation for the design of trust negotiation. This specification will become a part of the Software Development Life Cycle, which will provide developers a strong tool for incorporating trust and trust-related issues into the software they create. The specification defines components and their layout for the provision of the essential functionality of trust negotiation on one side as well as optional, additional features on the other side. The extra features make trust negotiation more robust, applicable for more scenarios and may provide a privacy protection functionality.

A CASE tool for Goal Dependency Model with Attributes based on An Existing UML Editor

To facilitate the suitable introduction of innovative information technologies into a social activity such as healthcare and entertainment, such an activity should be modeled and analyzed. We have already proposed a modeling language called Goal Dependency Model with Attributes (GDMA) for such purposes. To encourage many requirements analysts to use GDMA, the operational and learning effort shall be minimized as much as possible. In addition, described models shall be analyzed as efficiently as possible. To satisfy these two requirements, we proposed a UML-based notation for GDMA. We also developed a CASE tool based on an existing UML editor. We evaluated our notation and the tool through an experiment. Although subjects in the experiment were bachelor students, the subjects gave positive feedbacks to the tool.

Definition and use of Computation Independent Models in an MDA-based groupware development process

Groupware systems allow users to be part of a shared environment in order to carry out groupwork. Members of a group belong to organizations in which each one fulfils general and specific enterprise objectives. This paper presents a proposal, from the perspective of the CSCW (Computer-Supported Cooperative Work) systems, for modelling enterprise organization and developing groupware applications. This research work focuses on two specific models for the proposal: a conceptual domain model formalized through a domain ontology, and a system model built using a UML-based notation. The second stems from the first and each provides a Computation Independent View (CIV) with different objectives. Respectively, they allow a common vocabulary for knowledge sharing to be established, and organization functional requirements to be specified, particularly those concerning communication, coordination and collaboration. Furthermore, these models are part of a concrete MDA-based development process of groupware applications that is also introduced.

Architectural concepts and Design Patterns for behavior modeling and integration

The design of the control software for complex systems is a difficult task. It requires the modeling, the simulation, the integration and the adaptation of a multitude of interconnected entities and behaviors. To tackle this complexity, the approach proposed consists in combining architectural concepts, Design Patterns and object-oriented modeling with unified modeling language (UML). In this context, the present paper describes a modeling framework to take greater advantage of these concepts and to design flexible, intelligible control software. It proposes to objectify the behaviors, which leads to a two-level architecture based on three concepts: resources software images of the controlled system-behaviors applied to these resources, and meta-behaviors, i.e. means for behavior integration and adaptation. Two Design Patterns are proposed to describe how to specify behaviors and define the means to combine and adapt them. The first pattern, Polymorphic Behavior, provides the means to define new behaviors for a system and to plug them dynamically. The second one, Structured Behavior, provides the means to use finite state machines for behavior switching. The originality of the framework is that it defines concepts, a UML-based notation and heuristics which specifies how to apply these concepts. To illustrate the elements mentioned, this paper uses the control software of a walking robot as a running example.

A Formal Approach to Service Specification and Matching based on Graph Transformation

When Web services are composed by linking service providers and requestors, the requestor's requirements for a "useful" service have to be matched against the service description offered by the provider. Among other things, service specifications (requirements or descriptions) may contain operation contracts specifying pre-conditions and effects of (required or provided) operations. In this paper we provide a semi-formal, UML-based notation for contracts and contract matching, as well as a formalization of these notions in terms of graph transformation. We establish the desired semantic relation between requestor and provider specifications and prove the soundness of our syntactic notion of matching w.r.t. this relation.

Transforming Object Oriented Models with BOTL

In many application domains, like for example B2B, B2C, or CASE, a lot of heterogeneous applications exist which have to cooperate and exchange data. A major task of system integration is the mapping of different data models, on which the applications are built upon. In this paper, the Basic Object-oriented Transformation Language (BOTL) is introduced as a mathematically founded approach for the integration of data models. Class diagrams of the Unified Modelling Language (UML) are today established as a technique for meta modelling in the software engineering domain. Therefore, BOTL uses a UML-based notation for the definition of declarative mapping rules that allow reasoning about properties like applicability, metamodel conformance and bidirectionality of transformations.

SUPPORTING AGENT-ORIENTED MODELLING WITH UML

Software engineering relies on the possibility of describing a system at different levels of abstraction. Agent-oriented software engineering introduces a new level of abstraction, that we called agent level, to allow the architect modelling a system in terms of interacting agents. This level of abstraction is not supported by an accepted set of tools and notations yet, even if a number of proposals are available. This paper introduces: (i) An UML-based notation capable of modelling a system at the agent level and (ii) A development framework, called ParADE, exploiting such a notation. The notation we propose is formalized in terms of a UML profile and it supports the realisation of artefacts modelling two basic concepts of the agent level, i.e., the architecture of the multi-agent system and the ontology followed by agents. The choice of formalising our notation in terms of a UML profile allows using it with any off-the-shelf CASE tool. The ParADE framework takes advantage of this choice by providing a code generator capable of producing skeletons of FIPA-compliant agents from XMI files of agent-oriented models. The developer is requested to complete the generated skeletons exploiting the services that ParADE and the underlying agent platform provide.