5344113
An Object-Oriented Approach to the Formal Specification of ODP Trader
An Object-Z formal speci cation of the ODP Trader is presented which concisely captures the hierarchical context structure, the distribution of information and the communication aspects of the Trader. Particular use is made of generic classes, class inheritance and object aggregation (i.e. the instantiation of collections of similar objects) to give a structured speci cation that can be readily extended.
18649413
Capturing periodic concurrent interactions of mission computer tasks
Safety critical systems, such as aviation systems controlled by software, often have hard real-time requirements. Producing the correct result at the right time is the fundamental goal of such systems. Formally specifying the system functions and the timing requirements is the crucial step towards achieving such a goal. Aviation systems often need to be modified or upgraded on a regular basis, i.e. functionality and timing constraints may be altered. Therefore, the formal specification of such systems needs to be easily reused, maintained and modified. This paper demonstrates how the task scheduling aspects of an aircraft mission computer can be formalised in TCOZ.
18404140
Deep Semantic Links of TCSP and Object-Z: TCOZ Approach
Abstract. Formal methods can be used in effective combination only if the semantic links between individual methods are clearly established. This paper discusses the semantic design of TCOZ, a language blended from Object-Z and TCSP. The semantic model adopted is the infinite timed failures model of TCSP, extended to include initial state and update events for modelling operations on internal state. An infinite trace model has been used so as to ensure proper account is taken of the potentially unbounded non-determinism allowed by Z schemas.
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.
5239234
The role of secondary attributes in formal object modelling
When modelling a large and complex system, clarity of the specification becomes an important factor. In object-oriented specification, the states of individual objects are captured by the values of their attributes. Frequently however, there are dependencies between the attributes of an object. An appropriate indication of which attributes are primary (independent) and which are secondary (dependent) can add significantly to clarity. This paper details the notion of secondary attributes, their roles and implications in formal object-oriented specification.
10062286
Integrating Object-Z with timed automata
When designing a complex system, Object-Z is a powerful logic-based language for modeling the system state aspects, and timed automata is an excellent graph-based notation for capturing timed control behaviour of the system. This paper presents an effective combination of the two techniques with novel composition and communication mechanisms. The combined notation enhances Object-Z with realtime modeling capability and also extends timed automata with enhanced structure and state modeling features.
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.
15893082
Adding pattern related information in structural and behavioral diagrams
Abstract Design patterns capture the distilled experience of expert designers. The compositions of design patterns may reuse design experience and solve a set of problems. Design patterns and their compositions are usually modeled using unified modeling language (UML). When a design pattern is applied or composed with other patterns, the pattern-related information may be lost because UML does not track this information. Thus, it is hard for a designer to identify a design pattern when it is applied or composed. The benefits of design patterns are compromised because the designers cannot communicate with each other in terms of the design patterns they use when the design patterns are applied or composed. In this paper, we present notations to explicitly represent the structural and behavioral aspects of each pattern in the applications and compositions of design patterns. The notations allow us to maintain pattern-related information in class and collaboration diagrams. Thus, a design pattern is identifiable and traceable from its application and composition with others in these diagrams. A case study is used to illustrate our approach.
2938720
Extending UML to Visualize Design Patterns In Class Diagrams
A design pattern describes a general solution to a design problem that recurs repeatedly in many projects. Software designers adapt the pattern solution to their specific project. Design patterns are usually modeled using UML. However, UML does not keep track of pattern-related information when a design pattern is applied or composed with other patterns. Thus, it is hard for a designer to identify design patterns in software system designs. The benefits of design patterns are compromised because the designers cannot communicate with each other in terms of the design patterns they use and their design decisions and tradeoffs. In this paper, we present the essential features of a new member of the UML language family that supports working with object-oriented design patterns. This UML extension allows the explicit representation of design patterns in software designs. We also discuss some of the relevant aspects of the UML profile which is based on standard UML extension mechanisms. A case study shows how it can be used to assist pattern-based software development.
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.
36530209
Determination of the star valency of a graph
The star valency of a graph G is the minimum, over all star decompositions π, of the maximum number of elements in π incident with a vertex. The maximum average degree of G, denoted by dmax-ave(G), is the maximum average degree of all subgraphs of G. In this paper, we prove that the star valency of G is either ⌈dmax-ave(G)/2⌉ or ⌈dmax-ave(G)/2⌉ + 1, and provide a polynomial time algorithm for determining the star valency of a graph.