2,649 research outputs found
Design Environments for Complex Systems
The paper describes an approach for modeling complex systems by hiding as much formal details as possible from the user, still allowing verification and simulation of the model. The interface is based on UML to make the environment available to the largest audience. To carry out analysis, verification and simulation we automatically extract process algebras specifications from UML models. The results of the analysis is then reflected back in the UML model by annotating diagrams. The formal model includes stochastic information to handle quantitative parameters. We present here the stochastic -calculus and we discuss the implementation of its probabilistic support that allows simulation of processes. We exploit the benefits of our approach in two applicative domains: global computing and systems biology
Towards the Correctness of Software Behavior in UML: A Model Checking Approach Based on Slicing
Embedded systems are systems which have ongoing interactions with their environments, accepting requests and producing responses. Such systems are increasingly used in applications where failure is unacceptable: traffic control systems, avionics, automobiles, etc. Correct and highly dependable construction of such systems is particularly important and challenging. A very promising and increasingly attractive method for achieving this goal is using the approach of formal verification. A formal verification method consists of three major components: a model for describing the behavior of the system, a specification language to embody correctness requirements, and an analysis method to verify the behavior against the correctness requirements. This Ph.D. addresses the correctness of the behavioral design of embedded systems, using model checking as the verification technology. More precisely, we present an UML-based verification method that checks whether the conditions on the evolution of the embedded system are met by the model. Unfortunately, model checking is limited to medium size systems because of its high space requirements. To overcome this problem, this Ph.D. suggests the integration of the slicing (reduction) technique
To Do or Not to Do: Semantics and Patterns for Do Activities in UML PSSM State Machines
State machines are used ubiquitously in engineering software-intensive
systems. UML State Machines extend simple finite state machines with powerful
constructs. Among the many extensions, there is one seemingly simple and
innocent language construct that fundamentally changes state machines' reactive
model of computation: doActivity behaviors. DoActivity behaviors describe
behavior that is executed independently from the state machine once entered in
a given state, typically modeling complex computation or communication as
background tasks. However, the UML specification or textbooks are vague about
how the doActivity behavior construct should be appropriately used. This lack
of guidance is a severe issue as, when improperly used, doActivities can cause
concurrent, non-deterministic bugs that are especially challenging to find and
could ruin a seemingly correct software design. The Precise Semantics of UML
State Machines (PSSM) specification introduced detailed operational semantics
for state machines. To the best of our knowledge, there is no rigorous review
yet of doActivity's semantics as specified in PSSM. We analyzed the semantics
by collecting evidence from cross-checking the text of the specification, its
semantic model and executable test cases, and the simulators supporting PSSM.
We synthesized insights about subtle details and emergent behaviors relevant to
tool developers and advanced modelers. We reported inconsistencies and missing
clarifications in more than 20 issues to the standardization committee. Based
on these insights, we studied 11 patterns for doActivities detailing the
consequences of using a doActivity in a given situation and discussing
countermeasures or alternative design choices. We hope that our analysis of the
semantics and the patterns help vendors develop conformant simulators or
verification tools and engineers design better state machine models
A Formal Metamodeling Approach to a Transformation between Visual and Formal Modeling Techniques
Formal modeling notations and visual modeling notations can complement each other when developing software models. The most frequently adopted approach is to define transformations between the visual and formal models. However, a significant problem with the currently suggested approaches is that the transformation itself is often described imprecisely, with the result that the overall transformation task may be imprecise, incomplete and inconsistent. This paper presents a formal metamodeling approach to transform between UML and Object-Z. In the paper, the two languages are defined in terms of their formal metamodels, and a systematic transformation between the models is provided at the meta-level in terms of formal mapping functions. As a consequence, we can provide a precise, consistent and complete transformation between a visual model in UML and a formal model in Object-Z
- …