116 research outputs found
Subclassing errors, OOP, and practically checkable rules to prevent them
This paper considers an example of Object-Oriented Programming (OOP) leading
to subtle errors that break separation of interface and implementations. A
comprehensive principle that guards against such errors is undecidable. The
paper introduces a set of mechanically verifiable rules that prevent these
insidious problems. Although the rules seem restrictive, they are powerful and
expressive, as we show on several familiar examples. The rules contradict both
the spirit and the letter of the OOP. The present examples as well as available
theoretical and experimental results pose a question if OOP is conducive to
software development at all.Comment: 10 pages, 1 LaTeX file; accompanying C++ and Haskell code and
compilation instruction
Do Mutable Variables Have Reference Types?
Implicit heterogeneous metaprogramming (a.k.a. offshoring) is an attractive
approach for generating C with some correctness guarantees: generate OCaml
code, where the correctness guarantees are easier to establish, and then map
that code to C. The key idea is that simple imperative OCaml code looks like a
non-standard notation for C. Regretfully, it is false, when it comes to mutable
variables. In the past, the approach was salvaged by imposing strong ad hoc
restrictions. The present paper for the first time investigates the problem
systematically and discovers general solutions needing no restrictions. In the
process we explicate the subtleties of modeling mutable variables by values of
reference types and arrive at an intuitively and formally clear correspondence.
We also explain C assignment without resorting to L-values.Comment: Peer-reviewed, accepted for presentation and presented at the ACM
SIGPLAN ML Family Workshop 202
Implementing Explicit and Finding Implicit Sharing in Embedded DSLs
Aliasing, or sharing, is prominent in many domains, denoting that two
differently-named objects are in fact identical: a change in one object (memory
cell, circuit terminal, disk block) is instantly reflected in the other.
Languages for modelling such domains should let the programmer explicitly
define the sharing among objects or expressions. A DSL compiler may find other
identical expressions and share them, implicitly. Such common subexpression
elimination is crucial to the efficient implementation of DSLs. Sharing is
tricky in embedded DSL, since host aliasing may correspond to copying of the
underlying objects rather than their sharing.
This tutorial summarizes discussions of implementing sharing in Haskell DSLs
for automotive embedded systems and hardware description languages. The
technique has since been used in a Haskell SAT solver and the DSL for music
synthesis. We demonstrate the embedding in pure Haskell of a simple DSL with a
language form for explicit sharing. The DSL also has implicit sharing,
implemented via hash-consing. Explicit sharing greatly speeds up hash-consing.
The seemingly imperative nature of hash-consing is hidden beneath a simple
combinator language. The overall implementation remains pure functional and
easy to reason about.Comment: In Proceedings DSL 2011, arXiv:1109.032
Answer-Type Modification without Tears: Prompt-Passing Style Translation for Typed Delimited-Control Operators
The salient feature of delimited-control operators is their ability to modify
answer types during computation. The feature, answer-type modification (ATM for
short), allows one to express various interesting programs such as typed printf
compactly and nicely, while it makes it difficult to embed these operators in
standard functional languages.
In this paper, we present a typed translation of delimited-control operators
shift and reset with ATM into a familiar language with multi-prompt shift and
reset without ATM, which lets us use ATM in standard languages without
modifying the type system. Our translation generalizes Kiselyov's direct-style
implementation of typed printf, which uses two prompts to emulate the
modification of answer types, and passes them during computation. We prove that
our translation preserves typing. As the naive prompt-passing style translation
generates and passes many prompts even for pure terms, we show an optimized
translation that generate prompts only when needed, which is also
type-preserving. Finally, we give an implementation in the tagless-final style
which respects typing by construction.Comment: In Proceedings WoC 2015, arXiv:1606.0583
- …