The library provides functional vectors in two flavors: thread-safe, type disjoint, and structurally equal; or fast(er).

PLaneT Package Repository : PLaneT > dvanhorn > fector.plt

Here’s a comparison of both flavors against the random-access lists in the RaList library, the random-access lists in the Purely Functional Data Structures library, Racket’s hash tables, and a simple implementation representing vectors of X as functions in (Nat -> X). The benchmark and numbers are from Jay McCarthy and on github.


% rk bench-fvector.rkt
fec:fast: cpu: 6.45 real: 6.5 gc: 0.0 (averaged over 20 runs)
fec:slow: cpu: 8.2 real: 8.249999999999998 gc: 0.0 (averaged over 20 runs)
ralist: cpu: 18.549999999999997 real: 18.949999999999996 gc: 0.0
(averaged over 20 runs)
sbal: cpu: 19.700000000000003 real: 21.15 gc: 0.25 (averaged over 20 runs)
hasheq: cpu: 47.95000000000001 real: 48.4 gc: 2.9499999999999993
(averaged over 20 runs)
fvec: cpu: 114.45 real: 118.64999999999999 gc: 0.0 (averaged over 20 runs)
Normalized:
fec:fast: cpu: 1.00 real: 1.00 gc: inf (averaged over 20 runs)
fec:slow: cpu: 1.27 real: 1.27 gc: inf (averaged over 20 runs)
ralist: cpu: 2.88 real: 2.92 gc: inf (averaged over 20 runs)
sbal: cpu: 3.05 real: 3.25 gc: inf (averaged over 20 runs)
hasheq: cpu: 7.43 real: 7.45 gc: inf (averaged over 20 runs)
fvec: cpu: 17.74 real: 18.25 gc: inf (averaged over 20 runs)


http://www.brics.dk/~jmi/Midtgaard%3aCSur10.html

Control-flow Analysis of Functional Programs
Jan Midtgaard, ACM Computing Surveys, 2010, forthcoming

Abstract

We present a survey of control-flow analysis of functional programs, which has been the subject of extensive investigation throughout the past 30 years. Analyses of the control flow of functional programs have been formulated in multiple settings and have led to many different approximations, starting with the seminal works of Jones, Shivers, and Sestoft. In this paper, we survey control-flow analysis of functional programs by structuring the multitude of formulations and approximations and comparing them.

The next New England Programming Languages and Systems Symposium will take place on March 4th at Northeastern University. Please mark it in your calendars!

The speaker selection committee solicits talks for this meeting. To propose yourself or someone else, send a title, list of authors, and a brief description. You may provide UP TO ONE PAGE of description, but you can keep it as short as a paragraph. We particularly invite talks by researchers from outside the area who are visiting on the date of the NEPLS meeting.

Talks can vary in length. Though 30-minute conference-style slots are traditional, speakers may request slots of as little as 5 minutes; we encourage the shorter formats. This variety permits the presentation of smaller results, preliminary work, progress reports on ongoing projects (such as language standards and compiler toolkits), and updates to past presentations. In general, NEPLS talks need not sound like conference presentations.

The submission deadline is February 17th. Send your proposal to talks@nepls.org. (Replying to this message will work in most cases, but some mailing lists masquerade as your correspondents — please check before responding.)

More details about NEPLS are available on the NEPLS webpage:

http://www.nepls.org/

Sam Tobin-Hochstadt & David Van Horn

This thought-provoking paper combines theory and practice in a novel method for call-by-need evaluation. It uses the control stack and de Bruijn numbers for resolving variable references and incorporates a compacting, garbage-collection-like algorithm to keep the stack size small. The algorithm is backed up by a correctness proof, which makes it an excellent example of the well-defined, forward-looking contribution to functional programming that the TFP Symposium seeks for its program.

ICFP 2011 seeks original papers on the art and science of functional programming. Submissions are invited on all topics from principles to practice, from foundations to features, and from abstraction to application. The scope includes all languages that encourage functional programming, including both purely applicative and imperative languages, as well as languages with objects, concurrency, or parallelism. Particular topics of interest include

• Language Design: type systems; concurrency and distribution; modules; components and composition; metaprogramming; relations to imperative, object-oriented, or logic programming; interoperability
• Implementation: abstract machines; virtual machines; interpretation; compilation; compile-time and run-time optimization; memory management; multi-threading; exploiting parallel hardware; interfaces to foreign functions, services, components, or low-level machine resources
• Software-Development Techniques: algorithms and data structures; design patterns; specification; verification; validation; proof assistants; debugging; testing; tracing; profiling
• Foundations: formal semantics; lambda calculus; rewriting; type theory; mathematical logic; monads; continuations; delimited continuations; global, delimited, or local effects
• Transformation and Analysis: abstract interpretation; partial evaluation; program transformation; program calculation; program proofs; normalization by evaluation
• Applications and Domain-Specific Languages: symbolic computing; formal-methods tools; artificial intelligence; systems programming; distributed-systems and web programming; hardware design; databases; XML processing; scientific and numerical computing; graphical user interfaces; multimedia programming; scripting; system administration; security; education
• Functional Pearls: elegant, instructive, and fun essays on functional programming
• Experience Reports: short papers that provide evidence that functional programming really works or describe obstacles that have kept it from working in a particular application

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.