Exploiting constraints in design synthesis
Exploiting constraints in design synthesis
Tentative steps toward a development method for interfering programs
ACM Transactions on Programming Languages and Systems (TOPLAS)
An introduction to functional programming
An introduction to functional programming
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
Behavioural subtyping using invariants and constraints
Formal methods for distributed processing
Monads for incremental computing
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Separation Logic: A Logic for Shared Mutable Data Structures
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
A judgmental reconstruction of modal logic
Mathematical Structures in Computer Science
Semantics of Separation-Logic Typing and Higher-Order Frame Rules
LICS '05 Proceedings of the 20th Annual IEEE Symposium on Logic in Computer Science
Polymorphism and separation in hoare type theory
Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming
Adaptive functional programming
ACM Transactions on Programming Languages and Systems (TOPLAS)
BI-hyperdoctrines, higher-order separation logic, and abstraction
ACM Transactions on Programming Languages and Systems (TOPLAS) - Special Issue ESOP'05
Modular verification of higher-order methods with mandatory calls specified by model programs
Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented programming systems and applications
Separation logic, abstraction and inheritance
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Design patterns in separation logic
Proceedings of the 4th international workshop on Types in language design and implementation
Using history invariants to verify observers
ESOP'07 Proceedings of the 16th European conference on Programming
SuperGlue: component programming with object-oriented signals
ECOOP'06 Proceedings of the 20th European conference on Object-Oriented Programming
Embedding dynamic dataflow in a call-by-value language
ESOP'06 Proceedings of the 15th European conference on Programming Languages and Systems
The next 700 separation logics
VSTTE'10 Proceedings of the Third international conference on Verified software: theories, tools, experiments
Modular reasoning for deterministic parallelism
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
ESOP'10 Proceedings of the 19th European conference on Programming Languages and Systems
Formalized verification of snapshotable trees: separation and sharing
VSTTE'12 Proceedings of the 4th international conference on Verified Software: theories, tools, experiments
Superficially substructural types
Proceedings of the 17th ACM SIGPLAN international conference on Functional programming
Views: compositional reasoning for concurrent programs
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The ramifications of sharing in data structures
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Local Reasoning for Global Invariants, Part II: Dynamic Boundaries
Journal of the ACM (JACM)
Joins: a case study in modular specification of a concurrent reentrant higher-order library
ECOOP'13 Proceedings of the 27th European conference on Object-Oriented Programming
Abstract effects and proof-relevant logical relations
Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages
Hi-index | 0.00 |
Interactive programs, such as GUIs or spreadsheets, often maintain dependency information over dynamically-created networks of objects. That is, each imperative object tracks not only the objects its own invariant depends on, but also all of the objects which depend upon it, in order to notify them when it changes. These bidirectional linkages pose a serious challenge to verification, because their correctness relies upon a global invariant over the object graph. We show how to modularly verify programs written using dynamically-generated bidirectional dependency information. The critical idea is to distinguish between the footprint of a command, and the state whose invariants depends upon the footprint. To do so, we define an application-specific semantics of updates, and introduce the concept of a ramification operator to explain how local changes can alter our knowledge of the rest of the heap. We illustrate the applicability of this style of proof with a case study from functional reactive programming, and formally justify reasoning about an extremely imperative implementation as if it were pure.