Corpus ID: 52264517

Verifying Interfaces Between Container-Based Components

  title={Verifying Interfaces Between Container-Based Components},
  author={Christopher S. Meiklejohn},
Container-based programming has become the lingua franca for building distributed applications. More than ever before, application developers not only have to reason about the behavior of containerized components, but also the composition of these components that are increasingly presented to the developer as prepackaged, “black box” solutions. As a result, there is an increasing need for ways to ensure that composition preserves individual component invariants. In this work, we present a… Expand

Figures from this paper


Design Patterns for Container-based Distributed Systems
This paper describes three types of design patterns that are observed emerging in container-based distributed systems: single-container patterns for container management, single- node patterns of closely cooperating containers, and multi-node patterns for distributed algorithms. Expand
A Note on Distributed Computing
It is argued that objects that interact in a distributed system need to be dealt with in ways that are intrinsically different from objects that interactions in a single address space, because distributed systems require that the programmer be aware of latency, have a different model of memory access, and take into account issues of concurrency and partial failure. Expand
CORBA: integrating diverse applications within distributed heterogeneous environments
An overview of the Object Management Architecture is provided, in detail the CORBA component of that architecture is described, and a description of the OMG organization is described along with some of its current and future work. Expand
Lineage-driven Fault Injection
MOLLY is presented, a prototype of lineage-driven fault injection that exploits a novel combination of data lineage techniques from the database literature and state-of-the-art satisfiability testing that finds bugs in fault-tolerant data management systems rapidly. Expand
A behavioral notion of subtyping
This paper presents a way of specifying types that makes it convenient to define the subtype relation, and discusses the ramifications of this notion of subtyping on the design of type families. Expand
Programming with ASN.1 Using Polymorphic Types and Type Specialization
A set of object-oriented abstractions is described that permits direct programming with ASN.1 types as instances of class templates and makes use of class template for representing polymorphic types, class inheritance for type specialization, and typedefs forType specialization. Expand
A Theory of Type Polymorphism in Programming
  • R. Milner
  • Computer Science
  • J. Comput. Syst. Sci.
  • 1978
This work presents a formal type discipline for polymorphic procedures in the context of a simple programming language, and a compile time type-checking algorithm w which enforces the discipline. Expand
On understanding types, data abstraction, and polymorphism
A λ-calculus-based model for type systems that allows us to explore the interaction among the concepts of type, data abstraction, and polymorphism in a simple setting, unencumbered by complexities of production programming languages is developed. Expand
A Core Calculus for Scala Type Checking
A minimal core calculus is presented that captures interesting constructs of the Scala programming language: nested classes, abstract types, mixin composition, and path dependent types and it is shown that the problems of type assignment and subtyping are decidable. Expand
Local type inference
Two partial type inference methods for a language combining subtyping and impredicative polymorphism are studied, one of which infers type arguments in polymorphic applications using a local constraint solver and the other infers annotations on bound variables in function. Expand