A composite complexity approach for software defect modelling

An approach is proposed to develop defect models for software components based on a categorical multivariate regression analysis. This modelling technique is useful when the software components are sufficiently small so that the assumption of a continuous normally distributed defect distribution is not valid. Library unit aggregations from five Ada projects are analysed to yield a composite complexity measure which is a function of both software complexity characteristics and development environment characteristics. The probabilities of various numbers of defects are derived from this composite complexity measure. The probability distributions are used to calculate subsystem level defects which are then compared to the actual defects.     

Steps to an Advanced Ada1Programming Environment

Conceptual simplicity, tight coupling of tools, and effective support of host-target software development will characterize advanced Ada programming support environments. Several important principles have been demonstrated in the Arcturus system, including template-assisted Ada editing, command completion using Ada as a command language, and combining the advantages of interpretation and compilation. Other principles, relating to analysis, testing, and debugging of concurrent Ada programs, have appeared in other contexts. This paper discusses several of these topics, considers how they can be integrated, and argues for their inclusion in an environment appropriate for software development in the late 1980's.     

The impact of UML modeling on defect density and defect resolution time in a proprietary system

Background: The contribution of modeling in software development has been a subject of debates. The proponents of model-driven development argue that a big upfront modeling requires substantial investment, but it will payoff later in the implementation phase in terms of increased productivity and quality. Other software engineers perceive modeling activity as a waste of time and money without any real contribution to the final software product. Considering present advancement of model-based software development in software industry, we are challenged to investigate the real contribution of modeling in software development. Objective: We analyze the impacts of UML modeling, specifically the production of class and sequence diagrams, on the quality of the code, as measured by defect density, and on defect resolution time. Method: Using data of a proprietary system, we conduct post-mortem analyses to test the difference in defect density between software modules that are modeled and not modeled. Similarly, we test the difference in resolution time between defects that are related to modeled and not modeled functionality. Result: We have found that the production of UML class diagrams and sequence diagrams reduces defect density in the code and the time required to fix defects. These results are obtained after controlling for the effects of co-factors such as code coupling and complexity. Conclusion: The results confirm that not only does the production of UML class diagrams and sequence diagrams possibly help improve the quality of software, but also it possibly help increase the productivity in software maintenance.     

Ada programming language standardization

The need for software management and standardization of programming languages used in military systems was first identified by DoD in 1975. DoD at that time supported many limited use languages for what are now called embedded computer applications. This diversity of languages contributed to high software costs. In November 1976, DoD first established seven approved , , , -J3, -J73, , -2, -1. Eventually the number of approved DoD languages may be reduced to three, Ada, , and . Ada was established as Military Standard 1815, on 10 December 1980. The ANSI standardization process for Ada is in progress. The Ada concept places restrictions on what may be called an Ada compiler. Compilers may not be called Ada compilers until they have passed validation tests. Up to 80% of software costs are incurred after the software has been put into service. Ada can promote a programming style that leads to maintainable software. It is in the program maintenance phase of the software life cycle where large savings will be achieved through the use of Ada.     

Ada软件开发环境中求助技术

在软件开发环境中为软件设计人员提供界面友好、方便快捷的工具是一个优秀软件所须具备的特性之一。本文分析了Ada软件开发环境中的求助功能的特点,详细说明了其设计方法和实现中的一些关键技术,并总结了设计求助功能的一些基本原则。     

InRob: An approach for testing interoperability and robustness of real-time embedded software

Advances in digital technologies have contributed for significant reduction in accidents caused by hardware failures. However, the growing complexity of functions performed by embedded software has increased the number of accidents caused by software faults in critical systems. Moreover, due to the highly competitive market, software intensive subsystems are usually developed by different suppliers. Often these subsystems are required to interact with each other in order to provide a collaborative service. Testing approaches for subsystems integration support verification of the quality of service, focusing on the subsystems interfaces. The increasing complexity and tight coupling of real-time subsystems make integration testing unmanageable. The ad-hoc approach for testing is becoming less effective and more expensive. This article presents an integration testing approach denominated InRob, designed to verify the interoperability and robustness related to timing constraints of real-time embedded software. InRob guides the construction of services, based on formal models, aiming at the specifications of interoperability and robustness of test cases related to delays and time-outs of the messages exchanged in the interfaces of interconnected subsystems. The proposed formalism supports automatic test cases generation by verifying the relevant properties in the service behavioral model. As timing constraints are critical properties of aerospace systems, the feasibility of InRob is showed in the integration testing process of a telescope onboard in a satellite. The process is instantiated with existing testing tools and the case study is the software embedded in the telescope.     

The Specification and Implementation of GKS Application Software in ADA (R)

One of the most important uses of (interactive) computer graphics is as one of the tools available to a User Interface Management System (UIMS) for a variety of user-computer environments (UCE). Typical UCEs in vogue are Programming Support Environments (PSE), Expert System Builders (ESB), Office Automation systems (OAS). This paper concentrates on the conceptual relationship that exists between the users on the one hand and computer systems on the other. Such relationships are to be seen in the context of specific application domains. The two standards, GKS and Ada, are chosen to be the background against which the argument for a Software Methodology based on the Abstract Data Type approach, is presented. This has significant implications for a GKS binding to Ada and the development of GKS application software written in Ada. A collection of colour models is considered in detail.
Ada(R) is a registered trademark of the U.S. Government, Ada Joint Program Office.     

