Development and Verification of UML Architectures by Refinement and Extension Techniques (original) (raw)
Related papers
A contractual approach for the verification of UML2.0 software architectures
International Journal of Computer Applications in Technology
The functional and qualitative properties are conventionally considered after software is completed. Currently, researchers consider treating those properties as soon as the architectural design phase. In this paper, the modelling and verification of the syntactic, behavioural and qualitative properties in UML2.0 software architectures are studied. To achieve this, a UML profile extending the UML2.0 component model by a set of qualitative concepts is proposed. The new profile, called CUMLQoS, is able to model the UML2.0 software architectures equipped with qualitative properties. Our verification approach suggests using the Acme/Armani ADL as a checking machine of syntactic and qualitative properties of UML2.0 software architectures deriving from our CUMLQoS profile. The choice of this ADL is justified by its ability of formal verification of different types of properties related to software architectures. As a second step of our verification approach, UML2.0, Port State Machine (PoSM), Wright and CSP are combined to check the behavioural consistency of UML2.0 software architecture. To achieve this, a set of systematic rules is proposed allowing the translation of UML2.0 source model to the Wright target model. Using Wr2fdr tool, the Wright specification can automatically be translated to a CSP specification acceptable by the FDR2 model-checker.
An Approach for Modeling Architectural Design Rules in UML and its Application to Embedded Software
ACM Transactions on Software Engineering and Methodology, 2012
Current techniques for modelling software architecture do not provide sufficient support for modelling of architectural design rules. This is a problem in the context of Model-Driven Development in which it is assumed that major design artefacts are represented as formal or semi-formal models. This paper addresses this problem by presenting an approach to modelling architectural design rules in UML at the abstraction level of the meaning of the rules. The high abstraction level and the use of UML makes the rules both amenable to automation and easy to understand for both architects and developers, which is crucial to deployment in an organization. To provide a proof-of-concept a tool was developed that validates a system model against the architectural rules in a separate UML model. To demonstrate the feasibility of the approach the architectural design rules of an existing live industrial strength system were modelled according to the approach.
Incremental development of UML specifications using operation refinements
2008
In an incremental specification development process, operations are used to model dynamic aspects and can be refined gradually. We propose four kinds of operation refinement in order to control modifications when developing and refactoring UML specifications. Each refinement is described with its properties and illustrated by an example, showing which verifications can be done, using the B formal method.
An approach for modelling architectural design rules in UML and its application to embedded software
2012
peer-reviewedCurrent techniques for modelling software architecture do not provide sufficient support for modelling of architectural design rules. This is a problem in the context of Model-Driven Development in which it is assumed that major design artefacts are represented as formal or semi-formal models. This paper addresses this problem by presenting an approach to modelling architectural design rules in UML at the abstraction level of the meaning of the rules. The high abstraction level and the use of UML makes the rules both amenable to automation and easy to understand for both architects and developers, which is crucial to deployment in an organization. To provide a proof-of-concept a tool was developed that validates a system model against the architectural rules in a separate UML model. To demonstrate the feasibility of the approach the architectural design rules of an existing live industrial strength system were modelled according to the approac
Journal of Systems and Software, 2016
Modelling component behaviour is widely recognised as a complex task during the specification and design phases of reactive systems. Our proposal for treating this problem involves an incremental approach that allows UML state machines to be built using a composition of two types of development: model extension for adding services or behaviours, and refinement for adding details or eliminating non-determinism. At each step of the development process, the current model is verified for compliance with the model obtained during the previous step, in such a way that initial liveness properties are preserved. The novelty of this work lies in the possibility to combine and sequence both refinement and extension developments. This iterative process is usually not taken into account in conventional refinement relations. This set of development techniques and verification means are assembled into a framework called IDF (Incremental Development Framework), which is supported by a tool, under the acronym IDCM (Incremental Development of Compliant Models), developed herein in addition to the Topcased UML tool.
Automated Encapsulation of UML Activities for Incremental Development and Verification
Lecture Notes in Computer Science, 2009
With their revision in the UML 2.x standard, activities have been extended with streaming parameters. This facilitates a reuse-oriented specification style, in which dedicated functions can be contributed by self-contained activities as building blocks: Using streaming parameters, activities can be composed together in a quite powerful manner, since streaming parameters may also pass information while activities are executing. However, to compose them correctly, we must know in which sequence an activity may emit or accept these streaming parameters. Therefore, we propose special UML state machines that specify the externally visible behavior of activities. Further, we develop an algorithm to construct these state machines automatically for an activity based on model checking. Using these behavioral contracts, activities can then be composed without looking at their internal details. Moreover, the contracts can be used during system verification to reduce the complexity of the analysis.
Modeling Software Architecture with UML
2015
Abstract: Software Architecture is being widely used today to describe a very high level design methodology of large & heterogeneous software systems. A good Architectural representation scheme holds the key to the effectiveness of a Software architecture description and usage. In this paper, we look at UML (unified modeling language) as a prospect for a generalized architecture description language. UML also “unifies " the design principles of each of the object oriented methodologies into a single, standard, language that can be easily applied across the board for all object-oriented systems and a scheme AND-OR DFD method is introduced and developed.
An Institution for Simple UML State Machines
Lecture Notes in Computer Science, 2015
We present an institution for UML state machines without hierarchical states. The interaction with UML class diagrams is handled via institutions for guards and actions, which provide dynamic components of states (such as valuations of attributes) but abstract away from details of class diagrams. We also study a notion of interleaving product, which captures the interaction of several state machines. The interleaving product construction is the basis for a semantics of composite structure diagrams, which can be used to specify the interaction of state machines. This work is part of a larger effort to build a framework for formal software development with UML, based on a heterogeneous approach using institutions.