Implementing specification freedoms

Often the most effective diagrams are those which are very simple. However there is a strong tendency, particularly prevalent in visual formal modelling and specification languages, to take a diagrammatic language which at core is very simple, and then add many extensions and features to make it more expressive - often making it so expressive that the diagrams produced in the language are no longer readable; or at least, the diagrams are no longer obviously a more effective form of representation than a text-based one. Both the design of effective visual formal modelling and specification languages, and the effective formalisation of (the semantics of) such visual languages requires the unification of results from visual language theory, cognitive science, empirical psychology and graphic design. Integrating results from such diverse fields is a non-trivial task, which may be approached through a decomposition of the study of issues of effectiveness in diagrammatic languages according to analogous understandings of (written and spoken) natural languages.

In Wide Area Networks (WANs)inconsistencies among the security policies of Administrative Domains (ADs) may cause severe security flaws. Recently, security policies are written in natural language and as they get more complicated, even for an expert it might be impossible to detect such inconsistencies. However, when a formal language is used, it might be possible to make verification of security policies by automated theorem proving tools. Due to the existence of mobile devices such as laptops, PDAs and mobile agents, we need a formal language that is capable of defining the concept of mobility. In this paper, we extend Mob adtl [1] according its refinement methodology to obtain a formal policy specification language for an 802.11 WLAN with enhanced security network.

The readability of formal requirements specification languages is hypothesized as a limiting factor in the acceptance of formal methods by the industrial community. An empirical study was conducted to determine how various factors of state-based requirements specification language design affect readability using aerospace applications. Six factors were tested in all, including the representation of the overall state machine structure, the expression of triggering conditions, the use of macros, the use of internal broadcast events, the use of hierarchies, and transition perspective (going-to or coming-from). Subjects included computer scientists as well as aerospace engineers in an effort to determine whether background affects notational preferences. Because so little previous experimentation on this topic exists on which to build hypotheses, the study was designed as a preliminary exploration of what factors are most important with respect to readability. It can serve as a starting point for more thorough and carefully controlled experimentation in specification language readability.

Specification of software process measurement

Traditional structured analysis and design methods have been criticized because the methods lack formality to provide a design for rigorous development. Several approaches have been developed for verifying a design by integrating traditional structured analysis and design methods with formal specification languages. However, the integration of traditional structured analysis and design methods with formal specification languages may confuse the problem definition and understanding with the attempt to define system structures and algorithms in the design phase. In addition, formal specification languages may add complexity to the design due to the complexity of the language syntax and semantics. In this paper, we are presenting an approach to verification of a structured design in HOS without using formal specification languages. Rules for the partial and total correctness of the design are also discussed.

The Unified Modeling Language (UML) has become a widely adopted standard in the software development industry. Unfortunately, the UML is a semi-formal language which lacks precisely defined constructs. Z language is a formal specification language. Formal languages are used to ensure that systems meet regulations and standards. This paper aims to reduce risks associated with software development and increase safety and reliability. This goal is achieved by formalizing the syntax of (a sub-set of the popular UML diagrams (Use Case diagram, Class diagram, and State Machine diagram) using Z specifications.

Formal software development begins with formal specification of the user requirements or design of a system. Hence, formal specification languages are used to resolve ambiguities in user requirements or detect design errors at the early software life cycle. Furthermore, specification-based functional testing derives test inputs from its formal specification. However, formal specifications are expressed using set theory or predicate logics which are non-executable. Thus, functional test execution over abstract expressions would be impossible. Therefore, there is a need to refine abstract specification into a form that can be executable. In this paper, an automatic functional testing framework using object constraint language (OCL) formal specification has been proposed. The major objective of this paper is to describe how the refinement processes are integrated into the specification-based testing framework.

Verification of HOS software specification by a hierarchical software understanding approach

This paper deals with experience with specification languages at AEROSPATIALE Aircraft, Systems and Avionics Division. We describe first the current avionics development environment. Then, we present our results and viewpoints on the use of the three specification languages: LOTOS, ESTEREL, and B. The evaluation studies we performed, showed that each of these languages does not cover in a complete way our needs in specification, validation, and development of avionics. Afterwards, we propose and illustrate an investigation approach that allows to structure and compose different formal specification languages in the same environment.

Standardization of Formal Specification Languages

Developing reliable yet flexible software is a hard problem. Although modeling methods enjoy a lot of advantages, the exclusive use of just one of them, in many cases, may not guarantee the development of reliable and flexible software. Formal modeling methods ensure reliability because they use a rigorous approach to software development. However, lack of knowledge and high cost practically force developers to use semi-formal methods instead. Semi-formal (visual) modeling methods, which are widely used in practical large-scale software development, are not good enough for reliable software development. This paper proposes a new approach to the development of reliable yet flexible software by transforming formal and semi-formal models into each other. In this way, the advantages of both methods are incorporated in to the software development process. The structured rules, proposed in this paper, transform formal and visual models into each other through the iterative and evolutionary process. The feasibility as well as the effectiveness of the proposed approach is demonstrated using the multi-lift system as a test case.

A methodology for continuously monitoring a program for specification consistency during program execution is described. Prior development of the formal specification and program is assumed. The program is annotated with constructs from a formal specification language, and the formal specification constructs are transformed into checking code, which is then inserted into the underlying program. Calls to this checking code are inserted into underlying program wherever it can potentially become inconsistent with its specification. If an inconsistency does in fact occur, diagnostic information is provided. The implementation of such a system for Anna (annotated Ada) subtype annotations is presented.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Human organizational patterns applied to collaborative learning software systems

Development of next generation of smarter machines and services requires building an easy-to-use technology stack. These technologies include hardware, embedded software, data, and applications. Smarter machines support carrying out the precise job, better decision making, and create new ways of doing things to reduce cost and increase speed, accuracy, and automation. As technology meets iron through smart machines, there is increased embedded software within products. To provide distinctive customer experience for a solution system, along with reliability of hardware, development of reliable software also plays a critical role. This paper proposes models in which software reliability is a function of the number of residual faults and is measured with the help of software metrics based on development data. The intent is to establish a statistical relationship between product metrics (that deal with the measurement of the software product) or process metrics (the process by which it is developed) with measures of quality. Using both a pattern recognition algorithm approach for classifying fault proneness and applying fuzzy logic to software metrics for defect prediction is found to be beneficial for improving software reliability prediction in early development phases. This paper proposes non-parametric models like Artificial Neural Network from deep learning to predict expected number of failures utilizing past failure data for software reliability estimation and release readiness during launch.

The increasing complexity associated with many modern engineering applications, including autonomous robot guidance and navigation, process control in sensor-rich environments, and control of biological systems, has far-reaching implications for control system design. As an example, reactive, embedded software systems, interacting among themselves and remote users over communication networks, introduce a whole new set of system-level challenges, and classic control design objectives such as stability, performance, and robustness are being complemented with a number of new questions. These include the cost of hardware implementation, measured for example not only by computational requirements such as speed and memory, but also by communication requirements such as available communication bandwidth. Moreover, the complexity associated with specifying the control procedures and with verifying the behavior of the closed-loop system increasingly plays a fundamental role, especially in safety-critical control systems arising in energy and transportation networks, and in medical applications.