Requirements analysis of the VoD application using the tools in TRADE

This report contains a specification of requirements for a video-on-demand (VoD) application developed at Belgacom, used as a trial application in the 2RARE project. The specification contains three parts: an informal specification in natural language; a semiformal specification consisting of a number of diagrams intended to illustrate the informal specification; and a formal specification that makes the requiremants on the desired software system precise. The informal specification is structured in such a way that it resembles official specification documents conforming to standards such as that of IEEE or ESA. The semiformal specification uses some of the tools in from a requirements engineering toolkit called TRADE (Toolkit for Requirements And Design Engineering). The purpose of TRADE is to combine the best ideas in current structured and object-oriented analysis and design methods within a traditional systems engineering framework. In the case of the VoD system, the systems engineering framework is useful because it provides techniques for allocation and flowdown of system functions to components. TRADE consists of semiformal techniques taken from structured and object-oriented analysis as well as a formal specification langyage, which provides constructs that correspond to the semiformal constructs. The formal specification used in TRADE is LCM (Language for Conceptual Modeling), which is a syntactically sugared version of order-sorted dynamic logic with equality. The purpose of this report is to illustrate and validate the TRADE/LCM approach in the specification of distributed, communication-intensive systems

A Formal Methodology for the Specification of Distributed Systems From an Object Perspective.

Distributed computing systems are systems in which multiple processors run independently by communicating with each other. The design of distributed systems is difficult to achieve as the execution patterns of distributed system are typically more complex than those of non-distributed computing systems. The application of object-oriented techniques to the design of distributed systems has the potential to increase the power of modeling and computing. A formal methodology which includes a specification language, developed from an object perspective, for the development of distributed systems is presented. The formal specification language, DOSL (Distributed Object-based Specification Language), represents the specification of distributed systems from an object perspective. DOSL has a hybrid format which combines the property-oriented approach and the model-oriented approach. In particular, it has strong features for message passing specification. The semantics of DOSL is defined formally by two operational semantics methods: transition systems and Petri nets. In addition, a formal object-based methodology for the specification of distributed systems is given. The methodology presents a framework for using the DOSL specification language and includes an integrated formalized method for identification of objects, their operations and behaviors from multiple modeling formats. The implementation of the methodology is supported by assistance with a knowledge base

Object-Oriented Modeling and Design Using DELTA, an Incremental Design Language.

Object-oriented technology has opened the doors for many new ideas in system development. The object-oriented paradigm has produced many new object-oriented programming languages. As with any new methodology, a need for formalism arises to remove ambiguities and inconsistencies and to bring a sense of continuity to software design. Formal languages provide a sound basis for software development throughout the software life cycle. This work presents a set of characteristic features for object-oriented design languages and defines a formal object-oriented design language, DELTA. The rapidly changing face of software has led to an ever increasing need to update out-of-date methods and user interfaces. Software developers want to be able to use the same type of visual interfaces available in application software. The introduction of windowing environments has led to a market for methodologies which incorporate graphical features to supplement textual components of software. The present genre of formal languages must evolve in the same direction to be considered as effective in the design process. DELTA meets this need by providing a modern development environment with graphical features to complement the text that is necessary in any design specification. Researchers and prominent software engineers have provided a litany of object-oriented methodologies. The commonality of these methods is the step-by-step approach to software development. Software engineers agree in theory that the best approach to designing software which will stand the test of time is one which has a sound established discipline. Such a discipline produces a design in incrementations. DELTA supports this theory by providing established levels of incremental design representation. The advent of computer-aided design has led to the evolution of rapid-prototyping. Changes in system requirements, detection of errors, competition in the market, and the ongoing maintenance of software systems can be addressed by the development of system prototypes. DELTA responds to this challenge by establishing a design specification representation which can be easily mapped to an object-oriented programming language. This transition from design to prototype can be enhanced by formal annotations to the chosen implementation language. Annotations have been developed for DELTA software designs prototyped in the object-oriented language Actor

UML ACTION SEMANTICS FOR MODEL TRANSFORMATION SYSTEMS