Ada95层次库结构与大型软件开发

Ａｄａ９５提出了层次库和后扩库单元的概念提供了相应的设施，对Ａｄａ８３的分别编译设施与可见性规则进行了扩充。本文对层次库的概念与设施进行了详细的介绍、分析与讨论。     

State restoration in Ada 95: a portable approach to supporting software fault tolerance

Studies indicate that techniques for tolerating hardware faults are so effective that software design errors are the leading cause of all faults encountered. To handle these unanticipated software faults, two main approaches have been proposed: N-version programming and recovery blocks. Both are based on the concept of design diversity: the assumption that different designs will exhibit different faults (if any) for the same inputs and will, therefore, provide alternatives for each other. Both approaches have advantages, but this paper focuses upon recovery blocks; specifically, the requirement to save and restore application state. Judicious saving of state has been described as “checkpointing” for over a decade. Using the object-oriented features of the revised Ada language (Ada 95) – a language widely used in this domain – we present three portable implementations of a checkpointing facility and discuss the trade-offs offered by each. Results of the implementation of these mechanisms are used to highlight both the strengths and weaknesses of some of the object-oriented features of Ada. We then show a reusable implementation of recovery blocks illustrating the checkpointing schemes. A performance analysis is made and measurements are presented in support of the analysis.     

Lessons learned teaching Ada in the context of software engineering

Educators across the country are struggling with difficult issues in the teaching of Ada and its relationship to the computer science curriculum. By design, the language supports software engineering principles. Therefore, it would seem that the “natural” place for teaching Ada is within the context of software engineering. This paper reports on the author's and his students' experiences in learning and using Ada in different settings, including a software engineering project course, and a course centered on Ada and its use.     

面向对象建模集成环境AML-Tools的设计与实现

该文描述了一个新的面向对象建模集成环境AML-Tools。AML是一个基于Ada95的建模语言,它吸取了Ada95的基本原理和思想,利用支持面向对象建模的设施对其进行扩充和改造,使之适用于软件建模的各个阶段;引进了程序包、任务等程序单元的概念并使之成为AML的核心成份;吸取了多视点模型的思想,将描述同一实体不同侧面特征的信息分别封装在相应的程序单元声明、程序单元体和程序单元描述中;利用新的并发模型、同步设施和限制设施,有效地解决了系统并发性、不确定性等非功能特性的描述问题。     

Ada System Dependency Analyzer tool

A major thrust of modern software engineering methods, languages, and tools is to promote software visibility and to present information about the underlying software architecture. With large, complex software systems, automated tools are indispensable for identifying the architectural components, the structure that interconnects them, and other subtle dependencies. This article describes the construction of an Ada System Dependency Analyzer (SDA), a software architecture analysis tool that generates a quantitative snapshot of an Ada application's software architecture. The SDA can process thousands of Ada source files during a single run and report on them as a group of files comprising a single Ada system. Our SDA tool identifies Ada source code dependencies on COTS products such as operating systems, compilers, the X Window System, and on routines written in other languages, and can thus predict software portability and reliability problems. It rapidly and accurately processes 24,000 lines of code per minute (a time-consuming, if not impossible, operation if done manually) and has successfully processed more than seven million lines of code in eight complex systems. Although originally developed for Ada, our methods and the technology we adopted will let us construct analogous tools for other programming languages such as C, C++, Cobol; and PL/I     

Critical races in Ada programs

It is noted that critical races in concurrent Ada programs are an insidious source of system errors, and that the Ada language does not have concurrency features to ease the development of critical race-free programs. The authors illustrate this using the CRF language, which extends the Ada language by the addition of a powerful caller selection mechanism. It is this facility that implements a discriminatory mutual exclusion (dimutex) construct, an important feature for building less critical race-prone programs. The MLog language supports the CRF caller selection mechanisms; thus it is convenient as a rapid-prototyping platform. A design method for systematically converting CRF designs into Ada designs is presented. The method uses a mixture of mechanical and creative transformations that are guaranteed not to introduce critical races. D. Helmbold and D. Luckham's (1985) gas-station example is used to illustrate the various approaches to applying the design method     

Design and implementation of a Petri net based toolkit for Adatasking analysis

The use of Petri nets for defining a general static analysis framework for Ada tasking is advocated. The framework has evolved into a collection of tools that have proven to be a very valuable platform for experimental research. The design and implementation of tools that make up the tasking-oriented toolkit for the Ada language (TOTAL) are defined and discussed. Modeling and query/analysis methods and tools are discussed. Example Ada tasking programs are used to demonstrate the utility of each tool individually as well as the way the tools integrate. TOTAL is divided into two major subsystems, the front-end translator subsystem (FETS) and the back-end information display subsystem (BIDS). Three component tools that make up FETS are defined. Examples demonstrate the way these tools integrate in order to perform the translation of Ada source to Petri-net format. The BIDS subsystem and, in particular, the use of tools and techniques to support user-directed, but transparent, searches of Ada-net reachability graphs are discussed     

