Skip to content

PhD and Postdoc positions: Functional Programming and Automatic Differentiation

Barak Pearlmutter is looking for PhD students and postdocs to work on functional programming and automatic differentiation.

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”

NJPLS, NEPLS, TFP, WSFP, ICFP

This should keep you busy.

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

Oregon PL School: Logic, Languages, Compilation, and Verification

University of Oregon is hosting another Oregon Programming Languages Summer School this June. This year’s topic is Logic, Languages, Compilation, and Verification:

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.

CACM: Type Theory Comes of Age

The current issue of CACM has an article on type theory:

When the philosopher Bertrand Russell invented type theory at the beginning of the 20th century, he could hardly have imagined that his solution to a simple logic paradox—defining the set of all sets not in themselves—would one day shape the trajectory of 21st century computer science.

It is riddled with misconceptions, errors, and self-aggrandizement. It does us the great disservice of conflating (dynamic) memory safety and (static) type safety, and has whoppers like “A type system ensures the correct behavior of any program routine by enforcing a set of predetermined behaviors,” which is just false. But hey, ra-ra types! No?

Photos from POPL 2010

Some photos from POPL 2010 in Madrid, Spain.

Preprint: Resolving and Exploiting the k-CFA Paradox

A new preprint by Matthew Might, Yannis Smaragdakis, and David Van Horn.

Abstract:

Low-level program analysis is a fundamental problem, taking the shape of “flow analysis” in functional languages and “points-to” analysis in imperative and object-oriented (OO) languages. Despite the similarities, the vocabulary and results in the two communities remain largely distinct, with limited cross-understanding. One of the few links is Shivers’s k-CFA work, which has advanced the concept of “context-sensitive analysis” and is widely known in both communities. Recent results, however, indicate that the relationship between the different incarnations of the analysis is not understood. Van Horn and Mairson proved k-CFA for k ≥ 1 to be EXPTIME-complete, hence no polynomial algorithm exists. Yet there have been multiple polynomial formulations of context-sensitive points-to analyses in OO languages. Is functional k-CFA a profoundly different analysis from OO k-CFA? We resolve this paradox by showing that OO features conspire to make the exact same specification of k-CFA be polynomial-time: objects and closures are subtly different, in a way that interacts crucially with context-sensitivity. This leads to a significant practical result: by emulating the OO approximation, we derive a polynomial hierarchy of context-sensitive CFAs for functional programs, simultaneously achieving high precision and efficiency.

Update (2/2010): This work will appear at PLDI 2010. See you in Toronto!

Update (2/2010): Noticed on LtU: http://lambda-the-ultimate.org/node/3814.

Fortress, the Blog

The Fortress folks have announced a new blog:

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.

HOFA Forum

The Higher-Order Flow Analysis Forum has just been set up:

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.

Photos from the Scheme Workshop

Some photos from the 2009 Scheme and Functional Programming Workshop at Northeastern.

SRFI 102: Procedure Arity Inspection

A new SRFI for inspecting the arity of procedures:

Many Scheme systems provide mechanisms for inspecting the arity of a procedural value, making it a common feature, however there is no standard interface. As a result there is no portable way to observe the arity of a procedure without actually applying it. This SRFI proposes a simple interface that is consistent with existing Scheme systems’ facilities and prior proposals.

google

google

asus