• Corpus ID: 52264517

Verifying Interfaces Between Container-Based Components

@inproceedings{Meiklejohn2018VerifyingIB,
  title={Verifying Interfaces Between Container-Based Components},
  author={Christopher S. Meiklejohn and Zeeshan Ali Lakhani},
  year={2018}
}
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… 

Figures from this paper

Varda: A framework for compositional distributed programming

The Varda language is proposed to formalize the architecture of a system, i.e., its components, their interface, and their orchestration logic, and it relies on a generic interception mechanism to act upon distribution-related system features in a transparent and uniform manner.

References

SHOWING 1-10 OF 13 REFERENCES

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.

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.

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.

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.

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.

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.

A Theory of Type Polymorphism in Programming

  • R. Milner
  • Computer Science
    J. Comput. Syst. Sci.
  • 1978

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.

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.

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.