Subscribe to the gold package and get unlimited access to Shamra Academy
Register a new userThe Essence of Inheritance
64
0
0.0
(
0
)
Added by
Andrew Black
Publication date
2016
fields
Informatics Engineering
and research's language is
English
Ask ChatGPT about the research
No Arabic abstract
Programming languages serve a dual purpose: to communicate programs to computers, and to communicate programs to humans. Indeed, it is this dual purpose that makes programming language design a constrained and challenging problem. Inheritance is an essential aspect of that second purpose: it is a tool to improve communication. Humans understand new concepts most readily by first looking at a number of concrete examples, and later abstracting over those examples. The essence of inheritance is that it mirrors this process: it provides a formal mechanism for moving from the concrete to the abstract.
rate research
Read More
Rust claims to advance industrial programming by bridging the gap between low-level systems programming and high-level application programming. At the heart of the argument that this enables programmers to build more reliable and efficient software is the borrow checker - a novel approach to ownership that aims to balance type system expressivity with usability. And yet, to date there is no core type system that captures Rusts notion of ownership and borrowing, and hence no foundation for research on Rust to build upon. In this work, we set out to capture the essence of this model of ownership by developing a type systems account of Rusts borrow checker. We present Oxide, a formalized programming language close to source-level Rust (but with fully-annotated types). This presentation takes a new view of lifetimes as an approximation of the provenances of references, and our type system is able to automatically compute this information through a substructural typing judgment. We provide the first syntactic proof of type safety for borrow checking using progress and preservation. Oxide is a simpler formulation of borrow checking - including recent features such as non-lexical lifetimes - that we hope researchers will be able to use as the basis for work on Rust.
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.
For the past several decades, programmers have been modeling things in the world with trees using hierarchies of classes and object-oriented programming (OOP) languages. In this paper, we describe a novel approach to programming, called concept-oriented programming (COP), which generalizes classes and inheritance by introducing concepts and inclusion, respectively.
We perform numerical simulations of the gravitational collapse of a k-essence scalar field. When the field is sufficiently strongly gravitating, a black hole forms. However, the black hole has two horizons: a light horizon (the ordinary black hole horizon) and a sound horizon that traps k-essence. In certain cases the k-essence signals can travel faster than light and the sound horizon is inside the light horizon. Under those circumstances, k-essence signals can escape from the black hole. Eventually, the two horizons merge and the k-essence signals can no longer escape.
We give a new approach to handling hypergraph regularity. This approach allows for vertex-by-vertex embedding into regular partitions of hypergraphs, and generalises to regular partitions of sparse hypergraphs. We also prove a corresponding sparse hypergraph regularity lemma.
Log in to be able to interact and post comments
comments
Fetching comments
Sign in to be able to follow your search criteria
