1,700 research outputs found
A Type System for First-Class Layers with Inheritance, Subtyping, and Swapping
Context-Oriented Programming (COP) is a programming paradigm to encourage
modularization of context-dependent software. Key features of COP are
layers---modules to describe context-dependent behavioral variations of a
software system---and their dynamic activation, which can modify the behavior
of multiple objects that have already been instantiated. Typechecking programs
written in a COP language is difficult because the activation of a layer can
even change objects' interfaces. Inoue et al. have informally discussed how to
make JCop, an extension of Java for COP by Appeltauer et al., type-safe.
In this article, we formalize a small COP language called ContextFJ
with its operational semantics and type system and show its type soundness. The
language models main features of the type-safe version of JCop, including
dynamically activated first-class layers, inheritance of layer definitions,
layer subtyping, and layer swapping
Verified Subtyping with Traits and Mixins
Traits allow decomposing programs into smaller parts and mixins are a form of
composition that resemble multiple inheritance. Unfortunately, in the presence
of traits, programming languages like Scala give up on subtyping relation
between objects. In this paper, we present a method to check subtyping between
objects based on entailment in separation logic. We implement our method as a
domain specific language in Scala and apply it on the Scala standard library.
We have verified that 67% of mixins used in the Scala standard library do
indeed conform to subtyping between the traits that are used to build them.Comment: In Proceedings FSFMA 2014, arXiv:1407.195
Object orientation without extending Z
The good news of this paper is that without extending Z,
we can elegantly specify object-oriented systems, including encapsulation,
inheritance and subtype polymorphism (dynamic dispatch). The
bad news is that this specification style is rather different to normal
Z specifications, more abstract and axiomatic, which means that it is
not so well supported by current Z tools such as animators. It also enforces
behavioural subtyping, unlike most object-oriented programming
languages. This paper explains the proposed style, with examples, and
discusses its advantages and disadvantages
Covariance and Controvariance: a fresh look at an old issue (a primer in advanced type systems for learning functional programmers)
Twenty years ago, in an article titled "Covariance and contravariance:
conflict without a cause", I argued that covariant and contravariant
specialization of method parameters in object-oriented programming had
different purposes and deduced that, not only they could, but actually they
should both coexist in the same language.
In this work I reexamine the result of that article in the light of recent
advances in (sub-)typing theory and programming languages, taking a fresh look
at this old issue.
Actually, the revamping of this problem is just an excuse for writing an
essay that aims at explaining sophisticated type-theoretic concepts, in simple
terms and by examples, to undergraduate computer science students and/or
willing functional programmers.
Finally, I took advantage of this opportunity to describe some undocumented
advanced techniques of type-systems implementation that are known only to few
insiders that dug in the code of some compilers: therefore, even expert
language designers and implementers may find this work worth of reading
Matchmaking for covariant hierarchies
We describe a model of matchmaking suitable for the implementation of services, rather than their for their discovery and composition. In the model, processing requirements are modelled by client requests and computational resources are software processors that compete for request processing as the covariant implementations of an open service interface. Matchmaking then relies on type analysis to rank processors against requests in support of a wide range of dispatch strategies. We relate the model to the autonomicity of service provision and briefly report on its deployment within a production-level infrastructure for scientic computing
- ā¦