The Action Semantics for UML provides a standard and platform independent way to describe the behavior of methods and executable actions in object-oriented system design prior to implementation allowing the development of highly automated and optimized code generators for UML CASE tools. Model transformation systems provide visual but formal background to specify arbitrary transformations in the Model Driven Architecture (the leading trend in software engineering). In the current paper, we describe a general encoding of model transformation systems as executable Action Semantics expressions to provide a standard way for automatically generating the implementation of formal (and provenly correct) transformations by off-the-shelf MDA tools. In addition, we point out a weakness in the Action Semantics standard that must be improved to achieve a stand-alone and functionally complete action specification language

CoFI: The Common Framework Initiative for Algebraic Specification and Development

An open collaborative effort has been initiated: to design acommon framework for algebraic specification and development of software. The rationale behind this initiative is that the lack of such a common framework greatly hinders the dissemination and application of researchresults in algebraic specification. In particular, the proliferationof specification languages, some differing in only quite minor ways from each other, is a considerable obstacle for the use of algebraic methods in industrial contexts, making it difficult to exploit standard examples, case studies and training material. A common framework with widespread acceptancethroughout the research community is urgently needed.The aim is to base the common framework as much as possible on a critical selection of features that have already been explored in various contexts. The common framework will provide a family of specificationlanguages at different levels: a central, reasonably expressive language, called CASL, for specifying (requirements, design, and architecture of) conventional software; restrictions of CASL to simpler languages, for use primarily in connection with prototyping and verification tools; and extensionsof CASL, oriented towards particular programming paradigms,such as reactive systems and object-based systems. It should also be possibleto embed many existing algebraic specification languages in members of the CASL family. A tentative design for CASL has already been proposed. Task groupsare studying its formal semantics, tool support, methodology, and other aspects, in preparation for the finalization of the design

Formal Specification Of Design Patterns: A Comparison Of Three Existing Approaches And Proposing Two-Level Grammars As A New Approach

Patterns are Object-Oriented reusable units. The principal idea behind patterns is to capture and reuse the abstractions that have been formed by expert programmers and designers to solve problems that occur in particular contexts. These abstractions capture the valuable experiences of experts in solving problems. Although patterns are currently being used successfully, there is no general agreement among the software community as to how patterns should be formalized or represented. Various formal specification schemes have been proposed to complement the natural language description of patterns in order to alleviate the ambiguities inherent in the natural language description by rigorously reasoning about the structural and behavioral aspects of patterns. Existing formal specification languages of design patterns have generally failed to provide a standard definition, specification, or representation for patterns because there is no general agreement as to how patterns should be formalized. Also, each formal specification is generally based on a different mathematical formalism and when pattern users want to understand a pattern, first they have to understand the respective mathematical formalism. In addition to comparing three existing formal specification schemes, the main objective of this research work was to lay the foundation for developing a formal specification scheme that could be understandable without having to delve into the details of the underlying formalism. This research work attempted to capture and represent the structural aspects of design patterns since capturing the behavioral aspects of design patterns is a semantic issue and is beyond the scope of this work. Two-Level Grammar (TLG) was used to capture and represent the structural aspects of design patterns. This study was conducted using the GoF design patterns [Gamma et al. 1995]. It has already been demonstrated that TLGs have the capability to represent the building blocks of object-oriented software systems. The primary advantage of TLGs in defining design patterns is that specifications written in TLGs are understandable due to their natural-language-like vocabulary [Edupuganty 1987] [Lee 2003] [Maluszynski 1984]. The TLG representation of the observer pattern was developed to gauge the feasibility of the proposed pattern representation scheme. TLGs could help pattern users understand the formalized version of patterns more readily compared to other formal specification methods that are difficult to understand due to their arcane mathematical notations.Computer Science Departmen

A Machine With Class: A Framework for Object Generation, Integration and Language Authentication (FROGILA)

