A research review of quality assessment for software

Measures were recommended to assess the quality of software submitted to the AdaNet program. The quality factors that are important to software reuse are explored and methods of evaluating those factors are discussed. Quality factors important to software reuse are: correctness, reliability, verifiability, understandability, modifiability, and certifiability. Certifiability is included because the documentation of many factors about a software component such as its efficiency, portability, and development history, constitute a class for factors important to some users, not important at all to other, and impossible for AdaNet to distinguish between a priori. The quality factors may be assessed in different ways. There are a few quantitative measures which have been shown to indicate software quality. However, it is believed that there exists many factors that indicate quality and have not been empirically validated due to their subjective nature. These subjective factors are characterized by the way in which they support the software engineering principles of abstraction, information hiding, modularity, localization, confirmability, uniformity, and completeness

Shuttle Ground Operations Efficiencies/Technologies (SGOE/T) study. Volume 2: Ground Operations evaluation

The Ground Operations Evaluation describes the breath and depth of the various study elements selected as a result of an operational analysis conducted during the early part of the study. Analysis techniques used for the evaluation are described in detail. Elements selected for further evaluation are identified; the results of the analysis documented; and a follow-on course of action recommended. The background and rationale for developing recommendations for the current Shuttle or for future programs is presented

June: A Type Testability Transformation for Improved ATG Performance

Strings are universal containers: they are flexible to use, abundant in code, and difficult to test. String-controlled programs are programs that make branching decisions based on string input. Automatically generating valid test inputs for these programs considering only character sequences rather than any underlying string-encoded structures, can be prohibitively expensive. We present June, a tool that enables Java developers to expose any present latent string structure to test generation tools. June is an annotation-driven testability transformation and an extensible library, JuneLib, of structured string definitions. The core JuneLib definitions are empirically derived and provide templates for all structured strings in our test set. June takes lightly annotated source code and injects code that permits an automated test generator (ATG) to focus on the creation of mutable substrings inside a structured string. Using June costs the developer little, with an average of 2.1 annotations per string-controlled class. June uses standard Java build tools and therefore deploys seamlessly within a Java project. By feeding string structure information to an ATG tool, June dramatically reduces wasted effort; branches are effortlessly covered that would otherwise be extremely difficult, or impossible, to cover. This waste reduction both increases and speeds coverage. EvoSuite, for example, achieves the same coverage on June-ed classes in 1 minute, on average, as it does in 9 minutes on the un-June-ed class. These gains increase over time. On our corpus, June-ing a program compresses 24 hours of execution time into ca. 2 hours. We show that many ATG tools can reuse the same June-ed code: a few June annotations, a one-off cost, benefit many different testing regimes

A DFX ATTRIBUTION METHOD APPLIED TO INTEGRATED PRODUCT DEVELOPMENT WITHIN THE AEROSPACE DOMAIN

The aerospace industry constantly seeks to optimize its product development processes to stay competitive in the market. Design for Excellence (DFX) with its various technological areas, tools and methods play an essential role to allow meeting customer expectations while respecting organizational capabilities. However, the quantity and diversity of DFX technological areas and methods make sometimes difficult for the companies to address the appropriate ones for each project. Success in DFX application, keeping product development within scope, time, cost, and quality while not overloading it by applying, monitoring, and managing too many areas, is sometimes very context-dependent, being influenced by the experience of the engineering team as well as the kind of project portfolio or project phase. Considering this scenario, the motivation of this work is to perform a mapping of the technological areas of the DFX, given the decision-making problem of selecting the most appropriate for each kind of project. The objective is to evaluate, according to the point of view of the engineering team, if it is possible to define a general approach to guide, at least initially, project managers in selecting the main technological areas of the DFX, given a typical aerospace organization project portfolio as the boundary condition, and considering special characteristics in each phase of a project lifecycle. Departing from the literature review of the main technological areas of DFX used in the aerospace domain, the research is performed by means of a survey with senior product development engineers from a real aerospace company. Then, quantitative results are gathered through the Likert scale, which allows to draw a hierarchization analysis based on the multicriteria Analytic Hierarchy Process (AHP). A method to indicate the initial choice for the DFX area is presented, which is deemed to be suitable to help project managers and engineers during design of complex products

A Test Suite for High-Performance Parallel Java

The Java programming language has a number of features that make it attractive for writing high-quality, portable parallel programs. A pure object formulation, strong typing and the exception model make programs easier to create, debug, and maintain. The elegant threading provides a simple route to parallelism on shared-memory machines. Anticipating great improvements in numerical performance, this paper presents a suite of simple programs that indicate how a pure Java Navier-Stokes solver might perform. The suite includes a parallel Euler solver. We present results from a 32-processor Hewlett-Packard machine and a 4-processor Sun server. While speedup is excellent on both machines, indicating a high-quality thread scheduler, the single-processor performance needs much improvement