Applications are invited for postdoc positions in the areas of programming languages, formal verification, operating systems, and hardware design at the University of Pennsylvania, Harvard University, and Northeastern University.

The hosting project, SAFE (Semantically Aware Foundation Environment), is part of CRASH, a larger DARPA-funded effort to design new computer systems that are highly resistant to cyber-attack, can adapt after a successful attack in order to continue rendering useful services, can learn from previous attacks how to guard against and cope with future attacks, and can repair themselves after attacks have succeeded. It offers a rare opportunity to rethink the hardware / OS / software stack from a completely clean slate, with no legacy constraints whatsoever.

Specifically, we aim to build a suite of modern operating system services that embodies and supports fundamental security principles—including separation of privilege, least privilege, and mutual suspicion—down to its very bones, without compromising performance. Achieving this goal demands an integrated effort focusing on (1) processor architectures, (2) operating systems, (3) formal methods, and (4) programming languages and compilers — coupled with a co-design methodology in which all critical system layers are designed together, with a ruthless insistence on simplicity, security, and verifiability at every level.

The ideal candidate will have a Ph.D. in Computer Science, a combination of strong theoretical and practical interests, and expertise in two or more of the following areas: programming languages, security, formal verification, operating systems, and hardware design. The position is for one year in the first instance, with possible renewal up to four years. Starting date is negotiable. Applications from women and members of other under-represented groups are particularly welcome.

To apply, please send a CV, research statement, and the names of three people who can be asked for letters of reference to Benjamin Pierce (bcpierce@cis.upenn.edu). Inquiries can be directed to any of the PIs:

Andre Dehon (Penn)
Greg Morrisett (Harvard)
Benjamin Pierce (Penn)
Olin Shivers (Northeastern)
Jonathan Smith (Penn)

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.

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.

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

NJPLS:

The next NJPLS will be on Friday April 9 at Stevens Institute of
Technology. If you would like to present a cool idea to the NJPLS
community, please send me your talk request by March 17. Please send me
an email with your talk title and abstract. All topics in programming
languages and systems are welcome.

Stevens is located in Hoboken, just across the Hudson river from midtown
Manhattan.

Information about past NJPLS events can be found at http://www.njpls.org/

NEPLS:

This is an early announcement of the upcoming Spring 2010 NEPLS
meeting. It will take place on

April 29, Thursday, 2010

at Yale University. Please mark it in your calendars! For additional
information about NEPLS, please consult the Web page

http://www.nepls.org/

The speaker selection committee welcomes suggestions — you may
propose either yourself, or someone else whom the committee will
contact. To propose speakers, send mail to

talks@nepls.org

We will send another message to solicit talks in early March.

(Replying to this message will work in most cases, but some
mailing lists thwart the simplicity of this plan by masquerading as
your correspondents — please check before sending.)

Additional event information will appear on the Web in due course.

TFP:

TFP 2010: 11th SYMPOSIUM ON TRENDS IN FUNCTIONAL PROGRAMMING
May 17-19, 2010
University of Oklahoma http://www.cs.ou.edu/tfp2010/

TFP 2010 is an international forum for researchers with interests in any aspect of functional programming.

SUBMISSION and REGISTRATION DEADLINES
April 2: Submission deadline
April 16: Early registration deadline ($350, $200 for students)
May 7: Late registration deadline ($425)
May 17-19: TFP Symposium

POST-SYMPOSIUM PROCEEDINGS
Springer series: Lecture Notes in Computer Science

Details about the event schedule, symposium scope, submissions, and registration may be found on the symposium website (web browser key “tfp 2010″). http://www.cs.ou.edu/tfp2010/

Submitted papers and extended abstracts are reviewed for presentation at the symposium, and a formal refereeing process after the symposium selects the best presentations for publication the Springer series, Lecture Notes in Computer Science.

