Transportation of higher-level language programs: exemplified by an ALGOL 68 transportation representation /

Includes bibliographical references.

Measuring the knowledge-content of programs /

Bibliography: p. 41.

Computer planning for efficient solid waste collection : [a condensation] /

"Condensation of Mathematical Analysis of Solid Waste Collection by David H. Marks and Jon C. Liebman."

Maintenance testing for the data encryption standard /

"Issued August 1980."

Structured testing : a testing methodology using the cyclomatic complexity metric /

Mode of access: Internet.

Computer contribution.

GeoRef

Effects of GeneXpert MTB/RIF Testing and GxAlert eHealth Platforms on MDR-TB Diagnosis and Linkage to Care in Sofala Province, Mozambique

Thesis (Master's)--University of Washington, 2016-06

Mechanical alloying of MoSi2 with ternary alloying elements. Part 2 - computer simulation

A computer model of the mechanical alloying process has been developed to simulate phase formation during the mechanical alloying of Mo and Si elemental powders with a ternary addition of Al, Mg, Ti or Zr. Using the Arhennius equation, the model balances the formation rates of the competing reactions that are observed during milling. These reactions include the formation of tetragonal C11(b) MOSi2 (t-MoSi2) by combustion, the formation of the hexagonal C40 MoSi2 polymorph (h-MoSi2), the transformation of the tetragonal to the hexagonal form, and the recovery of t-MoSi2 from h-MoSi2 and deformed t-MoSi2. The addition of the ternary additions changes the free energy of formation of the associated MoSi2 alloys, i.e. Mo(Si, Al)(2), Mo(Mg, Al)(2), (Mo, Ti)Si-2 (Mo, Zr)Si-2 and (Mo, Fe)Si-2, respectively. Variation of the energy of formation alone is sufficient for the simulation to accurately model the observed phase formation. (C) 2003 Elsevier B.V. All rights reserved.

Genetic and economic analysis of a targeted marker-assisted wheat breeding strategy

The advent of molecular markers as a tool to aid selection has provided plant breeders with the opportunity to rapidly deliver superior genetic solutions to problems in agricultural production systems. However, a major constraint to the implementation of marker-assisted selection (MAS) in pragmatic breeding programs in the past has been the perceived high relative cost of MAS compared to conventional phenotypic selection. In this paper, computer simulation was used to design a genetically effective and economically efficient marker-assisted breeding strategy aimed at a specific outcome. Under investigation was a strategy involving the integration of both restricted backcrossing and doubled haploid (DH) technology. The point at which molecular markers are applied in a selection strategy can be critical to the effectiveness and cost efficiency of that strategy. The application of molecular markers was considered at three phases in the strategy: allele enrichment in the BC1F1 population, gene selection at the haploid stage and the selection for recurrent parent background of DHs prior to field testing. Overall, incorporating MAS at all three stages was the most effective, in terms of delivering a high frequency of desired outcomes and at combining the selected favourable rust resistance, end use quality and grain yield alleles. However, when costs were included in the model the combination of MAS at the BC1F1 and haploid stage was identified as the optimal strategy. A detailed economic analysis showed that incorporation of marker selection at these two stages not only increased genetic gain over the phenotypic alternative but actually reduced the over all cost by 40%.

Tool support for executable documentation of Java class hierarchies

While object-oriented programming offers great solutions for today's software developers, this success has created difficult problems in class documentation and testing. In Java, two tools provide assistance: Javadoc allows class interface documentation to be embedded as code comments and JUnit supports unit testing by providing assert constructs and a test framework. This paper describes JUnitDoc, an integration of Javadoc and JUnit, which provides better support for class documentation and testing. With JUnitDoc, test cases are embedded in Javadoc comments and used as both examples for documentation and test cases for quality assurance. JUnitDoc extracts the test cases for use in HTML files serving as class documentation and in JUnit drivers for class testing. To address the difficult problem of testing inheritance hierarchies, JUnitDoc provides a novel solution in the form of a parallel test hierarchy. A small controlled experiment compares the readability of JUnitDoc documentation to formal documentation written in Object-Z. Copyright (c) 2005 John Wiley & Sons, Ltd.

A theory for execution-time derivation in real-time programs

We provide an abstract command language for real-time programs and outline how a partial correctness semantics can be used to compute execution times. The notions of a timed command, refinement of a timed command, the command traversal condition, and the worst-case and best-case execution time of a command are formally introduced and investigated with the help of an underlying weakest liberal precondition semantics. The central result is a theory for the computation of worst-case and best-case execution times from the underlying semantics based on supremum and infimum calculations. The framework is applied to the analysis of a message transmitter program and its implementation. (c) 2005 Elsevier B.V. All rights reserved.

Progress in deriving concurrent programs: Emphasizing the role of stable guards

We present some techniques to obtain smooth derivations of concurrent programs that address both safety and progress in a formal manner. Our techniques form an extension to the calculational method of Feijen and van Casteren using a UNITY style progress logic. We stress the role of stable guards, and we illustrate the derivation techniques on some examples in which progress plays an essential role.

Viewpoint-based testing of concurrent components

The use of multiple partial viewpoints is recommended for specification. We believe they also can be useful for devising strategies for testing. In this paper, we use Object-Z to formally specify concurrent Java components from viewpoints based on the separation of application and synchronisation concerns inherent in Java monitors. We then use the Test-Template Framework on the Object-Z viewpoints to devise a strategy for testing the components. When combining the test templates for the different viewpoints we focus on the observable behaviour of the application to systematically derive a practical testing strategy. The Producer-Consumer and Readers-Writers problems are considered as case studies.

Mutation-based exploration of a method for verifying concurrent Java components

Summary form only given. The Java programming language supports concurrency. Concurrent programs are harder to verify than their sequential counterparts due to their inherent nondeterminism and a number of specific concurrency problems such as interference and deadlock. In previous work, we proposed a method for verifying concurrent Java components based on a mix of code inspection, static analysis tools, and the ConAn testing tool. The method was derived from an analysis of concurrency failures in Java components, but was not applied in practice. In this paper, we explore the method by applying it to an implementation of the well-known readers-writers problem and a number of mutants of that implementation. We only apply it to a single, well-known example, and so we do not attempt to draw any general conclusions about the applicability or effectiveness of the method. However, the exploration does point out several strengths and weaknesses in the method, which enable us to fine-tune the method before we carry out a more formal evaluation on other, more realistic components.

A case study in specification and implementation testing

Achieving consistency between a specification and its implementation is an important part of software development In previous work, we have presented a method and tool support for testing a formal specification using animation and then verifying an implementation of that specification. The method is based on a testgraph, which provides a partial model of the application under test. The testgraph is used in combination with an animator to generate test sequences for testing the formal specification. The same testgraph is used during testing to execute those same sequences on the implementation and to ensure that the implementation conforms to the specification. So far, the method and its tool support have been applied to software components that can be accessed through an application programmer interface (API). In this paper, we use an industrially-based case study to discuss the problems associated with applying the method to a software system with a graphical user interface (GUI). In particular, the lack of a standardised interface, as well as controllability and observability problems, make it difficult to automate the testing of the implementation. The method can still be applied, but the amount of testing that can be carried on the implementation is limited by the manual effort involved.