Design patterns: elements of reusable object-oriented software
Design patterns: elements of reusable object-oriented software
A modal analysis of staged computation
Journal of the ACM (JACM)
A Theory of Objects
Separation Logic: A Logic for Shared Mutable Data Structures
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
An Observationally Complete Program Logic for Imperative Higher-Order Frame Rules
LICS '05 Proceedings of the 20th Annual IEEE Symposium on Logic in Computer Science
Certified assembly programming with embedded code pointers
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Practical dynamic software updating for C
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Mutatis Mutandis: Safe and predictable dynamic software updating
ACM Transactions on Programming Languages and Systems (TOPLAS)
Ynot: dependent types for imperative programs
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
A Simple Model of Separation Logic for Higher-Order Store
ICALP '08 Proceedings of the 35th international colloquium on Automata, Languages and Programming, Part II
jStar: towards practical verification for java
Proceedings of the 23rd ACM SIGPLAN conference on Object-oriented programming systems languages and applications
Hoare type theory, polymorphism and separation1
Journal of Functional Programming
A realizability model for impredicative Hoare type theory
ESOP'08/ETAPS'08 Proceedings of the Theory and practice of software, 17th European conference on Programming languages and systems
Nested Hoare triples and frame rules for higher-order store
CSL'09/EACSL'09 Proceedings of the 23rd CSL international conference and 18th EACSL Annual conference on Computer science logic
Realisability semantics of parametric polymorphism, general references and recursive types
Mathematical Structures in Computer Science
Verifying generics and delegates
ECOOP'10 Proceedings of the 24th European conference on Object-oriented programming
Step-indexed kripke models over recursive worlds
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A quick tour of the VeriFast program verifier
APLAS'10 Proceedings of the 8th Asian conference on Programming languages and systems
Hoare logic for higher order store using simple semantics
WoLLIC'11 Proceedings of the 18th international conference on Logic, language, information and computation
Formal reasoning about runtime code update
ICDEW '11 Proceedings of the 2011 IEEE 27th International Conference on Data Engineering Workshops
Verification of unloadable modules
FM'11 Proceedings of the 17th international conference on Formal methods
Specification patterns and proofs for recursion through the store
FCT'11 Proceedings of the 18th international conference on Fundamentals of computation theory
Smallfoot: modular automatic assertion checking with separation logic
FMCO'05 Proceedings of the 4th international conference on Formal Methods for Components and Objects
About hoare logics for higher-order store
ICALP'05 Proceedings of the 32nd international conference on Automata, Languages and Programming
CSL'06 Proceedings of the 20th international conference on Computer Science Logic
Linux device drivers, third edition
Linux device drivers, third edition
A semantic foundation for hidden state
FOSSACS'10 Proceedings of the 13th international conference on Foundations of Software Science and Computational Structures
Crowfoot: a verifier for higher-order store programs
VMCAI'12 Proceedings of the 13th international conference on Verification, Model Checking, and Abstract Interpretation
Verifying the reflective visitor pattern
Proceedings of the 14th Workshop on Formal Techniques for Java-like Programs
Hi-index | 0.00 |
Higher-order store means that code can be stored on the mutable heap that programs manipulate, and is the basis of flexible software that can be changed or reconfigured at runtime. Specifying such programs is challenging because higher-order store allows recursion through the store, where new (mutual) recursions between code are set up on the fly. This paper presents a series of formal specification patterns that capture increasingly complex uses of recursion through the store. To express the necessary specifications we extend the separation logic for higher-order store given by Schwinghammer et al. (CSL, 2009), adding parameter passing, and certain recursively defined families of assertions. We give proof rules for our extended logic and show their soundness. Finally, we apply our specification patterns and rules to an example program that exploits many of the possibilities offered by higher-order store; this is the first larger case study conducted with logical techniques based on work by Schwinghammer et al. (CSL, 2009), and shows that they are practical.