The object technology model is constantly evolving to address the software crisis problem. This novel idea which informed and currently guides the design style of most modern scalable software systems has caused a strong belief that the object-oriented technology is the ultimate answer to the software crisis, i.e. applying an object-oriented development method will eventually lead to quality code. It is important to emphasise that object-orientedness does not make testing obsolete. As a matter of fact, some aspects of its very nature introduce new problems into the production of correct programs and their testing due to paradigmatic features like encapsulation, inheritance, polymorphism and dynamic binding as this research work shows. Most work in testing research has centred on procedure-oriented software with worthwhile methods of testing having been developed as a result. However, those cannot be applied directly to object-oriented software owing to the fact that the architectures of such systems differ on many key issues. In this thesis, we investigate and review the problems introduced by the features of the object technology model and then proceed to show why traditional structured software testing techniques are insufficient for testing object-oriented software by comparing the fundamental differences in their architecture. Also, by reviewing Weyuker’s test adequacy axioms we show that program-based testing and specification-based testing are orthogonal and complementary. Thus, a software testing methodology that is solely based on one of these approaches (i.e. program-based or specification-based testing) cannot adequately cover all the essential paths of the system under test or satisfactorily guarantee correctness in practice. We argue that a new method is required which integrates the benefits of the two approaches and further builds upon their individual strengths to create a more meaningful, practical and reliable solution. To this end, this thesis introduces and discusses a new automaton-based framework formalism for object-oriented classes called the Class-Machine and a test method that is based on this formalism. Here, the notion of a class or the idea behind classification in object-oriented languages is embodied within a machine framework. The Class-Machine model represents a polymorphic abstraction for heterogeneous families of Object-Machines that model a real life problem in a given domain; these Object-Machines are instances of different concrete machine types. The Class-Machine has an extensible machine implementation as well as an extensible machine interface. Thus, the Class-Machine is introduced as a formal framework for generating autonomous Object-Machines (i.e. Object-Machine Generator) that share common Generic Class-Machine States and Specific Object-Machine States. The states of these Object-Machines are manipulated by a set of processing functions (i.e. Class-Machine Methods and Object-Machine Methods) that must satisfy a set of preconditions before they are allowed to modify the state(s) of the Object-Machines. The Class-Machine model can also be viewed as a platform for integrating a society of communicating Object-Machines. To verify and completely test systems that adhere to the Class-Machine framework, a novel testing method is proposed i.e. the fault-finders (f²) - a distributed family of software checkers specifically designed to crawl through a Class-Machine implementation to look for a particular type of fault and tell us the location of the fault in the program (i.e. the class under test). Given this information, we can statistically show the distribution of faults in an object-oriented system and then provide a probabilistic assertion of the number and type of faults that remain undetected after testing is completed. To address the problems caused through the encapsulation mechanism, this thesis introduces and discusses another novel framework formalism that has complete visibility on all the encapsulated methods, memory states of the instance and class variables of a given Object-Machine or Class-Machine system under test. We call this the Class Machine Friend Function (CMƒƒ). In order to further illustrate all the fundamental theoretical ideas and paradigmatic features inherent within our proposed Class-Machine model, this thesis considers four different Class-Machine case studies. Finally, to further show that the Class-Machine theoretical purity does not mitigate against practical concerns, our novel object-oriented specification, verification, debugging and testing approaches proposed in this thesis are exemplified in an automated testing tool called: The Class-Machine Testing Tool (CMTT)

Structural Compatible Ontologies for Automation Technology

