25 research outputs found

    Theories in Practice: Easy-to-Write Specifications that Catch Bugs

    Get PDF
    Automated testing during development helps ensure that software works according to the test suite. Traditional test suites verify a few well-picked scenarios or example inputs. However, such example-based testing does not uncover errors in legal inputs that the test writer overlooked. We propose theory-based testing as an adjunct to example-based testing. A theory generalizes a (possibly infinite) set of example-based tests. A theory is an assertion that should be true for any data, and it can be exercised by human-chosen data or by automatic data generation. A theory is expressed in an ordinary programming language, it is easy for developers to use (often even easier than example-based testing), and it serves as a lightweight form of specification. Six case studies demonstrate the utility of theories that generalize existing tests to prevent bugs, clarify intentions, and reveal design problems

    Predicting and Explaining Automatic Testing Tool Effectiveness

    Get PDF
    Automatic white-box test generation is a challenging problem. Many existing tools rely on complex code analyses and heuristics. As a result, structural features of an input program may impact tool effectiveness in ways that tool users and designers may not expect or understand. We develop a technique that uses structural program metrics to both predict and explain the test coverage achieved by three automatic test generation tools. We use coverage and structural metrics extracted from 11 software projects to train several decision-tree classifiers. These classifiers can predict high or low coverage with success rates of 82% to 94%. In addition, they show tool users and designers the program structures that impact tool effectiveness

    HARMONIA: A Flexible Framework for Constructing Interactive Language-Based Programming Tools

    No full text
    Despite many attempts in both research and industry to develop successful language-based software engineering tools, the resulting systems consistently fail to become adopted by working programmers. One of the main reasons for this failure is the closed-world view adopted by these systems: it is virtually impossible to integrate them with any outside technology. To address this problem, and to create a flexible research infrastructure, we created Harmonia, an open framework for constructing interactive language-based programming tools. This report presents the architecture of the Harmonia framework. We briefly review the design of the two earlier Berkeley projects, the Pan and Ensemble systems, discuss their influences on the design of Harmonia, and present the organization and interactions of the majo

    Program Manipulation via Interactive Transformations

    No full text
    Systematic large-scale modification of source code is tedious and error-prone, because developers use authoring and editing tools poorly suited to the program maintenance task. We combine the results from psychology of programming, software visualization, program analysis, and program transformation fields to create a novel environment that lets the programmers express operations on program source code at a level above text-oriented editing

    Visual programming languages: A survey

    No full text
    Over the past ten years, frequent increases in computer processing speed and graphics display capabilities have made possible a great deal of research and experimentation in the field of visual programming languages. A variety of different design methodologies have arisen from these research efforts, and numerous visual programming systems have been developed to address both specific application areas, such as user interface design and physical simulation, and more general programming tasks. We present a survey of the field of visual programming languages beginning with an historical overview of some of the pioneering efforts in the field. In addition, we present different classifications of visual programming languages, touch on implementation and design issues, and discuss efforts to formalize the theoretical basis for visual languages. We also discuss and examine a variety of the more important projects in the field over the last few years. Note: This survey was originally written as a term project paper for the graduate course on programming language design in December 1997. As was required by the course instructor, we uploaded the report to a web page, received our grades, and forgot all about it. To our great surprise, others have found this paper through various Internet search engines and started referring to it. In December 2004 we decided to submi

    Aligning development tools with the way programmers think about code changes

    No full text
    Software developers must modify their programs to keep up with changing requirements and designs. Often, a conceptually simple change can require numerous edits that are similar but not identical, leading to errors and omissions. Researchers have designed programming environments to address this problem, but most of these systems are counter-intuitive and difficult to use. By applying a task-centered design process, we developed a visual tool that allows programmers to make complex code transformations in an intuitive manner. This approach uses a representation that aligns well with programmers ’ mental models of programming structures. The visual language combines textual and graphical elements and is expressive enough to support a broad range of code-changing tasks. To simplify learning the system, its user interface scaffolds construction and execution of transformations. An evaluation with Java programmers suggests that the interface is intuitive, easy to learn, and effective on a representative editing task. Author Keywords Transformations, visual languages, cognitive dimensions
    corecore