Franklyn A. Turbak

Intelligent information-sharing systems

The Information Lens system is a prototype intelligent information-sharing system that is designed to include not only good user interfaces for supporting the problem-solving activity of individuals, but also good organizational interfaces for supporting the problem-solving activities of groups.

A calculus with polymorphic and polyvariant flow types

We present λCIL, a typed λ-calculus which serves as the foundation for a typed intermediate language for optimizing compilers for higher-order polymorphic programming languages. The key innovation of λCIL is a novel formulation of intersection and union types and flow labels on both terms and types. These flow types can encode polyvariant control and data flow information within a polymorphically typed program representation. Flow types can guide a compiler in generating customized data representations in a strongly typed setting. Since λCIL enjoys confluence, standardization, and subject reduction properties, it is a valuable tool for reasoning about programs and program transformations.

Robotic Design Studio: Exploring the Big Ideas of Engineering in a Liberal Arts Environment

In this paper we argue that it is important to introduce liberal arts students to the essence of engineering. Toward this end we have developed Robotic Design Studio, a course where students learn how to design, assemble, and program robots made out of LEGO® parts, sensors, motors, and small embedded computers. The course has no prerequisites and has attracted students from a wide range of backgrounds. The course culminates in an exhibition where students show off the robots that they have designed and built. These creative projects tie together aspects of a surprisingly wide range of disciplines. Robotic Design Studio represents an alternative vision of how robot design can be used to teach engineering in a way that is more inclusive and provides more room for artistic expression than contest-centered formats. A web site with detailed descriptions of student projects and all other course materials can be found at http://cs.wellesley.edu/rds.

A Calculus for Link-Time Compilation

We present a module calculus for studying a simple model of link-time compilation. The calculus is stratified into a term calculus, a core module calculus, and a linking calculus. At each level, we show that the calculus enjoys a computational soundness property: if two terms are equivalent in the calculus, then they have the same outcome in a small-step operational semantics. This implies that any module transformation justified by the calculus is meaning preserving. This result is interesting because recursive module bindings thwart confluence at two levels of our calculus, and prohibit application of the traditional technique for showing computational soundness, which requires confluence. We introduce a new technique, based on properties we call lift and project, that uses a weaker notion of confluence with respect to evaluation to establish computational soundness for our module calculus.We also introduce the weak distributivity property for a transformation T operating on modules D1 and D2 linked by ⊕: T(D1 ⊕ D2) = T(T(D1) ⊕ T(D2)). We argue that this property finds promising candidates for link-time optimizations.

Learnable programming: blocks and beyond

New blocks frameworks open doors to greater experimentation for novices and professionals alike.

A Typed Intermediate Language for Flow-Directed Compilation

We present a typed intermediate language λCIL for optimizing compilers for function-oriented and polymorphically typed programming languages (e.g., ML). The language λCIL is a typed lambda calculus with product, sum, intersection, and union types as well as function types annotated with flow labels. A novel formulation of intersection and union types supports encoding flow information in the typed program representation. This flow information can direct optimization.

Relating typability and expressiveness in finite-rank intersection type systems (extended abstract)

We investigate finite-rank intersection type systems, analyzing the complexity of their type inference problems and their relation to the problem of recognizing semantically equivalent terms. Intersection types allow something of type &tau;<inf>1</inf> &Lambda; &tau;<inf>2</inf> to be used in some places at type &tau;<inf>1</inf> and in other places at type &tau;<inf>2</inf>. A <i>finite-rank</i> intersection type system bounds how deeply the &Lambda; can appear in type expressions. Such type systems enjoy strong normalization, subject reduction, and computable type inference, and they support a pragmatics for implementing parametric polymorphism. As a consequence, they provide a conceptually simple and tractable alternative to the impredicative polymorphism of System F and its extensions, while typing many more programs than the Hindley-Milner type system found in ML and Haskell.While type inference is computable at every rank, we show that its complexity grows exponentially as rank increases. Let <b>K</b>(0, <i>n</i>) = <i>n</i> and <b>K</b>(<i>t</i> + 1, <i>n</i>) = 2^{<b>K</b>(<i>t,n</i>)}; we prove that recognizing the pure &lambda;-terms of size <i>n</i> that are typable at rank <i>k</i> is complete for <sc>DTIME</sc>[<b>K</b>(<i>k</i>&minus;1, <i>n</i>)]. We then consider the problem of deciding whether two &lambda;-terms typable at rank <i>k</i> have the same normal form, generalizing a well-known result of Statman from simple types to finite-rank intersection types. We show that the equivalence problem is <sc>DTIME</sc>[<b>K</b>(<b>K</b>(<i>k</i> &minus; 1, <i>n</i>), 2)]-complete. This relationship between the complexity of typability and expressiveness is identical in wellknown decidable type systems such as simple types and Hindley-Milner types, but seems to fail for System F and its generalizations. The correspondence gives rise to a conjecture that if &Tau; is a predicative type system where typability has complexity <i>t</i>(<i>n</i>) and expressiveness has complexity <i>e</i>(<i>n</i>), then <i>t</i>(<i>n</i>) = &Omega;(log* <i>e</i>(<i>n</i>)).

Functioning without closure: type-safe customized function representations for standard ML

The CIL compiler for core Standard ML compiles whole ML programs using a novel typed intermediate language that supports the generation of type-safe customized data representations. In this paper, we present empirical data comparing the relative efficacy of several different flow-based customization strategies for function representations. We develop a cost model to interpret dynamic counts of operations required for each strategy. In this cost model, customizing the representation of closed functions gives a 12-17% improvement on average over uniform closure representations, depending on the layout of the closure. We also present data on the relative effectiveness of various strategies for reducing representation pollution, i.e., situations where flow constraints require the representation of a value to be less efficient than it would be in ideal circumstances. For the benchmarks tested and the types of representation pollution detected by our compiler, the pollution removal strategies we consider often cost more in overhead than they gain via enabled customizations. Notable exceptions are selective defunctionalization, a function representation strategy that often achieves significant customization benefits via aggressive pollution removal, and a simple form of flow-directed inlining, in which pollution removal allows multiple functions to be inlined at the same call site.

Faithful Translations between Polyvariant Flows and Polymorphic Types

Recent work has shown equivalences between various type systems and flow logics. Ideally, the translations upon which such equivalences are based should be faithful in the sense that information is not lost in round-trip translations from flows to types and back or from types to flows and back. Building on the work of Nielson & Nielson and of Palsberg & Pavlopoulou, we present the first faithful translations between a class of finitary polyvariant flow analyses and a type system supporting polymorphism in the form of intersection and union types. Additionally, our flow/type correspondence solves several open problems posed by Palsberg & Pavlopoulou: (1) it expresses call-string based polyvariance (such as k-CFA) as well as argument based polyvariance; (2) it enjoys a subject reduction property for flows as well as for types; and (3) it supports a flow-oriented perspective rather than a type-oriented one.

Blocks languages for creating tangible artifacts

Logo turtles and Hendersons picture language have long been used to teach computational thinking by inspiring learners to construct programs that create complex geometric designs. We have developed visual blocks-based versions of these languages, TurtleBlocks and PictureBlocks, that allow users to transform their designs into tangible artifacts produced by laser cutters and vinyl cutters. Our languages embody two novel features. First, they use constructive area geometry to convert the geometric designs generated by our programs into formats suitable for laser and vinyl cutters. Second, they leverage static typing and polymorphism to provide a new way to reference the names of procedure parameters and local variables in a blocks language.