错误流模型:硬件故障的软件传播建模与分析

无论是可靠性工程还是软件可靠性中的可靠性模型,都难以描述硬件故障在程序中的传播问题.首先建立了计算数据流模型,并以无穷存储机器的指令集为例,说明可以为任意程序建立计算数据流图.在计算数据流模型的基础上,进一步建立了错误流模型.把计算过程中的错误分成物理错误和传播错误两种,通过分析这两种错误的本质和传播规律,给出了6条有关错误传播的规则和2条独立定律.根据这些规则和定律,能够计算出在程序运行过程中,任意时刻在任意位置上出现错误的概率.最后以一个简单的无穷存储机器程序为例,简要地展示了错误流模型描述硬件故障在     

Multivariate Analysis and Rough Sets: Two Approaches for Software-quality Analysis

Computer programs are becoming more and more complex and voluminous in most firms. This raises the cost of maintenance. To minimize this cost, qualities must be given to computer programs that assure them good evolution, i.e., reliability, efficiency, flexibility, conformity, etc. This cost minimization must be preceded by a diagnosis that recommend a set of renovation actions to be undertaken in order to improve the software quality. The objective of this study is to associate a set of renovation action to each profile's program expressed in terms of metrics. To do this, two approaches are taken. First, a multivariate analysis is used to allocate each program to a predefined category reflecting the diagnosis of the program's health. Second, we try to work out a diagnosis of the health of these programs by developing a quality model composed of a set of decision rules supporting software quality improvement decisions. We have finally implemented this set of rules in the form of an expert system tool to allow the classification of new programs by the decision-maker.     

Model-checking software library API usage rules

Modern software increasingly relies on using third-party libraries which are accessed via application programming interfaces (APIs). Libraries usually impose constraints on how API functions can be used (API usage rules) and programmers have to obey these API usage rules. However, API usage rules often are not well documented or documented informally. In this work, we show how to use the SCTPL and SLTPL logics to precisely and formally specify API usage rules in libraries, where SCTPL/SLTPL can be seen as an extension of the branching/linear temporal logic CTL/LTL with variables, quantifiers and predicates over the stack. This allows library providers to formally describe API usage rules without knowing how their libraries will be used by programmers. We propose an automated approach to check whether programs using libraries violate API usage rules or not. Our approach consists in modeling programs as pushdown systems (PDSs) and checking API usage rules by SCTPL/SLTPL model-checking for PDSs. To make the model-checking procedure more efficient and precise, we propose an abstraction that reduces drastically the size of the program model and integrate may-alias analysis into our approach to reduce false alarms. Moreover, we characterize two sublogics rSCTPL and rSLTPL of SCTPL and SLTPL that are preserved by the abstraction. We implement our techniques in a tool and apply the tool to check several open-source programs. Our tool finds several previously unknown bugs in several programs. The may-alias analysis avoids most of the false alarms that occur using SCTPL or SLTPL model-checking techniques without may-alias analysis.     

析取回答集程序设计结构化测试方法

针对析取回答集程序的结构化测试基础理论匮乏的问题,系统化地提出析取回答集程序结构化测试覆盖的概念。首先,定义针对析取回答集程序的测试用例,确立析取回答集程序的主要测试实体为程序中的逻辑规则;其次,通过对规则的头、规则的体、规则的集合等不同测试目标构建了规则覆盖、定义覆盖、环覆盖等基本概念来模拟结构化测试中的语句覆盖、分支覆盖等概念;最后,提出了析取回答集程序的测试覆盖率计算公式,并举例说明各种覆盖下的覆盖率计算方法,并讨论了析取回答集程序的部分特殊性质和关键指标。     

用于控制系统分析和设计教学的一套小型工具──Minitools

Minitools（小型工具）是一套为教学和小型工业问题而专门设计的软件工具。与成熟的商品化的系统相比，它们虽只提供了有限的功能，但更容易学习和掌握。本文介绍了三个这样的程序：DESolver是一个求解微分方程的程序；Frequency是一个频率响应的分析和设计程序；BDESim．是一个基于系统方框图的仿真和频率响应分析程序。这三个程序皆可在Macintosh和IBMPC兼容机上运行。当在IBMPC上运行时，需要GEM环境的支持。本文是基于Minitools的最新改进版本。     

利用XML实现业务规则和信息系统分离的方法研究

企业信息系统常因业务规则的改变而导致信息系统无法使用,提出了将业务规则与信息系统分离的观点,探讨了利用XML作为描述软件需求文档的可行性.藉由XML的机器可读性,让信息系统直接读取包含业务规则的软件需求文档,以实现业务规则和程序代码分离,进而实现需求文档的重用.     

A transformation system for concurrent processes

