Verification of C Programs Using Automated Reasoning

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.

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.

MODELLING SYSTEM SPECIFICATIONS ON A FINITE STATE MACHINE

Human organizational patterns applied to collaborative learning software systems

Translating meaning representations to behavioural interface specifications

The complexity of designing concurrent and highly-evolving interactive systems has grown to a point where system verification has become a hurdle. Fortunately, formal verification methods have arrived at the right time. They detect errors, inconsistencies and incompleteness at early development stages of a system formally modeled using a formal specification language. -calculus (Milner, 1999) is one such formal language which provides strong mathematical base that can be used for verifying system specifications. But manually verifying the specifications of concurrent systems is a very tedious and error-prone work, especially if the specifications are large. Consequently, an automated verification tool would be essential for efficient system design and development. In addition, formal verification tools are vital ingredient to fully harness the potential of component-based software composition. The authors developed such an automated verification tool which is highly portable and seamlessly integrates with the visualization, reduction and performance evaluation tools introduced (Ahmad & Rahimi, 2008; Rahimi, 2006; Rahimi et al., 2001, 2008) to provide a comprehensive tool for designing and analyzing multi process/agent systems. Open-Bisimulation (Sangiorgi, 1996) concept is utilized as the theoretical base for the design and implementation of the tool which incorporates an expert system implemented in Java Expert System Shell (JESS) (Friedman-Hill, 2003).

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.

Implementing specification freedoms

Various works have been done in verifying object constraint language (OCL) by translating it to formal specification language. This paper presents the process of translating OCL to prototype verification system (PVS) using model transformation. PVS is a formal specification language based on higher-order logic and comes with a theorem prover. Two processes have been identified to translate OCL to PVS. The first process translates OCL constraint to PVS specification directly using model-to-text transformation while the second process transforms OCL to PVS model. Both processes are evaluated to identify the advantages and disadvantages. Transforming OCL to PVS model allow the result to be use for other model management operation.

SOFL is a formal language and method for system specification and design. It was developed by integrating Petri Nets, Data Flow Diagrams, and VDM-SL. As the major feature of the original SOFL method is to use structured techniques for analysis and specification, and object-oriented techniques for design and implementation, SOFL has its own implementation language that is similar to C++. However during our recent work of applying SOFL to software systems, the transformation of structured specifications to object-oriented implementations creates some difficulties, simply because of paradigms mismatch. In this paper we extend SOFL to a formal object-oriented language and method while keeping its structured features. This will allow powerful object-oriented reuse mechanisms, such as class inheritance and object composition, to be utilized in the early phases, and transformation from SOFL specifications to commercial object-oriented programming languages to be readily achieved.

One of the main goals of Software Engineering is to produce software with quality. But with the increasing use of agile methodologies in software development, it is observed that the existing quality assurance models do not adapt easily to these methods. In this context, the objective of this research is to propose critical factors of success (CFS) and tools for software development and management environment using agile methods, focusing on quality. Thus, initially, a literature review was conducted in SCOPUS and SCIELO bases, identifying 21 CFS, which were grouped into three categories: Individual; Organizational; and Technical / Process. Based on these factors, a questionnaire was applied to specialists in software management and development, reaching the sample of 101 respondents, with the most important CFS belonging to the Personal category, which reinforces the need for investment in this area. After this field research, a case study was done in a public company that uses traditional methods, making it possible to propose a development and management environment of software, adding the best practices, tools and CFS with the purpose of improve the quality of delivery of the final product. It was also observed the applicability of the agile Scrum method, allied to Kanban, taking advantage of the best practices of both, and how much was relevant in the context of the company, demonstrating the importance of agile methods to improve the quality and productivity of the whole team, including customers and sponsors. In addition, the present work generates an CFS base for knowledge of the academic community.

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.

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.

In this work the protocol WorldFIP for industrial communication networks, is specified with the formal specification language LOTOS. This specification is the foundation of new work lines such as efficiency analysis of WorldFIP performance with simulations in critical applications, the generation of benchmark patterns for conformance tests of WorldFIP communications equipment, and the proposal of new advances in the fieldbus area. Standardization institutions can benefit largely by this implemented methodology of formal specification, because some uncertainties in their description issues can be detected easily during the standard development, if a formal specification language is used at this stage.

Policy is a flexible mechanism to deal with complex coordination and management of organizational elements in an open system environment. A formal specification framework is proposed for such a kind of system called policy-governed institutional agency. The formal framework includes: an abstract architecture, a formal institutional model, and a formal specification language for this type of systems. The concrete syntax and semantics of the formal specification language are given. The core of the framework has been implemented in a prototype environment.