7 Formal description methods

The situation of telecommunications systems is rapidly evolving towards a state characterized by the presence of a multitude of services integrated in a single network structure. In order to ease their integration, it is important to provide an unambiguous description of the organization, of the functionality, and of the relationships existing among services. Since it is not possible to completely foresee the situation of services in the future, the description should be modular, so that the task of adding new services to an existing environment is simplified. Formal description techniques are languages designed to handle such descriptions. Their goal is to produce correct and unambiguous specifications, understanding and modeling the system and the domain within which it operates. Their input is a set of required statements and a conceptual overview of the system. Their output is a formal representation that captures the functional behavior. On the other hand, the throughput of physical networks is constantly growing, reaching the order of Gbit/s. In the meantime, services needing high throughput, like multimedia conferencing systems are being designed, creating a need for flexible, high performance communication systems. An important feature of new high speed services is their increased need for guarantees. Therefore, the use of powerful performance modeling techniques becomes of prime importance. Their goal is to obtain some notion of how the system will perform under a given set of conditions. Performance evaluation theorists have long been using system specifications to make a heuristic model of the system and then an analysis of the model. When system specifications exist, the question arises whether a more direct path to performance analysis can be found. Our scope is to provide a methodology that fully and consistently integrates formal specification and performance evaluation. A problem is that many of the bottlenecks and impediments to smooth data flow have to do with implementation issues not directly dealt within the system specification itself. Therefore, prior to generating a performance model, the formal specification should be enhanced with the relevant non-functional information. It is essential to assure a smooth specification of the non-functional information. Thus, it is necessary to consistently add this information to the formal specification. Besides, the extended formal method should focus on conserving the semantics of the original one, and on providing a coherent extension of the semantics and syntax for the new concepts. Since all relevant required information is integrated within the formal extended representation, we provide a mapping technique that translates the extended formal representation into a performance modeling conserving the properties of the formal model. In parallel to the development of a performance model, the formal model can be validated and verified, and their implementation can be tested for conformance towards the original formal model. Finally, the performance modelling is implemented in a programming language, and then simulated. The results from simulation can be reused as inputs for the optimization of the formal specification (functional optimization) or the extended formal model (design optimization). To sum up, the goal of this work is to: Define extensions to current formal methods that allow to enhance the formal specification with performance modeling related information. Develop a method to translate the extended formal specification into a performance modeling. Develop rules and guidelines to automatically implement the performance modeling for the purpose of a performance evaluation (we use the commercial tool Opnet). Develop a consistent and coherent methodology for the integration of performance modeling and formal specification.

This paper describes a research result on automatic generation of abstract test cases from INAP protocol in formal specifications by using and applying many existing related algorithms and techniques such as the testing framework, rural Chinese postman tour and UTO (Unique Input Output) sequence concepts. We use the I/OFSM (Input/Output Finite State Machine) generated from SDL specifications and a characterizing sequence, called Unique Input/Output (UIO) sequence, is defined for the I/O FSM. The UIO sequence is combined with the concept of rural Chinese postman tour, without reliable reset capability, to obtain an optimal test sequence. To develop this method, first of all, we establish a framework leading to formal testing methodology which can be used to assess the conformance of an IUT (Implementation Under Test) to the behaviours specified in an I/OFSM which is equivalent to corresponding FDT (Formal Description Technique) specification. By this framework, we present a methodology for automatic test generation from FDT specifications. A prototype of the proposed framework has been built with special attention to real application in order to generate the executable test cases in an automatic way.

Computer networks are large and complex systems. The use of natural language to design and analyse communications protocols will lead to ambiguous representations. This inadequacy of the natural language gives rise to the many recent research works on formal description techniques (FDTs). FDTs are methods to define the behaviour of an information processing system in a language with formal syntax and semantics. FDT has been chosen as a basis for the design of protocol converter. A survey of existing widely accepted FDTs is presented. From this survey, a selection is made for an appropriate FDT to be used as the basis for future research work on FDT-based protocol converter.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Falafel, a functional programming language with first-class arrays, is being developed at the University of Saskatchewan. It is an experimental vehicle for work in language definition and implementation. This paper discusses some of the fundamental design decisions that underlie the language and its implementations. Falafel has drawn ideas from array-based programming languages (APL [Iverson] and Nial [Jenkins]_[More]), functional programming languages (Miranda™ [Turner] and Haskell [Haskell]), and dataflow programming languages (Id [Nikhil]_and Sisal [Sisal]). This paper discusses the nature of Falafel’s value space, the structure of arrays, the role of strong polymorphic typing, the use of lazy evaluation, and a means of partial definition of arrays. A full definition of Falafel is to be published separately.

