2,882 research outputs found
Trust, but Verify: Two-Phase Typing for Dynamic Languages
A key challenge when statically typing so-called dynamic languages is the
ubiquity of value-based overloading, where a given function can dynamically
reflect upon and behave according to the types of its arguments. Thus, to
establish basic types, the analysis must reason precisely about values, but in
the presence of higher-order functions and polymorphism, this reasoning itself
can require basic types. In this paper we address this chicken-and-egg problem
by introducing the framework of two-phased typing. The first "trust" phase
performs classical, i.e. flow-, path- and value-insensitive type checking to
assign basic types to various program expressions. When the check inevitably
runs into "errors" due to value-insensitivity, it wraps problematic expressions
with DEAD-casts, which explicate the trust obligations that must be discharged
by the second phase. The second phase uses refinement typing, a flow- and
path-sensitive analysis, that decorates the first phase's types with logical
predicates to track value relationships and thereby verify the casts and
establish other correctness properties for dynamically typed languages
Static Types with Less Syntax: Locus Types
Optionally and gradually-typed languages allow types to be introduced
to dynamic code as needed. While this approach allows some gradual
movement from dynamically to statically-typed code, it requires
rewriting object-constructing code to use conventional static types.
We introduce a flexible notion of type, deemed "locus types", that
aims to minimize syntactic burden and the need for refactoring when
introducing types to dynamic code. Locus types are gained by objects
that pass through an annotated code site, following the creed of "code
is types". Their structure is inferred from local type information
computed through flow-based type refinement. The design of
LocusTypeScript, a language extending TypeScript with locus types, is
detailed. Tooling support, building on that of TypeScript, for
programming with locus types is described. As well, the general
properties and applicability of locus types are explored.
LocusTypeScript's simple algorithm for computing stable flow-based
refinement types is presented. The implications and performance impact
of making locus types sound are discussed
Building an IDE for the Calculational Derivation of Imperative Programs
In this paper, we describe an IDE called CAPS (Calculational Assistant for
Programming from Specifications) for the interactive, calculational derivation
of imperative programs. In building CAPS, our aim has been to make the IDE
accessible to non-experts while retaining the overall flavor of the
pen-and-paper calculational style. We discuss the overall architecture of the
CAPS system, the main features of the IDE, the GUI design, and the trade-offs
involved.Comment: In Proceedings F-IDE 2015, arXiv:1508.0338
- …