Gegenstand der vorliegenden Dissertation ist ein integriertes Entwurfsverfahren für Automatisierungssysteme, bei dem sowohl die verhaltenbeschreibende als auch die gerätetechnische Sicht gleichermaßen Berücksichtigung finden. Dieses Entwurfsverfahren basiert auf der Erkennung, Überprüfung und Einhaltung von Ähnlichkeiten, die zwischen geräte- und verhaltensbeschreibenden Systemmodellen herrschen. So können die während der Geräte- und Anlagenplanung entstehenden Spezifikationen (Stücklisten, Baugruppenhierarchien, Netzwerke) bis in die aus automatisierungstechnischer Sicht notwendige Detailltiefe in den Verhaltensmodellen konsistent nachgezogen werden. Auf der Basis prozesstheoretischer Überlegungen werden kombinierte Petrinetz- und Bondgraphen-Modelle als dynamische Beschreibungsmittel gewählt, um das für Automatisierungssysteme typische hybride Verhalten darstellen zu können. Für die Beschreibung gerätetechnischer Strukturen dient das STEP-Produktmodell nach ISO 10303. Um die Ähnlichkeiten zwischen der verhaltenbeschreibenden und der gerätetechnischen Sicht formal fassen zu können, werden die den Systemmodellen zugrundeliegenden Modellkonzepte in Ontologien überführt und diese dann mit strukturverträglichen Abbildungen, sogenannten Morphismen, aufeinander abgebildet. Sowohl die Ontologien als auch die über diesen Ontologien definierten Morphismen werden mit Mitteln der OMA (Object Management Architecture) in MOF/UML-Modelle und OCL-Spezifikationen übertragen. Diese Spezifikationen sind dann die Implementationsgrundlage einer Reihe von Softwarewerkzeugen, die einen Entwurfsrahmen bilden, mit dem das integrierte Entwurfsverfahren anhand von einfachen Beispielen näher untersucht wird.We present an integrated design methodology for automation systems, where both the behavioural and the device oriented aspects are considered. The design methodology is based on the recognition and compliance of similarities, which can be found between device oriented and behaviour describing system models. Herewith it is possible to align the behavioural models with existing device specifications (part lists, bills of material, assembly hierarchies networks) in a consistent way and with the granularity that is adequate for automation systems design. Based on a formal process theory the combination of Petrinets and Bondgraphs is choosen to represent the hybrid process dynamics which are characteristic for automation systems. The device oriented structures are described with STEP product models according to ISO 10303. The formal specification of the aforesaid similarities between device oriented and behavioural system models is achieved within two steps. First the used description methods are transformed into ontologies. Then the ontologies are mapped on each other based on structure respecting mappings called morphism. Both the ontologies and the morphisms are defined by means of OMA (Object Management Architecture), namely MOF/UML for the ontology specification and OCL for the morphism specification. These specifications are then the basis for the implementation of different software tools which are combined into one development framework. Utilizing this framework the integrated design methodology is examined with simple examples

Incorporating design explanation within formal object-oriented method (FOOM)

Requirements engineering is a commencing phase in the development of either software applications or information systems. It is concerned with understanding and specifying the customer\u27s requirements of the system to be delivered. Throughout the literature, this is agreed to be one of the most crucial and, unfortunately, problematic phases in development. Despite the diversity of research directions, approaches and methods, the question of process understanding and management is still limited. Among contemporary approaches to the improvement of the current practice of Requirements Engineering, Formal Object-Oriented Method (FOOM) has been introduced as a new promising solution. The FOOM approach to requirements engineering is based on a synthesis of socio-organisational theory, the object-oriented approach, and mathematical formal specification. The entire FOOM specification process is evolutionary and involves a large volume of changes in requirements. During this process, requirements evolve through various forms of informal, semi-formal, and formal while maintaining a semantic link between these forms and, most importantly, conforming to the customer\u27s requirements. A deep understanding of the complexity of the requirements model and its dynamics is critical in improving requirements engineering process management. This thesis investigates the benefits of documenting both the evolution of the requirements model and the rationale for that evolution. Design explanation explains and justifies the deliberations of, and decisions made during, the design activity. In this thesis, design explanation is used to describe the requirements engineering process in order to improve understandability of, and traceability within, the evolving requirements specification. The design explanation recorded during this research project is also useful in assisting the researcher in gaining insights into the creativity and opportunistic characteristics of the requirements engineering process. This thesis offers an interpretive investigation into incorporating design explanation within FOOM in order to extend and advantage the method. The researcher\u27s interpretation and analysis of collected data highlight an insight-driven and opportunistic process rather than a strictly and systematically predefined one. In fact, the process was not smoothly evolutionary, but involved occasional \u27crisis\u27 points at which the model was reconceptualised, simplified and restructured. Therefore, contributions of the thesis lie not only in an effective incorporation of design explanation within FOOM, but also a deep understanding of the dynamic process of requirements engineering. The new understanding of the complexity of the requirements model and its dynamics suggests new directions for future research and forms a basis for a new approach to process management