Program transformation techniques have been extensively studied in the framework of functional and logic languages, where they were applied mainly to obtain more efficient and readable programs. All these works are based on the Unfold/Fold program transformation method developed by Burstall and Darlington in the context of their recursive equational language. The use of Unfold/Fold based transformations for concurrent languages is a relevant issue that has not yet received an adequate attention. In this paper we define a transformation methodology for CCS. We give a set of general rules which are a specialization of classical program transformation rules, such as Fold and Unfold. Moreover, we define the general form of other rules, “oriented” to the goal of a transformation strategy, and we give conditions for the correctness of these rules. We prove that a strategy using the general rules and a set of goal oriented rules is sound, i.e. it transforms CCS programs into equivalent ones. We show an example of application of our method. We define a strategy to transform, if possible, a full CCS program into an equivalent program whose semantics is a finite transition system. We show that, by means of our methodology, we are able to a find finite representations for a class of CCS programs which is larger than the ones handled by the other existing methods. Our transformational approach can be seen as unifying in a common framework a set of different techniques of program analysis. A further advantage of our approach is that it is based only on syntactic transformations, thus it does not requires any semantic information. Received: 24 April 1997 / 19 November 1997     

Sound refactorings

Refactoring consists in restructuring an object-oriented program without changing its behaviour. In this paper, we present refactorings as transformation rules for programs written in a refinement language inspired on Java that allows reasoning about object-oriented programs and specifications. A set of programming laws is available for the imperative constructs of this language as well as for its object-oriented features; soundness of the laws is proved against a weakest precondition semantics. The proof that the refactoring rules preserve behaviour (semantics) is accomplished by the application of these programming laws and data simulation. As illustration of our approach to refactoring, we use our rules to restructure a program to be in accordance with a design pattern.     

基于AR规则的全路径测试数据自动生成方法

基于全路径的研究现正处于起步阶段,提出了一种全新的NRPS算法（不重复路径搜索算法）和AR规则来对程序的源文件进行静态分析,生成有向无负权图,进而得到不重复路径集;并结合粒子群优化算法最终生成最优测试用例。实验表明,该方法具有可行性。     

一种基于逻辑程序的重复协商框架

本文从基于信念修改的角度提出了两个AGENT之间的一个重复协商框架.在这个框架中,一个逻辑程序被当作一个协商的AGENT,每一个AGENT(逻辑程序)选择自己的一个回答作为自己最初的协商需求.两个AGENT之间的协商过程就是两个逻辑程序之间相互更新的过程,这个过程是通过协商的每一方接受对方的部分(或,全部)需求和放弃自己部分协商需求来实现的.本文设计了协商双方必须遵守的一些协商规则,根据这些规则对这个协商框架进行了形式化描述,并给出了协商的终止条件.     

Complexity measures for rule-based programs

Software complexity measures are quantitative estimates of the amount of effort required by a programmer to comprehend a piece of code. Many measures have been designed for standard procedural languages, but little work has been done to apply software complexity concepts to nontraditional programming paradigms. This paper presents a collection of software complexity measures that were specifically designed to quantify the conceptual complexity of rule-based programs. These measures are divided into two classes: bulk measures, which estimate complexity by examining aspects of program size, and rule measures, which gauge complexity based on the ways in which program rules interact with data and other rules. A pilot study was conducted to assess the effectiveness of these measures. Several measures were found to correlate well with the study participants' ratings of program difficulty and the time required by them to answer questions that required comprehension of program elements. The physical order of program rules was also shown to affect comprehension. The authors conclude that the development of software complexity measures for particular programming paradigms may lead to better tools for managing program development and predicting maintenance effort in nontraditional programming environments     

Signifying software engineering to computational thinking learners with AgentSheets and PoliFacets

Nonprofessional end user programs have increased remarkably in volume and diversity. However, for such programs to be usable and reliable, their creators should be familiar with software engineering practices that are typically not part of their range of competence and source of enjoyment. While the expansion of computational thinking acquisition (CTA) initiatives at schools and the availability of improved programming environments have contributed to facilitate the learners’ coding tasks, much less has been done to facilitate the acquisition of software quality notions. This paper reports on a Brazilian CTA program guided by semiotic principles and describes a study of how the technology used in it prefigures elements of software engineering in the participants’ programs created with AgentSheets. Our research contributions touch on the semiotic potential of CTA infrastructures and on associated pedagogical considerations for expanding CTA programs with software engineering basics. We also propose items for an interdisciplinary research agenda.     

Foundation of logic programming based on inductive definition

A logical system of inference rules intended to give the foundation of logic programs is presented. The distinguished point of the approach taken here is the application of the theory of inductive definitions, which allows us to uniformly treat various kinds of induction schema and also allows us to regardnegation as failure as a kind of induction schema. This approach corresponds to the so-called least fixpoint semantics. Moreover, in our formalism, logic programs are extended so that a condition of a clause may be any first-order formula. This makes it possible to write a quantified specification as a logic program. It also makes the class of induction schemata much larger to include the usual course-of-values inductions.     

RUGRAT: Evaluating program analysis and testing tools and compilers with large generated random benchmark applications

