Data abstraction and information hiding

@article{Leino2002DataAA,
  title={Data abstraction and information hiding},
  author={K. Rustan M. Leino and Greg Nelson},
  journal={ACM Trans. Program. Lang. Syst.},
  year={2002},
  volume={24},
  pages={491-553}
}
This article describes an approach for verifying programs in the presence of data abstraction and information hiding, which are key features of modern programming languages with objects and modules. This article draws on our experience building and using an automatic program checker, and focuses on the property of modular soundness: that is, the property that the separate verifications of the individual modules of a program suffice to ensure the correctness of the composite program. We found… 
A Calculus for Data Abstraction
TLDR
This thesis examines, to what extent the abstract specification functions (observers) and explicit dependencies can be exploited to simplify logical expressions on a syntactical level.
Validation techniques for object-oriented proof outlines
TLDR
This thesis presents a proof outline logic for a simple object-oriented programming language that supports inheritance, field shadowing, aliasing, dynamic object creation, subtype polymorphism, and dynamic binding and describes a tool that implements the logic.
A Verification Methodology for Model Fields
TLDR
A sound verification methodology for model fields that handles object-oriented features, supports data abstraction, and can be applied to a variety of realistic programs.
Local Reasoning for Global Invariants, Part I: Region Logic
TLDR
A novel technique for reasoning about error-avoiding partial correctness of programs featuring shared mutable objects is presented, and the technique is investigated by formalizing a logic.
Implicit dynamic frames
TLDR
This article proposes a variant of separation logic called implicit dynamic frames that supports heap-dependent expressions inside assertions inside assertions and shows that these verification conditions can be discharged automatically by standard first-order provers.
Ownership confinement ensures representation independence for object-oriented programs
TLDR
This article formulates representation independence for classes, in an imperative, object-oriented language with pointers, subclassing and dynamic dispatch, class oriented visibility control, recursive types and methods, and a simple form of module.
Safejava: a unified type system for safe programming
TLDR
A new type system that statically prevents data races and deadlocks in multithreaded programs, which are known to be some of the most difficult programming errors to detect, reproduce, and eliminate is presented.
Separation logic and abstraction
TLDR
This paper builds on the formalism of separation logic and introduces the new notion of an abstract predicate and, more generally, abstract predicate families, which provides a flexible mechanism for reasoning about the different forms of abstraction found in modern programming languages, such as abstract datatypes and objects.
9-2006 Information Hiding and Visibility in Interface Specifications
Information hiding controls which parts of a class are visible to non-privileged and privileged clients (e.g., subclasses). This affects detailed design specifications in two ways. First,
Automatic verification of Java programs with dynamic frames
TLDR
This paper proves that the dynamic frames approach can be integrated into an automatic verifier based on verification condition generation and automated theorem proving and has been implemented in a verifier prototype.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 103 REFERENCES
Modular Verification of Data Abstractions with Shared Realizations
TLDR
The authors have developed semantics for data abstractions and their method of specification, and have used it to prove that their verification method is logically sound and relatively complete in the sense of Cook (1978).
Modular specification and verification of object-oriented programs
TLDR
A method for modular specification and verification using the ideas of subtype and normal type, which corresponds to informal techniques used by object-oriented programmers, and a formal model of abstract type specifications is used.
Towards Reliable Modular Programs
TLDR
This thesis presents a theory for verifying programs based on Dijkstra's weakest-precondition calculus, and presents a simple model for object-oriented data types, in which concerns have been separated, resulting in the simplicity of the model.
Aspect: detecting bugs with abstract dependences
TLDR
The basic scheme of Aspect is explained and how it is elaborated to handle data abstraction and aliasing is shown.
Checking object invariants
TLDR
The paper suggests some programming idioms and program annotations that widen the range of object invariants that a static program checker can check.
The Programming Language Oberon-2
TLDR
Oberon-2 is a general-purpose language in the tradition of Oberon and Modula2 whose most important features are block structure, modularity, separate compilation, static typing with strong type checking, and type extension with type-bound procedures.
Abstraction and Specification in Program Development
"Abstraction and Specification in Program Development" offers professionals in program design and software engineering a methodology that will enable them to construct programs that are reliable and
Data groups: specifying the modification of extended state
TLDR
The paper shows that there is a problem to be solved in the specification of methods whose overrides may modify additional state introduced in subclasses and introduces data groups, which enable modular checking and rather naturally capture a programmer's design decisions.
A new notion of encapsulation
Generally speaking, a “module” is used as an “encapsulation mechanism” to tie together a set of declarations of variables and operations upon them. Although there is no standard way to instantiate or
Recursive Object Types in a Logic of Object-Oriented Programs
  • K. Leino
  • Computer Science
    Nord. J. Comput.
  • 1998
This paper formalizes a small object-oriented programming notation. The notation features imperative commands where objects can be shared (aliased), and is rich enough to allow subtypes and recursive
...
1
2
3
4
5
...