Formal Model-Driven Development of Communicating Systems (original) (raw)
Related papers
Model-driven development has gained increasing acceptance in the engineering community. Via abstraction and gradual model transformation, it offers an efficient way to cope with complexity of modern software-intensive systems, typical examples of which are distributed telecommunicating systems and communication protocols. However, variety of models representing the system structure and behaviour from different viewpoints and at different levels of abstraction raise the question of model consistency and their adherence to the predefined architectural rules. In this paper we formalize a development flow of distributed telecommunicating systems and communication protocols as an architectural profile in UML. We specify and formally verify this profile. The profile allows us to check adherence of models to the predefined architectural rules. Furthermore, by formalizing and verifying intra-and interconsistency rules, we ensure that the models do not contradict to each other. We use the B Method as our formal framework. The presented work establishes a basis for automating model-driven development of telecommunicating systems and communication protocols.
The object-oriented paradigm is widely applied in designing and implementing communication systems. The Unified Modeling Language (UML) is a standard language used to model the design of object-oriented systems. A protocol state machine is a UML adopted diagram that is widely used in designing communication protocols. It has two key attractive advantages over traditional finite-state-machines: modeling concurrency and modeling nested hierarchical states. In a distributed communication system, each entity of the system has its own protocol that defines when and how the entity exchanges messages with other communicating entities in the system. The order of the exchanged messages must conform to the overall service specifications of the system. In object-oriented systems, both the service and the protocol specifications are modeled in UML protocol state machines. Protocol specification synthesis methods have to be applied to automatically derive the protocol specification from the service specification. Otherwise, a time-consuming process of design, analysis, and error detection and correction has to be applied iteratively until the design of the protocol becomes error-free and consistent with the service specification. Several synthesis methods are proposed in the literature for models other than UML protocol state machines, and therefore, because of the unique features of the protocol state machines, these methods are inapplicable to services modeled in UML protocol state machines. In this paper, we propose a synthesis method that automatically synthesizes the protocol specification of distributed protocol entities from the service specification, given that both types of specifications are modeled in UML protocol state machines. Our method is based on the latest UML version (UML2.3), and it is proven to synthesize protocol specifications that are syntactically and semantically correct. As an example application, the synthesis method is used to derive the protocol specification of the H.323 standard used in Internet calls.
A distributed object-oriented model for telecommunication services
The purpose of this paper is to present some preliminary results of a research activity carried on at CSELT on the definition and prototype implementation of a distributed processing environment, based on the ODP Reference Model, . In particular we concentrate here on the computational and engineering viewpoints.
High Level Specification of Distributed and Mobile Information Systems
… Symposium on Innovation in Information & …, 2004
Nowadays, information systems are large and complex to develop. An important factor that influences in this complexity is that information systems are tending to be distributed with mobile components. Many technologies have emerged in dealing with distribution issues at an implementation level. However, few approaches have considered distribution from the beginning of the life cycle of software development and have dealt with distribution at a high abstraction level. In this paper, we focus on specifying distributed and mobile information systems at a high abstraction level using an approach called PRISMA. PRISMA is an architectural model which combines the Component-Based Software Development (CBSD) and Aspect-Oriented Software Development (AOSD) to describe software architectures. PRISMA has associated an Architectural Description Language (ADL) that is separated into a Type Definition Language and a Configuration Language. We use the Type Definition Language to specify the distribution aspect as a first order citizen of the language. Furthermore, we use the Configuration Language to configure the location of the instances of the software architecture.
Behaviour Modelling in Model Driven Architecture
… Proceedings Series WP09- …, 2009
Modeling languages that aim to capture PIM level behavior are still a challenge. We propose a high level behavioral formalism based on the Abstract State Machines (ASMs) for the specification and validation of software systems at PIM level. An ASM-based extension of the UML and its Action Semantics is here presented for the construction of executable class models at PIM level and also a model weaving process which makes the execution of such models possible. Our approach is illustrated using an Invoice Order System taken from the literature.
Seamless UML Support for Service-Based Software Architectures
Lecture Notes in Computer Science, 2004
The UML has become the de facto standard for the analysis and design of complex software. Tool support today includes the generation of code realizing the structural model described by class diagrams as well as code realizing the reactive behavior of the dynamic model described by statecharts. However, the CASE tool support for service-based architectures and especially later process phases addressed with component and deployment diagrams is rather limited. In this paper a seamless support of the whole service life cycle of service-based software architectures by means of UML is presented. We present the employed concepts to support the design of services (including full code generation), to compose applications out of services at design time, and to deploy services at run-time. Additionally, we describe our realization of these concepts in form of a CASE tool extension and a run-time framework.