Benchmarks are heavily used in different areas of computer science to evaluate algorithms and tools. In program analysis and testing, open‐source and commercial programs are routinely used as benchmarks to evaluate different aspects of algorithms and tools. Unfortunately, many of these programs are written by programmers who introduce different biases, not to mention that it is very difficult to find programs that can serve as benchmarks with high reproducibility of results. We propose a novel approach for generating random benchmarks for evaluating program analysis and testing tools and compilers. Our approach uses stochastic parse trees, where language grammar production rules are assigned probabilities that specify the frequencies with which instantiations of these rules will appear in the generated programs. We implemented our tool for Java and applied it to generate a set of large benchmark programs of up to 5M lines of code each with which we evaluated different program analysis and testing tools and compilers. The generated benchmarks let us independently rediscover several issues in the evaluated tools. Copyright © 2014 John Wiley & Sons, Ltd.     

Delphi至Kylix软件移植中知识树的构造与移植规则

在软件移植中,关键是如何根据运行环境的差异而相应地转换应用程序。W2L是把Windows下Delphi应用程序移植为Linux下的Kylix程序的移植工具。该文结合W2L开发过程,介绍了知识树这一数据结构的构造过程,并讨论通过知识树的比较得到Delphi和Kylix相同或有差异的信息,以及根据这些信息生成的基本移植规则。     

An abstract programming language and correctness proofs

The realization of an abstract programming language is a good approach for automating the software production process and facilitating the correctness proof of a software system.

This paper introduces a formal language for programming at the abstract level by combining Pascal with VDM (Vienna Development Method). The notation provided by the language obliges programmers to consider the correctness of programs throughout the whole process of programming, and the proof axiom and rules presented in this paper may be used to prove the correctness of programs. A complete example is given to illustrate how to program using APL and how to prove the correctness of programs using the given axiom and rules.     

Dynamic composition of parameterised logic modules

We present a logic-based programming language that features meta-level composition operations over programs. Object programs are parameterised named collections of definite clauses which may contain formulae of the form A in Pexp, where A is a standard atomic formula and Pexp is a program expression obtained by applying composition operations over named object programs. The semantics of the language is presented in two different equivalent styles. An operational, top-down semantics is given by means of inference rules, while a denotational, bottom-up semantics is given via an immediate consequence operator associated with program expressions. A meta-programming implementation of the language is also presented by transforming the operational inference rules into meta-level axioms. Several programming examples are discussed to illustrate the expressive power of the language.     

基于C_nV结构的自动语言辨识研究

与说话人识别、连续语音识别相比,自动语言辨识是一个相对较新的研究,而且是一项较难的课题。与音素配位学相比较韵律是语言辨识的更有希望的一个语言辨识特征。论文介绍了一种基于伪音节结构CnV的自动语言辨识方法,该系统提取了辅音、元音构成的伪音节结构的MFCC和!MFCC特征参数,使用了与语言无关的GMM算法模型化该特征。经过对OGI-TS数据库中的英语、法语、汉语测试表明,元音、辅音特征信息在语言辨识中起到一定作用,伪音节结构模型也是语言辨识的有效模型之一。     

Software mutational robustness

Neutral landscapes and mutational robustness are believed to be important enablers of evolvability in biology. We apply these concepts to software, defining mutational robustness to be the fraction of random mutations to program code that leave a program’s behavior unchanged. Test cases are used to measure program behavior and mutation operators are taken from earlier work on genetic programming. Although software is often viewed as brittle, with small changes leading to catastrophic changes in behavior, our results show surprising robustness in the face of random software mutations. The paper describes empirical studies of the mutational robustness of 22 programs, including 14 production software projects, the Siemens benchmarks, and four specially constructed programs. We find that over 30 % of random mutations are neutral with respect to their test suite. The results hold across all classes of programs, for mutations at both the source code and assembly instruction levels, across various programming languages, and bear only a limited relation to test suite coverage. We conclude that mutational robustness is an inherent property of software, and that neutral variants (i.e., those that pass the test suite) often fulfill the program’s original purpose or specification. Based on these results, we conjecture that neutral mutations can be leveraged as a mechanism for generating software diversity. We demonstrate this idea by generating a population of neutral program variants and showing that the variants automatically repair latent bugs. Neutral landscapes also provide a partial explanation for recent results that use evolutionary computation to automatically repair software bugs.     

FTSyn: a framework for automatic synthesis of fault-tolerance

In this paper, we present a software framework for adding fault-tolerance to existing finite-state programs. The input to our framework is a fault-intolerant program and a class of faults that perturbs the program. The output of our framework is a fault-tolerant version of the input program. Our framework provides (1) the first automated tool for the synthesis of fault-tolerant distributed programs, and (2) an extensible platform for researchers to develop a repository of heuristics that deal with the complexity of adding fault-tolerance to distributed programs. We also present a set of heuristics for polynomial-time addition of fault-tolerance to distributed programs. We have used this framework for automated synthesis of several fault-tolerant programs including a simplified version of an aircraft altitude switch, token ring, Byzantine agreement, and agreement in the presence of Byzantine and fail-stop faults. These examples illustrate that our framework can be used for synthesizing programs that tolerate different types of faults (process restarts, Byzantine and fail-stop) and programs that are subject to multiple faults (Byzantine and fail-stop) simultaneously. We have found our framework to be highly useful for pedagogical purposes, especially for teaching concepts of fault-tolerance, automatic program transformation, and the effect of heuristics.