168887
On analysis of design component contracts: a case study
Software patterns are a new design paradigm used to solve problems that arise when developing software within a particular context. Patterns capture the static and dynamic structure and collaboration among the components in a software design. A key promise of the pattern-based approach is that it may greatly simplify the construction of software systems out of building blocks and thus reuse experience and reduce cost. However, it also introduces significant problems in ensuring the integrity and reliability of these composed systems because of their complex software topologies, interactions, and transactions. There is a need to capture these features as a contract through a formal model that allows us to analyze pattern-based designs. In this paper, we provide a formal framework for ensuring the integrity of the compositions in object-oriented designs by providing mathematically rigorous modeling and analysis techniques for object-oriented systems comprising pattern-based designs as the basic building blocks or design components. A case study related to a hypermedia Web-based application is presented to illustrate our approach in distributed systems.
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.
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.
26263616
Developing a Formal Design Analysis Framework
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
10543361
Commutability of Design Pattern Instantiation and Integration
Design patterns capture expert design experience in generic design structure and behavior. A design pattern needs to be instantiated before using. It can be integrated with other patterns as well. The instantiation and integration operations are two important operations when a designer uses a design pattern in a particular application. In this paper, we investigate the commutability of these two operations based on our formal specification framework. We provide rigorous proofs on the conditions when the order of these two operations does not matter. Our results enable the software designers to choose their design processes with assurance of their equivalence.
207130315
Formal Designs for Embedded and Hybrid Systems
The design of embedded and hybrid systems requires powerful mechanisms for modeling data, state, concurrency and real-time behaviour. The {first} part of this paper illustrates a powerful design notation Timed Communicating Object Z (TCOZ) that has both channel based and sensor/actuator based interfaces. We believe that TCOZ is well suited for presenting more complete and coherent design models for complex embedded and hybrid systems. However, the challenge is how to analyze and check these models with tools support. One effective approach is to project (transform) the design models into multiple domains, then to use existing specialized tools in those domains to perform the checking and analyzing tasks. The second part of this paper demonstrates one particular projection from TCOZ designs to Timed Automata (TA) models so that TA model checkers can be used to check time related properties.
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.
31098795
Multipoint Fine-Scale Mapping Susceptibility Genes with Multiple Ancestral Haplotypes
13839820
Relating /spl pi/-calculus to Object-Z
Software systems have become increasingly distributed, dynamic and mobile. The complex state and dynamic interfaces of software components and their concurrent interactions provide challenging research issues in system specification and design. An effective combination of structured state-based formalism and dynamic action-based calculus may be a good solution for modeling complex distributed mobile systems. In this paper, we investigate the semantic links between Object-Z and /spl pi/ calculus and consequently introduce a powerful specification technique PiOZ that brings the strengths of the two together. The operational semantics of PiOZ integrates state transition semantics of Object-Z and /spl pi/-calculus reduction rules. The typing rules of PiOZ are developed and reasoning of a system property is presented.
12666680
Semantic Web Languages - Towards an Institutional Perspective
The Semantic Web (SW) is viewed as the next generation of the Web that enables intelligent software agents to process and aggregate data autonomously. Ontology languages provide basic vocabularies to semantically markup data on the SW. We have witnessed an increase of numbers of SW languages in the last years. These languages, such as RDF, RDF Schema (RDFS), the OWL suite of languages, the OWL− − suite, SWRL, are based on different semantics, such as the RDFS-based, description logic-based, Datalog-based semantics. The relationship among the various semantics poses a challenge for the SW community for making the languages interoperable. Institutions provide a means of reasoning about software specifications regardless of the logical system. This makes it an ideal candidate to represent and reason about the various languages in the Semantic Web. In this paper, we construct institutions for the SW languages and use institution morphisms to relate them. We show that RDF framework together with the RDF serializations of SW languages form an indexed institution. This allows the use of Grothendieck institutions to combine Web ontologies described in various languages.