Abstracting Abstract Machines.
David Van Horn and Matthew Might.
The 15th ACM SIGPLAN International Conference on Functional Programming (ICFP’10), Baltimore, Maryland, September, 2010.

We describe a derivational approach to abstract interpretation that yields novel and transparently sound static analyses when applied to well-established abstract machines. To demonstrate the technique and support our claim, we transform the CEK machine of Felleisen and Friedman, a lazy variant of Krivine’s machine, and the stack-inspecting CM machine of Clements and Felleisen into abstract interpretations of themselves. The resulting analyses bound temporal ordering of program events; predict return-flow and stack-inspection behavior; and approximate the flow and evaluation of by-need parameters. For all of these machines, we find that a series of well-known concrete machine refactorings, plus a technique we call store-allocated continuations, leads to machines that abstract into static analyses simply by bounding their stores. We demonstrate that the technique scales up uniformly to allow static analysis of realistic language features, including tail calls, conditionals, side effects, exceptions, first-class continuations, and even garbage collection.

• PDF

The second technique keeps continuations on the stack to achieve a push-down model of abstract interpretation. The resulting abstract interpreter always matches calls and returns, achieving a higher level of precision by never conflating call and return pairs. Although this technique produces abstract interpreters with infinite state-spaces, we demonstrate how basic static analysis questions remain decidable by casting them as language inclusion problems answered by push-down automata.

Pushdown Control-Flow Analysis of Higher-Order Programs.
Christopher Earl, Matthew Might, and David Van Horn.
The 2010 Workshop on Scheme and Functional Programming (SFP 2010), Montréal, Québec, Canada, August, 2010.

Context-free approaches to static analysis gain precision over classical approaches by perfectly matching returns to call sites—a property that eliminates spurious interprocedural paths. Vardoulakis and Shivers’s recent formulation of CFA2 showed that it is possible (if expensive) to apply context-free methods to higher-order languages and gain the same boost in precision achieved over first-order programs.

To this young body of work on context-free analysis of higher-order programs, we contribute a pushdown control-flow analysis framework, which we derive as an abstract interpretation of a CESK machine with an unbounded stack. One instantiation of this framework marks the first polyvariant pushdown analysis of higher-order programs; another marks the first polynomial-time analysis. In the end, we arrive at a framework for control-flow analysis that can efficiently compute pushdown generalizations of classical control-flow analyses.

• PDF

There are also slides (PDF) covering both techniques from a talk given at the Harvard PL seminar.

July 29, 2010, Hawthorne NY

The eleventh annual Programming Languages Day will be held at the IBM Thomas J. Watson Research Center on Thursday, July 29, 2010. The day will be held in cooperation with the New Jersey and New England Programming Languages and Systems Seminars. The main goal of the event is to increase awareness of each other’s work, and to encourage interaction and collaboration.

The Programming Languages Day features a keynote presentation and approximately 8 regular presentations. Prof. Doug Lea, State University of New York at Oswego, will deliver the keynote presentation this year.

If you would like to present your work, please send a title and abstract to etorlak@us.ibm.com by June 23, 2010. Tutorials or joint presentations are welcomed. We also solicit input on topics or particular presentations that would be of interest to attendees.

Abstracts will be selected by a committee consisting of Adriana Compagnoni, Stevens Institute of Technology; Joshua Guttman, Worcester Polytechnic Institute; and Emina Torlak, IBM Research. Notification of accepted abstracts will be sent by approximately June 30, 2010.

You are welcome from 9AM onwards, and the keynote presentation will start at 10AM sharp. We expect the program to run until 4PM. The Programming Languages day will be held in room GN-F15 in the Hawthorne-1 building in Hawthorne, New York.

If you plan to attend the Programming Languages Day, please register by sending an e-mail with your name, affiliation, contact information, and dietary restrictions to etorlak@us.ibm.com so that we can plan for lunch and refreshments.

Important Dates:

Talk title and abstract deadline: June 23rd
Acceptance notification: June 30th
PL Day 2010: July 29th

Program committee:

Adriana Compagnoni, Stevens Institute of Technology
Joshua Guttman, Worcester Polytechnic Institute
Emina Torlak, IBM T.J. Watson Research Center

Professor Gordon D. Plotkin has made fundamental advances in almost every area of the theory of programming languages. His contributions have helped to establish the mathematical foundations on which the scientific study of programming languages are based. His 1975 paper “Call-by-name, Call-by-value, and the λ-calculus” exposed the relationship between the reduction semantics of the λ-calculus and its operational semantics, as defined by Landin’s SECD machine. In the process, he defined what it meant for a calculus and a semantics to correspond: this launched the study of operational semantics as it is now understood. He invented Structural Operational Semantics as a technique for specifying the semantics of a wide range of programming languages, concurrent as well as sequential; this form of semantics is now one of the basic working tools of researchers developing new programming languages and type systems.