一个基于Ada的面向对象建模语言

给出了一个基于Ada的建模语言AML.AML以Ada95为基础,吸取了Ada95的基本原理和思想,利用支持建模的设施对其进行扩充,以便适用于软件建模的各个阶段.AML沿用了Ada95中的程序包概念,并将程序包作为它的核心成份,同时,沿用了Ada95的任务单元和保护单元等设施,以精确描述了软件系统中主动控制成份和资源保护成份的各种特性;AML吸取了图形化面向对象建模语言与建模方法所采用的多视点模型思想,将实体不同侧面的特征分开描述;AML利用一种新的并发模型和限制设施,有效地解决了系统的并发特性和不确定性等非功能特性的描述问题;AML有较强的可扩充性,能应用于各种应用领域.总之,AML是一个既面向用户,面向开发者,又面向系统的通用建模语言,有效地克服了现有一些建模语言在表达能力和应用范围等方面存在的诸多不足.     

软件缺陷预测技术研究进展

随着软件规模的扩大和复杂度的不断提高,软件的质量问题成为关注的焦点,软件缺陷是软件质量的对立面,威胁着软件质量,如何在软件开发的早期挖掘出缺陷模块成为一个亟需解决的问题.软件缺陷预测通过挖掘软件历史仓库,设计出与缺陷相关的内在度量元,然后借助机器学习等方法来提前发现与锁定缺陷模块,从而合理地分配有限的资源.因此,软件缺陷预测是软件质量保证的重要途径之一,近年来已成为软件工程中一个非常重要的研究课题.汇总近8年（2010年~2017年）国内外的缺陷预测技术的研究成果,并以缺陷预测的形式为主线进行分析,首先介绍了软件缺陷预测模型的框架;然后从软件缺陷数据集、构建模型的方法及评价指标这3个方面对已有的研究工作进行分类归纳和比较;最后探讨了软件缺陷预测的未来可能的研究方向、机遇和挑战.     

关于Ada并发可重用软件包的设计

文中首先分析了一般Ａｄａ顺序可重用软件包在用于开发Ａｄａ并发软件时所存在的问题，然后给出了几种可以支持并发软件开发的Ａｄａ可重用软件包的实现方案，并同时指出了各种方案的不足及可取之处。     

Defining and validating measures for object-based high-level design

The availability of significant measures in the early phases of the software development life-cycle allows for better management of the later phases, and more effective quality assessment when quality can be more easily affected by preventive or corrective actions. We introduce and compare various high-level design measures for object-based software systems. The measures are derived based on an experimental goal, identifying fault-prone software parts, and several experimental hypotheses arising from the development of Ada systems for Flight Dynamics Software at the NASA Goddard Space Flight Center (NASA/GSFC). Specifically, we define a set of measures for cohesion and coupling, which satisfy a previously published set of mathematical properties that are necessary for any such measures to be valid. We then investigate the measures' relationship to fault-proneness on three large scale projects, to provide empirical support for their practical significance and usefulness     

Measurement of language-supported reuse in object-oriented and object-based software

A major benefit of object-oriented software development is the support for reuse provided by object-oriented and object-based languages. Yet, measures and measurement tools that quantify such language-supported reuse have been lacking. Comprehensive reuse measures, particularly for reuse with modifications, are necessary to evaluate the status of reuse in an organization and to monitor improvements. We develop a set of measurable reuse attributes appropriate to object-oriented and object-based systems and a suite of measures that quantify these attributes. One of our major objectives is to measure reuse in software written in the object-based language Ada. A set of suitable primitive reuse measures are expressed in Ada Reuse Tables. These tables support the flexible use of primitive measures in programs with nested packages and subprograms, and Ada generic packages. We designed and implemented a prototype Ada Reuse Measurement Analyzer (ARMA) to generate measurement values from Ada programs. ARMA produces a reuse data representation and a corresponding forest representation of an Ada system that contain the information necessary to produce the primitive measures. Developers can use the representations to produce customized reports to satisfy a wide range of measurement goals. We use ARMA to measure primitive reuse attributes for a set of industrial Ada software. We also show that ARMA can be used to generate a set of component access and package visibility measures.     

Computer-aided software engineering and Ada -- The technological marriage of the decade

Computer-Aided Software Engineering (CASE) tools and Ada language compilers are now available for both mainframes and Personal Computers (PCs). Although CASE methodologies have existed since the early 1970s and the use of Ada has been required by the Department of Defense since 1985, only recently have CASE and Ada become of serious interest to engineers.

This paper identifies the capabilities of PC-based CASE software, the reasons for combining CASE with Ada, and the impact of CASE and Ada on research and teaching in the areas of Industrial and Computer Engineering. Based on the authors' first-hand experience, the advantages and/or disadvantages of several CASE tools and Ada environments will be discussed. Other topics addressed include the meanings of related terminology (e.g., object-oriented programming, design methodologies) and the future ramifications of CASE and Ada on the software engineering community.