4516614
Visualizing Design Patterns in Their Applications and Compositions
Design patterns are generic design solutions that can be applied and composed in different applications where pattern-related information is generally implicit in the Unified Modeling Language (UML) diagrams of the applications. It is unclear in which pattern instances each modeling element, such as class, attribute, and operation, participates. It is hard for a designer to find the design patterns used in an application design. Consequently, the benefits of design patterns are compromised because designers cannot communicate with each other in terms of the design patterns they used and their design decisions and trade-offs. In this paper, we present a UML profile that defines new stereotypes, tagged values, and constraints for tracing design patterns in UML diagrams. These new stereotypes and tagged values are attached to a modeling element to explicitly represent the role the modeling element plays in a design pattern so that the user can identify the pattern in a UML diagram. Based on this profile, we also develop a Web service (tool) for explicitly visualizing design patterns in UML diagrams. With this service, users are able to visualize design patterns in their applications and compositions because pattern-related information can be dynamically displayed. A real-world case study and a comparative experiment with existing approaches are conducted to evaluate our approach.
17418612
Visualizing design patterns with a UML profile
In this paper, we present a UML profile which defines new stereotypes, tagged values and constraints for visualizing design patterns in UML diagrams. These new stereotypes and tagged values are attached to a modeling element to explicitly represent the role the modeling element plays in a design pattern so that the user can identify the pattern in a UML diagram.
9559762
A logical framework for design composition
The design of a large component based software system typically involves the composition of different components. The lack of rigorous reasoning about the correctness of composition is an important barrier towards the promise of "plug and play". The author describes a rigorous logic framework to reason about component compositions. We focus our analysis on design components such as design patterns, which have been used by a large number of applications. We also propose methods to verify structural and behavioral composition correctness.
16769256
A model transformation approach for design pattern evolutions
The evolution of a design pattern typically involves the addition or removal of a group of modeling elements, such as classes, attributes, operations, and relationships. However, the possible evolutions of each design pattern are often not explicitly documented. Missing part of the evolution process may result in inconsistent evolution. In this paper, we define the evolution processes of design patterns in terms of two-level transformations, thus making the possible evolutions of each design pattern explicit. In addition, we automate the evolution processes as XSLT transformations that can transform the UML model of a design pattern application into the evolved UML model of the pattern. Both the original and evolved UML models are represented in the XML metadata interchange (XMI) format to facilitate the transformations. Furthermore, we check the consistency of the evolution results using the Java Theorem Prover
26328924
Model checking the composition of hypermedia design components
Component-based software development aims at building software system by assembling software components to reduce cost, risk and time-to-market. However, conflicts among components constitute a crucial barrier to successful software composition. In this paper, we present an approach to analyze the properties of components and their compositions in order to detect and correct composition errors. We also demonstrate how model checking can be used to verify properties about the composition of design components. Furthermore, using a hypermedia case study, we show how to represent, instantiate, and integrate design components, and how to find composition errors by applying model checking techniques.
26263616
Developing a Formal Design Analysis Framework
15362726
State, event, time and diagram in system modeling
The design of complex systems requires powerful mechanisms for modeling state, concurrent events, and real-time behavior; as well as for visualising and structuring systems in order to control complexity. Methods integration has become a recent research trend in software specification and design. In the graphical area, many object-oriented methods have merged into one, the Unified Modeling Language (UML) which combines various diagrammatic modeling techniques to model static and dynamic aspects of software systems. Although traditional formal methods have not scale-up well, new integrated formal methods show great promise. This tutorial will present the state of the art in formal modeling techniques (state-based Object-Z and event-based Timed CSP), their integration (TCOZ), and transformation techniques from the integrated formalism to UML diagrams. An XML web environment for projecting integrated formal models to UML diagrams will also be demonstrated.
15881034
Network Topology and a Case Study in TCOZ
Object-Z is strong in modeling the data and operations of complex systems. However, it is weak in specifying real-time and concurrent systems. Timed Communicating Object-Z (TCOZ) extends the Object-Z notation with Timed CSP constructs. TCOZ is particularly well suited for specifying complex systems whose components have their own thread of control. This paper demonstrates expressiveness of the TCOZ notation through a case study on specifying a multi-lift system that operates in real-time.
5467078
Software modeling techniques and the semantic Web
Following the success of XML, W3C envisions the semantic Web (Berners-Lee et al., 2001) as the next generation of Web in which data are given well-defined and machine-understandable semantics so that they can be processed by intelligent software agents. Semantic Web can be regarded as an emerging area from the knowledge representation and the Web communities. The software engineering community can also play an important role in the semantic Web development. Modeling and verification techniques can be useful at many stages during the design, maintenance and deployment of semantic Web ontology. We believe semantic Web will be a new research and application domain for software modeling techniques and tools. For example, recent research results have shown that UML, Z (Woodcock and Davis, 1996) and Alloy (Jackson, 2002) can provide modeling, reasoning and consistency checking services for semantic Web.
8741871
Living with free type and class union
There are two constructs in the formal specification language Object-Z for modelling polymorphic and recursive structures. One construct, the free type, is adopted from the Z specification language. The other, class-union, facilitates polymorphic class declarations. Free type and class-union constructs are respectively based upon the functional value point of view and the object reference point of view. Consequently, the roles these two constructs perform in system modelling are different. The free type and class-union constructs are compared and discussed through various examples. The aim of this comparison and discussion is to present guidelines on how to appropriately and effectively use these two constructs to specify polymorphic and recursive structures.
7872291
Sensors and Actuators in TCOZ
Timed Communicating Object Z (TCOZ) combines Object-Z's strengths in modeling complex data and algorithms with Timed CSP's strengths in modeling real-time concurrency. TCOZ inherits CSP's channel-based communication mechanism, in which messages represent discrete synchronisations between processes. The purpose of most control systems is to observe and control analog components. In such cases, the interface between the control system and the controlled systems cannot be satisfactorily described using the channel mechanism. In order to address this problem, TCOZ is extended with continuous-function interface mechanisms inspired by process control theory, the sensor and the actuator. The utility of these new mechanisms is demonstrated through their application to the design of an automobile cruise control system.