A Process Specification Formalism1

Modern day computer architectures offer ever-increasing support for parallel processing, still it turns out to be quite difficult for programmers and therefore programs to tap into these parallel resources. To benefit from real general-purpose parallel computing we claim that it is likely that a paradigm shift is needed in the way we think about programming. This change of thought in turn will need to be reflected in future programming languages as well. We think that the field of process algebra provides thorough insight in how to reason about the construction of software for concurrent systems and will be one of the enabling technologies supporting this transition. The wish to connect process algebra, a mathematical theory, to the world of computer-readable and executable specifications led to the development of PSF (Process Specification Formalism). PSF is an implementation of the process algebra ACP (Algebra of Communicating Processes) integrating ASF (Algebraic Specification Formalism) to specify algebraic data types. One of the first publications on PSF appeared in Fundamenta Informaticae in 1990. Here we stated as the first sentence of the abstract: "Traditional methods for programming sequential machines are inadequate for specifying parallel systems". Unfortunately, though some advancements have been made since 1990, we can still uphold this statement 20 years later. This current report documents the developments that lead to the construction of PSF and the 1990 publication and moreover it also documents how PSF and its tools have evolved since 1990 taking the conclusion and the outlook for future work from the original article as a reference point. Using the knowledge gained both in constructing tools for PSF and in using PSF to specify concurrent systems, we will judge, discuss and criticise the design decisions taken and show paths for future developments.

Alternating Bit Protocol (ABP) is a timeless communication protocol but it might be spiced up by adding up some time constraints to it. According to that, four cases have been defined herein and then, formal specifications and verifications have been performed in them following the rules of a process algebra called Algebra of Communicating Processes (ACP). Oftentimes process algebras lead to cumbersome calculations that are most frequently done by using specific software packages such as mCRL2 or LOTOS, which might lead to lose perspective on the basics. In this paper, a simplifying trick is presented in order to ease up those calculations, thus making easier a manual approach to ACP algebraic derivations and hence, helping a better understanding of them.

In this chapter we outline a process algebra, whose name — Petri Box Calculus (PBC) — arises from its original Petri net semantics [6, 7]. PBC combines a number of features taken from other process algebras, such as COSY (Concurrent Systems notation, [62]), CCS (Calculus of Communicating Systems, [80, 81]), SCCS (Synchronous CCS, [81]), CSP (Communicating Sequential Processes, [58]), TCSP (Theoretical CSP, [59]) and ACP (Algebra of Communicating Processes, [2]). However, there are some fundamental differences with each of these process algebras since PBC has been designed with two specific objectives in mind: To support a compositional Petri net semantics, together with an equivalent — more syntax-oriented — structured operational semantics (SOS) [89]. To provide as flexible as possible a basis for developing a compositional semantics of high-level concurrent specification and programming languages with full data and control features.

IVD, Interactive Visualization Debugger is intended to provide on-line and integrated mechanisms for debugging, performance analysis, and data visualization for message-passing parallel applications. The current IVD includes: (I) ESP, a mechanism to multicast window-based commands from a single control window to some subset of existing debuggers/visualizers on various processes; (2) program replay to reproduce program runs deterministically to enable cyclic debugging; and (3) ad hoc data visualization of distributed arrays using existing visualizers.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The main purpose of genericity in high lever programming language is to increase efficiency of software development and the safety and reusability of software. Genericity is the useful tool to implement generative software development and MDA. However, few modelling language has genericity mechanism and the mechanisms in typical programming language, say C++, Java, etc., is not sufficiently and is not ease to use. The situation in PAR platform is quite different. PAR platform supports Model Driven Software Engineering (MDE) and consists of algorithm modelling language Radl, abstract program modelling language Apla, a set of rules for the model transformation and a set of automatic transformation tools of algorithm model and program model. One of the distinct features of the PAR platform is the agile genericity mechanisms. In PAR not only a value, a data type and a computing-action (including operator, method, function and procedure, etc.) can be generic parameter, an ADT can be generic parameter also. We present new concepts, say type region, action region and ADT region, which can increase the safety of generic software obviously. The paper will pay special attention to describe the syntax and semantics of the ADT parameter. The case study describes the method to develop generic program with ADT as parameter.

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.

After a review of semaphores and monitors the principles underlying the programming language OCCAM are outlined. We show how it can also be used as a specification language. We also examine in detail the language CCS, principely by giving examples of processes or specifications. We end with some remarks on the issues raised by these modern languages which on the one hand may be viewed as programming languages for highly parallel architectures and on the other languages for specifying the required behaviour of systems.

CAFE is the name of a network based environment now under development for supporting systematic creation, checking, verification, and maintenance of formal specifications. CAFE has an algebraic specification language called CafeOBJ as its main specification language, and adopts an algebraic specification paradigm as its foundation. CafeOBJ is a successor of the OBJ language, and has important new features for concurrency and behavioral specifications. Concurrency and behavior are specified based on rewriting logic and behavioral (hidden sorted) algebra respectively. These new features make it possible to provide powerful language constructs for formal object oriented specifications. CAFE is designed to be a network based environment. For sharing specification documents systematically over networks, a new document formatting language called Forsdonnet (FORmal Specification Document ON NETwork) is designed by extending HTML. Forsdonnet includes constructs for formal and informal specifications, commands for executing (prototyping) and cheeking/verifying CafeOBJ specifications, etc. Forsdonnet is designed to be based on already established standard network infrastructure components like HTML and Netscape Navigator. The paper gives an overview and design considerations of the CAFE environment, featuring mainly CafeOBJ and Forsdonnet languages.

