Marcin Szlenk

Formal Semantics and Reasoning about UML Class Diagram

The main way of coping with the complexity of software systems is to construct and use models expressed in UML. Unfortunately, the semantics (meaning) of models written in UML is not precisely defined. It may result in the incorrect interpretation of a model and make it hard to strictly verify a model and its transformation. In this paper we formally (mathematically) define UML class diagram and its semantics. The problem of consistency of the diagram is then introduced and some examples of inconsistencies are forwarded

Reconfigurable Agent Architecture for Robots Utilising Cloud Computing

The paper presents the general architecture of the control system of a companion robot. As companion robots have to perform diverse and complex tasks, while computational capabilities of the local robot control computer are limited, the control system is split between the robot and the cloud. Moreover, the system is composed of agents, that are arranged into an application on demand of the user. Some of those agents are created on the robot and some in the cloud. As the requirements change the composition of the system changes too.

Modelling Architectural Decisions under Changing Requirements

One of the approaches for documenting software architecture is to treat it as a set of architectural design decisions. Such decisions are always made in the context of requirements that must be fulfilled and in the context of decisions that were made before. Currently, models for representing architectural decisions are mainly concentrated on showing the decision making process of the initial architectural design. However, decisions that have been made in such a process may need to be changed during further evolution and maintenance of the software architecture, typically in response to the new or changed requirements. A graphical modelling notation for documenting architectural decisions (Maps of Architectural Decisions) has been developed by our team. In this paper, it is presented how this notation could be used to model architectural decisions under changing requirements. It is proposed how one decision change could be effectively propagated through the rest of the architectural decision model and how a rigorous and tool-supported process of updating such models could be organized.

Reconfigurable control architecture for exploratory robots

Robots have to perform diverse and complex tasks. To face the limitations of the computational capabilities of robot on-board control computer, it is required to split the control systems between the robot embedded and the cloud computational resources. This paper presents a reconfigurable control architecture for a robot designed to meet this requirement. The embedded computer hosts a core agent, which provides the task-independent robot capabilities. The task dependent part called the dynamic agent is loaded from the cloud when required. The two mentioned agents execute the task, additionally utilising the capabilities of the cloud. Once the task is finished the dynamic agent is destroyed and the core agent awaits new user demands, upon which it reacts by downloading a new dynamic agent. Thus a reconfigurable system results, limited only by the resources provided by the cloud. The system is presented on an example of a humanoid robot exploring a home environment in search for hazards resulting from negligence of people suffering from mild dementia.

UML Static Models in Formal Approach

The semantics of models written in UML is not precisely defined. Thus, it is hard to determine, how a given change in a model influences its meaning and, for example, to verify whether a given model transformation preserves the semantics of the model or not. In the paper a formal (mathematical) semantics of key elements of the UML static models is presented. The aim is to define the basic semantic relations between models: a consequence (implication) and equivalence. The goal of the definitions and examples presented in the article is to form a very basic, concise, theoretical foundation for the formal comparison of the UML static models, based on their meanings.

Metamodel and UML Profile for Functional Programming Languages

Functional programming languages are ideally suited for developing dependable software, but not much work have been done on modeling functional programs. Although UML is mainly based on concepts which are native to imperative object-oriented programming languages, this chapter shows how – through the profile mechanism – it can be used to model software that is to be implemented in a functional programming language. In this chapter Haskell was chosen as one of the most popular modern, pure functional languages. First, a partial metamodel of Haskell is defined and then the corresponding UML profile is presented.

Towards Precise Architectural Decision Models

One of the modern approaches for documenting software architecture is to show the architectural design decisions that led an architect to the final form of software architecture. However, decisions that have been made in such a process may need to be changed during further evolution and maintenance of the software architecture. The main reasons for these changes are new or changed requirements. In our team we have developed a graphical modelling notation for documenting architectural decisions, called Maps of Architectural Decisions, that can support the process of making changes in the software architecture. In this work we define a formal background for the controlled process of making changes in architectural decision models that are documented using that notation.

AN EVOLUTION PROCESS FOR SERVICE-ORIENTED SYSTEMS

Evolution of service-oriented systems is quite a new research area, which be- comes more and more important as engineering challenges move from enabling service-orientation onto the maintenance and evolution of already developed service-oriented systems. However, the development of suitable evolution proces- ses and methodologies is still an open research problem. The evolution process presented in this paper has been designed to address the evolution of service- oriented systems, which are technically built out of a set of service compositions. The presented process comprises phases and tasks compliant with ISO 20000. The underlying model of service-oriented system consisting of business processes and corresponding service composition models has also been presented. A tra- ceability model and tools supporting change impact analysis have also been provisioned for. Preliminary industrial validation indicates that the evolution process should be easy to adapt by the industry.