This thesis proposes a novel way of performing type checking, whose results are incremental, depending on the provided local information. This new way of type checking is called co-contextual, where all context information of expressions, methods, classes, etc., is removed. Instead, we introduce corresponding structures using requirements. Standard type systems are translated to the co-contextual ones systematically using dualism as technique. Type systems play an important role to prevent execution errors from occurring during runtime. They are used to check programs statically for potential errors. Programs are type checked against a given set of rules. Depending on these rules programs are well-typed or not. The set of these rules is called typing rules. Each type rule associates types to the constructs of a program given a certain context. There can be different forms of contexts, depending on the features of the typed programming language. Functional languages use a typing context of variables and their types; object-oriented (OO) languages use additional class tables. Class tables are used for example to ensure that method and class declarations are well-typed. Type checking is performed top-down. While traversing the syntax tree of a program, typing contexts are extended with information on the expressions and their types. In case of OO, class tables are extended with clauses from class declarations, including the class members, i.e., fields, methods, or constructors. Contexts are passed through the nodes of the syntax tree in order to coordinate type checking between them. Therefore, while traversing the syntax tree top-down, the type checker creates dependencies between otherwise independent subexpressions. This way, it inhibits incrementalization and parallelization of type checking. That is, a change to a node of the syntax tree would require to redo the type check of the whole syntax tree. In this thesis a novel formulation of type systems is proposed, in order to remove dependencies between subexpressions. We propose a co-contextual formulation of typing rules that depends only on the local program constructs, e.g., expressions, methods, classes. The co-contextual typing rules have as conclusion a type and sets of requirements. That is, contexts and class tables are replaced by the dual concept of context and class table requirements. In addition, operations on contexts and class tables are replaced by new dual operations on requirements. The co-contextual type checker traverses a syntax tree bottom-up and merges context requirements of independently checked subexpressions. We describe a method for systematically constructing a co-contextual formulation of type rules from a regular context-based formulation and we show how co-contextual type rules give rise to incremental type checking. We derive co-contextual type checkers for functional and OO languages. As a representative of functional languages we consider PCF and extensions of it: records, parametric polymorphism, structural subtyping and let-polymorphism. Also, we investigate featherweight java (FJ) as the basis of OO languages and extensions of it: method overloading and generics. We build a1 co-contextual type checker for FJ enabling key features of OO languages: subtype polymorphism, nominal typing and implementation inheritance. The dualism between the co-contextual and contextual type systems preserves the correctness of the contextual calculus. That is, we prove the correctness of the co-contextual calculus via the equivalence between contextual type rules and their co-contextual formulations. We implemented an incremental type checker for PCF along with a performance evaluation showing that co-contextual type checking has performance comparable to standard context-based type checking, and incrementalization can improve performance significantly. Regarding FJ, we implemented a co-contextual type checker with incrementalization and compared its performance against javac on a number of realistic programs. Our performance evaluation shows significant speedups for the co-contextual type checker with incrementalization in comparison to javac.

Functional programming is a programming paradigm that is becoming increasingly popular among software developers. This is due in part to the rise of distributed systems and the need for more robust and scalable code. In the paper is presented an overview of the syntax and capabilities of Lambda expressions in three programming languages – C#, Java and Python. Performance of programming language constructions is an important research task. Some popular topics for investigation are comparison of programming languages efficiency in fields like bioinformatics or classification of Lambda expression usage and their productiveness. In the current study the performance of Lambda expressions is tested with three specific test cases and the results are compared to alternative technologies that could be used to solve similar problems. The results shows that speed performance of C# is the best from the compared languages and that List Comprehensions is the optimal method for collection filtering in Python.

Formal Description Techniques (FDT), such as LOTOS or SDL are at the base of a technology for the specification and the validation of telecommunication systems. Due to the availability of commercial tools, these formalisms are now being widely used in the industrial community. Alternatively, a number of quite effcient verification tools have been developed by the research community. But, most of these tools are based on simple ad hoc formalisms and the gap between them and real fdt restricts their use at industrial scale.This context motivated the development of an intermediate representation called if which is presented in the paper. if has a simple syntactic structure, but allows to express in a convenient way most useful concepts needed for the specification of timed asynchronous systems. The benefits of using if are multiples. First, it is general enough to handle significant subsets of most fdts, and in particular a translation from sdl to if is already implemented. Being built upon a mathematically sound model (extended timed automata) it allows to properly evaluate different semantics for fdts, in particular with respect to time considerations. Finally, if can serve as a basis for interconnecting various tools into a unified validation framework. Several levels of if program representations are already available via well defined apis and allow to connect tools ranging from static analyzers to model-checkers.keywordsasynchronytimed systemstimed automatamodel-checkingstatic analysis