We invite you to participate in TFP 2010.
– Rex Page, University of Oklahoma, Program Chair
– Viktia Zs and Zolt Horvath, Ev Lord University, Symposium Co-Chairs
Sponsors: Erlang Solutions Ltd and The University of Oklahoma

WSFP:

Call for Papers
2010 Workshop on Scheme and Functional Programming
Montréal, Québec, Canada
Saturday and Sunday August 21-22, 2010
http://www.iro.umontreal.ca/~sfp2010
Important Dates
Submission: 11 June 2010
Notification: 2 July 2010
Final papers due: 23 July 2010

All deadlines are at 14:00 UTC.

ICFP:

ICFP 2010: International Conference on Functional Programming

Baltimore, Maryland, 27 — 29 September 2010

http://www.icfpconference.org/icfp2010

Important Dates (at 14:00 UTC)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Submission: 2 April 2010
Author response: 24 — 25 May 2010
Notification: 7 June 2010
Final papers due: 12 July 2010

Everyday life and critical aspects of our economy, defense, and government depend on software, and software, in turn, depends on high-level programming languages and their efficient implementations. Ever since Fortran and its automatic compiler in the late 50s, language implementation techniques have been central to computer science, and have relied on well-defined theoretical contributions and central principles. The focus of this summer school is the mix or interplay of theory and practice in language implementation mechanisms, such as compilers or run-time systems. The main aim of this summer school is to enable participants to conduct research in the area, thereby contributing to improved software.

By presenting a range of material, from foundational work on language implementation theory, to advanced techniques based on cutting-edge research, to experience with applying the theory, we will provide a unique opportunity for participants to understand the current research landscape. Lectures will include discussions of core ideas such as abstract interpretation, static program analyses, and intermediate representations (e.g., continuations) and their connection to language semantics. The lectures will explore how these ideas can be adapted to yield efficient and general programming language implementations, at the level of a compiler or a run-time system.

At all times, material will be presented at a tutorial level that will help graduate students and researchers from academia or industry understand the critical issues and open problems confronting the field. We hope that students will be able to apply what they learn at the school in their own research. We believe that by doing so the school will have a broad impact on the next generation of programming language, compiler and software engineering researchers in industry and academia.

The course is open to anyone interested. Prerequisites are knowledge of programming language implementation (at the level usually covered in undergraduate classes on programming languages or compilers) as well as general knowledge of programming languages at the level provided by an undergraduate survey course. Our primary target group is first- or second-year graduate students. We also expect attendance by faculty members who would like to conduct research on this topic or introduce new courses at their universities.

The line-up of speakers looks outstanding. Having been to a couple of these summer schools already, I can say they are a great way to immerse yourself in an area of the field. I highly recommend it for PhD students looking for a topic to work on, but also more senior researchers can use the school to become familiar with a body of work outside of their immediate area.

The Fortress team has started a blog, to post a series of
announcements and news items about Fortress. Our goal is to let
people know about ongoing technical discussions and decisions, as well
as the current status of the implementation. We will also post
interesting examples of Fortress code. We hope to put up new posts at
least weekly.

So far we have four posts. The first and fourth posts discuss the new
wiki markup for tables and images for use in Fortress comments; the
second post discusses some changes to the typing rules for conditional
expressions that will help them to interact better with coercion; the
third post reports on an implementation of the “treap” data structure
in Fortress. We also plan to report soon on the status of our efforts
to construct a Fortress compiler. Please visit

http://projectfortress.sun.com/Projects/Community/blog

or click on the “Blog” item at the right-hand end of the menu bar on
the main Wiki page.

The HOFA forum is an email forum for the discussion and dissemination of research results in the area of higher-order flow analysis, broadly construed, within computer science and related disciplines. Flow analysis and related static analyses are a fundamental tool for program verification, bug detection, compiler optimization, program understanding, and software maintenance. The HOFA forum aims to facilitate theoretical, practical, and application advances in the area of functional, object-oriented, concurrent, distributed, and mobile programming.

Please sign up! Also, send me email if you or your group would like to be listed on the HOFA site.