The verifying compiler: A grand challenge for computing research

@article{Hoare2003TheVC,
  title={The verifying compiler: A grand challenge for computing research},
  author={Charles Antony Richard Hoare},
  journal={J. ACM},
  year={2003},
  volume={50},
  pages={63-69}
}
  • C. Hoare
  • Published 7 April 2003
  • Computer Science, Education
  • J. ACM
This contribution proposes a set of criteria that distinguish a grand challenge in science or engineering from the many other kinds of short-term or long-term research problems that engage the interest of scientists and engineers. As an example drawn from Computer Science, it revives an old challenge: the construction and application of a verifying compiler that guarantees correctness of a program before running it. 
Linking the Meaning of Programs to What the Compiler Can Verify
TLDR
The ASM method is explained how it allows one to bridge the gap between informal requirements and detailed code by combining application-centric experimentally validatable system modeling with mathematically verifiable refinementsof abstract models to compiler-verifiable code.
Applying the B Method to Take on the Grand Challenge of Verified Compilation
This paper investigates the application of the B method beyond the classical algorithmic level provided by the B0 sub-language, and presents refinements of B models at a level of precision equivalent
Provably Correct Code Generation: A Case Study
Scalable Specification and Reasoning : Technical Challenges for Program Logic
TLDR
The scientific challenges that this poses for research in program logic are discussed, and some test problems that would be useful in measuring advances on modular reasoning are suggested.
The Challenge of Hardware-Software Co-verification
TLDR
This work addresses issues of decomposing verification efforts into mostly separate tasks, one involving hardware and the other software, using as a running example the recent and on-going work on refinement-based pipelined machine verification.
Scalable Specification and Reasoning: Challenges for Program Logic
TLDR
The scientific challenges that this poses for research in program logic are discussed and some recent work on separation logic is described, and test problems that would be useful in measuring advances on modular reasoning are suggested.
Designing a verifying compiler: Lessons learned from developing Whiley
The verified software repository: a step towards the verifying compiler
TLDR
The verified software repository is a first step towards the realisation of this long-term vision of a future in which all computer systems justify the trust that society increasingly places in them, and will maintain and develop an evolving collection of state-of-the-art tools.
Model for Parallel Verification of Programs
TLDR
Under a closed environment, this paper explores proof reusing and organizing methodology and presents a model suitable for verifying numerous programs simultaneously.
Heaps and Data Structures: A Challenge for Automated Provers
TLDR
This work proposes a family of benchmarks in first-order logic with equality which is scalable, relatively simple to understand, yet closely resembles difficult verification conditions stemming from real-world C code.
...
...

References

SHOWING 1-10 OF 60 REFERENCES
A system and language for building system-specific, static analyses
TLDR
A flexible, easy-to-use extension language for specifying analyses and an efficent algorithm for executing these extensions, which believe is an effective framework for deploying new bug-finding analyses quickly and easily.
CMC: a pragmatic approach to model checking real code
TLDR
A new model checker, CMC, which checks C and C++ implementations directly, eliminating the need for a separate abstract description of the system behavior, and reduces missed errors as well as time-wasting false error reports resulting from inconsistencies between the abstract description and the actual implementation.
PVS: Combining Specification, Proof Checking, and Model Checking
We claim that no single technique such as rewriting, BDDs, or model checking is effective for all aspects of hardware verification. Many examples need the careful integration of these techniques. We
A Trace Model for Pointers and Objects
TLDR
A mathematical model and language for the formulation of assertions about objects and pointers are introduced, and a graphical calculus may help in reasoning about program correctness, which deals with both garbage-collected heaps and the other kind.
CCured: type-safe retrofitting of legacy code
TLDR
This paper describes the CCured type system, which extends that of C by separating pointer types according to their usage, and presents a surprisingly simple type inference algorithm that is able to infer the appropriate pointer kinds for existing C programs.
Automatically validating temporal safety properties of interfaces
TLDR
A process for validating temporal safety properties of software that uses a well-defined interface is presented, and it is found that the process converges on a set of predicates powerful enough to validate properties in just a few iterations.
Cyclone: A Safe Dialect of C
TLDR
This paper examines safety violations enabled by C’s design, and shows how Cyclone avoids them, without giving up C”s hallmark control over low-level details such as data representation and memory management.
Correctness by Construction: Developing a Commercial Secure System
TLDR
A systematic process from requirements elicitation through formal specification, user interface prototyping, rigorous design, and coding is used to deliver a highly reliable system that meets all its throughput and usability goals.
Automatic generation of program specifications
TLDR
The experimental results demonstrate that a specific technique, dynamic invariant detection, is effective at generating consistent, sufficient specifications for use by a static checker, and shows that combining static and dynamic analyses over program specifications has benefits for users of each technique.
Local Reasoning about Programs that Alter Data Structures
TLDR
An extension of Hoare's logic for reasoning about programs that alter data structures is described, based on a possible worlds model of the logic of bunched implications, and includes spatial conjunction and implication connectives alongside those of classical logic.
...
...