Two of the fundamental uses of generalization in object-oriented software development are the reusability of code and better structuring of the description of objects. Multiple inheritance is one of the important features of object-oriented methodologies which enables developers to combine concepts and increase the reusability of the resulting software. However, multiple inheritance is implemented differently in commonly used programming languages. In this paper, we use Chidamber and Kemerer (CK) metrics to study the complexity and reusability of multiple inheritance as implemented in Python, Java, and C++. The analysis of results suggests that out of the three languages investigated Python and C++ offer better reusability of software when using multiple inheritance, whereas Java has major deficiencies when implementing multiple inheritance resulting in poor structure of objects.

An introduction to metric semantics: operational and denotational models for programming and specification languages

We describe ongoing work on building an environment to support reasoning in proof assistants that represent formal systems using higher-order abstract syntax (HOAS). We use a simple and general specification language whose syntax supports HOAS. Using this language, we can encode the syntax and inference rules of a variety of formal systems, such as programming languages and logics. We describe our tool, implemented in OCaml, which parses this syntax, and translates it to a Coq library that includes definitions and hints for aiding automated proof in the Hybrid system. Hybrid itself is implemented in Coq, and designed specifically to reason about such formal systems. Given an input specification, the library that is automatically generated by our tool imports the general Hybrid library and adds definitions and hints for aiding automated proof in Hybrid about the specific programming language or logic defined in the specification. This work is part of a larger project to compare reasoning in systems supporting HOAS. Our current work focuses on Hybrid, Abella, Twelf, and Beluga, and the specification language is designed to be general enough to allow the automatic generation of libraries for all of these systems from a single specification.

: Odyssey Research Associates has undertaken a study of the feasibility of developing formally verified Ada programs. We have designed a specification language for sequential Ada programs. It is a member of the Larch family of specification languages. We have built a prototype program editor that is intended to help programmers develop programs and proofs from specifications, as advocated by Dijkstra and Gries (2,4). It contains predicate transformers, which compute wp (an approximation to the weakest precondition of a program), and it generates verification conditions. The semantics of the specification language and the definition of the predicate transformers are derivable from a denotational definition of sequential Ada. The predicate transformers can be proved sound with respect to these definitions by structural induction on programs. The denotational-style definition of the predicate transformers is well suited to an implementation as an attribute grammar. The program editor is designed to be used on program fragments, not just complete programs. The next step in improving the prototype editor is to find ways to simplify the intermediate values of wp so they can be used to guide the development of fragments into programs. Ada, Larch, Larch/Ada, Formal Methods, Formal Specification, Program Verification, Predicate Transformers, Ada Verification.

Current research in specifications is emphasizing the practical use of formal specifications in program design. One way to encourage their use in practice is to provide specification languages that are accessible to both designers and programmers. With this goal in mind, the Larch family of formal specification languages has evolved to support a two-tiered approach to writing specifications. This approach separates the specification of state transformations and programming language dependencies from the specification of underlying abstractions. Thus, each member of the Larch family has a subset derived from a programming language and another subset independent of any programming languages. We call the former interface languages, and the latter the Larch Shared Language. This paper focuses on Larch interface language specifications. Through examples, we illustrate some salient features of Larch/CLU, a Larch interface language for the programming language CLU. We give an example of writing an interface specification following the two-tiered approach and discuss in detail issues involved in writing interface specifications and their interaction with their Shared Language components.

For a long time, one of the major research goals in the computer science research community has been to raise the level of abstraction power of specification languages/programming languages. Many specification languages and formalisms have been invented, but unfortunately very few of those are practically useful, due to limited computer support of these languages and/or inefficient implementations. Thus, one important goal is executable specification languages of high abstraction power and with high performance, good enough for practical usage and comparable in execution speed to hand implementations of applications in low-level languages such as C or C++. In this paper we briefly describe our work in creating efficient executable specification languages for two application domains. The first area is formal specification of programming language semantics, whereas the second is formal specification of complex systems for which we have developed an object-oriented mathematical modeling language called Modelica, including architectural support for components and connectors. Based on these efforts, we are currently working on a unified equation-based mathematical modeling language that can handle modeling of items as diverse as programming languages, computer algebra, event-driven systems, and continuous-time physical systems. The key unifying feature is the notion of equation. In this paper we describe the design and implementation of the unified language. A compiler implementation is already up and running, and used for substantial applications.KeywordsModeling LanguageUnify Modeling LanguageAbstract Syntax TreeNatural SemanticPattern EquationThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The paper is devoted to the convergence of critical and non-critical IT in the area of Business Analysis and Requirements Engineering. We consider Domain Specific Modelling (DSM) and Domain Specific Language (DSL) as promising points to improve Requirements Engineering maturity and quality in a safety-critical and security-critical domain. The paper presents a DSM-based procedure of knowledge management that can be implemented in a software engineering company to support the reuse of domain knowledge and technical solutions. Afterward, we select Gherkin language as a sample of DSL-based requirements elicitation, analysis, documentation, and validation in a frame of Behavior Driven Development. To provide a DSM&DSL-based Requirements Engineering technique we analyzed Gherkin's applicability for different kinds and levels of critical requirements.