This paper describes the use of PROTEAN and associated methodology to verify the ISO FTAM (File Transfer, Access and Management) DIS (Draft international standard) protocol and discusses the analysis of its behaviour using PROTEAN facilities. PROTEAN is an automated validation tool developed by Telecom Australia. The formal description technique used is Numerical Petri Nets (NPNs), an extension of Petri Nets. The procedures carried out were based primarily on reachability analysis. The behaviour of the protocol as specified was compared to its service specification. There are two protocol machines specified for FTAM: the basic protocol and the error recovery protocol machines.

Specifications of a simplified transport protocol using different formal description techniques

This is the 23rd Self-Assessment Procedure. 1 The purpose of this procedure is to let its readers test their knowledge of some of the more important features of significant programming languages. The features of imperative languages like Fortran, Algol 60, PL/I, Pascal, Modula-2, C, and Ada considered are data types, data structures, control structures, program units, scope of names, and parameter passing. Some of the corresponding features of functional languages like Lisp, logic programming languages like Prolog, and ohject-oriented programming languages like C++ and Smalltalk, are reviewed. Finally brief consideration is given to syntax and semantics, chiefly by reference to the Backus-Naur form, BNF. The features of programming languages affect all aspects of programming, including the ease of writing and maintaining programs, the reliahility of software, and the efficiency and portability of programs. Knowledge of programming language concepts and constructs is of importance to software developers, programmers, and designers of programming languages and compilers. The topic of this procedure should be of interest to any computer science student or practitioner who wishes to test his or her knowledge and learn more about one of the most important and broad areas in the computer field. The language used most often in the questions is Pascal, with Ada, Lisp, and Prolog also featured prominently. A glossary is included which defines some of the terms used in the procedure. The questions are either multiple-choice or short answer. Some of the multiple-choice questions allow for more than one correct answer.

Computer scientists often need to learn new programming languages quickly. The best way to prepare for this is to understand the foundational principles that underlie even the most complicated industrial languages. This text for an undergraduate programming languages course distills great languages and their design principles down to easy-to-learn 'bridge' languages implemented by interpreters whose key parts are explained in the text. The book goes deep into the roots of both functional and object-oriented programming, and it shows how types and modules, including generics/polymorphism, contribute to effective programming. The book is not just about programming languages; it is also about programming. Through concepts, examples, and more than 300 practice exercises that exploit the interpreter, students learn not only what programming-language features are but also how to do things with them. Substantial implementation projects include Milner's type inference, both copying and mark-and-sweep garbage collection, and arithmetic on arbitrary-precision integers.

Computer scientists often need to learn new programming languages quickly. The best way to prepare for this is to understand the foundational principles that underlie even the most complicated industrial languages. This text for an undergraduate programming languages course distills great languages and their design principles down to easy-to-learn 'bridge' languages implemented by interpreters whose key parts are explained in the text. The book goes deep into the roots of both functional and object-oriented programming, and it shows how types and modules, including generics/polymorphism, contribute to effective programming. The book is not just about programming languages; it is also about programming. Through concepts, examples, and more than 300 practice exercises that exploit the interpreter, students learn not only what programming-language features are but also how to do things with them. Substantial implementation projects include Milner's type inference, both copying and mark-and-sweep garbage collection, and arithmetic on arbitrary-precision integers.

An industrial robot is an automatic multi-purpose manipulator, programmable in three or more axes. A program written in a high-level programming language controls these robots, many of these programs involve multiple tasks controlling different robots. Data races are a common problem in concurrent and multi-threaded programming and they are of big concern for the multi-task industrial robotics programmers too. We present a static analysis method for detecting data races in multi-task programs for industrial robots. We propose a technique based on a relation that models when two or more statements from a task occur in between two or more statements in another task. Our static analysis is preceded by a manual, dynamic analysis step for ensuring consistency among tasks for one of the constructs which involves a task waiting for a particular duration. We define a set of not-occurs in-between rules to detect whether two statements in different tasks may race with each other. We have developed a prototype implementation of our tool for the Rapid programming language that is used to program industrial robots of ABB. Rapid has all the features of a typical programming language for industrial robots and hence our race detection framework will generalize to any programming language for industrial robots.

The aim of this paper is to show that some computational models inspired from biological membranes, such as P systems, can be simulated on digital computers in an efficient manner. To this aim, it is necessary to characterize non-determinism and parallel execution of evolution rules inside regions. Both these issues are formally described here in order to obtain a feasible description in terms of data structures and operations able to be implemented in a functional programming language. Static and dynamic structures of transition P systems are formalised in order to define a bio-language to represent them. Finally, a draft of a language for describing a transition P systems is presented. It will facilitate the description of transition P systems in terms of sentences in a high level programming language; such sentences will define a program. A process of compilation will parse the program to appropriate data structures and will launch the execution of the simulation process.

2 - Completion and Its Applications