NYC LOCAL: Tuesday 20 November 2007 New York FP Meetup: Anton van Straaten on Functions, Contracts, the Lazy, the Eager, and the SEC - BSD

This is a discussion on NYC LOCAL: Tuesday 20 November 2007 New York FP Meetup: Anton van Straaten on Functions, Contracts, the Lazy, the Eager, and the SEC - BSD ; what="official New York Functional Programmers Meetup announcement"
source-url="http://lisp.meetup.com/59/calendar/6617972"
edits="some, because the web page had much stuff"
note="The Meetup system provides a notification service, so likely
"we will not forward future notices."
nb="You must RSVP via Meetup web page in order ...

NYC LOCAL: Tuesday 20 November 2007 New York FP Meetup: Anton van Straaten on Functions, Contracts, the Lazy, the Eager, and the SEC

what="official New York Functional Programmers Meetup announcement"
source-url="http://lisp.meetup.com/59/calendar/6617972"
edits="some, because the web page had much stuff"
note="The Meetup system provides a notification service, so likely
"we will not forward future notices."
nb="You must RSVP via Meetup web page in order to attend.">

Anton van Straaten is giving a talk, "Functional Financial
Contracts in Haskell and OCaml". His description:

This talk will discuss the approach to modeling financial
contracts originally presented in the paper "Composing
contracts: an adventure in financial engineering"[*] by
Peyton-Jones, Eber and Seward. According to the paper's
abstract:

"Financial and insurance contracts do not sound like promising
territory for functional programming and formal semantics, but
in fact we have discovered that insights from programming
languages bear directly on the complex subject of describing and
valuing a large class of contracts.

"We introduce a combinator library that allows us to describe
such contracts precisely, and a compositional denotational
semantics that says what such contracts are worth. We sketch an
implementation of our combinator library in Haskell.
Interestingly, lazy evaluation plays a crucial role."

The approach described in the paper provides a precise way to
specify financial contracts, value them, and process their
evolution through time. To achieve this, it uses a
domain-specific embedded language, exploiting concepts and
techniques from programming language theory.

The talk will provide an overview of this approach and its
advantages, along with a simple implementation of the core
concepts in the paper, presented in Haskell and OCaml[2]. The
programming language theory features exploited by the paper will
be analyzed.

No prior knowledge of financial contracts or programming
language theory is required, but some knowledge of a functional
programming language such as Haskell or ML will help.

< ... />

RSVP now to attend this Meetup!

Your RSVP lets us keep you up-to-date with any changes and saves you a
spot when space is limited.
Can you attend?