Plotkin’s contributions to the development of the mathematical theory of domains, and its applications to the denotational semantics of programming languages, have been of fundamental importance: they include his powerdomain construction, systematic development of the general theory of the solution of recursive domain equations, and his work on PCF and the full abstraction problem.

Plotkin’s work with Glynn Winskel on event structures is the basis for reasoning about distributed systems, process algebras, and reactive systems. Event structures have been enormously influential in the development of models of concurrency. He has also investigated the logical foundations of computer security, including logics for specifying authorization policies for computer systems. Plotkin continues to make bold and deep contributions, for example, in his current work on the algebraic theory of effects, and on languages and calculi for biochemical modelling. Taken together, Gordon Plotkin’s contributions over the past four decades exhibit a range and depth unmatched in the field.

A man of modest background and quiet brilliance, Milner made ground-breaking contributions to the fields of verification, programming languages, and concurrency. He was born in 1934 near Plymouth, England, and won scholarships to Eton—where he developed an enduring love of math as well as a prodigious work ethic—and King’s College, Cambridge. It was during his time at Cambridge that Milner was introduced to programming, though the subject didn’t interest him initially. “I regarded programming as really rather inelegant,” he recalled in an interview in 2001 with Martin Berger, a professor at the University of Sussex. “So I resolved that I would never go near a computer in my life.”

PLT is happy to announce the release of Racket, available from

http://racket-lang.org/

With Racket, you can script command shells and web servers; you can quickly prototype animations and complex GUIs; regexps and threads are here to serve you. To organize your systems, you can mix and match classes, modules or components. Best of all, you start without writing down types. If you later wish to turn your script into a program, equip your Racket modules with explicit type declarations as you wish. And Racket doesn’t just come as a typed variant; you can also write your modules in a purely functional and lazy dialect.

Racket comes in so many flavors because Racket is much more than a standard scripting language or a plain programming language. Racket supports language extensibility to an unequaled degree. A Racket programmer knows that making up a new language is as easy as writing a new library.

To help you start quickly, Racket includes batteries in all shapes and sizes, most importantly, extensive documentation and all kinds of libraries.

Racket occupies a unique position between research and practice. It inherits many major ideas from language research, among them type safety (when the type system says that x is a number, then at runtime it always is a number) and memory safety (when some memory is reclaimed by the garbage collector it is impossible to still have a reference to it). At the same time, user demand governs rigid adherence to purely theoretical principles.

Racket, formerly PLT Scheme, is a product of over 15 years of development. Although Racket starts with a mature software base and an established user community, its new name reflects our view that this is just the beginning of Racket’s evolution.

(define (± x y)
  (shift k (values (k (+ x y)) (k (- x y)))))

(define (quadratic-formula-roots a b c)
  (reset (/ (± (- b) (√ (- (² b) (* 4 a c))))
	    (* 2 a))))

Abstract:

Ariola and Felleisen’s call-by-need λ-calculus replaces a variable occurrence with its value at the last possible moment. To support this gradual notion of substitution, function applications—once established—are never discharged. In this paper we show how to translate this notion of reduction into an abstract machine that resolves variable references via the control stack. In particular, the machine uses the static address of a variable occurrence to extract its current value from the dynamic control stack.

PDF

I’m looking for PhD students and postdocs interested in working on an
elegant combination of functional programming and big-iron style
numeric computing. Blurb below. If you know anyone good who might be
interested, I’d be grateful if you’d pass this along.

Sounds fun!

Functional Programming and Automatic Differentiation

PhD Studentships
Postdoctoral Positions

We are adding exact first-class derivative calculation operators
(Automatic Differentiation or AD) to the lambda calculus, and
embodying the combination into a production-quality optimising
compiler. Our research prototype compiler generates object code
competitive with the fastest current systems, which are based on
FORTRAN. We are seeking PhD students and postdocs with interest and
experience in relevant areas: programming language theory, numeric
computing/numeric linear algebra, or differential geometry; and a
burning drive to help lift big iron numeric computing out of the 1960s
and into a newer higher order. Specific sub-projects include:
compiler and numeric programming environment construction; writing,
simplifying, and generalising numeric algorithms through the use of AD
operators; and associated type/lambda calculus/PLT/real computation
issues.

The project headquarters will be in the Hamilton Institute, NUI
Maynooth, Ireland, http://www.hamilton.ie/.

Applications to:
“Barak A. Pearlmutter”